polymer-rails 0.3.0 → 1.0.0

data/app/assets/javascripts/polymer/polymer.html

@@ -1,59 +1,3779 @@
 <!--
 @license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+--><!--
+@license
 Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
 This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
 The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
 The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
 Code distributed by Google as part of the polymer project is also
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
--->
-
-<link rel="import" href="polymer-mini.html">
-
-<link rel="import" href="src/standard/annotations.html">
-<link rel="import" href="src/standard/events.html">
-<link rel="import" href="src/standard/utils.html">
-<link rel="import" href="src/standard/effects.html">
-<link rel="import" href="src/standard/configure.html">
-<link rel="import" href="src/standard/notify-path.html">
-<link rel="import" href="src/standard/resolveUrl.html">
-<link rel="import" href="src/standard/styling.html">
-<link rel="import" href="src/standard/x-styling.html">
-
-<script>
-
-  Polymer.Base.addFeature({
-
-    registerFeatures: function() {
-      this._prepIs();
-      this._prepMixins();
-      this._prepExtends();
-      this._prepConstructor();
-      this._prepTemplate();
-      this._prepAnnotations();
-      this._prepEffects();
-      this._prepContent();
-    },
-
-    initFeatures: function() {
-      this._poolContent();
-      this._setupConfigure();
-      this._pushHost();
-      this._stampTemplate();
-      this._popHost();
-      this._marshalAnnotationReferences();
-      this._marshalInstanceEffects();
-      this._marshalAttributes();
-      this._marshalListeners();
-      this._readyContent();
-    }
-
-  });
-
-</script>
-
-<link rel="import" href="src/lib/x-style.html">
-<link rel="import" href="src/lib/template/x-autobind.html">
-<link rel="import" href="src/lib/template/x-template.html">
-<link rel="import" href="src/lib/template/x-repeat.html">
-<link rel="import" href="src/lib/template/x-array-selector.html">
+--><link rel="import" href="polymer-mini.html">
+
+<script>Polymer.nar = [];
+
+Polymer.Annotations = {
+parseAnnotations: function(template) {
+var list = [];
+var content = template._content || template.content;
+this._parseNodeAnnotations(content, list);
+return list;
+},
+_parseNodeAnnotations: function(node, list) {
+return node.nodeType === Node.TEXT_NODE ? this._parseTextNodeAnnotation(node, list) : this._parseElementAnnotations(node, list);
+},
+_testEscape: function(value) {
+var escape = value.slice(0, 2);
+if (escape === "{{" || escape === "[[") {
+return escape;
+}
+},
+_parseTextNodeAnnotation: function(node, list) {
+var v = node.textContent;
+var escape = this._testEscape(v);
+if (escape) {
+node.textContent = " ";
+var annote = {
+bindings: [ {
+kind: "text",
+mode: escape[0],
+value: v.slice(2, -2).trim()
+} ]
+};
+list.push(annote);
+return annote;
+}
+},
+_parseElementAnnotations: function(element, list) {
+var annote = {
+bindings: [],
+events: []
+};
+this._parseChildNodesAnnotations(element, annote, list);
+if (element.attributes) {
+this._parseNodeAttributeAnnotations(element, annote, list);
+if (this.prepElement) {
+this.prepElement(element);
+}
+}
+if (annote.bindings.length || annote.events.length || annote.id) {
+list.push(annote);
+}
+return annote;
+},
+_parseChildNodesAnnotations: function(root, annote, list, callback) {
+if (root.firstChild) {
+for (var i = 0, node = root.firstChild; node; node = node.nextSibling, i++) {
+if (node.localName === "template" && !node.hasAttribute("preserve-content")) {
+this._parseTemplate(node, i, list, annote);
+}
+var childAnnotation = this._parseNodeAnnotations(node, list, callback);
+if (childAnnotation) {
+childAnnotation.parent = annote;
+childAnnotation.index = i;
+}
+}
+}
+},
+_parseTemplate: function(node, index, list, parent) {
+var content = document.createDocumentFragment();
+content._notes = this.parseAnnotations(node);
+content.appendChild(node.content);
+list.push({
+bindings: Polymer.nar,
+events: Polymer.nar,
+templateContent: content,
+parent: parent,
+index: index
+});
+},
+_parseNodeAttributeAnnotations: function(node, annotation) {
+for (var i = node.attributes.length - 1, a; a = node.attributes[i]; i--) {
+var n = a.name, v = a.value;
+if (n === "id" && !this._testEscape(v)) {
+annotation.id = v;
+} else if (n.slice(0, 3) === "on-") {
+node.removeAttribute(n);
+annotation.events.push({
+name: n.slice(3),
+value: v
+});
+} else {
+var b = this._parseNodeAttributeAnnotation(node, n, v);
+if (b) {
+annotation.bindings.push(b);
+}
+}
+}
+},
+_parseNodeAttributeAnnotation: function(node, n, v) {
+var escape = this._testEscape(v);
+if (escape) {
+var customEvent;
+var name = n;
+var mode = escape[0];
+v = v.slice(2, -2).trim();
+var not = false;
+if (v[0] == "!") {
+v = v.substring(1);
+not = true;
+}
+var kind = "property";
+if (n[n.length - 1] == "$") {
+name = n.slice(0, -1);
+kind = "attribute";
+}
+var notifyEvent, colon;
+if (mode == "{" && (colon = v.indexOf("::")) > 0) {
+notifyEvent = v.substring(colon + 2);
+v = v.substring(0, colon);
+customEvent = true;
+}
+if (node.localName == "input" && n == "value") {
+node.setAttribute(n, "");
+}
+node.removeAttribute(n);
+if (kind === "property") {
+name = Polymer.CaseMap.dashToCamelCase(name);
+}
+return {
+kind: kind,
+mode: mode,
+name: name,
+value: v,
+negate: not,
+event: notifyEvent,
+customEvent: customEvent
+};
+}
+},
+_localSubTree: function(node, host) {
+return node === host ? node.childNodes : node._lightChildren || node.childNodes;
+},
+findAnnotatedNode: function(root, annote) {
+var parent = annote.parent && Polymer.Annotations.findAnnotatedNode(root, annote.parent);
+return !parent ? root : Polymer.Annotations._localSubTree(parent, root)[annote.index];
+}
+};
+
+(function() {
+function resolveCss(cssText, ownerDocument) {
+return cssText.replace(CSS_URL_RX, function(m, pre, url, post) {
+return pre + "'" + resolve(url.replace(/["']/g, ""), ownerDocument) + "'" + post;
+});
+}
+function resolveAttrs(element, ownerDocument) {
+for (var name in URL_ATTRS) {
+var a$ = URL_ATTRS[name];
+for (var i = 0, l = a$.length, a, at, v; i < l && (a = a$[i]); i++) {
+if (name === "*" || element.localName === name) {
+at = element.attributes[a];
+v = at && at.value;
+if (v && v.search(BINDING_RX) < 0) {
+at.value = a === "style" ? resolveCss(v, ownerDocument) : resolve(v, ownerDocument);
+}
+}
+}
+}
+}
+function resolve(url, ownerDocument) {
+var resolver = getUrlResolver(ownerDocument);
+resolver.href = url;
+return resolver.href || url;
+}
+var tempDoc;
+var tempDocBase;
+function resolveUrl(url, baseUri) {
+if (!tempDoc) {
+tempDoc = document.implementation.createHTMLDocument("temp");
+tempDocBase = tempDoc.createElement("base");
+tempDoc.head.appendChild(tempDocBase);
+}
+tempDocBase.href = baseUri;
+return resolve(url, tempDoc);
+}
+function getUrlResolver(ownerDocument) {
+return ownerDocument.__urlResolver || (ownerDocument.__urlResolver = ownerDocument.createElement("a"));
+}
+var CSS_URL_RX = /(url\()([^)]*)(\))/g;
+var URL_ATTRS = {
+"*": [ "href", "src", "style", "url" ],
+form: [ "action" ]
+};
+var BINDING_RX = /\{\{|\[\[/;
+Polymer.ResolveUrl = {
+resolveCss: resolveCss,
+resolveAttrs: resolveAttrs,
+resolveUrl: resolveUrl
+};
+})();
+
+Polymer.Base._addFeature({
+_prepAnnotations: function() {
+if (!this._template) {
+this._notes = [];
+} else {
+Polymer.Annotations.prepElement = this._prepElement.bind(this);
+this._notes = Polymer.Annotations.parseAnnotations(this._template);
+this._processAnnotations(this._notes);
+Polymer.Annotations.prepElement = null;
+}
+},
+_processAnnotations: function(notes) {
+for (var i = 0; i < notes.length; i++) {
+var note = notes[i];
+for (var j = 0; j < note.bindings.length; j++) {
+var b = note.bindings[j];
+b.signature = this._parseMethod(b.value);
+if (!b.signature) {
+b.model = this._modelForPath(b.value);
+}
+}
+if (note.templateContent) {
+this._processAnnotations(note.templateContent._notes);
+var pp = note.templateContent._parentProps = this._discoverTemplateParentProps(note.templateContent._notes);
+var bindings = [];
+for (var prop in pp) {
+bindings.push({
+index: note.index,
+kind: "property",
+mode: "{",
+name: "_parent_" + prop,
+model: prop,
+value: prop
+});
+}
+note.bindings = note.bindings.concat(bindings);
+}
+}
+},
+_discoverTemplateParentProps: function(notes) {
+var pp = {};
+notes.forEach(function(n) {
+n.bindings.forEach(function(b) {
+if (b.signature) {
+var args = b.signature.args;
+for (var k = 0; k < args.length; k++) {
+pp[args[k].model] = true;
+}
+} else {
+pp[b.model] = true;
+}
+});
+if (n.templateContent) {
+var tpp = n.templateContent._parentProps;
+Polymer.Base.mixin(pp, tpp);
+}
+});
+return pp;
+},
+_prepElement: function(element) {
+Polymer.ResolveUrl.resolveAttrs(element, this._template.ownerDocument);
+},
+_findAnnotatedNode: Polymer.Annotations.findAnnotatedNode,
+_marshalAnnotationReferences: function() {
+if (this._template) {
+this._marshalIdNodes();
+this._marshalAnnotatedNodes();
+this._marshalAnnotatedListeners();
+}
+},
+_configureAnnotationReferences: function() {
+this._configureTemplateContent();
+},
+_configureTemplateContent: function() {
+this._notes.forEach(function(note, i) {
+if (note.templateContent) {
+this._nodes[i]._content = note.templateContent;
+}
+}, this);
+},
+_marshalIdNodes: function() {
+this.$ = {};
+this._notes.forEach(function(a) {
+if (a.id) {
+this.$[a.id] = this._findAnnotatedNode(this.root, a);
+}
+}, this);
+},
+_marshalAnnotatedNodes: function() {
+if (this._nodes) {
+this._nodes = this._nodes.map(function(a) {
+return this._findAnnotatedNode(this.root, a);
+}, this);
+}
+},
+_marshalAnnotatedListeners: function() {
+this._notes.forEach(function(a) {
+if (a.events && a.events.length) {
+var node = this._findAnnotatedNode(this.root, a);
+a.events.forEach(function(e) {
+this.listen(node, e.name, e.value);
+}, this);
+}
+}, this);
+}
+});
+
+Polymer.Base._addFeature({
+listeners: {},
+_listenListeners: function(listeners) {
+var node, name, key;
+for (key in listeners) {
+if (key.indexOf(".") < 0) {
+node = this;
+name = key;
+} else {
+name = key.split(".");
+node = this.$[name[0]];
+name = name[1];
+}
+this.listen(node, name, listeners[key]);
+}
+},
+listen: function(node, eventName, methodName) {
+this._listen(node, eventName, this._createEventHandler(node, eventName, methodName));
+},
+_createEventHandler: function(node, eventName, methodName) {
+var host = this;
+return function(e) {
+if (host[methodName]) {
+host[methodName](e, e.detail);
+} else {
+host._warn(host._logf("_createEventHandler", "listener method `" + methodName + "` not defined"));
+}
+};
+},
+_listen: function(node, eventName, handler) {
+node.addEventListener(eventName, handler);
+}
+});
+
+(function() {
+"use strict";
+var HAS_NATIVE_TA = typeof document.head.style.touchAction === "string";
+var GESTURE_KEY = "__polymerGestures";
+var HANDLED_OBJ = "__polymerGesturesHandled";
+var TOUCH_ACTION = "__polymerGesturesTouchAction";
+var TAP_DISTANCE = 25;
+var TRACK_DISTANCE = 5;
+var TRACK_LENGTH = 2;
+var MOUSE_TIMEOUT = 2500;
+var MOUSE_EVENTS = [ "mousedown", "mousemove", "mouseup", "click" ];
+var mouseCanceller = function(mouseEvent) {
+mouseEvent[HANDLED_OBJ] = {
+skip: true
+};
+if (mouseEvent.type === "click") {
+var path = Polymer.dom(mouseEvent).path;
+for (var i = 0; i < path.length; i++) {
+if (path[i] === POINTERSTATE.mouse.target) {
+return;
+}
+}
+mouseEvent.preventDefault();
+mouseEvent.stopPropagation();
+}
+};
+function setupTeardownMouseCanceller(setup) {
+for (var i = 0, en; i < MOUSE_EVENTS.length; i++) {
+en = MOUSE_EVENTS[i];
+if (setup) {
+document.addEventListener(en, mouseCanceller, true);
+} else {
+document.removeEventListener(en, mouseCanceller, true);
+}
+}
+}
+function ignoreMouse() {
+if (!POINTERSTATE.mouse.mouseIgnoreJob) {
+setupTeardownMouseCanceller(true);
+}
+var unset = function() {
+setupTeardownMouseCanceller();
+POINTERSTATE.mouse.target = null;
+POINTERSTATE.mouse.mouseIgnoreJob = null;
+};
+POINTERSTATE.mouse.mouseIgnoreJob = Polymer.Debounce(POINTERSTATE.mouse.mouseIgnoreJob, unset, MOUSE_TIMEOUT);
+}
+var POINTERSTATE = {
+tapPrevented: false,
+mouse: {
+target: null,
+mouseIgnoreJob: null
+},
+touch: {
+x: 0,
+y: 0,
+id: -1,
+scrollDecided: false
+}
+};
+function firstTouchAction(ev) {
+var path = Polymer.dom(ev).path;
+var ta = "auto";
+for (var i = 0, n; i < path.length; i++) {
+n = path[i];
+if (n[TOUCH_ACTION]) {
+ta = n[TOUCH_ACTION];
+break;
+}
+}
+return ta;
+}
+var Gestures = {
+gestures: {},
+recognizers: [],
+deepTargetFind: function(x, y) {
+var node = document.elementFromPoint(x, y);
+var next = node;
+while (next && next.shadowRoot) {
+next = next.shadowRoot.elementFromPoint(x, y);
+if (next) {
+node = next;
+}
+}
+return node;
+},
+handleNative: function(ev) {
+var handled;
+var type = ev.type;
+var node = ev.currentTarget;
+var gobj = node[GESTURE_KEY];
+var gs = gobj[type];
+if (!gs) {
+return;
+}
+if (!ev[HANDLED_OBJ]) {
+ev[HANDLED_OBJ] = {};
+if (type.slice(0, 5) === "touch") {
+var t = ev.changedTouches[0];
+if (type === "touchstart") {
+if (ev.touches.length === 1) {
+POINTERSTATE.touch.id = t.identifier;
+}
+}
+if (POINTERSTATE.touch.id !== t.identifier) {
+return;
+}
+if (!HAS_NATIVE_TA) {
+if (type === "touchstart" || type === "touchmove") {
+Gestures.handleTouchAction(ev);
+}
+}
+if (type === "touchend") {
+POINTERSTATE.mouse.target = Polymer.dom(ev).rootTarget;
+ignoreMouse(true);
+}
+}
+}
+handled = ev[HANDLED_OBJ];
+if (handled.skip) {
+return;
+}
+var recognizers = Gestures.recognizers;
+for (var i = 0, r; i < recognizers.length; i++) {
+r = recognizers[i];
+if (gs[r.name] && !handled[r.name]) {
+handled[r.name] = true;
+r[type](ev);
+}
+}
+},
+handleTouchAction: function(ev) {
+var t = ev.changedTouches[0];
+var type = ev.type;
+if (type === "touchstart") {
+POINTERSTATE.touch.x = t.clientX;
+POINTERSTATE.touch.y = t.clientY;
+POINTERSTATE.touch.scrollDecided = false;
+} else if (type === "touchmove") {
+if (POINTERSTATE.touch.scrollDecided) {
+return;
+}
+POINTERSTATE.touch.scrollDecided = true;
+var ta = firstTouchAction(ev);
+var prevent = false;
+var dx = Math.abs(POINTERSTATE.touch.x - t.clientX);
+var dy = Math.abs(POINTERSTATE.touch.y - t.clientY);
+if (!ev.cancelable) {} else if (ta === "none") {
+prevent = true;
+} else if (ta === "pan-x") {
+prevent = dy > dx;
+} else if (ta === "pan-y") {
+prevent = dx > dy;
+}
+if (prevent) {
+ev.preventDefault();
+}
+}
+},
+add: function(node, evType, handler) {
+var recognizer = this.gestures[evType];
+var deps = recognizer.deps;
+var name = recognizer.name;
+var gobj = node[GESTURE_KEY];
+if (!gobj) {
+node[GESTURE_KEY] = gobj = {};
+}
+for (var i = 0, dep, gd; i < deps.length; i++) {
+dep = deps[i];
+gd = gobj[dep];
+if (!gd) {
+gobj[dep] = gd = {};
+node.addEventListener(dep, this.handleNative);
+}
+gd[name] = (gd[name] || 0) + 1;
+}
+node.addEventListener(evType, handler);
+if (recognizer.touchAction) {
+this.setTouchAction(node, recognizer.touchAction);
+}
+},
+register: function(recog) {
+this.recognizers.push(recog);
+for (var i = 0; i < recog.emits.length; i++) {
+this.gestures[recog.emits[i]] = recog;
+}
+},
+setTouchAction: function(node, value) {
+if (HAS_NATIVE_TA) {
+node.style.touchAction = value;
+}
+node[TOUCH_ACTION] = value;
+},
+fire: function(target, type, detail) {
+var ev = new CustomEvent(type, {
+detail: detail,
+bubbles: true,
+cancelable: true
+});
+target.dispatchEvent(ev);
+}
+};
+Gestures.register({
+name: "downup",
+deps: [ "mousedown", "touchstart", "touchend" ],
+emits: [ "down", "up" ],
+mousedown: function(e) {
+var t = e.currentTarget;
+var self = this;
+var upfn = function upfn(e) {
+self.fire("up", t, e);
+document.removeEventListener("mouseup", upfn);
+};
+document.addEventListener("mouseup", upfn);
+this.fire("down", t, e);
+},
+touchstart: function(e) {
+this.fire("down", e.currentTarget, e.changedTouches[0]);
+},
+touchend: function(e) {
+this.fire("up", e.currentTarget, e.changedTouches[0]);
+},
+fire: function(type, target, event) {
+Gestures.fire(target, type, {
+x: event.clientX,
+y: event.clientY,
+sourceEvent: event
+});
+}
+});
+Gestures.register({
+name: "track",
+touchAction: "none",
+deps: [ "mousedown", "touchstart", "touchmove", "touchend" ],
+emits: [ "track" ],
+info: {
+x: 0,
+y: 0,
+state: "start",
+started: false,
+moves: [],
+addMove: function(move) {
+if (this.moves.length > TRACK_LENGTH) {
+this.moves.shift();
+}
+this.moves.push(move);
+}
+},
+clearInfo: function() {
+this.info.state = "start";
+this.info.started = false;
+this.info.moves = [];
+this.info.x = 0;
+this.info.y = 0;
+},
+hasMovedEnough: function(x, y) {
+if (this.info.started) {
+return true;
+}
+var dx = Math.abs(this.info.x - x);
+var dy = Math.abs(this.info.y - y);
+return dx >= TRACK_DISTANCE || dy >= TRACK_DISTANCE;
+},
+mousedown: function(e) {
+var t = e.currentTarget;
+var self = this;
+var movefn = function movefn(e) {
+var x = e.clientX, y = e.clientY;
+if (self.hasMovedEnough(x, y)) {
+self.info.state = self.info.started ? e.type === "mouseup" ? "end" : "track" : "start";
+self.info.addMove({
+x: x,
+y: y
+});
+self.fire(t, e);
+e.preventDefault();
+self.info.started = true;
+}
+};
+var upfn = function upfn(e) {
+if (self.info.started) {
+POINTERSTATE.tapPrevented = true;
+movefn(e);
+}
+self.clearInfo();
+document.removeEventListener("mousemove", movefn);
+document.removeEventListener("mouseup", upfn);
+};
+document.addEventListener("mousemove", movefn);
+document.addEventListener("mouseup", upfn);
+this.info.x = e.clientX;
+this.info.y = e.clientY;
+},
+touchstart: function(e) {
+var ct = e.changedTouches[0];
+this.info.x = ct.clientX;
+this.info.y = ct.clientY;
+},
+touchmove: function(e) {
+var t = e.currentTarget;
+var ct = e.changedTouches[0];
+var x = ct.clientX, y = ct.clientY;
+if (this.hasMovedEnough(x, y)) {
+this.info.addMove({
+x: x,
+y: y
+});
+this.fire(t, ct);
+this.info.state = "track";
+this.info.started = true;
+}
+},
+touchend: function(e) {
+var t = e.currentTarget;
+var ct = e.changedTouches[0];
+if (this.info.started) {
+POINTERSTATE.tapPrevented = true;
+this.info.state = "end";
+this.info.addMove({
+x: ct.clientX,
+y: ct.clientY
+});
+this.fire(t, ct);
+}
+this.clearInfo();
+},
+fire: function(target, touch) {
+var secondlast = this.info.moves[this.info.moves.length - 2];
+var lastmove = this.info.moves[this.info.moves.length - 1];
+var dx = lastmove.x - this.info.x;
+var dy = lastmove.y - this.info.y;
+var ddx, ddy = 0;
+if (secondlast) {
+ddx = lastmove.x - secondlast.x;
+ddy = lastmove.y - secondlast.y;
+}
+return Gestures.fire(target, "track", {
+state: this.info.state,
+x: touch.clientX,
+y: touch.clientY,
+dx: dx,
+dy: dy,
+ddx: ddx,
+ddy: ddy,
+sourceEvent: touch,
+hover: function() {
+return Gestures.deepTargetFind(touch.clientX, touch.clientY);
+}
+});
+}
+});
+Gestures.register({
+name: "tap",
+deps: [ "mousedown", "click", "touchstart", "touchend" ],
+emits: [ "tap" ],
+start: {
+x: NaN,
+y: NaN
+},
+reset: function() {
+this.start.x = NaN;
+this.start.y = NaN;
+},
+save: function(e) {
+this.start.x = e.clientX;
+this.start.y = e.clientY;
+},
+mousedown: function(e) {
+POINTERSTATE.tapPrevented = false;
+this.save(e);
+},
+click: function(e) {
+this.forward(e);
+},
+touchstart: function(e) {
+POINTERSTATE.tapPrevented = false;
+this.save(e.changedTouches[0]);
+},
+touchend: function(e) {
+this.forward(e.changedTouches[0]);
+},
+forward: function(e) {
+var dx = Math.abs(e.clientX - this.start.x);
+var dy = Math.abs(e.clientY - this.start.y);
+if (isNaN(dx) || isNaN(dy) || dx <= TAP_DISTANCE && dy <= TAP_DISTANCE) {
+if (!POINTERSTATE.tapPrevented) {
+Gestures.fire(e.target, "tap", {
+x: e.clientX,
+y: e.clientY,
+sourceEvent: e
+});
+}
+}
+this.reset();
+}
+});
+var DIRECTION_MAP = {
+x: "pan-x",
+y: "pan-y",
+none: "none",
+all: "auto"
+};
+Polymer.Base._addFeature({
+_listen: function(node, eventName, handler) {
+if (Gestures.gestures[eventName]) {
+Gestures.add(node, eventName, handler);
+} else {
+node.addEventListener(eventName, handler);
+}
+},
+setScrollDirection: function(direction, node) {
+node = node || this;
+Gestures.setTouchAction(node, DIRECTION_MAP[direction] || "auto");
+}
+});
+Polymer.Gestures = Gestures;
+})();
+
+Polymer.Async = function() {
+var currVal = 0;
+var lastVal = 0;
+var callbacks = [];
+var twiddle = document.createTextNode("");
+function runAsync(callback, waitTime) {
+if (waitTime > 0) {
+return ~setTimeout(callback, waitTime);
+} else {
+twiddle.textContent = currVal++;
+callbacks.push(callback);
+return currVal - 1;
+}
+}
+function cancelAsync(handle) {
+if (handle < 0) {
+clearTimeout(~handle);
+} else {
+var idx = handle - lastVal;
+if (idx >= 0) {
+if (!callbacks[idx]) {
+throw "invalid async handle: " + handle;
+}
+callbacks[idx] = null;
+}
+}
+}
+function atEndOfMicrotask() {
+var len = callbacks.length;
+for (var i = 0; i < len; i++) {
+var cb = callbacks[i];
+if (cb) {
+cb();
+}
+}
+callbacks.splice(0, len);
+lastVal += len;
+}
+new (window.MutationObserver || JsMutationObserver)(atEndOfMicrotask).observe(twiddle, {
+characterData: true
+});
+return {
+run: runAsync,
+cancel: cancelAsync
+};
+}();
+
+Polymer.Debounce = function() {
+var Async = Polymer.Async;
+var Debouncer = function(context) {
+this.context = context;
+this.boundComplete = this.complete.bind(this);
+};
+Debouncer.prototype = {
+go: function(callback, wait) {
+var h;
+this.finish = function() {
+Async.cancel(h);
+};
+h = Async.run(this.boundComplete, wait);
+this.callback = callback;
+},
+stop: function() {
+if (this.finish) {
+this.finish();
+this.finish = null;
+}
+},
+complete: function() {
+if (this.finish) {
+this.stop();
+this.callback.call(this.context);
+}
+}
+};
+function debounce(debouncer, callback, wait) {
+if (debouncer) {
+debouncer.stop();
+} else {
+debouncer = new Debouncer(this);
+}
+debouncer.go(callback, wait);
+return debouncer;
+}
+return debounce;
+}();
+
+Polymer.Base._addFeature({
+$$: function(slctr) {
+return Polymer.dom(this.root).querySelector(slctr);
+},
+toggleClass: function(name, bool, node) {
+node = node || this;
+if (arguments.length == 1) {
+bool = !node.classList.contains(name);
+}
+if (bool) {
+Polymer.dom(node).classList.add(name);
+} else {
+Polymer.dom(node).classList.remove(name);
+}
+},
+toggleAttribute: function(name, bool, node) {
+node = node || this;
+if (arguments.length == 1) {
+bool = !node.hasAttribute(name);
+}
+if (bool) {
+Polymer.dom(node).setAttribute(name, "");
+} else {
+Polymer.dom(node).removeAttribute(name);
+}
+},
+classFollows: function(name, toElement, fromElement) {
+if (fromElement) {
+Polymer.dom(fromElement).classList.remove(name);
+}
+if (toElement) {
+Polymer.dom(toElement).classList.add(name);
+}
+},
+attributeFollows: function(name, toElement, fromElement) {
+if (fromElement) {
+Polymer.dom(fromElement).removeAttribute(name);
+}
+if (toElement) {
+Polymer.dom(toElement).setAttribute(name, "");
+}
+},
+getContentChildNodes: function(slctr) {
+return Polymer.dom(Polymer.dom(this.root).querySelector(slctr || "content")).getDistributedNodes();
+},
+getContentChildren: function(slctr) {
+return this.getContentChildNodes(slctr).filter(function(n) {
+return n.nodeType === Node.ELEMENT_NODE;
+});
+},
+fire: function(type, detail, options) {
+options = options || Polymer.nob;
+var node = options.node || this;
+var detail = detail === null || detail === undefined ? Polymer.nob : detail;
+var bubbles = options.bubbles === undefined ? true : options.bubbles;
+var event = new CustomEvent(type, {
+bubbles: Boolean(bubbles),
+cancelable: Boolean(options.cancelable),
+detail: detail
+});
+node.dispatchEvent(event);
+return event;
+},
+async: function(callback, waitTime) {
+return Polymer.Async.run(callback.bind(this), waitTime);
+},
+cancelAsync: function(handle) {
+Polymer.Async.cancel(handle);
+},
+arrayDelete: function(path, item) {
+var index;
+if (Array.isArray(path)) {
+index = path.indexOf(item);
+if (index >= 0) {
+return path.splice(index, 1);
+}
+} else {
+var arr = this.get(path);
+index = arr.indexOf(item);
+if (index >= 0) {
+return this.splice(path, index, 1);
+}
+}
+},
+transform: function(transform, node) {
+node = node || this;
+node.style.webkitTransform = transform;
+node.style.transform = transform;
+},
+translate3d: function(x, y, z, node) {
+node = node || this;
+this.transform("translate3d(" + x + "," + y + "," + z + ")", node);
+},
+importHref: function(href, onload, onerror) {
+var l = document.createElement("link");
+l.rel = "import";
+l.href = href;
+if (onload) {
+l.onload = onload.bind(this);
+}
+if (onerror) {
+l.onerror = onerror.bind(this);
+}
+document.head.appendChild(l);
+return l;
+},
+create: function(tag, props) {
+var elt = document.createElement(tag);
+if (props) {
+for (var n in props) {
+elt[n] = props[n];
+}
+}
+return elt;
+},
+mixin: function(target, source) {
+for (var i in source) {
+target[i] = source[i];
+}
+}
+});
+
+Polymer.Bind = {
+prepareModel: function(model) {
+model._propertyEffects = {};
+model._bindListeners = [];
+var api = this._modelApi;
+for (var n in api) {
+model[n] = api[n];
+}
+},
+_modelApi: {
+_notifyChange: function(property) {
+var eventName = Polymer.CaseMap.camelToDashCase(property) + "-changed";
+this.fire(eventName, {
+value: this[property]
+}, {
+bubbles: false
+});
+},
+_propertySet: function(property, value, effects) {
+var old = this.__data__[property];
+if (old !== value) {
+this.__data__[property] = value;
+if (typeof value == "object") {
+this._clearPath(property);
+}
+if (this._propertyChanged) {
+this._propertyChanged(property, value, old);
+}
+if (effects) {
+this._effectEffects(property, value, effects, old);
+}
+}
+return old;
+},
+_effectEffects: function(property, value, effects, old) {
+effects.forEach(function(fx) {
+var fn = Polymer.Bind["_" + fx.kind + "Effect"];
+if (fn) {
+fn.call(this, property, value, fx.effect, old);
+}
+}, this);
+},
+_clearPath: function(path) {
+for (var prop in this.__data__) {
+if (prop.indexOf(path + ".") === 0) {
+this.__data__[prop] = undefined;
+}
+}
+}
+},
+ensurePropertyEffects: function(model, property) {
+var fx = model._propertyEffects[property];
+if (!fx) {
+fx = model._propertyEffects[property] = [];
+}
+return fx;
+},
+addPropertyEffect: function(model, property, kind, effect) {
+var fx = this.ensurePropertyEffects(model, property);
+fx.push({
+kind: kind,
+effect: effect
+});
+},
+createBindings: function(model) {
+var fx$ = model._propertyEffects;
+if (fx$) {
+for (var n in fx$) {
+var fx = fx$[n];
+fx.sort(this._sortPropertyEffects);
+this._createAccessors(model, n, fx);
+}
+}
+},
+_sortPropertyEffects: function() {
+var EFFECT_ORDER = {
+compute: 0,
+annotation: 1,
+computedAnnotation: 2,
+reflect: 3,
+notify: 4,
+observer: 5,
+complexObserver: 6,
+"function": 7
+};
+return function(a, b) {
+return EFFECT_ORDER[a.kind] - EFFECT_ORDER[b.kind];
+};
+}(),
+_createAccessors: function(model, property, effects) {
+var defun = {
+get: function() {
+return this.__data__[property];
+}
+};
+var setter = function(value) {
+this._propertySet(property, value, effects);
+};
+if (model.getPropertyInfo && model.getPropertyInfo(property).readOnly) {
+model["_set" + this.upper(property)] = setter;
+} else {
+defun.set = setter;
+}
+Object.defineProperty(model, property, defun);
+},
+upper: function(name) {
+return name[0].toUpperCase() + name.substring(1);
+},
+_addAnnotatedListener: function(model, index, property, path, event) {
+var fn = this._notedListenerFactory(property, path, this._isStructured(path), this._isEventBogus);
+var eventName = event || Polymer.CaseMap.camelToDashCase(property) + "-changed";
+model._bindListeners.push({
+index: index,
+property: property,
+path: path,
+changedFn: fn,
+event: eventName
+});
+},
+_isStructured: function(path) {
+return path.indexOf(".") > 0;
+},
+_isEventBogus: function(e, target) {
+return e.path && e.path[0] !== target;
+},
+_notedListenerFactory: function(property, path, isStructured, bogusTest) {
+return function(e, target) {
+if (!bogusTest(e, target)) {
+if (e.detail && e.detail.path) {
+this.notifyPath(this._fixPath(path, property, e.detail.path), e.detail.value);
+} else {
+var value = target[property];
+if (!isStructured) {
+this[path] = target[property];
+} else {
+if (this.__data__[path] != value) {
+this.set(path, value);
+}
+}
+}
+}
+};
+},
+prepareInstance: function(inst) {
+inst.__data__ = Object.create(null);
+},
+setupBindListeners: function(inst) {
+inst._bindListeners.forEach(function(info) {
+var node = inst._nodes[info.index];
+node.addEventListener(info.event, inst._notifyListener.bind(inst, info.changedFn));
+});
+}
+};
+
+Polymer.Base.extend(Polymer.Bind, {
+_shouldAddListener: function(effect) {
+return effect.name && effect.mode === "{" && !effect.negate && effect.kind != "attribute";
+},
+_annotationEffect: function(source, value, effect) {
+if (source != effect.value) {
+value = this.get(effect.value);
+this.__data__[effect.value] = value;
+}
+var calc = effect.negate ? !value : value;
+if (!effect.customEvent || this._nodes[effect.index][effect.name] !== calc) {
+return this._applyEffectValue(calc, effect);
+}
+},
+_reflectEffect: function(source) {
+this.reflectPropertyToAttribute(source);
+},
+_notifyEffect: function(source) {
+this._notifyChange(source);
+},
+_functionEffect: function(source, value, fn, old) {
+fn.call(this, source, value, old);
+},
+_observerEffect: function(source, value, effect, old) {
+var fn = this[effect.method];
+if (fn) {
+fn.call(this, value, old);
+} else {
+this._warn(this._logf("_observerEffect", "observer method `" + effect.method + "` not defined"));
+}
+},
+_complexObserverEffect: function(source, value, effect) {
+var fn = this[effect.method];
+if (fn) {
+var args = Polymer.Bind._marshalArgs(this.__data__, effect, source, value);
+if (args) {
+fn.apply(this, args);
+}
+} else {
+this._warn(this._logf("_complexObserverEffect", "observer method `" + effect.method + "` not defined"));
+}
+},
+_computeEffect: function(source, value, effect) {
+var args = Polymer.Bind._marshalArgs(this.__data__, effect, source, value);
+if (args) {
+var fn = this[effect.method];
+if (fn) {
+this[effect.property] = fn.apply(this, args);
+} else {
+this._warn(this._logf("_computeEffect", "compute method `" + effect.method + "` not defined"));
+}
+}
+},
+_annotatedComputationEffect: function(source, value, effect) {
+var computedHost = this._rootDataHost || this;
+var fn = computedHost[effect.method];
+if (fn) {
+var args = Polymer.Bind._marshalArgs(this.__data__, effect, source, value);
+if (args) {
+var computedvalue = fn.apply(computedHost, args);
+if (effect.negate) {
+computedvalue = !computedvalue;
+}
+this._applyEffectValue(computedvalue, effect);
+}
+} else {
+computedHost._warn(computedHost._logf("_annotatedComputationEffect", "compute method `" + effect.method + "` not defined"));
+}
+},
+_marshalArgs: function(model, effect, path, value) {
+var values = [];
+var args = effect.args;
+for (var i = 0, l = args.length; i < l; i++) {
+var arg = args[i];
+var name = arg.name;
+if (arg.literal) {
+v = arg.value;
+} else if (arg.structured) {
+v = Polymer.Base.get(name, model);
+} else {
+v = model[name];
+}
+if (args.length > 1 && v === undefined) {
+return;
+}
+if (arg.wildcard) {
+var baseChanged = name.indexOf(path + ".") === 0;
+var matches = effect.trigger.name.indexOf(name) === 0 && !baseChanged;
+values[i] = {
+path: matches ? path : name,
+value: matches ? value : v,
+base: v
+};
+} else {
+values[i] = v;
+}
+}
+return values;
+}
+});
+
+Polymer.Base._addFeature({
+_addPropertyEffect: function(property, kind, effect) {
+Polymer.Bind.addPropertyEffect(this, property, kind, effect);
+},
+_prepEffects: function() {
+Polymer.Bind.prepareModel(this);
+this._addAnnotationEffects(this._notes);
+},
+_prepBindings: function() {
+Polymer.Bind.createBindings(this);
+},
+_addPropertyEffects: function(properties) {
+if (properties) {
+for (var p in properties) {
+var prop = properties[p];
+if (prop.observer) {
+this._addObserverEffect(p, prop.observer);
+}
+if (prop.computed) {
+this._addComputedEffect(p, prop.computed);
+}
+if (prop.notify) {
+this._addPropertyEffect(p, "notify");
+}
+if (prop.reflectToAttribute) {
+this._addPropertyEffect(p, "reflect");
+}
+if (prop.readOnly) {
+Polymer.Bind.ensurePropertyEffects(this, p);
+}
+}
+}
+},
+_addComputedEffect: function(name, expression) {
+var sig = this._parseMethod(expression);
+sig.args.forEach(function(arg) {
+this._addPropertyEffect(arg.model, "compute", {
+method: sig.method,
+args: sig.args,
+trigger: arg,
+property: name
+});
+}, this);
+},
+_addObserverEffect: function(property, observer) {
+this._addPropertyEffect(property, "observer", {
+method: observer,
+property: property
+});
+},
+_addComplexObserverEffects: function(observers) {
+if (observers) {
+observers.forEach(function(observer) {
+this._addComplexObserverEffect(observer);
+}, this);
+}
+},
+_addComplexObserverEffect: function(observer) {
+var sig = this._parseMethod(observer);
+sig.args.forEach(function(arg) {
+this._addPropertyEffect(arg.model, "complexObserver", {
+method: sig.method,
+args: sig.args,
+trigger: arg
+});
+}, this);
+},
+_addAnnotationEffects: function(notes) {
+this._nodes = [];
+notes.forEach(function(note) {
+var index = this._nodes.push(note) - 1;
+note.bindings.forEach(function(binding) {
+this._addAnnotationEffect(binding, index);
+}, this);
+}, this);
+},
+_addAnnotationEffect: function(note, index) {
+if (Polymer.Bind._shouldAddListener(note)) {
+Polymer.Bind._addAnnotatedListener(this, index, note.name, note.value, note.event);
+}
+if (note.signature) {
+this._addAnnotatedComputationEffect(note, index);
+} else {
+note.index = index;
+this._addPropertyEffect(note.model, "annotation", note);
+}
+},
+_addAnnotatedComputationEffect: function(note, index) {
+var sig = note.signature;
+if (sig.static) {
+this.__addAnnotatedComputationEffect("__static__", index, note, sig, null);
+} else {
+sig.args.forEach(function(arg) {
+if (!arg.literal) {
+this.__addAnnotatedComputationEffect(arg.model, index, note, sig, arg);
+}
+}, this);
+}
+},
+__addAnnotatedComputationEffect: function(property, index, note, sig, trigger) {
+this._addPropertyEffect(property, "annotatedComputation", {
+index: index,
+kind: note.kind,
+property: note.name,
+negate: note.negate,
+method: sig.method,
+args: sig.args,
+trigger: trigger
+});
+},
+_parseMethod: function(expression) {
+var m = expression.match(/(\w*)\((.*)\)/);
+if (m) {
+var sig = {
+method: m[1],
+"static": true
+};
+if (m[2].trim()) {
+var args = m[2].replace(/\\,/g, "&comma;").split(",");
+return this._parseArgs(args, sig);
+} else {
+sig.args = Polymer.nar;
+return sig;
+}
+}
+},
+_parseArgs: function(argList, sig) {
+sig.args = argList.map(function(rawArg) {
+var arg = this._parseArg(rawArg);
+if (!arg.literal) {
+sig.static = false;
+}
+return arg;
+}, this);
+return sig;
+},
+_parseArg: function(rawArg) {
+var arg = rawArg.trim().replace(/&comma;/g, ",").replace(/\\(.)/g, "$1");
+var a = {
+name: arg,
+model: this._modelForPath(arg)
+};
+var fc = arg[0];
+if (fc >= "0" && fc <= "9") {
+fc = "#";
+}
+switch (fc) {
+case "'":
+case '"':
+a.value = arg.slice(1, -1);
+a.literal = true;
+break;
+
+case "#":
+a.value = Number(arg);
+a.literal = true;
+break;
+}
+if (!a.literal) {
+a.structured = arg.indexOf(".") > 0;
+if (a.structured) {
+a.wildcard = arg.slice(-2) == ".*";
+if (a.wildcard) {
+a.name = arg.slice(0, -2);
+}
+}
+}
+return a;
+},
+_marshalInstanceEffects: function() {
+Polymer.Bind.prepareInstance(this);
+Polymer.Bind.setupBindListeners(this);
+},
+_applyEffectValue: function(value, info) {
+var node = this._nodes[info.index];
+var property = info.property || info.name || "textContent";
+if (info.kind == "attribute") {
+this.serializeValueToAttribute(value, property, node);
+} else {
+if (property === "className") {
+value = this._scopeElementClass(node, value);
+}
+if (property === "textContent" || node.localName == "input" && property == "value") {
+value = value == undefined ? "" : value;
+}
+return node[property] = value;
+}
+},
+_executeStaticEffects: function() {
+if (this._propertyEffects.__static__) {
+this._effectEffects("__static__", null, this._propertyEffects.__static__);
+}
+}
+});
+
+Polymer.Base._addFeature({
+_setupConfigure: function(initialConfig) {
+this._config = initialConfig || {};
+this._handlers = [];
+},
+_marshalAttributes: function() {
+this._takeAttributesToModel(this._config);
+},
+_configValue: function(name, value) {
+this._config[name] = value;
+},
+_beforeClientsReady: function() {
+this._configure();
+},
+_configure: function() {
+this._configureAnnotationReferences();
+var config = {};
+this.behaviors.forEach(function(b) {
+this._configureProperties(b.properties, config);
+}, this);
+this._configureProperties(this.properties, config);
+this._mixinConfigure(config, this._config);
+this._config = config;
+this._distributeConfig(this._config);
+},
+_configureProperties: function(properties, config) {
+for (var i in properties) {
+var c = properties[i];
+if (c.value !== undefined) {
+var value = c.value;
+if (typeof value == "function") {
+value = value.call(this, this._config);
+}
+config[i] = value;
+}
+}
+},
+_mixinConfigure: function(a, b) {
+for (var prop in b) {
+if (!this.getPropertyInfo(prop).readOnly) {
+a[prop] = b[prop];
+}
+}
+},
+_distributeConfig: function(config) {
+var fx$ = this._propertyEffects;
+if (fx$) {
+for (var p in config) {
+var fx = fx$[p];
+if (fx) {
+for (var i = 0, l = fx.length, x; i < l && (x = fx[i]); i++) {
+if (x.kind === "annotation") {
+var node = this._nodes[x.effect.index];
+if (node._configValue) {
+var value = p === x.effect.value ? config[p] : this.get(x.effect.value, config);
+node._configValue(x.effect.name, value);
+}
+}
+}
+}
+}
+}
+},
+_afterClientsReady: function() {
+this._executeStaticEffects();
+this._applyConfig(this._config);
+this._flushHandlers();
+},
+_applyConfig: function(config) {
+for (var n in config) {
+if (this[n] === undefined) {
+var effects = this._propertyEffects[n];
+if (effects) {
+this._propertySet(n, config[n], effects);
+} else {
+this[n] = config[n];
+}
+}
+}
+},
+_notifyListener: function(fn, e) {
+if (!this._clientsReadied) {
+this._queueHandler([ fn, e, e.target ]);
+} else {
+return fn.call(this, e, e.target);
+}
+},
+_queueHandler: function(args) {
+this._handlers.push(args);
+},
+_flushHandlers: function() {
+var h$ = this._handlers;
+for (var i = 0, l = h$.length, h; i < l && (h = h$[i]); i++) {
+h[0].call(this, h[1], h[2]);
+}
+}
+});
+
+(function() {
+"use strict";
+Polymer.Base._addFeature({
+notifyPath: function(path, value, fromAbove) {
+var old = this._propertySet(path, value);
+if (old !== value) {
+this._pathEffector(path, value);
+if (!fromAbove) {
+this._notifyPath(path, value);
+}
+}
+},
+_getPathParts: function(path) {
+if (Array.isArray(path)) {
+var parts = [];
+for (var i = 0; i < path.length; i++) {
+var args = path[i].toString().split(".");
+for (var j = 0; j < args.length; j++) {
+parts.push(args[j]);
+}
+}
+return parts;
+} else {
+return path.toString().split(".");
+}
+},
+set: function(path, value, root) {
+var prop = root || this;
+var parts = this._getPathParts(path);
+var array;
+var last = parts[parts.length - 1];
+if (parts.length > 1) {
+for (var i = 0; i < parts.length - 1; i++) {
+prop = prop[parts[i]];
+if (array) {
+parts[i] = Polymer.Collection.get(array).getKey(prop);
+}
+if (!prop) {
+return;
+}
+array = Array.isArray(prop) ? prop : null;
+}
+prop[last] = value;
+if (!root) {
+this.notifyPath(parts.join("."), value);
+}
+} else {
+prop[path] = value;
+}
+},
+get: function(path, root) {
+var prop = root || this;
+var parts = this._getPathParts(path);
+var last = parts.pop();
+while (parts.length) {
+prop = prop[parts.shift()];
+if (!prop) {
+return;
+}
+}
+return prop[last];
+},
+_pathEffector: function(path, value) {
+var model = this._modelForPath(path);
+var fx$ = this._propertyEffects[model];
+if (fx$) {
+fx$.forEach(function(fx) {
+var fxFn = this["_" + fx.kind + "PathEffect"];
+if (fxFn) {
+fxFn.call(this, path, value, fx.effect);
+}
+}, this);
+}
+if (this._boundPaths) {
+this._notifyBoundPaths(path, value);
+}
+},
+_annotationPathEffect: function(path, value, effect) {
+if (effect.value === path || effect.value.indexOf(path + ".") === 0) {
+Polymer.Bind._annotationEffect.call(this, path, value, effect);
+} else if (path.indexOf(effect.value + ".") === 0 && !effect.negate) {
+var node = this._nodes[effect.index];
+if (node && node.notifyPath) {
+var p = this._fixPath(effect.name, effect.value, path);
+node.notifyPath(p, value, true);
+}
+}
+},
+_complexObserverPathEffect: function(path, value, effect) {
+if (this._pathMatchesEffect(path, effect)) {
+Polymer.Bind._complexObserverEffect.call(this, path, value, effect);
+}
+},
+_computePathEffect: function(path, value, effect) {
+if (this._pathMatchesEffect(path, effect)) {
+Polymer.Bind._computeEffect.call(this, path, value, effect);
+}
+},
+_annotatedComputationPathEffect: function(path, value, effect) {
+if (this._pathMatchesEffect(path, effect)) {
+Polymer.Bind._annotatedComputationEffect.call(this, path, value, effect);
+}
+},
+_pathMatchesEffect: function(path, effect) {
+var effectArg = effect.trigger.name;
+return effectArg == path || effectArg.indexOf(path + ".") === 0 || effect.trigger.wildcard && path.indexOf(effectArg) === 0;
+},
+linkPaths: function(to, from) {
+this._boundPaths = this._boundPaths || {};
+if (from) {
+this._boundPaths[to] = from;
+} else {
+this.unbindPath(to);
+}
+},
+unlinkPaths: function(path) {
+if (this._boundPaths) {
+delete this._boundPaths[path];
+}
+},
+_notifyBoundPaths: function(path, value) {
+var from, to;
+for (var a in this._boundPaths) {
+var b = this._boundPaths[a];
+if (path.indexOf(a + ".") == 0) {
+from = a;
+to = b;
+break;
+}
+if (path.indexOf(b + ".") == 0) {
+from = b;
+to = a;
+break;
+}
+}
+if (from && to) {
+var p = this._fixPath(to, from, path);
+this.notifyPath(p, value);
+}
+},
+_fixPath: function(property, root, path) {
+return property + path.slice(root.length);
+},
+_notifyPath: function(path, value) {
+var rootName = this._modelForPath(path);
+var dashCaseName = Polymer.CaseMap.camelToDashCase(rootName);
+var eventName = dashCaseName + this._EVENT_CHANGED;
+this.fire(eventName, {
+path: path,
+value: value
+}, {
+bubbles: false
+});
+},
+_modelForPath: function(path) {
+var dot = path.indexOf(".");
+return dot < 0 ? path : path.slice(0, dot);
+},
+_EVENT_CHANGED: "-changed",
+_notifySplice: function(array, path, index, added, removed) {
+var splices = [ {
+index: index,
+addedCount: added,
+removed: removed,
+object: array,
+type: "splice"
+} ];
+var change = {
+keySplices: Polymer.Collection.get(array).applySplices(splices),
+indexSplices: splices
+};
+this.set(path + ".splices", change);
+if (added != removed.length) {
+this.notifyPath(path + ".length", array.length);
+}
+change.keySplices = null;
+change.indexSplices = null;
+},
+push: function(path) {
+var array = this.get(path);
+var args = Array.prototype.slice.call(arguments, 1);
+var len = array.length;
+var ret = array.push.apply(array, args);
+this._notifySplice(array, path, len, args.length, []);
+return ret;
+},
+pop: function(path) {
+var array = this.get(path);
+var args = Array.prototype.slice.call(arguments, 1);
+var rem = array.slice(-1);
+var ret = array.pop.apply(array, args);
+this._notifySplice(array, path, array.length, 0, rem);
+return ret;
+},
+splice: function(path, start, deleteCount) {
+var array = this.get(path);
+var args = Array.prototype.slice.call(arguments, 1);
+var rem = array.slice(start, start + deleteCount);
+var ret = array.splice.apply(array, args);
+this._notifySplice(array, path, start, args.length - 2, rem);
+return ret;
+},
+shift: function(path) {
+var array = this.get(path);
+var args = Array.prototype.slice.call(arguments, 1);
+var ret = array.shift.apply(array, args);
+this._notifySplice(array, path, 0, 0, [ ret ]);
+return ret;
+},
+unshift: function(path) {
+var array = this.get(path);
+var args = Array.prototype.slice.call(arguments, 1);
+var ret = array.unshift.apply(array, args);
+this._notifySplice(array, path, 0, args.length, []);
+return ret;
+}
+});
+})();
+
+Polymer.Base._addFeature({
+resolveUrl: function(url) {
+var module = Polymer.DomModule.import(this.is);
+var root = "";
+if (module) {
+var assetPath = module.getAttribute("assetpath") || "";
+root = Polymer.ResolveUrl.resolveUrl(assetPath, module.ownerDocument.baseURI);
+}
+return Polymer.ResolveUrl.resolveUrl(url, root);
+}
+});
+
+Polymer.CssParse = function() {
+var api = {
+parse: function(text) {
+text = this._clean(text);
+return this._parseCss(this._lex(text), text);
+},
+_clean: function(cssText) {
+return cssText.replace(rx.comments, "").replace(rx.port, "");
+},
+_lex: function(text) {
+var root = {
+start: 0,
+end: text.length
+};
+var n = root;
+for (var i = 0, s = 0, l = text.length; i < l; i++) {
+switch (text[i]) {
+case this.OPEN_BRACE:
+if (!n.rules) {
+n.rules = [];
+}
+var p = n;
+var previous = p.rules[p.rules.length - 1];
+n = {
+start: i + 1,
+parent: p,
+previous: previous
+};
+p.rules.push(n);
+break;
+
+case this.CLOSE_BRACE:
+n.end = i + 1;
+n = n.parent || root;
+break;
+}
+}
+return root;
+},
+_parseCss: function(node, text) {
+var t = text.substring(node.start, node.end - 1);
+node.parsedCssText = node.cssText = t.trim();
+if (node.parent) {
+var ss = node.previous ? node.previous.end : node.parent.start;
+t = text.substring(ss, node.start - 1);
+t = t.substring(t.lastIndexOf(";") + 1);
+var s = node.parsedSelector = node.selector = t.trim();
+node.atRule = s.indexOf(AT_START) === 0;
+if (node.atRule) {
+if (s.indexOf(MEDIA_START) === 0) {
+node.type = this.types.MEDIA_RULE;
+} else if (s.match(rx.keyframesRule)) {
+node.type = this.types.KEYFRAMES_RULE;
+}
+} else {
+if (s.indexOf(VAR_START) === 0) {
+node.type = this.types.MIXIN_RULE;
+} else {
+node.type = this.types.STYLE_RULE;
+}
+}
+}
+var r$ = node.rules;
+if (r$) {
+for (var i = 0, l = r$.length, r; i < l && (r = r$[i]); i++) {
+this._parseCss(r, text);
+}
+}
+return node;
+},
+stringify: function(node, preserveProperties, text) {
+text = text || "";
+var cssText = "";
+if (node.cssText || node.rules) {
+var r$ = node.rules;
+if (r$ && (preserveProperties || !hasMixinRules(r$))) {
+for (var i = 0, l = r$.length, r; i < l && (r = r$[i]); i++) {
+cssText = this.stringify(r, preserveProperties, cssText);
+}
+} else {
+cssText = preserveProperties ? node.cssText : removeCustomProps(node.cssText);
+cssText = cssText.trim();
+if (cssText) {
+cssText = "  " + cssText + "\n";
+}
+}
+}
+if (cssText) {
+if (node.selector) {
+text += node.selector + " " + this.OPEN_BRACE + "\n";
+}
+text += cssText;
+if (node.selector) {
+text += this.CLOSE_BRACE + "\n\n";
+}
+}
+return text;
+},
+types: {
+STYLE_RULE: 1,
+KEYFRAMES_RULE: 7,
+MEDIA_RULE: 4,
+MIXIN_RULE: 1e3
+},
+OPEN_BRACE: "{",
+CLOSE_BRACE: "}"
+};
+function hasMixinRules(rules) {
+return rules[0].selector.indexOf(VAR_START) >= 0;
+}
+function removeCustomProps(cssText) {
+return cssText.replace(rx.customProp, "").replace(rx.mixinProp, "").replace(rx.mixinApply, "").replace(rx.varApply, "");
+}
+var VAR_START = "--";
+var MEDIA_START = "@media";
+var AT_START = "@";
+var rx = {
+comments: /\/\*[^*]*\*+([^\/*][^*]*\*+)*\//gim,
+port: /@import[^;]*;/gim,
+customProp: /(?:^|[\s;])--[^;{]*?:[^{};]*?;/gim,
+mixinProp: /(?:^|[\s;])--[^;{]*?:[^{;]*?{[^}]*?};?/gim,
+mixinApply: /@apply[\s]*\([^)]*?\)[\s]*;/gim,
+varApply: /[^;:]*?:[^;]*var[^;]*;/gim,
+keyframesRule: /^@[^\s]*keyframes/
+};
+return api;
+}();
+
+Polymer.StyleUtil = function() {
+return {
+MODULE_STYLES_SELECTOR: "style, link[rel=import][type~=css]",
+toCssText: function(rules, callback, preserveProperties) {
+if (typeof rules === "string") {
+rules = this.parser.parse(rules);
+}
+if (callback) {
+this.forEachStyleRule(rules, callback);
+}
+return this.parser.stringify(rules, preserveProperties);
+},
+forRulesInStyles: function(styles, callback) {
+for (var i = 0, l = styles.length, s; i < l && (s = styles[i]); i++) {
+this.forEachStyleRule(this.rulesForStyle(s), callback);
+}
+},
+rulesForStyle: function(style) {
+if (!style.__cssRules) {
+style.__cssRules = this.parser.parse(style.textContent);
+}
+return style.__cssRules;
+},
+clearStyleRules: function(style) {
+style.__cssRules = null;
+},
+forEachStyleRule: function(node, callback) {
+var s = node.selector;
+var skipRules = false;
+if (node.type === this.ruleTypes.STYLE_RULE) {
+callback(node);
+} else if (node.type === this.ruleTypes.KEYFRAMES_RULE || node.type === this.ruleTypes.MIXIN_RULE) {
+skipRules = true;
+}
+var r$ = node.rules;
+if (r$ && !skipRules) {
+for (var i = 0, l = r$.length, r; i < l && (r = r$[i]); i++) {
+this.forEachStyleRule(r, callback);
+}
+}
+},
+applyCss: function(cssText, moniker, target, afterNode) {
+var style = document.createElement("style");
+if (moniker) {
+style.setAttribute("scope", moniker);
+}
+style.textContent = cssText;
+target = target || document.head;
+if (!afterNode) {
+var n$ = target.querySelectorAll("style[scope]");
+afterNode = n$[n$.length - 1];
+}
+target.insertBefore(style, afterNode && afterNode.nextSibling || target.firstChild);
+return style;
+},
+cssFromModule: function(moduleId) {
+var m = Polymer.DomModule.import(moduleId);
+if (m && !m._cssText) {
+var cssText = "";
+var e$ = Array.prototype.slice.call(m.querySelectorAll(this.MODULE_STYLES_SELECTOR));
+for (var i = 0, e; i < e$.length; i++) {
+e = e$[i];
+if (e.localName === "style") {
+e = e.__appliedElement || e;
+e.parentNode.removeChild(e);
+} else {
+e = e.import && e.import.body;
+}
+if (e) {
+cssText += Polymer.ResolveUrl.resolveCss(e.textContent, e.ownerDocument);
+}
+}
+m._cssText = cssText;
+}
+return m && m._cssText || "";
+},
+parser: Polymer.CssParse,
+ruleTypes: Polymer.CssParse.types
+};
+}();
+
+Polymer.StyleTransformer = function() {
+var nativeShadow = Polymer.Settings.useNativeShadow;
+var styleUtil = Polymer.StyleUtil;
+var api = {
+dom: function(node, scope, useAttr, shouldRemoveScope) {
+this._transformDom(node, scope || "", useAttr, shouldRemoveScope);
+},
+_transformDom: function(node, selector, useAttr, shouldRemoveScope) {
+if (node.setAttribute) {
+this.element(node, selector, useAttr, shouldRemoveScope);
+}
+var c$ = Polymer.dom(node).childNodes;
+for (var i = 0; i < c$.length; i++) {
+this._transformDom(c$[i], selector, useAttr, shouldRemoveScope);
+}
+},
+element: function(element, scope, useAttr, shouldRemoveScope) {
+if (useAttr) {
+if (shouldRemoveScope) {
+element.removeAttribute(SCOPE_NAME);
+} else {
+element.setAttribute(SCOPE_NAME, scope);
+}
+} else {
+if (scope) {
+if (element.classList) {
+if (shouldRemoveScope) {
+element.classList.remove(SCOPE_NAME);
+element.classList.remove(scope);
+} else {
+element.classList.add(SCOPE_NAME);
+element.classList.add(scope);
+}
+} else if (element.getAttribute) {
+var c = element.getAttribute(CLASS);
+if (shouldRemoveScope) {
+if (c) {
+element.setAttribute(CLASS, c.replace(SCOPE_NAME, "").replace(scope, ""));
+}
+} else {
+element.setAttribute(CLASS, c + (c ? " " : "") + SCOPE_NAME + " " + scope);
+}
+}
+}
+}
+},
+elementStyles: function(element, callback) {
+var styles = element._styles;
+var cssText = "";
+for (var i = 0, l = styles.length, s, text; i < l && (s = styles[i]); i++) {
+var rules = styleUtil.rulesForStyle(s);
+cssText += nativeShadow ? styleUtil.toCssText(rules, callback) : this.css(rules, element.is, element.extends, callback, element._scopeCssViaAttr) + "\n\n";
+}
+return cssText.trim();
+},
+css: function(rules, scope, ext, callback, useAttr) {
+var hostScope = this._calcHostScope(scope, ext);
+scope = this._calcElementScope(scope, useAttr);
+var self = this;
+return styleUtil.toCssText(rules, function(rule) {
+if (!rule.isScoped) {
+self.rule(rule, scope, hostScope);
+rule.isScoped = true;
+}
+if (callback) {
+callback(rule, scope, hostScope);
+}
+});
+},
+_calcElementScope: function(scope, useAttr) {
+if (scope) {
+return useAttr ? CSS_ATTR_PREFIX + scope + CSS_ATTR_SUFFIX : CSS_CLASS_PREFIX + scope;
+} else {
+return "";
+}
+},
+_calcHostScope: function(scope, ext) {
+return ext ? "[is=" + scope + "]" : scope;
+},
+rule: function(rule, scope, hostScope) {
+this._transformRule(rule, this._transformComplexSelector, scope, hostScope);
+},
+_transformRule: function(rule, transformer, scope, hostScope) {
+var p$ = rule.selector.split(COMPLEX_SELECTOR_SEP);
+for (var i = 0, l = p$.length, p; i < l && (p = p$[i]); i++) {
+p$[i] = transformer.call(this, p, scope, hostScope);
+}
+rule.selector = p$.join(COMPLEX_SELECTOR_SEP);
+},
+_transformComplexSelector: function(selector, scope, hostScope) {
+var stop = false;
+var self = this;
+selector = selector.replace(SIMPLE_SELECTOR_SEP, function(m, c, s) {
+if (!stop) {
+var o = self._transformCompoundSelector(s, c, scope, hostScope);
+if (o.stop) {
+stop = true;
+}
+c = o.combinator;
+s = o.value;
+}
+return c + s;
+});
+return selector;
+},
+_transformCompoundSelector: function(selector, combinator, scope, hostScope) {
+var jumpIndex = selector.search(SCOPE_JUMP);
+if (selector.indexOf(HOST) >= 0) {
+selector = selector.replace(HOST_PAREN, function(m, host, paren) {
+return hostScope + paren;
+});
+selector = selector.replace(HOST, hostScope);
+} else if (jumpIndex !== 0) {
+selector = scope ? this._transformSimpleSelector(selector, scope) : selector;
+}
+if (selector.indexOf(CONTENT) >= 0) {
+combinator = "";
+}
+var stop;
+if (jumpIndex >= 0) {
+selector = selector.replace(SCOPE_JUMP, " ");
+stop = true;
+}
+return {
+value: selector,
+combinator: combinator,
+stop: stop
+};
+},
+_transformSimpleSelector: function(selector, scope) {
+var p$ = selector.split(PSEUDO_PREFIX);
+p$[0] += scope;
+return p$.join(PSEUDO_PREFIX);
+},
+rootRule: function(rule) {
+this._transformRule(rule, this._transformRootSelector);
+},
+_transformRootSelector: function(selector) {
+return selector.match(SCOPE_JUMP) ? this._transformComplexSelector(selector) : selector.trim() + SCOPE_ROOT_SELECTOR;
+},
+SCOPE_NAME: "style-scope"
+};
+var SCOPE_NAME = api.SCOPE_NAME;
+var SCOPE_ROOT_SELECTOR = ":not([" + SCOPE_NAME + "])" + ":not(." + SCOPE_NAME + ")";
+var COMPLEX_SELECTOR_SEP = ",";
+var SIMPLE_SELECTOR_SEP = /(^|[\s>+~]+)([^\s>+~]+)/g;
+var HOST = ":host";
+var HOST_PAREN = /(\:host)(?:\(((?:\([^)(]*\)|[^)(]*)+?)\))/g;
+var CONTENT = "::content";
+var SCOPE_JUMP = /\:\:content|\:\:shadow|\/deep\//;
+var CSS_CLASS_PREFIX = ".";
+var CSS_ATTR_PREFIX = "[" + SCOPE_NAME + "~=";
+var CSS_ATTR_SUFFIX = "]";
+var PSEUDO_PREFIX = ":";
+var CLASS = "class";
+return api;
+}();
+
+Polymer.StyleExtends = function() {
+var styleUtil = Polymer.StyleUtil;
+return {
+hasExtends: function(cssText) {
+return Boolean(cssText.match(this.rx.EXTEND));
+},
+transform: function(style) {
+var rules = styleUtil.rulesForStyle(style);
+var self = this;
+styleUtil.forEachStyleRule(rules, function(rule) {
+var map = self._mapRule(rule);
+if (rule.parent) {
+var m;
+while (m = self.rx.EXTEND.exec(rule.cssText)) {
+var extend = m[1];
+var extendor = self._findExtendor(extend, rule);
+if (extendor) {
+self._extendRule(rule, extendor);
+}
+}
+}
+rule.cssText = rule.cssText.replace(self.rx.EXTEND, "");
+});
+return styleUtil.toCssText(rules, function(rule) {
+if (rule.selector.match(self.rx.STRIP)) {
+rule.cssText = "";
+}
+}, true);
+},
+_mapRule: function(rule) {
+if (rule.parent) {
+var map = rule.parent.map || (rule.parent.map = {});
+var parts = rule.selector.split(",");
+for (var i = 0, p; i < parts.length; i++) {
+p = parts[i];
+map[p.trim()] = rule;
+}
+return map;
+}
+},
+_findExtendor: function(extend, rule) {
+return rule.parent && rule.parent.map && rule.parent.map[extend] || this._findExtendor(extend, rule.parent);
+},
+_extendRule: function(target, source) {
+if (target.parent !== source.parent) {
+this._cloneAndAddRuleToParent(source, target.parent);
+}
+target.extends = target.extends || (target.extends = []);
+target.extends.push(source);
+source.selector = source.selector.replace(this.rx.STRIP, "");
+source.selector = (source.selector && source.selector + ",\n") + target.selector;
+if (source.extends) {
+source.extends.forEach(function(e) {
+this._extendRule(target, e);
+}, this);
+}
+},
+_cloneAndAddRuleToParent: function(rule, parent) {
+rule = Object.create(rule);
+rule.parent = parent;
+if (rule.extends) {
+rule.extends = rule.extends.slice();
+}
+parent.rules.push(rule);
+},
+rx: {
+EXTEND: /@extends\(([^)]*)\)\s*?;/gim,
+STRIP: /%[^,]*$/
+}
+};
+}();
+
+(function() {
+var prepElement = Polymer.Base._prepElement;
+var nativeShadow = Polymer.Settings.useNativeShadow;
+var styleUtil = Polymer.StyleUtil;
+var styleTransformer = Polymer.StyleTransformer;
+var styleExtends = Polymer.StyleExtends;
+Polymer.Base._addFeature({
+_prepElement: function(element) {
+if (this._encapsulateStyle) {
+styleTransformer.element(element, this.is, this._scopeCssViaAttr);
+}
+prepElement.call(this, element);
+},
+_prepStyles: function() {
+if (this._encapsulateStyle === undefined) {
+this._encapsulateStyle = !nativeShadow && Boolean(this._template);
+}
+this._styles = this._collectStyles();
+var cssText = styleTransformer.elementStyles(this);
+if (cssText && this._template) {
+var style = styleUtil.applyCss(cssText, this.is, nativeShadow ? this._template.content : null);
+if (!nativeShadow) {
+this._scopeStyle = style;
+}
+}
+},
+_collectStyles: function() {
+var styles = [];
+var cssText = "", m$ = this.styleModules;
+if (m$) {
+for (var i = 0, l = m$.length, m; i < l && (m = m$[i]); i++) {
+cssText += styleUtil.cssFromModule(m);
+}
+}
+cssText += styleUtil.cssFromModule(this.is);
+if (cssText) {
+var style = document.createElement("style");
+style.textContent = cssText;
+if (styleExtends.hasExtends(style.textContent)) {
+cssText = styleExtends.transform(style);
+}
+styles.push(style);
+}
+return styles;
+},
+_elementAdd: function(node) {
+if (this._encapsulateStyle && !node.__styleScoped) {
+styleTransformer.dom(node, this.is, this._scopeCssViaAttr);
+}
+},
+_elementRemove: function(node) {
+if (this._encapsulateStyle) {
+styleTransformer.dom(node, this.is, this._scopeCssViaAttr, true);
+}
+},
+scopeSubtree: function(container, shouldObserve) {
+if (nativeShadow) {
+return;
+}
+var self = this;
+var scopify = function(node) {
+if (node.nodeType === Node.ELEMENT_NODE) {
+node.className = self._scopeElementClass(node, node.className);
+var n$ = node.querySelectorAll("*");
+Array.prototype.forEach.call(n$, function(n) {
+n.className = self._scopeElementClass(n, n.className);
+});
+}
+};
+scopify(container);
+if (shouldObserve) {
+var mo = new MutationObserver(function(mxns) {
+mxns.forEach(function(m) {
+if (m.addedNodes) {
+for (var i = 0; i < m.addedNodes.length; i++) {
+scopify(m.addedNodes[i]);
+}
+}
+});
+});
+mo.observe(container, {
+childList: true,
+subtree: true
+});
+return mo;
+}
+}
+});
+})();
+
+Polymer.StyleProperties = function() {
+var nativeShadow = Polymer.Settings.useNativeShadow;
+var matchesSelector = Polymer.DomApi.matchesSelector;
+var styleUtil = Polymer.StyleUtil;
+var styleTransformer = Polymer.StyleTransformer;
+return {
+decorateStyles: function(styles) {
+var self = this, props = {};
+styleUtil.forRulesInStyles(styles, function(rule) {
+self.decorateRule(rule);
+self.collectPropertiesInCssText(rule.propertyInfo.cssText, props);
+});
+var names = [];
+for (var i in props) {
+names.push(i);
+}
+return names;
+},
+decorateRule: function(rule) {
+if (rule.propertyInfo) {
+return rule.propertyInfo;
+}
+var info = {}, properties = {};
+var hasProperties = this.collectProperties(rule, properties);
+if (hasProperties) {
+info.properties = properties;
+rule.rules = null;
+}
+info.cssText = this.collectCssText(rule);
+rule.propertyInfo = info;
+return info;
+},
+collectProperties: function(rule, properties) {
+var info = rule.propertyInfo;
+if (info) {
+if (info.properties) {
+Polymer.Base.mixin(properties, info.properties);
+return true;
+}
+} else {
+var m, rx = this.rx.VAR_ASSIGN;
+var cssText = rule.parsedCssText;
+var any;
+while (m = rx.exec(cssText)) {
+properties[m[1]] = (m[2] || m[3]).trim();
+any = true;
+}
+return any;
+}
+},
+collectCssText: function(rule) {
+var customCssText = "";
+var cssText = rule.parsedCssText;
+cssText = cssText.replace(this.rx.BRACKETED, "").replace(this.rx.VAR_ASSIGN, "");
+var parts = cssText.split(";");
+for (var i = 0, p; i < parts.length; i++) {
+p = parts[i];
+if (p.match(this.rx.MIXIN_MATCH) || p.match(this.rx.VAR_MATCH)) {
+customCssText += p + ";\n";
+}
+}
+return customCssText;
+},
+collectPropertiesInCssText: function(cssText, props) {
+var m;
+while (m = this.rx.VAR_CAPTURE.exec(cssText)) {
+props[m[1]] = true;
+}
+},
+reify: function(props) {
+var names = Object.getOwnPropertyNames(props);
+for (var i = 0, n; i < names.length; i++) {
+n = names[i];
+props[n] = this.valueForProperty(props[n], props);
+}
+},
+valueForProperty: function(property, props) {
+if (property) {
+if (property.indexOf(";") >= 0) {
+property = this.valueForProperties(property, props);
+} else {
+var self = this;
+var fn = function(all, prefix, value, fallback) {
+var propertyValue = self.valueForProperty(props[value], props) || (props[fallback] ? self.valueForProperty(props[fallback], props) : fallback);
+return prefix + (propertyValue || "");
+};
+property = property.replace(this.rx.VAR_MATCH, fn);
+}
+}
+return property && property.trim() || "";
+},
+valueForProperties: function(property, props) {
+var parts = property.split(";");
+for (var i = 0, p, m; i < parts.length && (p = parts[i]); i++) {
+m = p.match(this.rx.MIXIN_MATCH);
+if (m) {
+p = this.valueForProperty(props[m[1]], props);
+} else {
+var pp = p.split(":");
+if (pp[1]) {
+pp[1] = pp[1].trim();
+pp[1] = this.valueForProperty(pp[1], props) || pp[1];
+}
+p = pp.join(":");
+}
+parts[i] = p && p.lastIndexOf(";") === p.length - 1 ? p.slice(0, -1) : p || "";
+}
+return parts.join(";");
+},
+applyProperties: function(rule, props) {
+var output = "";
+if (!rule.properties) {
+this.decorateRule(rule);
+}
+if (rule.propertyInfo.cssText) {
+output = this.valueForProperties(rule.propertyInfo.cssText, props);
+}
+rule.cssText = output;
+},
+propertyDataFromStyles: function(styles, element) {
+var props = {}, self = this;
+var o = [], i = 0;
+styleUtil.forRulesInStyles(styles, function(rule) {
+if (!rule.propertyInfo) {
+self.decorateRule(rule);
+}
+if (element && rule.propertyInfo.properties && matchesSelector.call(element, rule.selector)) {
+self.collectProperties(rule, props);
+addToBitMask(i, o);
+}
+i++;
+});
+return {
+properties: props,
+key: o
+};
+},
+scopePropertiesFromStyles: function(styles) {
+if (!styles._scopeStyleProperties) {
+styles._scopeStyleProperties = this.selectedPropertiesFromStyles(styles, this.SCOPE_SELECTORS);
+}
+return styles._scopeStyleProperties;
+},
+hostPropertiesFromStyles: function(styles) {
+if (!styles._hostStyleProperties) {
+styles._hostStyleProperties = this.selectedPropertiesFromStyles(styles, this.HOST_SELECTORS);
+}
+return styles._hostStyleProperties;
+},
+selectedPropertiesFromStyles: function(styles, selectors) {
+var props = {}, self = this;
+styleUtil.forRulesInStyles(styles, function(rule) {
+if (!rule.propertyInfo) {
+self.decorateRule(rule);
+}
+for (var i = 0; i < selectors.length; i++) {
+if (rule.parsedSelector === selectors[i]) {
+self.collectProperties(rule, props);
+return;
+}
+}
+});
+return props;
+},
+transformStyles: function(element, properties, scopeSelector) {
+var self = this;
+var hostRx = new RegExp(this.rx.HOST_PREFIX + element.is + this.rx.HOST_SUFFIX);
+return styleTransformer.elementStyles(element, function(rule) {
+self.applyProperties(rule, properties);
+if (rule.cssText && !nativeShadow) {
+self._scopeSelector(rule, hostRx, element.is, element._scopeCssViaAttr, scopeSelector);
+}
+});
+},
+_scopeSelector: function(rule, hostRx, is, viaAttr, scopeId) {
+rule.transformedSelector = rule.transformedSelector || rule.selector;
+var selector = rule.transformedSelector;
+var scope = viaAttr ? "[" + styleTransformer.SCOPE_NAME + "~=" + scopeId + "]" : "." + scopeId;
+var parts = selector.split(",");
+for (var i = 0, l = parts.length, p; i < l && (p = parts[i]); i++) {
+parts[i] = p.match(hostRx) ? p.replace(is, is + scope) : scope + " " + p;
+}
+rule.selector = parts.join(",");
+},
+applyElementScopeSelector: function(element, selector, old, viaAttr) {
+var c = viaAttr ? element.getAttribute(styleTransformer.SCOPE_NAME) : element.className;
+v = old ? c.replace(old, selector) : (c ? c + " " : "") + this.XSCOPE_NAME + " " + selector;
+if (c !== v) {
+if (viaAttr) {
+element.setAttribute(styleTransformer.SCOPE_NAME, v);
+} else {
+element.className = v;
+}
+}
+},
+applyElementStyle: function(element, properties, selector, style) {
+var cssText = style ? style.textContent || "" : this.transformStyles(element, properties, selector);
+var s = element._customStyle;
+if (s && !nativeShadow && s !== style) {
+s._useCount--;
+if (s._useCount <= 0) {
+s.parentNode.removeChild(s);
+}
+}
+if (nativeShadow || (!style || !style.parentNode)) {
+if (nativeShadow && element._customStyle) {
+element._customStyle.textContent = cssText;
+style = element._customStyle;
+} else if (cssText) {
+style = styleUtil.applyCss(cssText, selector, nativeShadow ? element.root : null, element._scopeStyle);
+}
+}
+if (style) {
+style._useCount = style._useCount || 0;
+if (element._customStyle != style) {
+style._useCount++;
+}
+element._customStyle = style;
+}
+return style;
+},
+rx: {
+VAR_ASSIGN: /(?:^|;\s*)(--[^\:;]*?):\s*?(?:([^;{]*?)|{([^}]*)})(?=;)/gim,
+MIXIN_MATCH: /(?:^|\W+)@apply[\s]*\(([^)]*)\);?/im,
+VAR_MATCH: /(^|\W+)var\([\s]*([^,)]*)[\s]*,?[\s]*((?:[^,)]*)|(?:[^;]*\([^;)]*\)))[\s]*?\)/gim,
+VAR_CAPTURE: /\([\s]*(--[^,\s)]*)(?:,[\s]*(--[^,\s)]*))?(?:\)|,)/gim,
+BRACKETED: /\{[^}]*\}/g,
+HOST_PREFIX: "(?:^|[^.])",
+HOST_SUFFIX: "($|[.:[\\s>+~])"
+},
+HOST_SELECTORS: [ ":host" ],
+SCOPE_SELECTORS: [ ":root" ],
+XSCOPE_NAME: "x-scope"
+};
+function addToBitMask(n, bits) {
+var o = parseInt(n / 32);
+var v = 1 << n % 32;
+bits[o] = (bits[o] || 0) | v;
+}
+}();
+
+Polymer.StyleDefaults = function() {
+var styleProperties = Polymer.StyleProperties;
+var styleUtil = Polymer.StyleUtil;
+var style = document.createElement("style");
+var api = {
+style: style,
+_styles: [ style ],
+_properties: null,
+applyCss: function(cssText) {
+this.style.textContent += cssText;
+styleUtil.clearStyleRules(this.style);
+this._properties = null;
+},
+get _styleProperties() {
+if (!this._properties) {
+styleProperties.decorateStyles(this._styles);
+this._styles._scopeStyleProperties = null;
+this._properties = styleProperties.scopePropertiesFromStyles(this._styles);
+}
+return this._properties;
+},
+_needsStyleProperties: function() {},
+_computeStyleProperties: function() {
+return this._styleProperties;
+}
+};
+return api;
+}();
+
+(function() {
+Polymer.StyleCache = function() {
+this.cache = {};
+};
+Polymer.StyleCache.prototype = {
+MAX: 100,
+store: function(is, data, keyValues, keyStyles) {
+data.keyValues = keyValues;
+data.styles = keyStyles;
+var s$ = this.cache[is] = this.cache[is] || [];
+s$.push(data);
+if (s$.length > this.MAX) {
+s$.shift();
+}
+},
+retrieve: function(is, keyValues, keyStyles) {
+var cache = this.cache[is];
+if (cache) {
+for (var i = cache.length - 1, data; i >= 0; i--) {
+data = cache[i];
+if (keyStyles === data.styles && this._objectsEqual(keyValues, data.keyValues)) {
+return data;
+}
+}
+}
+},
+clear: function() {
+this.cache = {};
+},
+_objectsEqual: function(target, source) {
+for (var i in target) {
+if (target[i] !== source[i]) {
+return false;
+}
+}
+if (Array.isArray(target)) {
+return target.length === source.length;
+}
+return true;
+}
+};
+})();
+
+(function() {
+var serializeValueToAttribute = Polymer.Base.serializeValueToAttribute;
+var propertyUtils = Polymer.StyleProperties;
+var styleTransformer = Polymer.StyleTransformer;
+var styleUtil = Polymer.StyleUtil;
+var styleDefaults = Polymer.StyleDefaults;
+var nativeShadow = Polymer.Settings.useNativeShadow;
+Polymer.Base._addFeature({
+_prepStyleProperties: function() {
+this._ownStylePropertyNames = this._styles ? propertyUtils.decorateStyles(this._styles) : [];
+},
+_setupStyleProperties: function() {
+this.customStyle = {};
+},
+_needsStyleProperties: function() {
+return Boolean(this._ownStylePropertyNames && this._ownStylePropertyNames.length);
+},
+_beforeAttached: function() {
+if (!this._scopeSelector && this._needsStyleProperties()) {
+this._updateStyleProperties();
+}
+},
+_updateStyleProperties: function() {
+var info, scope = this.domHost || styleDefaults;
+if (!scope._styleCache) {
+scope._styleCache = new Polymer.StyleCache();
+}
+var scopeData = propertyUtils.propertyDataFromStyles(scope._styles, this);
+info = scope._styleCache.retrieve(this.is, scopeData.key, this._styles);
+var scopeCached = Boolean(info);
+if (scopeCached) {
+this._styleProperties = info._styleProperties;
+} else {
+this._computeStyleProperties(scopeData.properties);
+}
+this._computeOwnStyleProperties();
+if (!scopeCached) {
+info = styleCache.retrieve(this.is, this._ownStyleProperties, this._styles);
+}
+var globalCached = Boolean(info) && !scopeCached;
+style = this._applyStyleProperties(info);
+if (!scopeCached) {
+var cacheableStyle = style;
+if (nativeShadow) {
+cacheableStyle = style.cloneNode ? style.cloneNode(true) : Object.create(style || null);
+}
+info = {
+style: cacheableStyle,
+_scopeSelector: this._scopeSelector,
+_styleProperties: this._styleProperties
+};
+scope._styleCache.store(this.is, info, scopeData.key, this._styles);
+if (!globalCached) {
+styleCache.store(this.is, Object.create(info), this._ownStyleProperties, this._styles);
+}
+}
+},
+_computeStyleProperties: function(scopeProps) {
+var scope = this.domHost || styleDefaults;
+if (!scope._styleProperties) {
+scope._computeStyleProperties();
+}
+var props = Object.create(scope._styleProperties);
+this.mixin(props, propertyUtils.hostPropertiesFromStyles(this._styles));
+scopeProps = scopeProps || propertyUtils.propertyDataFromStyles(scope._styles, this).properties;
+this.mixin(props, scopeProps);
+this.mixin(props, propertyUtils.scopePropertiesFromStyles(this._styles));
+this.mixin(props, this.customStyle);
+propertyUtils.reify(props);
+this._styleProperties = props;
+},
+_computeOwnStyleProperties: function() {
+var props = {};
+for (var i = 0, n; i < this._ownStylePropertyNames.length; i++) {
+n = this._ownStylePropertyNames[i];
+props[n] = this._styleProperties[n];
+}
+this._ownStyleProperties = props;
+},
+_scopeCount: 0,
+_applyStyleProperties: function(info) {
+var oldScopeSelector = this._scopeSelector;
+this._scopeSelector = info ? info._scopeSelector : this.is + "-" + this.__proto__._scopeCount++;
+style = propertyUtils.applyElementStyle(this, this._styleProperties, this._scopeSelector, info && info.style);
+if ((style || oldScopeSelector) && !nativeShadow) {
+propertyUtils.applyElementScopeSelector(this, this._scopeSelector, oldScopeSelector, this._scopeCssViaAttr);
+}
+return style || {};
+},
+serializeValueToAttribute: function(value, attribute, node) {
+node = node || this;
+if (attribute === "class") {
+var host = node === this ? this.domHost || this.dataHost : this;
+if (host) {
+value = host._scopeElementClass(node, value);
+}
+}
+node = Polymer.dom(node);
+serializeValueToAttribute.call(this, value, attribute, node);
+},
+_scopeElementClass: function(element, selector) {
+if (!nativeShadow && !this._scopeCssViaAttr) {
+selector += (selector ? " " : "") + SCOPE_NAME + " " + this.is + (element._scopeSelector ? " " + XSCOPE_NAME + " " + element._scopeSelector : "");
+}
+return selector;
+},
+updateStyles: function() {
+if (this.isAttached) {
+if (this._needsStyleProperties()) {
+this._updateStyleProperties();
+} else {
+this._styleProperties = null;
+}
+if (this._styleCache) {
+this._styleCache.clear();
+}
+this._updateRootStyles();
+}
+},
+_updateRootStyles: function(root) {
+root = root || this.root;
+var c$ = Polymer.dom(root)._query(function(e) {
+return e.shadyRoot || e.shadowRoot;
+});
+for (var i = 0, l = c$.length, c; i < l && (c = c$[i]); i++) {
+if (c.updateStyles) {
+c.updateStyles();
+}
+}
+}
+});
+Polymer.updateStyles = function() {
+styleDefaults._styleCache.clear();
+Polymer.Base._updateRootStyles(document);
+};
+var styleCache = new Polymer.StyleCache();
+Polymer.customStyleCache = styleCache;
+var SCOPE_NAME = styleTransformer.SCOPE_NAME;
+var XSCOPE_NAME = propertyUtils.XSCOPE_NAME;
+})();
+
+Polymer.Base._addFeature({
+_registerFeatures: function() {
+this._prepIs();
+this._prepAttributes();
+this._prepExtends();
+this._prepConstructor();
+this._prepTemplate();
+this._prepStyles();
+this._prepStyleProperties();
+this._prepAnnotations();
+this._prepEffects();
+this._prepBehaviors();
+this._prepBindings();
+this._prepShady();
+},
+_prepBehavior: function(b) {
+this._addPropertyEffects(b.properties);
+this._addComplexObserverEffects(b.observers);
+this._addHostAttributes(b.hostAttributes);
+},
+_initFeatures: function() {
+this._poolContent();
+this._setupConfigure();
+this._setupStyleProperties();
+this._pushHost();
+this._stampTemplate();
+this._popHost();
+this._marshalAnnotationReferences();
+this._marshalHostAttributes();
+this._setupDebouncers();
+this._marshalInstanceEffects();
+this._marshalBehaviors();
+this._marshalAttributes();
+this._tryReady();
+},
+_marshalBehavior: function(b) {
+this._listenListeners(b.listeners);
+}
+});
+
+(function() {
+var nativeShadow = Polymer.Settings.useNativeShadow;
+var propertyUtils = Polymer.StyleProperties;
+var styleUtil = Polymer.StyleUtil;
+var styleDefaults = Polymer.StyleDefaults;
+Polymer({
+is: "custom-style",
+"extends": "style",
+created: function() {
+this._appliesToDocument = this.parentNode.localName !== "dom-module";
+if (this._appliesToDocument) {
+var e = this.__appliedElement || this;
+var rules = styleUtil.rulesForStyle(e);
+propertyUtils.decorateStyles([ e ]);
+this._rulesToDefaultProperties(rules);
+this.async(this._applyStyle);
+}
+},
+_applyStyle: function() {
+var e = this.__appliedElement || this;
+this._computeStyleProperties();
+var props = this._styleProperties;
+var self = this;
+e.textContent = styleUtil.toCssText(styleUtil.rulesForStyle(e), function(rule) {
+if (rule.selector === ":root") {
+rule.selector = "body";
+}
+var css = rule.cssText = rule.parsedCssText;
+if (rule.propertyInfo.cssText) {
+css = css.replace(propertyUtils.rx.VAR_ASSIGN, "");
+rule.cssText = propertyUtils.valueForProperties(css, props);
+}
+if (!nativeShadow) {
+Polymer.StyleTransformer.rootRule(rule);
+}
+});
+},
+_rulesToDefaultProperties: function(rules) {
+styleUtil.forEachStyleRule(rules, function(rule) {
+if (!rule.propertyInfo.properties) {
+rule.cssText = "";
+}
+});
+var cssText = styleUtil.parser.stringify(rules, true);
+if (cssText) {
+styleDefaults.applyCss(cssText);
+}
+}
+});
+})();
+
+Polymer.Templatizer = {
+properties: {
+_hideTemplateChildren: {
+observer: "_hideTemplateChildrenChanged"
+}
+},
+_templatizerStatic: {
+count: 0,
+callbacks: {},
+debouncer: null
+},
+_instanceProps: Polymer.nob,
+created: function() {
+this._templatizerId = this._templatizerStatic.count++;
+},
+templatize: function(template) {
+if (!template._content) {
+template._content = template.content;
+}
+if (template._content._ctor) {
+this.ctor = template._content._ctor;
+this._prepParentProperties(this.ctor.prototype, template);
+return;
+}
+var archetype = Object.create(Polymer.Base);
+this._customPrepAnnotations(archetype, template);
+archetype._prepEffects();
+this._customPrepEffects(archetype);
+archetype._prepBehaviors();
+archetype._prepBindings();
+this._prepParentProperties(archetype, template);
+archetype._notifyPath = this._notifyPathImpl;
+archetype._scopeElementClass = this._scopeElementClassImpl;
+archetype.listen = this._listenImpl;
+var _constructor = this._constructorImpl;
+var ctor = function TemplateInstance(model, host) {
+_constructor.call(this, model, host);
+};
+ctor.prototype = archetype;
+archetype.constructor = ctor;
+template._content._ctor = ctor;
+this.ctor = ctor;
+},
+_getRootDataHost: function() {
+return this.dataHost && this.dataHost._rootDataHost || this.dataHost;
+},
+_hideTemplateChildrenChanged: function(hidden) {
+if (this._hideChildren) {
+this._hideChildren(hidden);
+}
+},
+_debounceTemplate: function(fn) {
+this._templatizerStatic.callbacks[this._templatizerId] = fn.bind(this);
+this._templatizerStatic.debouncer = Polymer.Debounce(this._templatizerStatic.debouncer, this._flushTemplates.bind(this, true));
+},
+_flushTemplates: function(debouncerExpired) {
+var db = this._templatizerStatic.debouncer;
+while (debouncerExpired || db && db.finish) {
+db.stop();
+var cbs = this._templatizerStatic.callbacks;
+this._templatizerStatic.callbacks = {};
+for (var id in cbs) {
+cbs[id]();
+}
+debouncerExpired = false;
+}
+},
+_customPrepEffects: function(archetype) {
+var parentProps = archetype._parentProps;
+for (var prop in parentProps) {
+archetype._addPropertyEffect(prop, "function", this._createHostPropEffector(prop));
+}
+},
+_customPrepAnnotations: function(archetype, template) {
+archetype._template = template;
+var c = template._content;
+if (!c._notes) {
+var rootDataHost = archetype._rootDataHost;
+if (rootDataHost) {
+Polymer.Annotations.prepElement = rootDataHost._prepElement.bind(rootDataHost);
+}
+c._notes = Polymer.Annotations.parseAnnotations(template);
+Polymer.Annotations.prepElement = null;
+this._processAnnotations(c._notes);
+}
+archetype._notes = c._notes;
+archetype._parentProps = c._parentProps;
+},
+_prepParentProperties: function(archetype, template) {
+var parentProps = this._parentProps = archetype._parentProps;
+if (this._forwardParentProp && parentProps) {
+var proto = archetype._parentPropProto;
+var prop;
+if (!proto) {
+for (prop in this._instanceProps) {
+delete parentProps[prop];
+}
+proto = archetype._parentPropProto = Object.create(null);
+if (template != this) {
+Polymer.Bind.prepareModel(proto);
+}
+for (prop in parentProps) {
+var parentProp = "_parent_" + prop;
+var effects = [ {
+kind: "function",
+effect: this._createForwardPropEffector(prop)
+}, {
+kind: "notify"
+} ];
+Polymer.Bind._createAccessors(proto, parentProp, effects);
+}
+}
+if (template != this) {
+Polymer.Bind.prepareInstance(template);
+template._forwardParentProp = this._forwardParentProp.bind(this);
+}
+this._extendTemplate(template, proto);
+}
+},
+_createForwardPropEffector: function(prop) {
+return function(source, value) {
+this._forwardParentProp(prop, value);
+};
+},
+_createHostPropEffector: function(prop) {
+return function(source, value) {
+this.dataHost["_parent_" + prop] = value;
+};
+},
+_extendTemplate: function(template, proto) {
+Object.getOwnPropertyNames(proto).forEach(function(n) {
+var val = template[n];
+var pd = Object.getOwnPropertyDescriptor(proto, n);
+Object.defineProperty(template, n, pd);
+if (val !== undefined) {
+template._propertySet(n, val);
+}
+});
+},
+_forwardInstancePath: function(inst, path, value) {},
+_notifyPathImpl: function(path, value) {
+var dataHost = this.dataHost;
+var dot = path.indexOf(".");
+var root = dot < 0 ? path : path.slice(0, dot);
+dataHost._forwardInstancePath.call(dataHost, this, path, value);
+if (root in dataHost._parentProps) {
+dataHost.notifyPath("_parent_" + path, value);
+}
+},
+_pathEffector: function(path, value, fromAbove) {
+if (this._forwardParentPath) {
+if (path.indexOf("_parent_") === 0) {
+this._forwardParentPath(path.substring(8), value);
+}
+}
+Polymer.Base._pathEffector.apply(this, arguments);
+},
+_constructorImpl: function(model, host) {
+this._rootDataHost = host._getRootDataHost();
+this._setupConfigure(model);
+this._pushHost(host);
+this.root = this.instanceTemplate(this._template);
+this.root.__styleScoped = true;
+this._popHost();
+this._marshalAnnotatedNodes();
+this._marshalInstanceEffects();
+this._marshalAnnotatedListeners();
+var children = [];
+for (var n = this.root.firstChild; n; n = n.nextSibling) {
+children.push(n);
+n._templateInstance = this;
+}
+this._children = children;
+this._tryReady();
+},
+_listenImpl: function(node, eventName, methodName) {
+var model = this;
+var host = this._rootDataHost;
+var handler = host._createEventHandler(node, eventName, methodName);
+var decorated = function(e) {
+e.model = model;
+handler(e);
+};
+host._listen(node, eventName, decorated);
+},
+_scopeElementClassImpl: function(node, value) {
+var host = this._rootDataHost;
+if (host) {
+return host._scopeElementClass(node, value);
+}
+},
+stamp: function(model) {
+model = model || {};
+if (this._parentProps) {
+for (var prop in this._parentProps) {
+model[prop] = this["_parent_" + prop];
+}
+}
+return new this.ctor(model, this);
+}
+};
+
+Polymer({
+is: "dom-template",
+"extends": "template",
+behaviors: [ Polymer.Templatizer ],
+ready: function() {
+this.templatize(this);
+}
+});
+
+Polymer._collections = new WeakMap();
+
+Polymer.Collection = function(userArray) {
+Polymer._collections.set(userArray, this);
+this.userArray = userArray;
+this.store = userArray.slice();
+this.initMap();
+};
+
+Polymer.Collection.prototype = {
+constructor: Polymer.Collection,
+initMap: function() {
+var omap = this.omap = new WeakMap();
+var pmap = this.pmap = {};
+var s = this.store;
+for (var i = 0; i < s.length; i++) {
+var item = s[i];
+if (item && typeof item == "object") {
+omap.set(item, i);
+} else {
+pmap[item] = i;
+}
+}
+},
+add: function(item) {
+var key = this.store.push(item) - 1;
+if (item && typeof item == "object") {
+this.omap.set(item, key);
+} else {
+this.pmap[item] = key;
+}
+return key;
+},
+removeKey: function(key) {
+this._removeFromMap(this.store[key]);
+delete this.store[key];
+},
+_removeFromMap: function(item) {
+if (typeof item == "object") {
+this.omap.delete(item);
+} else {
+delete this.pmap[item];
+}
+},
+remove: function(item) {
+var key = this.getKey(item);
+this.removeKey(key);
+return key;
+},
+getKey: function(item) {
+if (typeof item == "object") {
+return this.omap.get(item);
+} else {
+return this.pmap[item];
+}
+},
+getKeys: function() {
+return Object.keys(this.store);
+},
+setItem: function(key, value) {
+this.store[key] = value;
+},
+getItem: function(key) {
+return this.store[key];
+},
+getItems: function() {
+var items = [], store = this.store;
+for (var key in store) {
+items.push(store[key]);
+}
+return items;
+},
+applySplices: function(splices) {
+var keySplices = [];
+for (var i = 0; i < splices.length; i++) {
+var j, o, key, s = splices[i];
+var removed = [];
+for (j = 0; j < s.removed.length; j++) {
+o = s.removed[j];
+key = this.remove(o);
+removed.push(key);
+}
+var added = [];
+for (j = 0; j < s.addedCount; j++) {
+o = this.userArray[s.index + j];
+key = this.add(o);
+added.push(key);
+}
+keySplices.push({
+index: s.index,
+removed: removed,
+removedItems: s.removed,
+added: added
+});
+}
+return keySplices;
+}
+};
+
+Polymer.Collection.get = function(userArray) {
+return Polymer._collections.get(userArray) || new Polymer.Collection(userArray);
+};
+
+Polymer({
+is: "dom-repeat",
+"extends": "template",
+properties: {
+items: {
+type: Array
+},
+as: {
+type: String,
+value: "item"
+},
+indexAs: {
+type: String,
+value: "index"
+},
+sort: {
+type: Function,
+observer: "_sortChanged"
+},
+filter: {
+type: Function,
+observer: "_filterChanged"
+},
+observe: {
+type: String,
+observer: "_observeChanged"
+},
+delay: Number
+},
+behaviors: [ Polymer.Templatizer ],
+observers: [ "_itemsChanged(items.*)" ],
+detached: function() {
+if (this.rows) {
+for (var i = 0; i < this.rows.length; i++) {
+this._detachRow(i);
+}
+}
+this.rows = null;
+},
+ready: function() {
+this._instanceProps = {
+__key__: true
+};
+this._instanceProps[this.as] = true;
+this._instanceProps[this.indexAs] = true;
+if (!this.ctor) {
+this.templatize(this);
+}
+},
+_sortChanged: function() {
+var dataHost = this._getRootDataHost();
+var sort = this.sort;
+this._sortFn = sort && (typeof sort == "function" ? sort : function() {
+return dataHost[sort].apply(dataHost, arguments);
+});
+this._fullRefresh = true;
+if (this.items) {
+this._debounceTemplate(this._render);
+}
+},
+_filterChanged: function() {
+var dataHost = this._getRootDataHost();
+var filter = this.filter;
+this._filterFn = filter && (typeof filter == "function" ? filter : function() {
+return dataHost[filter].apply(dataHost, arguments);
+});
+this._fullRefresh = true;
+if (this.items) {
+this._debounceTemplate(this._render);
+}
+},
+_observeChanged: function() {
+this._observePaths = this.observe && this.observe.replace(".*", ".").split(" ");
+},
+_itemsChanged: function(change) {
+if (change.path == "items") {
+if (Array.isArray(this.items)) {
+this.collection = Polymer.Collection.get(this.items);
+} else if (!this.items) {
+this.collection = null;
+} else {
+this._error(this._logf("dom-repeat", "expected array for `items`," + " found", this.items));
+}
+this._splices = [];
+this._fullRefresh = true;
+this._debounceTemplate(this._render);
+} else if (change.path == "items.splices") {
+this._splices = this._splices.concat(change.value.keySplices);
+this._debounceTemplate(this._render);
+} else {
+var subpath = change.path.slice(6);
+this._forwardItemPath(subpath, change.value);
+this._checkObservedPaths(subpath);
+}
+},
+_checkObservedPaths: function(path) {
+if (this._observePaths) {
+path = path.substring(path.indexOf(".") + 1);
+var paths = this._observePaths;
+for (var i = 0; i < paths.length; i++) {
+if (path.indexOf(paths[i]) === 0) {
+this._fullRefresh = true;
+if (this.delay) {
+this.debounce("render", this._render, this.delay);
+} else {
+this._debounceTemplate(this._render);
+}
+return;
+}
+}
+}
+},
+render: function() {
+this._fullRefresh = true;
+this.debounce("render", this._render);
+this._flushTemplates();
+},
+_render: function() {
+var c = this.collection;
+if (!this._fullRefresh) {
+if (this._sortFn) {
+this._applySplicesViewSort(this._splices);
+} else {
+if (this._filterFn) {
+this._fullRefresh = true;
+} else {
+this._applySplicesArraySort(this._splices);
+}
+}
+}
+if (this._fullRefresh) {
+this._sortAndFilter();
+this._fullRefresh = false;
+}
+this._splices = [];
+var rowForKey = this._rowForKey = {};
+var keys = this._orderedKeys;
+this.rows = this.rows || [];
+for (var i = 0; i < keys.length; i++) {
+var key = keys[i];
+var item = c.getItem(key);
+var row = this.rows[i];
+rowForKey[key] = i;
+if (!row) {
+this.rows.push(row = this._insertRow(i, null, item));
+}
+row[this.as] = item;
+row.__key__ = key;
+row[this.indexAs] = i;
+}
+for (;i < this.rows.length; i++) {
+this._detachRow(i);
+}
+this.rows.splice(keys.length, this.rows.length - keys.length);
+this.fire("dom-change");
+},
+_sortAndFilter: function() {
+var c = this.collection;
+if (!this._sortFn) {
+this._orderedKeys = [];
+var items = this.items;
+if (items) {
+for (var i = 0; i < items.length; i++) {
+this._orderedKeys.push(c.getKey(items[i]));
+}
+}
+} else {
+this._orderedKeys = c ? c.getKeys() : [];
+}
+if (this._filterFn) {
+this._orderedKeys = this._orderedKeys.filter(function(a) {
+return this._filterFn(c.getItem(a));
+}, this);
+}
+if (this._sortFn) {
+this._orderedKeys.sort(function(a, b) {
+return this._sortFn(c.getItem(a), c.getItem(b));
+}.bind(this));
+}
+},
+_keySort: function(a, b) {
+return this.collection.getKey(a) - this.collection.getKey(b);
+},
+_applySplicesViewSort: function(splices) {
+var c = this.collection;
+var keys = this._orderedKeys;
+var rows = this.rows;
+var removedRows = [];
+var addedKeys = [];
+var pool = [];
+var sortFn = this._sortFn || this._keySort.bind(this);
+splices.forEach(function(s) {
+for (var i = 0; i < s.removed.length; i++) {
+var idx = this._rowForKey[s.removed[i]];
+if (idx != null) {
+removedRows.push(idx);
+}
+}
+for (var i = 0; i < s.added.length; i++) {
+addedKeys.push(s.added[i]);
+}
+}, this);
+if (removedRows.length) {
+removedRows.sort();
+for (var i = removedRows.length - 1; i >= 0; i--) {
+var idx = removedRows[i];
+pool.push(this._detachRow(idx));
+rows.splice(idx, 1);
+keys.splice(idx, 1);
+}
+}
+if (addedKeys.length) {
+if (this._filterFn) {
+addedKeys = addedKeys.filter(function(a) {
+return this._filterFn(c.getItem(a));
+}, this);
+}
+addedKeys.sort(function(a, b) {
+return this._sortFn(c.getItem(a), c.getItem(b));
+}.bind(this));
+var start = 0;
+for (var i = 0; i < addedKeys.length; i++) {
+start = this._insertRowIntoViewSort(start, addedKeys[i], pool);
+}
+}
+},
+_insertRowIntoViewSort: function(start, key, pool) {
+var c = this.collection;
+var item = c.getItem(key);
+var end = this.rows.length - 1;
+var idx = -1;
+var sortFn = this._sortFn || this._keySort.bind(this);
+while (start <= end) {
+var mid = start + end >> 1;
+var midKey = this._orderedKeys[mid];
+var cmp = sortFn(c.getItem(midKey), item);
+if (cmp < 0) {
+start = mid + 1;
+} else if (cmp > 0) {
+end = mid - 1;
+} else {
+idx = mid;
+break;
+}
+}
+if (idx < 0) {
+idx = end + 1;
+}
+this._orderedKeys.splice(idx, 0, key);
+this.rows.splice(idx, 0, this._insertRow(idx, pool, c.getItem(key)));
+return idx;
+},
+_applySplicesArraySort: function(splices) {
+var keys = this._orderedKeys;
+var pool = [];
+splices.forEach(function(s) {
+for (var i = 0; i < s.removed.length; i++) {
+pool.push(this._detachRow(s.index + i));
+}
+this.rows.splice(s.index, s.removed.length);
+}, this);
+var c = this.collection;
+splices.forEach(function(s) {
+var args = [ s.index, s.removed.length ].concat(s.added);
+keys.splice.apply(keys, args);
+for (var i = 0; i < s.added.length; i++) {
+var item = c.getItem(s.added[i]);
+var row = this._insertRow(s.index + i, pool, item);
+this.rows.splice(s.index + i, 0, row);
+}
+}, this);
+},
+_detachRow: function(idx) {
+var row = this.rows[idx];
+var parentNode = Polymer.dom(this).parentNode;
+for (var i = 0; i < row._children.length; i++) {
+var el = row._children[i];
+Polymer.dom(row.root).appendChild(el);
+}
+return row;
+},
+_insertRow: function(idx, pool, item) {
+var row = pool && pool.pop() || this._generateRow(idx, item);
+var beforeRow = this.rows[idx];
+var beforeNode = beforeRow ? beforeRow._children[0] : this;
+var parentNode = Polymer.dom(this).parentNode;
+Polymer.dom(parentNode).insertBefore(row.root, beforeNode);
+return row;
+},
+_generateRow: function(idx, item) {
+var model = {
+__key__: this.collection.getKey(item)
+};
+model[this.as] = item;
+model[this.indexAs] = idx;
+var row = this.stamp(model);
+return row;
+},
+_hideChildren: function(hidden) {
+if (this.rows) {
+for (var i = 0; i < this.rows.length; i++) {
+var c$ = this.rows[i]._children;
+for (var j = 0; j < c$.length; j++) {
+var c = c$[j];
+if (c.style) {
+c.style.display = hidden ? "none" : "";
+}
+c._hideTemplateChildren = hidden;
+}
+}
+}
+},
+_forwardInstancePath: function(row, path, value) {
+if (path.indexOf(this.as + ".") === 0) {
+this.notifyPath("items." + row.__key__ + "." + path.slice(this.as.length + 1), value);
+return true;
+}
+},
+_forwardParentProp: function(prop, value) {
+if (this.rows) {
+this.rows.forEach(function(row) {
+row[prop] = value;
+}, this);
+}
+},
+_forwardParentPath: function(path, value) {
+if (this.rows) {
+this.rows.forEach(function(row) {
+row.notifyPath(path, value, true);
+}, this);
+}
+},
+_forwardItemPath: function(path, value) {
+if (this._rowForKey) {
+var dot = path.indexOf(".");
+var key = path.substring(0, dot < 0 ? path.length : dot);
+var idx = this._rowForKey[key];
+var row = this.rows[idx];
+if (row) {
+if (dot >= 0) {
+path = this.as + "." + path.substring(dot + 1);
+row.notifyPath(path, value, true);
+} else {
+row[this.as] = value;
+}
+}
+}
+},
+modelForElement: function(el) {
+var model;
+while (el) {
+if (model = el._templateInstance) {
+if (model.dataHost != this) {
+el = model.dataHost;
+} else {
+return model;
+}
+} else {
+el = el.parentNode;
+}
+}
+},
+itemForElement: function(el) {
+var instance = this.modelForElement(el);
+return instance && instance[this.as];
+},
+keyForElement: function(el) {
+var instance = this.modelForElement(el);
+return instance && instance.__key__;
+},
+indexForElement: function(el) {
+var instance = this.modelForElement(el);
+return instance && instance[this.indexAs];
+}
+});
+
+Polymer({
+is: "array-selector",
+properties: {
+items: {
+type: Array,
+observer: "_itemsChanged"
+},
+selected: {
+type: Object,
+notify: true
+},
+toggle: Boolean,
+multi: Boolean
+},
+_itemsChanged: function() {
+if (Array.isArray(this.selected)) {
+for (var i = 0; i < this.selected.length; i++) {
+this.unlinkPaths("selected." + i);
+}
+} else {
+this.unlinkPaths("selected");
+}
+if (this.multi) {
+this.selected = [];
+} else {
+this.selected = null;
+}
+},
+deselect: function(item) {
+if (this.multi) {
+var scol = Polymer.Collection.get(this.selected);
+var sidx = this.selected.indexOf(item);
+if (sidx >= 0) {
+var skey = scol.getKey(item);
+this.splice("selected", sidx, 1);
+this.unlinkPaths("selected." + skey);
+return true;
+}
+} else {
+this.selected = null;
+this.unlinkPaths("selected");
+}
+},
+select: function(item) {
+var icol = Polymer.Collection.get(this.items);
+var key = icol.getKey(item);
+if (this.multi) {
+var scol = Polymer.Collection.get(this.selected);
+var skey = scol.getKey(item);
+if (skey >= 0) {
+this.deselect(item);
+} else if (this.toggle) {
+this.push("selected", item);
+this.async(function() {
+skey = scol.getKey(item);
+this.linkPaths("selected." + skey, "items." + key);
+});
+}
+} else {
+if (this.toggle && item == this.selected) {
+this.deselect();
+} else {
+this.linkPaths("selected", "items." + key);
+this.selected = item;
+}
+}
+}
+});
+
+Polymer({
+is: "dom-if",
+"extends": "template",
+properties: {
+"if": {
+type: Boolean,
+value: false
+},
+restamp: {
+type: Boolean,
+value: false
+}
+},
+behaviors: [ Polymer.Templatizer ],
+observers: [ "_queueRender(if, restamp)" ],
+_queueRender: function() {
+this._debounceTemplate(this._render);
+},
+detached: function() {
+this._teardownInstance();
+},
+attached: function() {
+if (this.if && this.ctor) {
+this.async(this._ensureInstance);
+}
+},
+render: function() {
+this._flushTemplates();
+},
+_render: function() {
+if (this.if) {
+if (!this.ctor) {
+this._wrapTextNodes(this._content || this.content);
+this.templatize(this);
+}
+this._ensureInstance();
+this._hideTemplateChildren = false;
+} else if (this.restamp) {
+this._teardownInstance();
+}
+if (!this.restamp && this._instance) {
+this._hideTemplateChildren = !this.if;
+}
+if (this.if != this._lastIf) {
+this.fire("dom-change");
+this._lastIf = this.if;
+}
+},
+_ensureInstance: function() {
+if (!this._instance) {
+this._instance = this.stamp();
+var root = this._instance.root;
+var parent = Polymer.dom(Polymer.dom(this).parentNode);
+parent.insertBefore(root, this);
+}
+},
+_teardownInstance: function() {
+if (this._instance) {
+var c = this._instance._children;
+if (c) {
+var parent = Polymer.dom(Polymer.dom(c[0]).parentNode);
+c.forEach(function(n) {
+parent.removeChild(n);
+});
+}
+this._instance = null;
+}
+},
+_wrapTextNodes: function(root) {
+for (var n = root.firstChild; n; n = n.nextSibling) {
+if (n.nodeType === Node.TEXT_NODE) {
+var s = document.createElement("span");
+root.insertBefore(s, n);
+s.appendChild(n);
+n = s;
+}
+}
+},
+_hideChildren: function(hidden) {
+if (this._instance) {
+var c$ = this._instance._children;
+for (var i = 0; i < c$.length; i++) {
+var c = c$[i];
+c.style.display = hidden ? "none" : "";
+c._hideTemplateChildren = hidden;
+}
+}
+},
+_forwardParentProp: function(prop, value) {
+if (this._instance) {
+this._instance[prop] = value;
+}
+},
+_forwardParentPath: function(path, value) {
+if (this._instance) {
+this._instance.notifyPath(path, value, true);
+}
+}
+});
+
+Polymer.ImportStatus = {
+_ready: false,
+_callbacks: [],
+whenLoaded: function(cb) {
+if (this._ready) {
+cb();
+} else {
+this._callbacks.push(cb);
+}
+},
+_importsLoaded: function() {
+this._ready = true;
+this._callbacks.forEach(function(cb) {
+cb();
+});
+this._callbacks = [];
+}
+};
+
+window.addEventListener("load", function() {
+Polymer.ImportStatus._importsLoaded();
+});
+
+if (window.HTMLImports) {
+HTMLImports.whenReady(function() {
+Polymer.ImportStatus._importsLoaded();
+});
+}
+
+Polymer({
+is: "dom-bind",
+"extends": "template",
+created: function() {
+Polymer.ImportStatus.whenLoaded(this._readySelf.bind(this));
+},
+_registerFeatures: function() {
+this._prepExtends();
+this._prepConstructor();
+},
+_insertChildren: function() {
+var parentDom = Polymer.dom(Polymer.dom(this).parentNode);
+parentDom.insertBefore(this.root, this);
+},
+_removeChildren: function() {
+if (this._children) {
+for (var i = 0; i < this._children.length; i++) {
+this.root.appendChild(this._children[i]);
+}
+}
+},
+_initFeatures: function() {},
+_scopeElementClass: function(element, selector) {
+if (this.dataHost) {
+return this.dataHost._scopeElementClass(element, selector);
+} else {
+return selector;
+}
+},
+_prepConfigure: function() {
+var config = {};
+for (var prop in this._propertyEffects) {
+config[prop] = this[prop];
+}
+this._setupConfigure = this._setupConfigure.bind(this, config);
+},
+attached: function() {
+if (!this._children) {
+this._template = this;
+this._prepAnnotations();
+this._prepEffects();
+this._prepBehaviors();
+this._prepConfigure();
+this._prepBindings();
+Polymer.Base._initFeatures.call(this);
+this._children = Array.prototype.slice.call(this.root.childNodes);
+}
+this._insertChildren();
+this.fire("dom-change");
+},
+detached: function() {
+this._removeChildren();
+}
+});</script>