Index: third_party/polymer/v1_0/components/polymer/polymer.html |
diff --git a/third_party/polymer/v1_0/components/polymer/polymer.html b/third_party/polymer/v1_0/components/polymer/polymer.html |
deleted file mode 100644 |
index 89e28a32df2f9f51ade61f5611fc13dcf5a1e2da..0000000000000000000000000000000000000000 |
--- a/third_party/polymer/v1_0/components/polymer/polymer.html |
+++ /dev/null |
@@ -1,4040 +0,0 @@ |
-<!-- |
-@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"> |
- |
-<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: [] |
-}; |
-if (element.localName === 'content') { |
-list._hasContent = true; |
-} |
-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); |
-} |
-if (node.nodeType === Node.TEXT_NODE) { |
-var n = node.nextSibling; |
-while (n && n.nodeType === Node.TEXT_NODE) { |
-node.textContent += n.textContent; |
-root.removeChild(n); |
-n = n.nextSibling; |
-} |
-} |
-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) { |
-if (url && url[0] === '#') { |
-return url; |
-} |
-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)); |
-}, |
-_boundListenerKey: function (eventName, methodName) { |
-return eventName + ':' + methodName; |
-}, |
-_recordEventHandler: function (host, eventName, target, methodName, handler) { |
-var hbl = host.__boundListeners; |
-if (!hbl) { |
-hbl = host.__boundListeners = new WeakMap(); |
-} |
-var bl = hbl.get(target); |
-if (!bl) { |
-bl = {}; |
-hbl.set(target, bl); |
-} |
-var key = this._boundListenerKey(eventName, methodName); |
-bl[key] = handler; |
-}, |
-_recallEventHandler: function (host, eventName, target, methodName) { |
-var hbl = host.__boundListeners; |
-if (!hbl) { |
-return; |
-} |
-var bl = hbl.get(target); |
-if (!bl) { |
-return; |
-} |
-var key = this._boundListenerKey(eventName, methodName); |
-return bl[key]; |
-}, |
-_createEventHandler: function (node, eventName, methodName) { |
-var host = this; |
-var handler = function (e) { |
-if (host[methodName]) { |
-host[methodName](e, e.detail); |
-} else { |
-host._warn(host._logf('_createEventHandler', 'listener method `' + methodName + '` not defined')); |
-} |
-}; |
-this._recordEventHandler(host, eventName, node, methodName, handler); |
-return handler; |
-}, |
-unlisten: function (node, eventName, methodName) { |
-var handler = this._recallEventHandler(this, eventName, node, methodName); |
-if (handler) { |
-this._unlisten(node, eventName, handler); |
-} |
-}, |
-_listen: function (node, eventName, handler) { |
-node.addEventListener(eventName, handler); |
-}, |
-_unlisten: function (node, eventName, handler) { |
-node.removeEventListener(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 IS_TOUCH_ONLY = navigator.userAgent.match(/iP(?:[oa]d|hone)|Android/); |
-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 (IS_TOUCH_ONLY) { |
-return; |
-} |
-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 = { |
-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; |
-}, |
-findOriginalTarget: function (ev) { |
-if (ev.path) { |
-return ev.path[0]; |
-} |
-return ev.target; |
-}, |
-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]; |
-if (IS_TOUCH_ONLY && MOUSE_EVENTS.indexOf(dep) > -1) { |
-continue; |
-} |
-gd = gobj[dep]; |
-if (!gd) { |
-gobj[dep] = gd = { _count: 0 }; |
-} |
-if (gd._count === 0) { |
-node.addEventListener(dep, this.handleNative); |
-} |
-gd[name] = (gd[name] || 0) + 1; |
-gd._count = (gd._count || 0) + 1; |
-} |
-node.addEventListener(evType, handler); |
-if (recognizer.touchAction) { |
-this.setTouchAction(node, recognizer.touchAction); |
-} |
-}, |
-remove: function (node, evType, handler) { |
-var recognizer = this.gestures[evType]; |
-var deps = recognizer.deps; |
-var name = recognizer.name; |
-var gobj = node[GESTURE_KEY]; |
-if (gobj) { |
-for (var i = 0, dep, gd; i < deps.length; i++) { |
-dep = deps[i]; |
-gd = gobj[dep]; |
-if (gd && gd[name]) { |
-gd[name] = (gd[name] || 1) - 1; |
-gd._count = (gd._count || 1) - 1; |
-} |
-if (gd._count === 0) { |
-node.removeEventListener(dep, this.handleNative); |
-} |
-} |
-} |
-node.removeEventListener(evType, handler); |
-}, |
-register: function (recog) { |
-this.recognizers.push(recog); |
-for (var i = 0; i < recog.emits.length; i++) { |
-this.gestures[recog.emits[i]] = recog; |
-} |
-}, |
-findRecognizerByEvent: function (evName) { |
-for (var i = 0, r; i < this.recognizers.length; i++) { |
-r = this.recognizers[i]; |
-for (var j = 0, n; j < r.emits.length; j++) { |
-n = r.emits[j]; |
-if (n === evName) { |
-return r; |
-} |
-} |
-} |
-return null; |
-}, |
-setTouchAction: function (node, value) { |
-if (HAS_NATIVE_TA) { |
-node.style.touchAction = value; |
-} |
-node[TOUCH_ACTION] = value; |
-}, |
-fire: function (target, type, detail) { |
-var ev = Polymer.Base.fire(type, detail, { |
-node: target, |
-bubbles: true, |
-cancelable: true |
-}); |
-if (ev.defaultPrevented) { |
-var se = detail.sourceEvent; |
-if (se && se.preventDefault) { |
-se.preventDefault(); |
-} |
-} |
-}, |
-prevent: function (evName) { |
-var recognizer = this.findRecognizerByEvent(evName); |
-if (recognizer.info) { |
-recognizer.info.prevent = true; |
-} |
-} |
-}; |
-Gestures.register({ |
-name: 'downup', |
-deps: [ |
-'mousedown', |
-'touchstart', |
-'touchend' |
-], |
-emits: [ |
-'down', |
-'up' |
-], |
-mousedown: function (e) { |
-var t = Gestures.findOriginalTarget(e); |
-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', Gestures.findOriginalTarget(e), e.changedTouches[0]); |
-}, |
-touchend: function (e) { |
-this.fire('up', Gestures.findOriginalTarget(e), e.changedTouches[0]); |
-}, |
-fire: function (type, target, event) { |
-var self = this; |
-Gestures.fire(target, type, { |
-x: event.clientX, |
-y: event.clientY, |
-sourceEvent: event, |
-prevent: Gestures.prevent.bind(Gestures) |
-}); |
-} |
-}); |
-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); |
-}, |
-prevent: false |
-}, |
-clearInfo: function () { |
-this.info.state = 'start'; |
-this.info.started = false; |
-this.info.moves = []; |
-this.info.x = 0; |
-this.info.y = 0; |
-this.info.prevent = false; |
-}, |
-hasMovedEnough: function (x, y) { |
-if (this.info.prevent) { |
-return false; |
-} |
-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 = Gestures.findOriginalTarget(e); |
-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); |
-self.info.started = true; |
-} |
-}; |
-var upfn = function upfn(e) { |
-if (self.info.started) { |
-Gestures.prevent('tap'); |
-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 = Gestures.findOriginalTarget(e); |
-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 = Gestures.findOriginalTarget(e); |
-var ct = e.changedTouches[0]; |
-if (this.info.started) { |
-Gestures.prevent('tap'); |
-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'], |
-info: { |
-x: NaN, |
-y: NaN, |
-prevent: false |
-}, |
-reset: function () { |
-this.info.x = NaN; |
-this.info.y = NaN; |
-this.info.prevent = false; |
-}, |
-save: function (e) { |
-this.info.x = e.clientX; |
-this.info.y = e.clientY; |
-}, |
-mousedown: function (e) { |
-this.save(e); |
-}, |
-click: function (e) { |
-this.forward(e); |
-}, |
-touchstart: function (e) { |
-this.save(e.changedTouches[0]); |
-}, |
-touchend: function (e) { |
-this.forward(e.changedTouches[0]); |
-}, |
-forward: function (e) { |
-var dx = Math.abs(e.clientX - this.info.x); |
-var dy = Math.abs(e.clientY - this.info.y); |
-var t = Gestures.findOriginalTarget(e); |
-if (isNaN(dx) || isNaN(dy) || dx <= TAP_DISTANCE && dy <= TAP_DISTANCE) { |
-if (!this.info.prevent) { |
-Gestures.fire(t, '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); |
-} |
-}, |
-_unlisten: function (node, eventName, handler) { |
-if (Gestures.gestures[eventName]) { |
-Gestures.remove(node, eventName, handler); |
-} else { |
-node.removeEventListener(eventName, handler); |
-} |
-}, |
-setScrollDirection: function (direction, node) { |
-node = node || this; |
-Gestures.setTouchAction(node, DIRECTION_MAP[direction] || 'auto'); |
-} |
-}); |
-Polymer.Gestures = Gestures; |
-}()); |
-Polymer.Async = { |
-_currVal: 0, |
-_lastVal: 0, |
-_callbacks: [], |
-_twiddleContent: 0, |
-_twiddle: document.createTextNode(''), |
-run: function (callback, waitTime) { |
-if (waitTime > 0) { |
-return ~setTimeout(callback, waitTime); |
-} else { |
-this._twiddle.textContent = this._twiddleContent++; |
-this._callbacks.push(callback); |
-return this._currVal++; |
-} |
-}, |
-cancel: function (handle) { |
-if (handle < 0) { |
-clearTimeout(~handle); |
-} else { |
-var idx = handle - this._lastVal; |
-if (idx >= 0) { |
-if (!this._callbacks[idx]) { |
-throw 'invalid async handle: ' + handle; |
-} |
-this._callbacks[idx] = null; |
-} |
-} |
-}, |
-_atEndOfMicrotask: function () { |
-var len = this._callbacks.length; |
-for (var i = 0; i < len; i++) { |
-var cb = this._callbacks[i]; |
-if (cb) { |
-try { |
-cb(); |
-} catch (e) { |
-i++; |
-this._callbacks.splice(0, i); |
-this._lastVal += i; |
-this._twiddle.textContent = this._twiddleContent++; |
-throw e; |
-} |
-} |
-} |
-this._callbacks.splice(0, len); |
-this._lastVal += len; |
-} |
-}; |
-new (window.MutationObserver || JsMutationObserver)(Polymer.Async._atEndOfMicrotask.bind(Polymer.Async)).observe(Polymer.Async._twiddle, { characterData: true }); |
-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) { |
-var content = Polymer.dom(this.root).querySelector(slctr || 'content'); |
-return content ? Polymer.dom(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 cancelable = Boolean(options.cancelable); |
-var event = new CustomEvent(type, { |
-bubbles: Boolean(bubbles), |
-cancelable: 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; |
-} |
-}); |
-Polymer.Bind = { |
-prepareModel: function (model) { |
-model._propertyEffects = {}; |
-model._bindListeners = []; |
-Polymer.Base.mixin(model, this._modelApi); |
-}, |
-_modelApi: { |
-_notifyChange: function (property) { |
-var eventName = Polymer.CaseMap.camelToDashCase(property) + '-changed'; |
-Polymer.Base.fire(eventName, { value: this[property] }, { |
-bubbles: false, |
-node: this |
-}); |
-}, |
-_propertySetter: function (property, value, effects, fromAbove) { |
-var old = this.__data__[property]; |
-if (old !== value && (old === old || value === 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, fromAbove); |
-} |
-} |
-return old; |
-}, |
-__setProperty: function (property, value, quiet, node) { |
-node = node || this; |
-var effects = node._propertyEffects && node._propertyEffects[property]; |
-if (effects) { |
-node._propertySetter(property, value, effects, quiet); |
-} else { |
-node[property] = value; |
-} |
-}, |
-_effectEffects: function (property, value, effects, old, fromAbove) { |
-effects.forEach(function (fx) { |
-var fn = Polymer.Bind['_' + fx.kind + 'Effect']; |
-if (fn) { |
-fn.call(this, property, value, fx.effect, old, fromAbove); |
-} |
-}, 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._propertySetter(property, value, effects); |
-}; |
-var info = model.getPropertyInfo && model.getPropertyInfo(property); |
-if (info && info.readOnly) { |
-if (!info.computed) { |
-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, value, effect, old, fromAbove) { |
-if (!fromAbove) { |
-this._notifyChange(source); |
-} |
-}, |
-_functionEffect: function (source, value, fn, old, fromAbove) { |
-fn.call(this, source, value, old, fromAbove); |
-}, |
-_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.__setProperty(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; |
-var v; |
-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) { |
-prop.readOnly = true; |
-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, ',').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(/,/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(); |
-this._aboveConfig = this.mixin({}, this._config); |
-var config = {}; |
-this.behaviors.forEach(function (b) { |
-this._configureProperties(b.properties, config); |
-}, this); |
-this._configureProperties(this.properties, config); |
-this._mixinConfigure(config, this._aboveConfig); |
-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._aboveConfig); |
-this._flushHandlers(); |
-}, |
-_applyConfig: function (config, aboveConfig) { |
-for (var n in config) { |
-if (this[n] === undefined) { |
-this.__setProperty(n, config[n], n in aboveConfig); |
-} |
-} |
-}, |
-_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._propertySetter(path, value); |
-if (old !== value && (old === old || value === value)) { |
-this._pathEffector(path, value); |
-if (!fromAbove) { |
-this._notifyPath(path, value); |
-} |
-return true; |
-} |
-}, |
-_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; |
-} |
-if (array) { |
-var coll = Polymer.Collection.get(array); |
-var old = prop[last]; |
-var key = coll.getKey(old); |
-if (key) { |
-parts[i] = key; |
-coll.setItem(key, value); |
-} |
-} |
-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.applySplices(array, 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 ret = array.splice.apply(array, args); |
-this._notifySplice(array, path, start, args.length - 2, ret); |
-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: 1000 |
-}, |
-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;])--[^;{]*?:[^{};]*?(?:[;\n]|$)/gim, |
-mixinProp: /(?:^|[\s;])--[^;{]*?:[^{;]*?{[^}]*?}(?:[;\n]|$)?/gim, |
-mixinApply: /@apply[\s]*\([^)]*?\)[\s]*(?:[;\n]|$)?/gim, |
-varApply: /[^;:]*?:[^;]*var[^;]*(?:[;\n]|$)?/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) { |
-if (styles) { |
-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.textContent) { |
-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 hostContext = false; |
-var self = this; |
-selector = selector.replace(SIMPLE_SELECTOR_SEP, function (m, c, s) { |
-if (!stop) { |
-var info = self._transformCompoundSelector(s, c, scope, hostScope); |
-stop = stop || info.stop; |
-hostContext = hostContext || info.hostContext; |
-c = info.combinator; |
-s = info.value; |
-} else { |
-s = s.replace(SCOPE_JUMP, ' '); |
-} |
-return c + s; |
-}); |
-if (hostContext) { |
-selector = selector.replace(HOST_CONTEXT_PAREN, function (m, pre, paren, post) { |
-return pre + paren + ' ' + hostScope + post + COMPLEX_SELECTOR_SEP + ' ' + pre + hostScope + paren + post; |
-}); |
-} |
-return selector; |
-}, |
-_transformCompoundSelector: function (selector, combinator, scope, hostScope) { |
-var jumpIndex = selector.search(SCOPE_JUMP); |
-var hostContext = false; |
-if (selector.indexOf(HOST_CONTEXT) >= 0) { |
-hostContext = true; |
-} else 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, |
-hostContext: hostContext |
-}; |
-}, |
-_transformSimpleSelector: function (selector, scope) { |
-var p$ = selector.split(PSEUDO_PREFIX); |
-p$[0] += scope; |
-return p$.join(PSEUDO_PREFIX); |
-}, |
-documentRule: function (rule) { |
-rule.selector = rule.parsedSelector; |
-this.normalizeRootSelector(rule); |
-if (!nativeShadow) { |
-this._transformRule(rule, this._transformDocumentSelector); |
-} |
-}, |
-normalizeRootSelector: function (rule) { |
-if (rule.selector === ROOT) { |
-rule.selector = 'body'; |
-} |
-}, |
-_transformDocumentSelector: function (selector) { |
-return selector.match(SCOPE_JUMP) ? this._transformComplexSelector(selector, SCOPE_DOC_SELECTOR) : this._transformSimpleSelector(selector.trim(), SCOPE_DOC_SELECTOR); |
-}, |
-SCOPE_NAME: 'style-scope' |
-}; |
-var SCOPE_NAME = api.SCOPE_NAME; |
-var SCOPE_DOC_SELECTOR = ':not([' + SCOPE_NAME + '])' + ':not(.' + SCOPE_NAME + ')'; |
-var COMPLEX_SELECTOR_SEP = ','; |
-var SIMPLE_SELECTOR_SEP = /(^|[\s>+~]+)([^\s>+~]+)/g; |
-var HOST = ':host'; |
-var ROOT = ':root'; |
-var HOST_PAREN = /(\:host)(?:\(((?:\([^)(]*\)|[^)(]*)+?)\))/g; |
-var HOST_CONTEXT = ':host-context'; |
-var HOST_CONTEXT_PAREN = /(.*)(?:\:host-context)(?:\(((?:\([^)(]*\)|[^)(]*)+?)\))(.*)/; |
-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) { |
-if (node.__styleScoped) { |
-node.__styleScoped = false; |
-} else { |
-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 () { |
-'use strict'; |
-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; |
-var def = m[2]; |
-if (def && def.match(this.rx.IS_VAR)) { |
-props[def] = 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.propertyInfo) { |
-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 hostSelector = styleTransformer._calcHostScope(element.is, element.extends); |
-var rxHostSelector = element.extends ? '\\' + hostSelector.slice(0, -1) + '\\]' : hostSelector; |
-var hostRx = new RegExp(this.rx.HOST_PREFIX + rxHostSelector + this.rx.HOST_SUFFIX); |
-return styleTransformer.elementStyles(element, function (rule) { |
-self.applyProperties(rule, properties); |
-if (rule.cssText && !nativeShadow) { |
-self._scopeSelector(rule, hostRx, hostSelector, element._scopeCssViaAttr, scopeSelector); |
-} |
-}); |
-}, |
-_scopeSelector: function (rule, hostRx, hostSelector, 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(hostSelector, hostSelector + scope) : scope + ' ' + p; |
-} |
-rule.selector = parts.join(','); |
-}, |
-applyElementScopeSelector: function (element, selector, old, viaAttr) { |
-var c = viaAttr ? element.getAttribute(styleTransformer.SCOPE_NAME) : element.className; |
-var 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) { |
-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; |
-}, |
-mixinCustomStyle: function (props, customStyle) { |
-var v; |
-for (var i in customStyle) { |
-v = customStyle[i]; |
-if (v || v === 0) { |
-props[i] = v; |
-} |
-} |
-}, |
-rx: { |
-VAR_ASSIGN: /(?:^|[;\n]\s*)(--[\w-]*?):\s*(?:([^;{]*)|{([^}]*)})(?:(?=[;\n])|$)/gi, |
-MIXIN_MATCH: /(?:^|\W+)@apply[\s]*\(([^)]*)\)/i, |
-VAR_MATCH: /(^|\W+)var\([\s]*([^,)]*)[\s]*,?[\s]*((?:[^,)]*)|(?:[^;]*\([^;)]*\)))[\s]*?\)/gi, |
-VAR_CAPTURE: /\([\s]*(--[^,\s)]*)(?:,[\s]*(--[^,\s)]*))?(?:\)|,)/gi, |
-IS_VAR: /^--/, |
-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; |
-} |
-}(); |
-(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) { |
-var t, s; |
-for (var i in target) { |
-t = target[i], s = source[i]; |
-if (!(typeof t === 'object' && t ? this._objectsStrictlyEqual(t, s) : t === s)) { |
-return false; |
-} |
-} |
-if (Array.isArray(target)) { |
-return target.length === source.length; |
-} |
-return true; |
-}, |
-_objectsStrictlyEqual: function (target, source) { |
-return this._objectsEqual(target, source) && this._objectsEqual(source, target); |
-} |
-}; |
-}()); |
-Polymer.StyleDefaults = function () { |
-var styleProperties = Polymer.StyleProperties; |
-var styleUtil = Polymer.StyleUtil; |
-var StyleCache = Polymer.StyleCache; |
-var api = { |
-_styles: [], |
-_properties: null, |
-customStyle: {}, |
-_styleCache: new StyleCache(), |
-addStyle: function (style) { |
-this._styles.push(style); |
-this._properties = null; |
-}, |
-get _styleProperties() { |
-if (!this._properties) { |
-styleProperties.decorateStyles(this._styles); |
-this._styles._scopeStyleProperties = null; |
-this._properties = styleProperties.scopePropertiesFromStyles(this._styles); |
-styleProperties.mixinCustomStyle(this._properties, this.customStyle); |
-styleProperties.reify(this._properties); |
-} |
-return this._properties; |
-}, |
-_needsStyleProperties: function () { |
-}, |
-_computeStyleProperties: function () { |
-return this._styleProperties; |
-}, |
-updateStyles: function (properties) { |
-this._properties = null; |
-if (properties) { |
-Polymer.Base.mixin(this.customStyle, properties); |
-} |
-this._styleCache.clear(); |
-for (var i = 0, s; i < this._styles.length; i++) { |
-s = this._styles[i]; |
-s = s.__importElement || s; |
-s._apply(); |
-} |
-} |
-}; |
-return api; |
-}(); |
-(function () { |
-'use strict'; |
-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(); |
-} |
-}, |
-_findStyleHost: function () { |
-var e = this, root; |
-while (root = Polymer.dom(e).getOwnerRoot()) { |
-if (Polymer.isInstance(root.host)) { |
-return root.host; |
-} |
-e = root.host; |
-} |
-return styleDefaults; |
-}, |
-_updateStyleProperties: function () { |
-var info, scope = this._findStyleHost(); |
-if (!scope._styleCache) { |
-scope._styleCache = new Polymer.StyleCache(); |
-} |
-var scopeData = propertyUtils.propertyDataFromStyles(scope._styles, this); |
-scopeData.key.customStyle = this.customStyle; |
-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; |
-var style = this._applyStyleProperties(info); |
-if (!scopeCached) { |
-style = style && nativeShadow ? style.cloneNode(true) : style; |
-info = { |
-style: style, |
-_scopeSelector: this._scopeSelector, |
-_styleProperties: this._styleProperties |
-}; |
-scopeData.key.customStyle = {}; |
-this.mixin(scopeData.key.customStyle, this.customStyle); |
-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._findStyleHost(); |
-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)); |
-propertyUtils.mixinCustomStyle(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++; |
-var style = propertyUtils.applyElementStyle(this, this._styleProperties, this._scopeSelector, info && info.style); |
-if (!nativeShadow) { |
-propertyUtils.applyElementScopeSelector(this, this._scopeSelector, oldScopeSelector, this._scopeCssViaAttr); |
-} |
-return style; |
-}, |
-serializeValueToAttribute: function (value, attribute, node) { |
-node = node || this; |
-if (attribute === 'class' && !nativeShadow) { |
-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 (properties) { |
-if (this.isAttached) { |
-if (properties) { |
-this.mixin(this.customStyle, properties); |
-} |
-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 (properties) { |
-styleDefaults.updateStyles(properties); |
-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._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; |
-var styleTransformer = Polymer.StyleTransformer; |
-Polymer({ |
-is: 'custom-style', |
-extends: 'style', |
-created: function () { |
-this._tryApply(); |
-}, |
-attached: function () { |
-this._tryApply(); |
-}, |
-_tryApply: function () { |
-if (!this._appliesToDocument) { |
-if (this.parentNode && this.parentNode.localName !== 'dom-module') { |
-this._appliesToDocument = true; |
-var e = this.__appliedElement || this; |
-styleDefaults.addStyle(e); |
-if (e.textContent) { |
-this._apply(); |
-} else { |
-var observer = new MutationObserver(function () { |
-observer.disconnect(); |
-this._apply(); |
-}.bind(this)); |
-observer.observe(e, { childList: true }); |
-} |
-} |
-} |
-}, |
-_apply: function () { |
-var e = this.__appliedElement || this; |
-this._computeStyleProperties(); |
-var props = this._styleProperties; |
-var self = this; |
-e.textContent = styleUtil.toCssText(styleUtil.rulesForStyle(e), function (rule) { |
-var css = rule.cssText = rule.parsedCssText; |
-if (rule.propertyInfo && rule.propertyInfo.cssText) { |
-css = css.replace(propertyUtils.rx.VAR_ASSIGN, ''); |
-rule.cssText = propertyUtils.valueForProperties(css, props); |
-} |
-styleTransformer.documentRule(rule); |
-}); |
-} |
-}); |
-}()); |
-Polymer.Templatizer = { |
-properties: { __hideTemplateChildren__: { observer: '_showHideChildren' } }, |
-_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; |
-archetype._showHideChildren = this._showHideChildrenImpl; |
-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; |
-}, |
-_showHideChildrenImpl: function (hide) { |
-var c = this._children; |
-for (var i = 0; i < c.length; i++) { |
-var n = c[i]; |
-if (n.style) { |
-n.style.display = hide ? 'none' : ''; |
-n.__hideTemplateChildren__ = hide; |
-} |
-} |
-}, |
-_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)); |
-} |
-for (var prop in this._instanceProps) { |
-archetype._addPropertyEffect(prop, 'function', this._createInstancePropEffector(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; |
-}; |
-}, |
-_createInstancePropEffector: function (prop) { |
-return function (source, value, old, fromAbove) { |
-if (!fromAbove) { |
-this.dataHost._forwardInstanceProp(this, 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._propertySetter(n, val); |
-} |
-}); |
-}, |
-_showHideChildren: function (hidden) { |
-}, |
-_forwardInstancePath: function (inst, path, value) { |
-}, |
-_forwardInstanceProp: function (inst, prop, 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.__noContent = !this._notes._hasContent; |
-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; |
-if (host.__hideTemplateChildren__) { |
-this._showHideChildren(true); |
-} |
-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); |
-}, |
-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; |
-} |
-} |
-} |
-}; |
-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 (item && 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 (item && typeof item == 'object') { |
-return this.omap.get(item); |
-} else { |
-return this.pmap[item]; |
-} |
-}, |
-getKeys: function () { |
-return Object.keys(this.store); |
-}, |
-setItem: function (key, item) { |
-var old = this.store[key]; |
-if (old) { |
-this._removeFromMap(old); |
-} |
-if (item && typeof item == 'object') { |
-this.omap.set(item, key); |
-} else { |
-this.pmap[item] = key; |
-} |
-this.store[key] = item; |
-}, |
-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.Collection.applySplices = function (userArray, splices) { |
-var coll = Polymer._collections.get(userArray); |
-return coll ? coll._applySplices(splices) : null; |
-}; |
-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.*)'], |
-created: function () { |
-this._instances = []; |
-}, |
-detached: function () { |
-for (var i = 0; i < this._instances.length; i++) { |
-this._detachRow(i); |
-} |
-}, |
-attached: function () { |
-var parentNode = Polymer.dom(this).parentNode; |
-for (var i = 0; i < this._instances.length; i++) { |
-Polymer.dom(parentNode).insertBefore(this._instances[i].root, this); |
-} |
-}, |
-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._needFullRefresh = 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._needFullRefresh = 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._needFullRefresh = 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._needFullRefresh = true; |
-if (this.delay) { |
-this.debounce('render', this._render, this.delay); |
-} else { |
-this._debounceTemplate(this._render); |
-} |
-return; |
-} |
-} |
-} |
-}, |
-render: function () { |
-this._needFullRefresh = true; |
-this._debounceTemplate(this._render); |
-this._flushTemplates(); |
-}, |
-_render: function () { |
-var c = this.collection; |
-if (this._needFullRefresh) { |
-this._applyFullRefresh(); |
-this._needFullRefresh = false; |
-} else { |
-if (this._sortFn) { |
-this._applySplicesUserSort(this._splices); |
-} else { |
-if (this._filterFn) { |
-this._applyFullRefresh(); |
-} else { |
-this._applySplicesArrayOrder(this._splices); |
-} |
-} |
-} |
-this._splices = []; |
-var keyToIdx = this._keyToInstIdx = {}; |
-for (var i = 0; i < this._instances.length; i++) { |
-var inst = this._instances[i]; |
-keyToIdx[inst.__key__] = i; |
-inst.__setProperty(this.indexAs, i, true); |
-} |
-this.fire('dom-change'); |
-}, |
-_applyFullRefresh: function () { |
-var c = this.collection; |
-var keys; |
-if (this._sortFn) { |
-keys = c ? c.getKeys() : []; |
-} else { |
-keys = []; |
-var items = this.items; |
-if (items) { |
-for (var i = 0; i < items.length; i++) { |
-keys.push(c.getKey(items[i])); |
-} |
-} |
-} |
-if (this._filterFn) { |
-keys = keys.filter(function (a) { |
-return this._filterFn(c.getItem(a)); |
-}, this); |
-} |
-if (this._sortFn) { |
-keys.sort(function (a, b) { |
-return this._sortFn(c.getItem(a), c.getItem(b)); |
-}.bind(this)); |
-} |
-for (var i = 0; i < keys.length; i++) { |
-var key = keys[i]; |
-var inst = this._instances[i]; |
-if (inst) { |
-inst.__setProperty('__key__', key, true); |
-inst.__setProperty(this.as, c.getItem(key), true); |
-} else { |
-this._instances.push(this._insertRow(i, key)); |
-} |
-} |
-for (; i < this._instances.length; i++) { |
-this._detachRow(i); |
-} |
-this._instances.splice(keys.length, this._instances.length - keys.length); |
-}, |
-_keySort: function (a, b) { |
-return this.collection.getKey(a) - this.collection.getKey(b); |
-}, |
-_applySplicesUserSort: function (splices) { |
-var c = this.collection; |
-var instances = this._instances; |
-var keyMap = {}; |
-var pool = []; |
-var sortFn = this._sortFn || this._keySort.bind(this); |
-splices.forEach(function (s) { |
-for (var i = 0; i < s.removed.length; i++) { |
-var key = s.removed[i]; |
-keyMap[key] = keyMap[key] ? null : -1; |
-} |
-for (var i = 0; i < s.added.length; i++) { |
-var key = s.added[i]; |
-keyMap[key] = keyMap[key] ? null : 1; |
-} |
-}, this); |
-var removedIdxs = []; |
-var addedKeys = []; |
-for (var key in keyMap) { |
-if (keyMap[key] === -1) { |
-removedIdxs.push(this._keyToInstIdx[key]); |
-} |
-if (keyMap[key] === 1) { |
-addedKeys.push(key); |
-} |
-} |
-if (removedIdxs.length) { |
-removedIdxs.sort(); |
-for (var i = removedIdxs.length - 1; i >= 0; i--) { |
-var idx = removedIdxs[i]; |
-if (idx !== undefined) { |
-pool.push(this._detachRow(idx)); |
-instances.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._insertRowUserSort(start, addedKeys[i], pool); |
-} |
-} |
-}, |
-_insertRowUserSort: function (start, key, pool) { |
-var c = this.collection; |
-var item = c.getItem(key); |
-var end = this._instances.length - 1; |
-var idx = -1; |
-var sortFn = this._sortFn || this._keySort.bind(this); |
-while (start <= end) { |
-var mid = start + end >> 1; |
-var midKey = this._instances[mid].__key__; |
-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._instances.splice(idx, 0, this._insertRow(idx, key, pool)); |
-return idx; |
-}, |
-_applySplicesArrayOrder: function (splices) { |
-var pool = []; |
-var c = this.collection; |
-splices.forEach(function (s) { |
-for (var i = 0; i < s.removed.length; i++) { |
-var inst = this._detachRow(s.index + i); |
-if (!inst.isPlaceholder) { |
-pool.push(inst); |
-} |
-} |
-this._instances.splice(s.index, s.removed.length); |
-for (var i = 0; i < s.added.length; i++) { |
-var inst = { |
-isPlaceholder: true, |
-key: s.added[i] |
-}; |
-this._instances.splice(s.index + i, 0, inst); |
-} |
-}, this); |
-for (var i = this._instances.length - 1; i >= 0; i--) { |
-var inst = this._instances[i]; |
-if (inst.isPlaceholder) { |
-this._instances[i] = this._insertRow(i, inst.key, pool, true); |
-} |
-} |
-}, |
-_detachRow: function (idx) { |
-var inst = this._instances[idx]; |
-if (!inst.isPlaceholder) { |
-var parentNode = Polymer.dom(this).parentNode; |
-for (var i = 0; i < inst._children.length; i++) { |
-var el = inst._children[i]; |
-Polymer.dom(inst.root).appendChild(el); |
-} |
-} |
-return inst; |
-}, |
-_insertRow: function (idx, key, pool, replace) { |
-var inst; |
-if (inst = pool && pool.pop()) { |
-inst.__setProperty(this.as, this.collection.getItem(key), true); |
-inst.__setProperty('__key__', key, true); |
-} else { |
-inst = this._generateRow(idx, key); |
-} |
-var beforeRow = this._instances[replace ? idx + 1 : idx]; |
-var beforeNode = beforeRow ? beforeRow._children[0] : this; |
-var parentNode = Polymer.dom(this).parentNode; |
-Polymer.dom(parentNode).insertBefore(inst.root, beforeNode); |
-return inst; |
-}, |
-_generateRow: function (idx, key) { |
-var model = { __key__: key }; |
-model[this.as] = this.collection.getItem(key); |
-model[this.indexAs] = idx; |
-var inst = this.stamp(model); |
-return inst; |
-}, |
-_showHideChildren: function (hidden) { |
-for (var i = 0; i < this._instances.length; i++) { |
-this._instances[i]._showHideChildren(hidden); |
-} |
-}, |
-_forwardInstanceProp: function (inst, prop, value) { |
-if (prop == this.as) { |
-var idx; |
-if (this._sortFn || this._filterFn) { |
-idx = this.items.indexOf(this.collection.getItem(inst.__key__)); |
-} else { |
-idx = inst[this.indexAs]; |
-} |
-this.set('items.' + idx, value); |
-} |
-}, |
-_forwardInstancePath: function (inst, path, value) { |
-if (path.indexOf(this.as + '.') === 0) { |
-this.notifyPath('items.' + inst.__key__ + '.' + path.slice(this.as.length + 1), value); |
-} |
-}, |
-_forwardParentProp: function (prop, value) { |
-this._instances.forEach(function (inst) { |
-inst.__setProperty(prop, value, true); |
-}, this); |
-}, |
-_forwardParentPath: function (path, value) { |
-this._instances.forEach(function (inst) { |
-inst.notifyPath(path, value, true); |
-}, this); |
-}, |
-_forwardItemPath: function (path, value) { |
-if (this._keyToInstIdx) { |
-var dot = path.indexOf('.'); |
-var key = path.substring(0, dot < 0 ? path.length : dot); |
-var idx = this._keyToInstIdx[key]; |
-var inst = this._instances[idx]; |
-if (inst) { |
-if (dot >= 0) { |
-path = this.as + '.' + path.substring(dot + 1); |
-inst.notifyPath(path, value, true); |
-} else { |
-inst.__setProperty(this.as, value, true); |
-} |
-} |
-} |
-}, |
-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) { |
-if (this.toggle) { |
-this.deselect(item); |
-} |
-} else { |
-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, |
-observer: '_queueRender' |
-}, |
-restamp: { |
-type: Boolean, |
-value: false, |
-observer: '_queueRender' |
-} |
-}, |
-behaviors: [Polymer.Templatizer], |
-_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._showHideChildren(); |
-} else if (this.restamp) { |
-this._teardownInstance(); |
-} |
-if (!this.restamp && this._instance) { |
-this._showHideChildren(); |
-} |
-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 && n.textContent.trim()) { |
-var s = document.createElement('span'); |
-root.insertBefore(s, n); |
-s.appendChild(n); |
-n = s; |
-} |
-} |
-}, |
-_showHideChildren: function () { |
-var hidden = this.__hideTemplateChildren__ || !this.if; |
-if (this._instance) { |
-this._instance._showHideChildren(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._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> |