update polymer and platform.js

pkg/polymer/lib/src/js/polymer/polymer.concat.js

 /**
  * @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
  */
-window.PolymerGestures = {};
+window.PolymerGestures = {
+  hasSDPolyfill: Boolean(window.ShadowDOMPolyfill)
+};
+PolymerGestures.wrap = PolymerGestures.hasSDPolyfill ? ShadowDOMPolyfill.wrapIfNeeded : function(a){ return a; };
 
 /*
  * 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
  */
 
 (function(scope) {
+  var HAS_FULL_PATH = false;
+
+  // test for full event path support
+  var pathTest = document.createElement('meta');
+  if (!scope.hasSDPolyfill && pathTest.createShadowRoot) {
+    var sr = pathTest.createShadowRoot();
+    var s = document.createElement('span');
+    sr.appendChild(s);
+    pathTest.addEventListener('testpath', function(ev) {
+      if (ev.path) {
+        // if the span is in the event path, then path[0] is the real source for all events
+        HAS_FULL_PATH = ev.path[0] === s;
+      }
+      ev.stopPropagation();
+    });
+    var ev = new CustomEvent('testpath', {bubbles: true});
+    // must add node to DOM to trigger event listener
+    document.head.appendChild(pathTest);
+    s.dispatchEvent(ev);
+    pathTest.parentNode.removeChild(pathTest);
+    sr = s = null;
+  }
+  pathTest = null;
+
   var target = {
     shadow: function(inEl) {
       if (inEl) {
         return inEl.shadowRoot || inEl.webkitShadowRoot;
       }
     },
     canTarget: function(shadow) {
       return shadow && Boolean(shadow.elementFromPoint);
     },
     targetingShadow: function(inEl) {
@@ skipping 14 matching lines @@
     },
     allShadows: function(element) {
       var shadows = [], s = this.shadow(element);
       while(s) {
         shadows.push(s);
         s = this.olderShadow(s);
       }
       return shadows;
     },
     searchRoot: function(inRoot, x, y) {
+      var t, st, sr, os;
       if (inRoot) {
-        var t = inRoot.elementFromPoint(x, y);
-        var st, sr, os;
-        // is element a shadow host?
-        sr = this.targetingShadow(t);
-        while (sr) {
-          // find the the element inside the shadow root
-          st = sr.elementFromPoint(x, y);
-          if (!st) {
-            // check for older shadows
-            sr = this.olderShadow(sr);
-          } else {
-            // shadowed element may contain a shadow root
-            var ssr = this.targetingShadow(st);
-            return this.searchRoot(ssr, x, y) || st;
-          }
+        t = inRoot.elementFromPoint(x, y);
+        if (t) {
+          // found element, check if it has a ShadowRoot
+          sr = this.targetingShadow(t);
+        } else if (inRoot !== document) {
+          // check for sibling roots
+          sr = this.olderShadow(inRoot);
         }
-        // light dom element is the target
-        return t;
+        // search other roots, fall back to light dom element
+        return this.searchRoot(sr, x, y) || t;
       }
     },
     owner: function(element) {
       if (!element) {
         return document;
       }
       var s = element;
       // walk up until you hit the shadow root or document
       while (s.parentNode) {
         s = s.parentNode;
       }
       // the owner element is expected to be a Document or ShadowRoot
       if (s.nodeType != Node.DOCUMENT_NODE && s.nodeType != Node.DOCUMENT_FRAGMENT_NODE) {
         s = document;
       }
       return s;
     },
     findTarget: function(inEvent) {
+      if (HAS_FULL_PATH && inEvent.path) {
+        return inEvent.path[0];
+      }
       var x = inEvent.clientX, y = inEvent.clientY;
       // if the listener is in the shadow root, it is much faster to start there
       var s = this.owner(inEvent.target);
       // if x, y is not in this root, fall back to document search
       if (!s.elementFromPoint(x, y)) {
         s = document;
       }
       return this.searchRoot(s, x, y);
     },
+    findScrollAxis: function(inEvent) {
+      var n;
+      if (HAS_FULL_PATH && inEvent.path) {
+        var path = inEvent.path;
+        for (var i = 0; i < path.length; i++) {
+          n = path[i];
+          if (n._scrollType) {
+            return n._scrollType;
+          }
+        }
+      } else {
+        n = scope.wrap(inEvent.currentTarget);
+        while(n) {
+          if (n._scrollType) {
+            return n._scrollType;
+          }
+          n = n.parentNode || n.host;
+        }
+      }
+    },
     LCA: function(a, b) {
       if (a === b) {
         return a;
       }
       if (a && !b) {
         return a;
       }
       if (b && !a) {
         return b;
       }
       if (!b && !a) {
         return document;
       }
       // fast case, a is a direct descendant of b or vice versa
       if (a.contains && a.contains(b)) {
         return a;
       }
       if (b.contains && b.contains(a)) {
         return b;
       }
       var adepth = this.depth(a);
       var bdepth = this.depth(b);
       var d = adepth - bdepth;
-      if (d > 0) {
+      if (d >= 0) {
         a = this.walk(a, d);
       } else {
         b = this.walk(b, -d);
       }
-      while(a && b && a !== b) {
-        a = this.walk(a, 1);
-        b = this.walk(b, 1);
+      while (a && b && a !== b) {
+        a = a.parentNode || a.host;
+        b = b.parentNode || b.host;
       }
       return a;
     },
     walk: function(n, u) {
       for (var i = 0; n && (i < u); i++) {
         n = n.parentNode || n.host;
       }
       return n;
     },
     depth: function(n) {
@@ skipping 79 matching lines @@
     'none',
     'auto',
     'pan-x',
     'pan-y',
     {
       rule: 'pan-x pan-y',
       selectors: [
         'pan-x pan-y',
         'pan-y pan-x'
       ]
-    }
+    },
+    'manipulation'
   ];
   var styles = '';
   // only install stylesheet if the browser has touch action support
   var head = document.head;
   var hasTouchAction = typeof document.head.style.touchAction === 'string';
   // only add shadow selectors if shadowdom is supported
   var hasShadowRoot = !window.ShadowDOMPolyfill && document.head.createShadowRoot;
 
   if (hasTouchAction) {
     attrib2css.forEach(function(r) {
@@ skipping 127 matching lines @@
       // define the properties of the PointerEvent interface
       e.pointerId = inDict.pointerId || 0;
       e.width = inDict.width || 0;
       e.height = inDict.height || 0;
       e.pressure = pressure;
       e.tiltX = inDict.tiltX || 0;
       e.tiltY = inDict.tiltY || 0;
       e.pointerType = inDict.pointerType || '';
       e.hwTimestamp = inDict.hwTimestamp || 0;
       e.isPrimary = inDict.isPrimary || false;
+      e._source = inDict._source || '';
       return e;
     }
   };
 
   scope.eventFactory = eventFactory;
 })(window.PolymerGestures);
 
 /*
  * 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
@@ skipping 103 matching lines @@
     // event instance
     'type',
     'target',
     'currentTarget',
     'which',
     'pageX',
     'pageY',
     'timeStamp',
     // gesture addons
     'preventTap',
-    'tapPrevented'
+    'tapPrevented',
+    '_source'
   ];
 
   var CLONE_DEFAULTS = [
     // MouseEvent
     false,
     false,
     null,
     null,
     0,
     0,
@@ skipping 24 matching lines @@
     0,
     0,
     0,
     0,
     function(){},
     false
   ];
 
   var HAS_SVG_INSTANCE = (typeof SVGElementInstance !== 'undefined');
 
-  var wrap = window.ShadowDOMPolyfill && ShadowDOMPolyfill.wrapIfNeeded || function(e){ return e; };
+  var eventFactory = scope.eventFactory;
 
-  var eventFactory = scope.eventFactory;
+  var hasSDPolyfill = scope.hasSDPolyfill;
+  var wrap = scope.wrap;
+
   /**
    * This module is for normalizing events. Mouse and Touch events will be
    * collected here, and fire PointerEvents that have the same semantics, no
    * matter the source.
    * Events fired:
    *   - pointerdown: a pointing is added
    *   - pointerup: a pointer is removed
    *   - pointermove: a pointer is moved
    *   - pointerover: a pointer crosses into an element
    *   - pointerout: a pointer leaves an element
@@ skipping 26 matching lines @@
           }
         }, this);
         this.eventSources[name] = s;
         this.eventSourceList.push(s);
       }
     },
     registerGesture: function(name, source) {
       this.gestures.push(source);
     },
     register: function(element) {
-      // NOTE: Work around for #4, don't add listeners to individual Polymer elmenets in SD Polyfill
-      if (window.ShadowDOMPolyfill && element !== document) {
-        return;
-      }
       var l = this.eventSourceList.length;
       for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) {
         // call eventsource register
         es.register.call(es, element);
       }
     },
     unregister: function(element) {
       var l = this.eventSourceList.length;
       for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) {
         // call eventsource register
@@ skipping 26 matching lines @@
       }
       var type = inEvent.type;
       var fn = this.eventMap && this.eventMap[type];
       if (fn) {
         fn(inEvent);
       }
       inEvent._handledByPG = true;
     },
     // set up event listeners
     listen: function(target, events) {
-      events.forEach(function(e) {
+      for (var i = 0, l = events.length, e; (i < l) && (e = events[i]); i++) {
         this.addEvent(target, e);
-      }, this);
+      }
     },
     // remove event listeners
     unlisten: function(target, events) {
-      events.forEach(function(e) {
+      for (var i = 0, l = events.length, e; (i < l) && (e = events[i]); i++) {
         this.removeEvent(target, e);
-      }, this);
+      }
     },
     addEvent: function(target, eventName) {
       // NOTE: Work around for #4, use native event listener in SD Polyfill
-      if (window.ShadowDOMPolyfill) {
+      if (hasSDPolyfill) {
         target.addEventListener_(eventName, this.boundHandler);
       } else {
         target.addEventListener(eventName, this.boundHandler);
       }
     },
     removeEvent: function(target, eventName) {
       // NOTE: Work around for #4, use native event listener in SD Polyfill
-      if (window.ShadowDOMPolyfill) {
+      if (hasSDPolyfill) {
         target.removeEventListener_(eventName, this.boundHandler);
       } else {
         target.removeEventListener(eventName, this.boundHandler);
       }
     },
     // EVENT CREATION AND TRACKING
     /**
      * Creates a new Event of type `inType`, based on the information in
      * `inEvent`.
      *
@@ skipping 53 matching lines @@
         // clone after dispatch to pick up gesture prevention code
         var clone = this.cloneEvent(inEvent);
         clone.target = t;
         this.fillGestureQueue(clone);
       }
     },
     gestureTrigger: function() {
       // process the gesture queue
       for (var i = 0, e; i < this.gestureQueue.length; i++) {
         e = this.gestureQueue[i];
-        for (var j = 0, g; j < this.gestures.length; j++) {
+        for (var j = 0, g, fn; j < this.gestures.length; j++) {
           g = this.gestures[j];
-          if (g.events.indexOf(e.type) >= 0) {
-            g[e.type].call(g, e);
+          fn = g[e.type];
+          if (fn) {
+            fn.call(g, e);
           }
         }
       }
       this.gestureQueue.length = 0;
     },
     fillGestureQueue: function(ev) {
       // only trigger the gesture queue once
       if (!this.gestureQueue.length) {
         requestAnimationFrame(this.boundGestureTrigger);
       }
       this.gestureQueue.push(ev);
     }
   };
   dispatcher.boundHandler = dispatcher.eventHandler.bind(dispatcher);
   dispatcher.boundGestureTrigger = dispatcher.gestureTrigger.bind(dispatcher);
   scope.dispatcher = dispatcher;
-  scope.register = dispatcher.register.bind(dispatcher);
+  scope.register = function(root) {
+    dispatcher.register(root);
+  };
   scope.unregister = dispatcher.unregister.bind(dispatcher);
+  scope.wrap = wrap;
 })(window.PolymerGestures);
 
 /*
  * 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
  */
@@ skipping 136 matching lines @@
     HAS_BUTTONS = new MouseEvent('test', {buttons: 1}).buttons === 1;
   } catch (e) {}
 
   // handler block for native mouse events
   var mouseEvents = {
     POINTER_ID: 1,
     POINTER_TYPE: 'mouse',
     events: [
       'mousedown',
       'mousemove',
-      'mouseup',
+      'mouseup'
     ],
     register: function(target) {
+      if (target !== document) {
+        return;
+      }
       dispatcher.listen(target, this.events);
     },
     unregister: function(target) {
       dispatcher.unlisten(target, this.events);
     },
     lastTouches: [],
     // collide with the global mouse listener
     isEventSimulatedFromTouch: function(inEvent) {
       var lts = this.lastTouches;
       var x = inEvent.clientX, y = inEvent.clientY;
       for (var i = 0, l = lts.length, t; i < l && (t = lts[i]); i++) {
         // simulated mouse events will be swallowed near a primary touchend
         var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);
         if (dx <= DEDUP_DIST && dy <= DEDUP_DIST) {
           return true;
         }
       }
     },
     prepareEvent: function(inEvent) {
       var e = dispatcher.cloneEvent(inEvent);
       e.pointerId = this.POINTER_ID;
       e.isPrimary = true;
       e.pointerType = this.POINTER_TYPE;
+      e._source = 'mouse';
       if (!HAS_BUTTONS) {
         e.buttons = WHICH_TO_BUTTONS[e.which] || 0;
       }
       return e;
     },
     mousedown: function(inEvent) {
       if (!this.isEventSimulatedFromTouch(inEvent)) {
         var p = pointermap.has(this.POINTER_ID);
         // TODO(dfreedman) workaround for some elements not sending mouseup
         // http://crbug/149091
         if (p) {
           this.mouseup(inEvent);
         }
         var e = this.prepareEvent(inEvent);
+        e.target = scope.wrap(scope.findTarget(inEvent));
         pointermap.set(this.POINTER_ID, e.target);
         dispatcher.down(e);
       }
     },
     mousemove: function(inEvent) {
       if (!this.isEventSimulatedFromTouch(inEvent)) {
         var e = this.prepareEvent(inEvent);
         e.target = pointermap.get(this.POINTER_ID);
         dispatcher.move(e);
       }
     },
     mouseup: function(inEvent) {
       if (!this.isEventSimulatedFromTouch(inEvent)) {
         var e = this.prepareEvent(inEvent);
-        e.relatedTarget = e.target;
+        e.relatedTarget = scope.wrap(scope.findTarget(inEvent));
         e.target = pointermap.get(this.POINTER_ID);
         dispatcher.up(e);
         this.cleanupMouse();
       }
     },
     cleanupMouse: function() {
       pointermap['delete'](this.POINTER_ID);
     }
   };
 
@@ skipping 10 matching lines @@
  */
 
 (function(scope) {
   var dispatcher = scope.dispatcher;
   var allShadows = scope.targetFinding.allShadows.bind(scope.targetFinding);
   var pointermap = dispatcher.pointermap;
   var touchMap = Array.prototype.map.call.bind(Array.prototype.map);
   // This should be long enough to ignore compat mouse events made by touch
   var DEDUP_TIMEOUT = 2500;
   var CLICK_COUNT_TIMEOUT = 200;
+  var HYSTERESIS = 20;
   var ATTRIB = 'touch-action';
   var INSTALLER;
-  var HAS_TOUCH_ACTION = typeof document.head.style.touchAction === 'string';
+  // maybe one day...
+  // var CAN_USE_GLOBAL = ATTRIB in document.head.style;
+  var CAN_USE_GLOBAL = false;
 
   // handler block for native touch events
   var touchEvents = {
     events: [
       'touchstart',
       'touchmove',
       'touchend',
       'touchcancel'
     ],
     register: function(target) {
-      if (HAS_TOUCH_ACTION) {
+      if (CAN_USE_GLOBAL) {
         dispatcher.listen(target, this.events);
       } else {
         INSTALLER.enableOnSubtree(target);
       }
     },
     unregister: function(target) {
-      if (HAS_TOUCH_ACTION) {
+      if (CAN_USE_GLOBAL) {
         dispatcher.unlisten(target, this.events);
       } else {
         // TODO(dfreedman): is it worth it to disconnect the MO?
       }
     },
     elementAdded: function(el) {
       var a = el.getAttribute(ATTRIB);
       var st = this.touchActionToScrollType(a);
       if (st) {
         el._scrollType = st;
@@ skipping 27 matching lines @@
       } else if (oldSt) {
         this.elementRemoved(el);
       } else if (st) {
         this.elementAdded(el);
       }
     },
     scrollTypes: {
       EMITTER: 'none',
       XSCROLLER: 'pan-x',
       YSCROLLER: 'pan-y',
-      SCROLLER: /^(?:pan-x pan-y)|(?:pan-y pan-x)|auto$/
+      SCROLLER: /^(?:pan-x pan-y)|(?:pan-y pan-x)|auto|manipulation$/
     },
     touchActionToScrollType: function(touchAction) {
       var t = touchAction;
       var st = this.scrollTypes;
       if (t === 'none') {
         return 'none';
       } else if (t === st.XSCROLLER) {
         return 'X';
       } else if (t === st.YSCROLLER) {
         return 'Y';
       } else if (st.SCROLLER.exec(t)) {
         return 'XY';
       }
     },
     POINTER_TYPE: 'touch',
     firstTouch: null,
     isPrimaryTouch: function(inTouch) {
       return this.firstTouch === inTouch.identifier;
     },
     setPrimaryTouch: function(inTouch) {
       // set primary touch if there no pointers, or the only pointer is the mouse
       if (pointermap.pointers() === 0 || (pointermap.pointers() === 1 && pointermap.has(1))) {
         this.firstTouch = inTouch.identifier;
         this.firstXY = {X: inTouch.clientX, Y: inTouch.clientY};
-        this.scrolling = false;
+        this.scrolling = null;
         this.cancelResetClickCount();
       }
     },
     removePrimaryPointer: function(inPointer) {
       if (inPointer.isPrimary) {
         this.firstTouch = null;
         this.firstXY = null;
         this.resetClickCount();
       }
     },
@@ skipping 13 matching lines @@
     },
     typeToButtons: function(type) {
       var ret = 0;
       if (type === 'touchstart' || type === 'touchmove') {
         ret = 1;
       }
       return ret;
     },
     findTarget: function(touch, id) {
       if (this.currentTouchEvent.type === 'touchstart') {
-        return scope.findTarget(touch);
+        if (this.isPrimaryTouch(touch)) {
+          var fastPath = {
+            clientX: touch.clientX,
+            clientY: touch.clientY,
+            path: this.currentTouchEvent.path,
+            target: scope.wrap(this.currentTouchEvent.target)
+          };
+          return scope.findTarget(fastPath);
+        } else {
+          return scope.findTarget(touch);
+        }
       }
       // reuse target we found in touchstart
       return pointermap.get(id);
     },
     touchToPointer: function(inTouch) {
       var cte = this.currentTouchEvent;
       var e = dispatcher.cloneEvent(inTouch);
       // Spec specifies that pointerId 1 is reserved for Mouse.
       // Touch identifiers can start at 0.
       // Add 2 to the touch identifier for compatibility.
       var id = e.pointerId = inTouch.identifier + 2;
-      e.target = this.findTarget(inTouch, id);
+      e.target = scope.wrap(this.findTarget(inTouch, id));
       e.bubbles = true;
       e.cancelable = true;
       e.detail = this.clickCount;
       e.buttons = this.typeToButtons(cte.type);
       e.width = inTouch.webkitRadiusX || inTouch.radiusX || 0;
       e.height = inTouch.webkitRadiusY || inTouch.radiusY || 0;
       e.pressure = inTouch.webkitForce || inTouch.force || 0.5;
       e.isPrimary = this.isPrimaryTouch(inTouch);
       e.pointerType = this.POINTER_TYPE;
+      e._source = 'touch';
       // forward touch preventDefaults
       var self = this;
       e.preventDefault = function() {
         self.scrolling = false;
         self.firstXY = null;
         cte.preventDefault();
       };
       return e;
     },
     processTouches: function(inEvent, inFunction) {
       var tl = inEvent.changedTouches;
       this.currentTouchEvent = inEvent;
-      for (var i = 0, t; i < tl.length; i++) {
+      for (var i = 0, t, p; i < tl.length; i++) {
         t = tl[i];
-        inFunction.call(this, this.touchToPointer(t));
+        p = this.touchToPointer(t);
+        if (inEvent.type === 'touchstart') {
+          pointermap.set(p.pointerId, p.target);
+        }
+        if (pointermap.has(p.pointerId)) {
+          inFunction.call(this, p);
+        }
+        if (inEvent.type === 'touchend' || inEvent._cancel) {
+          this.cleanUpPointer(p);
+        }
       }
     },
     // For single axis scrollers, determines whether the element should emit
     // pointer events or behave as a scroller
     shouldScroll: function(inEvent) {
       if (this.firstXY) {
         var ret;
-        var scrollAxis = inEvent.currentTarget._scrollType;
+        var scrollAxis = scope.targetFinding.findScrollAxis(inEvent);
         if (scrollAxis === 'none') {
           // this element is a touch-action: none, should never scroll
           ret = false;
         } else if (scrollAxis === 'XY') {
           // this element should always scroll
           ret = true;
         } else {
           var t = inEvent.changedTouches[0];
           // check the intended scroll axis, and other axis
           var a = scrollAxis;
           var oa = scrollAxis === 'Y' ? 'X' : 'Y';
           var da = Math.abs(t['client' + a] - this.firstXY[a]);
           var doa = Math.abs(t['client' + oa] - this.firstXY[oa]);
           // if delta in the scroll axis > delta other axis, scroll instead of
           // making events
           ret = da >= doa;
         }
-        this.firstXY = null;
         return ret;
       }
     },
     findTouch: function(inTL, inId) {
       for (var i = 0, l = inTL.length, t; i < l && (t = inTL[i]); i++) {
         if (t.identifier === inId) {
           return true;
         }
       }
     },
     // In some instances, a touchstart can happen without a touchend. This
     // leaves the pointermap in a broken state.
     // Therefore, on every touchstart, we remove the touches that did not fire a
     // touchend event.
     // To keep state globally consistent, we fire a
     // pointercancel for this "abandoned" touch
     vacuumTouches: function(inEvent) {
       var tl = inEvent.touches;
       // pointermap.pointers() should be < tl.length here, as the touchstart has not
       // been processed yet.
       if (pointermap.pointers() >= tl.length) {
         var d = [];
         pointermap.forEach(function(value, key) {
           // Never remove pointerId == 1, which is mouse.
           // Touch identifiers are 2 smaller than their pointerId, which is the
           // index in pointermap.
           if (key !== 1 && !this.findTouch(tl, key - 2)) {
-            var p = value.out;
+            var p = value;
             d.push(p);
           }
         }, this);
-        d.forEach(this.cancelOut, this);
+        d.forEach(function(p) {
+          this.cancel(p);
+          pointermap.delete(p.pointerId);
+        });
       }
     },
     touchstart: function(inEvent) {
       this.vacuumTouches(inEvent);
       this.setPrimaryTouch(inEvent.changedTouches[0]);
       this.dedupSynthMouse(inEvent);
       if (!this.scrolling) {
         this.clickCount++;
         this.processTouches(inEvent, this.down);
       }
     },
     down: function(inPointer) {
-      var p = pointermap.set(inPointer.pointerId, inPointer.target);
       dispatcher.down(inPointer);
     },
     touchmove: function(inEvent) {
-      if (HAS_TOUCH_ACTION) {
+      if (CAN_USE_GLOBAL) {
         this.processTouches(inEvent, this.move);
       } else {
         if (!this.scrolling) {
-          if (this.shouldScroll(inEvent)) {
+          if (this.scrolling === null && this.shouldScroll(inEvent)) {
             this.scrolling = true;
-            this.touchcancel(inEvent);
           } else {
+            this.scrolling = false;
             inEvent.preventDefault();
             this.processTouches(inEvent, this.move);
           }
+        } else if (this.firstXY) {
+          var t = inEvent.changedTouches[0];
+          var dx = t.clientX - this.firstXY.X;
+          var dy = t.clientY - this.firstXY.Y;
+          var dd = Math.sqrt(dx * dx + dy * dy);
+          if (dd >= HYSTERESIS) {
+            this.touchcancel(inEvent);
+            this.scrolling = true;
+            this.firstXY = null;
+          }
         }
       }
     },
     move: function(inPointer) {
-      var pointer = pointermap.get(inPointer.pointerId);
-      // a finger drifted off the screen, ignore it
-      if (!pointer) {
-        return;
-      }
       dispatcher.move(inPointer);
     },
     touchend: function(inEvent) {
       this.dedupSynthMouse(inEvent);
       this.processTouches(inEvent, this.up);
     },
     up: function(inPointer) {
-      if (!this.scrolling) {
-        inPointer.relatedTarget = scope.findTarget(inPointer);
-        dispatcher.up(inPointer);
-      }
-      this.cleanUpPointer(inPointer);
+      inPointer.relatedTarget = scope.wrap(scope.findTarget(inPointer));
+      dispatcher.up(inPointer);
     },
     cancel: function(inPointer) {
-      inPointer.relatedTarget = scope.findTarget(inPointer);
       dispatcher.cancel(inPointer);
-      this.cleanUpPointer(inPointer);
     },
     touchcancel: function(inEvent) {
+      inEvent._cancel = true;
       this.processTouches(inEvent, this.cancel);
     },
     cleanUpPointer: function(inPointer) {
       pointermap['delete'](inPointer.pointerId);
       this.removePrimaryPointer(inPointer);
     },
     // prevent synth mouse events from creating pointer events
     dedupSynthMouse: function(inEvent) {
       var lts = scope.mouseEvents.lastTouches;
       var t = inEvent.changedTouches[0];
       // only the primary finger will synth mouse events
       if (this.isPrimaryTouch(t)) {
         // remember x/y of last touch
         var lt = {x: t.clientX, y: t.clientY};
         lts.push(lt);
         var fn = (function(lts, lt){
           var i = lts.indexOf(lt);
           if (i > -1) {
             lts.splice(i, 1);
           }
         }).bind(null, lts, lt);
         setTimeout(fn, DEDUP_TIMEOUT);
       }
     }
   };
 
-  if (!HAS_TOUCH_ACTION) {
+  if (!CAN_USE_GLOBAL) {
     INSTALLER = new scope.Installer(touchEvents.elementAdded, touchEvents.elementRemoved, touchEvents.elementChanged, touchEvents);
   }
 
   scope.touchEvents = touchEvents;
 })(window.PolymerGestures);
 
 /*
  * 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
  */
 
 (function(scope) {
   var dispatcher = scope.dispatcher;
   var pointermap = dispatcher.pointermap;
   var HAS_BITMAP_TYPE = window.MSPointerEvent && typeof window.MSPointerEvent.MSPOINTER_TYPE_MOUSE === 'number';
   var msEvents = {
     events: [
       'MSPointerDown',
       'MSPointerMove',
       'MSPointerUp',
       'MSPointerCancel',
     ],
     register: function(target) {
+      if (target !== document) {
+        return;
+      }
       dispatcher.listen(target, this.events);
     },
     unregister: function(target) {
       dispatcher.unlisten(target, this.events);
     },
     POINTER_TYPES: [
       '',
       'unavailable',
       'touch',
       'pen',
       'mouse'
     ],
     prepareEvent: function(inEvent) {
       var e = inEvent;
+      e = dispatcher.cloneEvent(inEvent);
       if (HAS_BITMAP_TYPE) {
-        e = dispatcher.cloneEvent(inEvent);
         e.pointerType = this.POINTER_TYPES[inEvent.pointerType];
       }
+      e._source = 'ms';
       return e;
     },
     cleanup: function(id) {
       pointermap['delete'](id);
     },
     MSPointerDown: function(inEvent) {
       var e = this.prepareEvent(inEvent);
+      e.target = scope.wrap(scope.findTarget(inEvent));
       pointermap.set(inEvent.pointerId, e.target);
       dispatcher.down(e);
     },
     MSPointerMove: function(inEvent) {
       var e = this.prepareEvent(inEvent);
       e.target = pointermap.get(e.pointerId);
       dispatcher.move(e);
     },
     MSPointerUp: function(inEvent) {
       var e = this.prepareEvent(inEvent);
-      e.relatedTarget = e.target;
+      e.relatedTarget = scope.wrap(scope.findTarget(inEvent));
       e.target = pointermap.get(e.pointerId);
       dispatcher.up(e);
       this.cleanup(inEvent.pointerId);
     },
     MSPointerCancel: function(inEvent) {
       var e = this.prepareEvent(inEvent);
-      e.relatedTarget = e.target;
+      e.relatedTarget = scope.wrap(scope.findTarget(inEvent));
       e.target = pointermap.get(e.pointerId);
       dispatcher.cancel(e);
       this.cleanup(inEvent.pointerId);
     }
   };
 
   scope.msEvents = msEvents;
 })(window.PolymerGestures);
 
 /*
  * 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
  */
 
 (function(scope) {
   var dispatcher = scope.dispatcher;
   var pointermap = dispatcher.pointermap;
   var pointerEvents = {
     events: [
       'pointerdown',
       'pointermove',
       'pointerup',
       'pointercancel'
     ],
     prepareEvent: function(inEvent) {
-      return dispatcher.cloneEvent(inEvent);
+      var e = dispatcher.cloneEvent(inEvent);
+      e._source = 'pointer';
+      return e;
     },
     register: function(target) {
+      if (target !== document) {
+        return;
+      }
       dispatcher.listen(target, this.events);
     },
     unregister: function(target) {
       dispatcher.unlisten(target, this.events);
     },
     cleanup: function(id) {
       pointermap['delete'](id);
     },
     pointerdown: function(inEvent) {
       var e = this.prepareEvent(inEvent);
+      e.target = scope.wrap(scope.findTarget(inEvent));
       pointermap.set(e.pointerId, e.target);
       dispatcher.down(e);
     },
     pointermove: function(inEvent) {
       var e = this.prepareEvent(inEvent);
       e.target = pointermap.get(e.pointerId);
       dispatcher.move(e);
     },
     pointerup: function(inEvent) {
       var e = this.prepareEvent(inEvent);
-      e.relatedTarget = e.target;
+      e.relatedTarget = scope.wrap(scope.findTarget(inEvent));
       e.target = pointermap.get(e.pointerId);
       dispatcher.up(e);
       this.cleanup(inEvent.pointerId);
     },
     pointercancel: function(inEvent) {
       var e = this.prepareEvent(inEvent);
-      e.relatedTarget = e.target;
+      e.relatedTarget = scope.wrap(scope.findTarget(inEvent));
       e.target = pointermap.get(e.pointerId);
       dispatcher.cancel(e);
       this.cleanup(inEvent.pointerId);
     }
   };
 
   scope.pointerEvents = pointerEvents;
 })(window.PolymerGestures);
 
 /*
@@ skipping 177 matching lines @@
          clientY: inEvent.clientY,
          pageX: inEvent.pageX,
          pageY: inEvent.pageY,
          screenX: inEvent.screenX,
          screenY: inEvent.screenY,
          xDirection: t.xDirection,
          yDirection: t.yDirection,
          trackInfo: t.trackInfo,
          relatedTarget: inEvent.relatedTarget,
          pointerType: inEvent.pointerType,
-         pointerId: inEvent.pointerId
+         pointerId: inEvent.pointerId,
+         _source: 'track'
        });
        t.downTarget.dispatchEvent(e);
      },
      down: function(inEvent) {
        if (inEvent.isPrimary && (inEvent.pointerType === 'mouse' ? inEvent.buttons === 1 : true)) {
          var p = {
            downEvent: inEvent,
            downTarget: inEvent.target,
            trackInfo: {},
            lastMoveEvent: null,
@@ skipping 78 matching lines @@
  * @extends hold
  */
 /**
  * Milliseconds pointer has been held down.
  * @type Number
  * @property holdTime
  */
 /**
  * This event is fired when a held pointer is released or moved.
  *
- * @class released
+ * @class release
  */
 
 (function(scope) {
   var dispatcher = scope.dispatcher;
   var eventFactory = scope.eventFactory;
   var hold = {
     // wait at least HOLD_DELAY ms between hold and pulse events
     HOLD_DELAY: 200,
     // pointer can move WIGGLE_THRESHOLD pixels before not counting as a hold
     WIGGLE_THRESHOLD: 16,
@@ skipping 41 matching lines @@
         }
       }
     },
     fireHold: function(inType, inHoldTime) {
       var p = {
         bubbles: true,
         cancelable: true,
         pointerType: this.heldPointer.pointerType,
         pointerId: this.heldPointer.pointerId,
         x: this.heldPointer.clientX,
-        y: this.heldPointer.clientY
+        y: this.heldPointer.clientY,
+        _source: 'hold'
       };
       if (inHoldTime) {
         p.holdTime = inHoldTime;
       }
       var e = eventFactory.makeGestureEvent(inType, p);
       this.target.dispatchEvent(e);
     }
   };
   dispatcher.registerGesture('hold', hold);
 })(window.PolymerGestures);
@@ skipping 72 matching lines @@
             bubbles: true,
             cancelable: true,
             x: inEvent.clientX,
             y: inEvent.clientY,
             detail: inEvent.detail,
             pointerType: inEvent.pointerType,
             pointerId: inEvent.pointerId,
             altKey: inEvent.altKey,
             ctrlKey: inEvent.ctrlKey,
             metaKey: inEvent.metaKey,
-            shiftKey: inEvent.shiftKey
+            shiftKey: inEvent.shiftKey,
+            _source: 'tap'
           });
           t.dispatchEvent(e);
         }
       }
       pointermap.delete(inEvent.pointerId);
     }
   };
   // patch eventFactory to remove id from tap's pointermap for preventTap calls
   eventFactory.preventTap = function(e) {
     return function() {
@@ skipping 751 matching lines @@
         expect('[');
 
         expr = parseExpression();
 
         expect(']');
 
         return expr;
     }
 
     function parseLeftHandSideExpression() {
-        var expr, property;
+        var expr, args, property;
 
         expr = parsePrimaryExpression();
 
-        while (match('.') || match('[')) {
+        while (true) {
             if (match('[')) {
                 property = parseComputedMember();
                 expr = delegate.createMemberExpression('[', expr, property);
-            } else {
+            } else if (match('.')) {
                 property = parseNonComputedMember();
                 expr = delegate.createMemberExpression('.', expr, property);
+            } else if (match('(')) {
+                args = parseArguments();
+                expr = delegate.createCallExpression(expr, args);
+            } else {
+                break;
             }
         }
 
         return expr;
     }
 
     // 11.3 Postfix Expressions
 
     var parsePostfixExpression = parseLeftHandSideExpression;
 
@@ skipping 352 matching lines @@
 
     setValue: function(model, newValue) {
       if (this.path.length == 1);
         model = findScope(model, this.path[0]);
 
       return this.path.setValueFrom(model, newValue);
     }
   };
 
   function MemberExpression(object, property, accessor) {
+    this.computed = accessor == '[';
+
     this.dynamicDeps = typeof object == 'function' ||
                        object.dynamicDeps ||
-                       (accessor == '[' && !(property instanceof Literal));
-
-    // convert literal computed property access where literal value is a value
-    // path to ident dot-access.
-    if (accessor == '[' &&
-        property instanceof Literal &&
-        Path.get(property.value).valid) {
-      accessor = '.';
-      property = new IdentPath(property.value);
-    }
+                       (this.computed && !(property instanceof Literal));
 
     this.simplePath =
         !this.dynamicDeps &&
-        property instanceof IdentPath &&
+        (property instanceof IdentPath || property instanceof Literal) &&
         (object instanceof MemberExpression || object instanceof IdentPath);
 
     this.object = this.simplePath ? object : getFn(object);
-    this.property = accessor == '.' ? property : getFn(property);
+    this.property = !this.computed || this.simplePath ?
+        property : getFn(property);
   }
 
   MemberExpression.prototype = {
     get fullPath() {
       if (!this.fullPath_) {
-        var last = this.object instanceof IdentPath ?
-            this.object.name : this.object.fullPath;
-        this.fullPath_ = Path.get(last + '.' + this.property.name);
+
+        var parts = this.object instanceof MemberExpression ?
+            this.object.fullPath.slice() : [this.object.name];
+        parts.push(this.property instanceof IdentPath ?
+            this.property.name : this.property.value);
+        this.fullPath_ = Path.get(parts);
       }
 
       return this.fullPath_;
     },
 
     valueFn: function() {
       if (!this.valueFn_) {
         var object = this.object;
 
         if (this.simplePath) {
           var path = this.fullPath;
 
           this.valueFn_ = function(model, observer) {
             if (observer)
               observer.addPath(model, path);
 
             return path.getValueFrom(model);
           };
-        } else if (this.property instanceof IdentPath) {
+        } else if (!this.computed) {
           var path = Path.get(this.property.name);
 
-          this.valueFn_ = function(model, observer) {
-            var context = object(model, observer);
+          this.valueFn_ = function(model, observer, filterRegistry) {
+            var context = object(model, observer, filterRegistry);
 
             if (observer)
               observer.addPath(context, path);
 
             return path.getValueFrom(context);
           }
         } else {
           // Computed property.
           var property = this.property;
 
-          this.valueFn_ = function(model, observer) {
-            var context = object(model, observer);
-            var propName = property(model, observer);
+          this.valueFn_ = function(model, observer, filterRegistry) {
+            var context = object(model, observer, filterRegistry);
+            var propName = property(model, observer, filterRegistry);
             if (observer)
-              observer.addPath(context, propName);
+              observer.addPath(context, [propName]);
 
             return context ? context[propName] : undefined;
           };
         }
       }
       return this.valueFn_;
     },
 
     setValue: function(model, newValue) {
       if (this.simplePath) {
@@ skipping 10 matching lines @@
 
   function Filter(name, args) {
     this.name = name;
     this.args = [];
     for (var i = 0; i < args.length; i++) {
       this.args[i] = getFn(args[i]);
     }
   }
 
   Filter.prototype = {
-    transform: function(value, toModelDirection, filterRegistry, model,
-                        observer) {
+    transform: function(model, observer, filterRegistry, toModelDirection,
+                        initialArgs) {
       var fn = filterRegistry[this.name];
       var context = model;
       if (fn) {
         context = undefined;
       } else {
         fn = context[this.name];
         if (!fn) {
-          console.error('Cannot find filter: ' + this.name);
+          console.error('Cannot find function or filter: ' + this.name);
           return;
         }
       }
 
       // If toModelDirection is falsey, then the "normal" (dom-bound) direction
       // is used. Otherwise, it looks for a 'toModel' property function on the
       // object.
       if (toModelDirection) {
         fn = fn.toModel;
       } else if (typeof fn.toDOM == 'function') {
         fn = fn.toDOM;
       }
 
       if (typeof fn != 'function') {
-        console.error('No ' + (toModelDirection ? 'toModel' : 'toDOM') +
-                      ' found on' + this.name);
+        console.error('Cannot find function or filter: ' + this.name);
         return;
       }
 
-      var args = [value];
+      var args = initialArgs || [];
       for (var i = 0; i < this.args.length; i++) {
-        args[i + 1] = getFn(this.args[i])(model, observer);
+        args.push(getFn(this.args[i])(model, observer, filterRegistry));
       }
 
       return fn.apply(context, args);
     }
   };
 
   function notImplemented() { throw Error('Not Implemented'); }
 
   var unaryOperators = {
     '+': function(v) { return +v; },
@@ skipping 33 matching lines @@
     this.dynamicDeps = false;
   }
 
   ASTDelegate.prototype = {
     createUnaryExpression: function(op, argument) {
       if (!unaryOperators[op])
         throw Error('Disallowed operator: ' + op);
 
       argument = getFn(argument);
 
-      return function(model, observer) {
-        return unaryOperators[op](argument(model, observer));
+      return function(model, observer, filterRegistry) {
+        return unaryOperators[op](argument(model, observer, filterRegistry));
       };
     },
 
     createBinaryExpression: function(op, left, right) {
       if (!binaryOperators[op])
         throw Error('Disallowed operator: ' + op);
 
       left = getFn(left);
       right = getFn(right);
 
-      return function(model, observer) {
-        return binaryOperators[op](left(model, observer),
-                                   right(model, observer));
+      return function(model, observer, filterRegistry) {
+        return binaryOperators[op](left(model, observer, filterRegistry),
+                                   right(model, observer, filterRegistry));
       };
     },
 
     createConditionalExpression: function(test, consequent, alternate) {
       test = getFn(test);
       consequent = getFn(consequent);
       alternate = getFn(alternate);
 
-      return function(model, observer) {
-        return test(model, observer) ?
-            consequent(model, observer) : alternate(model, observer);
+      return function(model, observer, filterRegistry) {
+        return test(model, observer, filterRegistry) ?
+            consequent(model, observer, filterRegistry) :
+            alternate(model, observer, filterRegistry);
       }
     },
 
     createIdentifier: function(name) {
       var ident = new IdentPath(name);
       ident.type = 'Identifier';
       return ident;
     },
 
     createMemberExpression: function(accessor, object, property) {
       var ex = new MemberExpression(object, property, accessor);
       if (ex.dynamicDeps)
         this.dynamicDeps = true;
       return ex;
     },
 
+    createCallExpression: function(expression, args) {
+      if (!(expression instanceof IdentPath))
+        throw Error('Only identifier function invocations are allowed');
+
+      var filter = new Filter(expression.name, args);
+
+      return function(model, observer, filterRegistry) {
+        return filter.transform(model, observer, filterRegistry, false);
+      };
+    },
+
     createLiteral: function(token) {
       return new Literal(token.value);
     },
 
     createArrayExpression: function(elements) {
       for (var i = 0; i < elements.length; i++)
         elements[i] = getFn(elements[i]);
 
-      return function(model, observer) {
+      return function(model, observer, filterRegistry) {
         var arr = []
         for (var i = 0; i < elements.length; i++)
-          arr.push(elements[i](model, observer));
+          arr.push(elements[i](model, observer, filterRegistry));
         return arr;
       }
     },
 
     createProperty: function(kind, key, value) {
       return {
         key: key instanceof IdentPath ? key.name : key.value,
         value: value
       };
     },
 
     createObjectExpression: function(properties) {
       for (var i = 0; i < properties.length; i++)
         properties[i].value = getFn(properties[i].value);
 
-      return function(model, observer) {
+      return function(model, observer, filterRegistry) {
         var obj = {};
         for (var i = 0; i < properties.length; i++)
-          obj[properties[i].key] = properties[i].value(model, observer);
+          obj[properties[i].key] =
+              properties[i].value(model, observer, filterRegistry);
         return obj;
       }
     },
 
     createFilter: function(name, args) {
       this.filters.push(new Filter(name, args));
     },
 
     createAsExpression: function(expression, scopeIdent) {
       this.expression = expression;
@@ skipping 70 matching lines @@
 
       function setValueFn(newValue) {
         self.setValue(model, newValue, filterRegistry);
         return newValue;
       }
 
       return new ObserverTransform(observer, valueFn, setValueFn, true);
     },
 
     getValue: function(model, observer, filterRegistry) {
-      var value = getFn(this.expression)(model, observer);
+      var value = getFn(this.expression)(model, observer, filterRegistry);
       for (var i = 0; i < this.filters.length; i++) {
-        value = this.filters[i].transform(value, false, filterRegistry, model,
-                                          observer);
+        value = this.filters[i].transform(model, observer, filterRegistry,
+            false, [value]);
       }
 
       return value;
     },
 
     setValue: function(model, newValue, filterRegistry) {
       var count = this.filters ? this.filters.length : 0;
       while (count-- > 0) {
-        newValue = this.filters[count].transform(newValue, true, filterRegistry,
-                                                 model);
+        newValue = this.filters[count].transform(model, undefined,
+            filterRegistry, true, [newValue]);
       }
 
       if (this.expression.setValue)
         return this.expression.setValue(model, newValue);
     }
   }
 
   /**
    * Converts a style property name to a css property name. For example:
    * "WebkitUserSelect" to "-webkit-user-select"
@@ skipping 91 matching lines @@
       if (!scopeName)
         return;
 
       var parentScope = template.templateInstance ?
           template.templateInstance.model :
           template.model;
 
       var indexName = template.polymerExpressionIndexIdent_;
 
       return function(model) {
-        var scope = Object.create(parentScope);
-        scope[scopeName] = model;
-        scope[indexName] = undefined;
-        scope[parentScopeName] = parentScope;
-        return scope;
+        return createScopeObject(parentScope, model, scopeName, indexName);
       };
     }
   };
 
+  var createScopeObject = ('__proto__' in {}) ?
+    function(parentScope, model, scopeName, indexName) {
+      var scope = {};
+      scope[scopeName] = model;
+      scope[indexName] = undefined;
+      scope[parentScopeName] = parentScope;
+      scope.__proto__ = parentScope;
+      return scope;
+    } :
+    function(parentScope, model, scopeName, indexName) {
+      var scope = Object.create(parentScope);
+      Object.defineProperty(scope, scopeName,
+          { value: model, configurable: true, writable: true });
+      Object.defineProperty(scope, indexName,
+          { value: undefined, configurable: true, writable: true });
+      Object.defineProperty(scope, parentScopeName,
+          { value: parentScope, configurable: true, writable: true });
+      return scope;
+    };
+
   global.PolymerExpressions = PolymerExpressions;
-  if (global.exposeGetExpression)
-    global.getExpression_ = getExpression;
-
+  PolymerExpressions.getExpression = getExpression;
 })(this);
 
 /*
  * 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
  */
 Polymer = {
-  version: '0.3.1-604ba08'
+  version: '0.3.3-0e73963'
 };
 
 /*
  * 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
  */
@@ skipping 458 matching lines @@
       * Fire an event asynchronously.
       * @method asyncFire
       * @param {string} type An event name.
       * @param detail
       * @param {Node} toNode Target node.
       */
     asyncFire: function(/*inType, inDetail*/) {
       this.async("fire", arguments);
     },
     /**
-      * Remove class from old, add class to anew, if they exist
+      * Remove class from old, add class to anew, if they exist.
       * @param classFollows
       * @param anew A node.
       * @param old A node
       * @param className
       */
     classFollows: function(anew, old, className) {
       if (old) {
         old.classList.remove(className);
       }
       if (anew) {
         anew.classList.add(className);
       }
+    },
+    /**
+      * Inject HTML which contains markup bound to this element into
+      * a target element (replacing target element content).
+      * @param String html to inject
+      * @param Element target element
+      */
+    injectBoundHTML: function(html, element) {
+      var template = document.createElement('template');
+      template.innerHTML = html;
+      var fragment = this.instanceTemplate(template);
+      if (element) {
+        element.textContent = '';
+        element.appendChild(fragment);
+      }
+      return fragment;
     }
   };
 
   // no-operation function for handy stubs
   var nop = function() {};
 
   // null-object for handy stubs
   var nob = {};
 
   // deprecated
@@ skipping 176 matching lines @@
   var log = window.logFlags || {};
 
   // magic words
 
   var OBSERVE_SUFFIX = 'Changed';
 
   // element api
 
   var empty = [];
 
+  var updateRecord = {
+    object: undefined,
+    type: 'update',
+    name: undefined,
+    oldValue: undefined
+  };
+
+  var numberIsNaN = Number.isNaN || function(value) {
+    return typeof value === 'number' && isNaN(value);
+  }
+
+  function areSameValue(left, right) {
+    if (left === right)
+      return left !== 0 || 1 / left === 1 / right;
+    if (numberIsNaN(left) && numberIsNaN(right))
+      return true;
+
+    return left !== left && right !== right;
+  }
+
+  // capture A's value if B's value is null or undefined,
+  // otherwise use B's value
+  function resolveBindingValue(oldValue, value) {
+    if (value === undefined && oldValue === null) {
+      return value;
+    }
+    return (value === null || value === undefined) ? oldValue : value;
+  }
+
   var properties = {
     createPropertyObserver: function() {
       var n$ = this._observeNames;
       if (n$ && n$.length) {
         var o = this._propertyObserver = new CompoundObserver(true);
-        this.registerObservers([o]);
+        this.registerObserver(o);
         // TODO(sorvell): may not be kosher to access the value here (this[n]);
         // previously we looked at the descriptor on the prototype
-        // this doesn't work for inheritance and not for accessors without 
+        // this doesn't work for inheritance and not for accessors without
         // a value property
         for (var i=0, l=n$.length, n; (i<l) && (n=n$[i]); i++) {
           o.addPath(this, n);
           this.observeArrayValue(n, this[n], null);
         }
       }
     },
     openPropertyObserver: function() {
       if (this._propertyObserver) {
         this._propertyObserver.open(this.notifyPropertyChanges, this);
@@ skipping 46 matching lines @@
         if (Array.isArray(value)) {
           log.observe && console.log('[%s] observeArrayValue: register observer [%s]', this.localName, name, value);
           var observer = new ArrayObserver(value);
           observer.open(function(value, old) {
             this.invokeMethod(callbackName, [old]);
           }, this);
           this.registerNamedObserver(name + '__array', observer);
         }
       }
     },
+    emitPropertyChangeRecord: function(name, value, oldValue) {
+      var object = this;
+      if (areSameValue(value, oldValue))
+        return;
+
+      this.propertyChanged_(name, value, oldValue);
+
+      if (!Observer.hasObjectObserve)
+        return;
+
+      var notifier = this.notifier_;
+      if (!notifier)
+        notifier = this.notifier_ = Object.getNotifier(this);
+
+      updateRecord.object = this;
+      updateRecord.name = name;
+      updateRecord.oldValue = oldValue;
+
+      notifier.notify(updateRecord);
+    },
+    bindToAccessor: function(name, observable, resolveFn) {
+      var privateName = name + '_';
+      var privateObservable  = name + 'Observable_';
+
+      this[privateObservable] = observable;
+      var oldValue = this[privateName];
+
+      var self = this;
+      var value = observable.open(function(value, oldValue) {
+        self[privateName] = value;
+        self.emitPropertyChangeRecord(name, value, oldValue);
+      });
+
+      if (resolveFn && !areSameValue(oldValue, value)) {
+        var resolvedValue = resolveFn(oldValue, value);
+        if (!areSameValue(value, resolvedValue)) {
+          value = resolvedValue;
+          if (observable.setValue)
+            observable.setValue(value);
+        }
+      }
+
+      this[privateName] = value;
+      this.emitPropertyChangeRecord(name, value, oldValue);
+
+      var observer = {
+        close: function() {
+          observable.close();
+          self[privateObservable] = undefined;
+        }
+      };
+      this.registerObserver(observer);
+      return observer;
+    },
+    createComputedProperties: function() {
+      if (!this._computedNames) {
+        return;
+      }
+
+      for (var i = 0; i < this._computedNames.length; i++) {
+        var name = this._computedNames[i];
+        var expressionText = this.computed[name];
+        try {
+          var expression = PolymerExpressions.getExpression(expressionText);
+          var observable = expression.getBinding(this, this.element.syntax);
+          this.bindToAccessor(name, observable);
+        } catch (ex) {
+          console.error('Failed to create computed property', ex);
+        }
+      }
+    },
     bindProperty: function(property, observable, oneTime) {
       if (oneTime) {
         this[property] = observable;
         return;
       }
-      return bindProperties(this, property, observable);
+      return this.bindToAccessor(property, observable, resolveBindingValue);
     },
     invokeMethod: function(method, args) {
       var fn = this[method] || method;
       if (typeof fn === 'function') {
         fn.apply(this, args);
       }
     },
-    registerObservers: function(observers) {
-      this._observers = this._observers || [];
-      this._observers.push(observers);
+    registerObserver: function(observer) {
+      if (!this._observers) {
+        this._observers = [observer];
+        return;
+      }
+
+      this._observers.push(observer);
     },
     // observer array items are arrays of observers.
     closeObservers: function() {
       if (!this._observers) {
         return;
       }
-      for (var i=0, l=this._observers.length; i<l; i++) {
-        this.closeObserverArray(this._observers[i]);
-      }
-      this._observers = [];
-    },
-    closeObserverArray: function(observerArray) {
-      for (var i=0, l=observerArray.length, o; i<l; i++) {
-        o = observerArray[i];
-        if (o && o.close) {
-          o.close();
+
+      var observers = this._observers;
+      for (var i = 0; i < observers.length; i++) {
+        var observer = observers[i];
+        if (observer && typeof observer.close == 'function') {
+          observer.close();
         }
       }
+
+      this._observers = [];
     },
     // bookkeeping observers for memory management
     registerNamedObserver: function(name, observer) {
       var o$ = this._namedObservers || (this._namedObservers = {});
       o$[name] = observer;
     },
     closeNamedObserver: function(name) {
       var o$ = this._namedObservers;
       if (o$ && o$[name]) {
         o$[name].close();
         o$[name] = null;
         return true;
       }
     },
     closeNamedObservers: function() {
       if (this._namedObservers) {
         for (var i in this._namedObservers) {
           this.closeNamedObserver(i);
         }
         this._namedObservers = {};
       }
     }
   };
 
-  // property binding
-  // bind a property in A to a path in B by converting A[property] to a
-  // getter/setter pair that accesses B[...path...]
-  function bindProperties(a, property, observable) {
-    // apply Polymer two-way reference binding
-    return Observer.bindToInstance(a, property, observable, resolveBindingValue);
-  }
-
-  // capture A's value if B's value is null or undefined,
-  // otherwise use B's value
-  function resolveBindingValue(oldValue, value) {
-    if (value === undefined && oldValue === null) {
-      return value;
-    }
-    return (value === null || value === undefined) ? oldValue : value;
-  }
-
   // logging
   var LOG_OBSERVE = '[%s] watching [%s]';
   var LOG_OBSERVED = '[%s#%s] watch: [%s] now [%s] was [%s]';
   var LOG_CHANGED = '[%s#%s] propertyChanged: [%s] now [%s] was [%s]';
 
   // exports
 
   scope.api.instance.properties = properties;
 
 })(Polymer);
@@ skipping 13 matching lines @@
 
   var log = window.logFlags || 0;
 
   // element api supporting mdv
   var mdv = {
     instanceTemplate: function(template) {
       // ensure a default bindingDelegate
       var syntax = this.syntax || (!template.bindingDelegate &&
           this.element.syntax);
       var dom = template.createInstance(this, syntax);
-      this.registerObservers(dom.bindings_);
+      var observers = dom.bindings_;
+      for (var i = 0; i < observers.length; i++) {
+        this.registerObserver(observers[i]);
+      }
       return dom;
     },
     bind: function(name, observable, oneTime) {
       var property = this.propertyForAttribute(name);
       if (!property) {
         // TODO(sjmiles): this mixin method must use the special form
         // of `super` installed by `mixinMethod` in declaration/prototype.js
         return this.mixinSuper(arguments);
       } else {
         // use n-way Polymer binding
@@ skipping 132 matching lines @@
       // process input attributes
       this.takeAttributes();
       // add event listeners
       this.addHostListeners();
     },
     makeElementReady: function() {
       if (this._readied) {
         return;
       }
       this._readied = true;
+      this.createComputedProperties();
       // TODO(sorvell): We could create an entry point here
       // for the user to compute property values.
       // process declarative resources
       this.parseDeclarations(this.__proto__);
       // TODO(sorvell): CE polyfill uses unresolved attribute to simulate
       // :unresolved; remove this attribute to be compatible with native
       // CE.
       this.removeAttribute('unresolved');
       // user entry point
       this.ready();
       // TODO (sorvell): temporarily open observer when created
       // turn on property observation and take any initial changes
       //this.openPropertyObserver();
     },
     attachedCallback: function() {
       this.cancelUnbindAll();
       // invoke user action
       if (this.attached) {
         this.attached();
       }
       // TODO(sorvell): bc
       if (this.enteredView) {
         this.enteredView();
       }
-      // NOTE: domReady can be used to access elements in dom (descendants, 
+      // NOTE: domReady can be used to access elements in dom (descendants,
       // ancestors, siblings) such that the developer is enured to upgrade
       // ordering. If the element definitions have loaded, domReady
       // can be used to access upgraded elements.
       if (!this.hasBeenAttached) {
         this.hasBeenAttached = true;
         if (this.domReady) {
           this.async('domReady');
         }
       }
     },
@@ skipping 44 matching lines @@
     // return a shadow-root template (if desired), override for custom behavior
     fetchTemplate: function(elementElement) {
       return elementElement.querySelector('template');
     },
     // utility function that creates a shadow root from a <template>
     shadowFromTemplate: function(template) {
       if (template) {
         // make a shadow root
         var root = this.createShadowRoot();
         // stamp template
-        // which includes parsing and applying MDV bindings before being 
+        // which includes parsing and applying MDV bindings before being
         // inserted (to avoid {{}} in attribute values)
         // e.g. to prevent <img src="images/{{icon}}"> from generating a 404.
         var dom = this.instanceTemplate(template);
         // append to shadow dom
         root.appendChild(dom);
         // perform post-construction initialization tasks on shadow root
         this.shadowRootReady(root, template);
         // return the created shadow root
         return root;
       }
     },
     // utility function that stamps a <template> into light-dom
     lightFromTemplate: function(template, refNode) {
       if (template) {
         // TODO(sorvell): mark this element as an eventController so that
         // event listeners on bound nodes inside it will be called on it.
-        // Note, the expectation here is that events on all descendants 
+        // Note, the expectation here is that events on all descendants
         // should be handled by this element.
         this.eventController = this;
         // stamp template
-        // which includes parsing and applying MDV bindings before being 
+        // which includes parsing and applying MDV bindings before being
         // inserted (to avoid {{}} in attribute values)
         // e.g. to prevent <img src="images/{{icon}}"> from generating a 404.
         var dom = this.instanceTemplate(template);
         // append to shadow dom
         if (refNode) {
-          this.insertBefore(dom, refNode);          
+          this.insertBefore(dom, refNode);
         } else {
           this.appendChild(dom);
         }
         // perform post-construction initialization tasks on ahem, light root
         this.shadowRootReady(this);
         // return the created shadow root
         return dom;
       }
     },
     shadowRootReady: function(root) {
@@ skipping 27 matching lines @@
       var observer = new MutationObserver(function(mutations) {
         listener.call(this, observer, mutations);
         observer.disconnect();
       }.bind(this));
       observer.observe(node, {childList: true, subtree: true});
     }
   };
 
   // true if object has own PolymerBase api
   function isBase(object) {
-    return object.hasOwnProperty('PolymerBase') 
+    return object.hasOwnProperty('PolymerBase')
   }
 
   // name a base constructor for dev tools
 
   function PolymerBase() {};
   PolymerBase.prototype = base;
   base.constructor = PolymerBase;
-  
+
   // exports
 
   scope.Base = PolymerBase;
   scope.isBase = isBase;
   scope.api.instance.base = base;
-  
+
 })(Polymer);
 
 /*
  * 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
  */
@@ skipping 644 matching lines @@
           }
         }
       }
       if (prototype.publish) {
         // construct name list
         var a = prototype._publishNames = [];
         for (var n in prototype.publish) {
           a.push(n);
         }
       }
+      if (prototype.computed) {
+        // construct name list
+        var a = prototype._computedNames = [];
+        for (var n in prototype.computed) {
+          a.push(n);
+        }
+      }
     },
     publishProperties: function(prototype, base) {
       // if we have any properties to publish
       var publish = prototype.publish;
       if (publish) {
         // transcribe `publish` entries onto own prototype
         this.requireProperties(publish, prototype, base);
         // construct map of lower-cased property names
         prototype._publishLC = this.lowerCaseMap(publish);
       }
     },
-    // sync prototype to property descriptors; 
-    // desriptor format contains default value and optionally a 
+    // sync prototype to property descriptors;
+    // desriptor format contains default value and optionally a
     // hint for reflecting the property to an attribute.
     // e.g. {foo: 5, bar: {value: true, reflect: true}}
     // reflect: {foo: true} is also supported
-    // 
+    //
     requireProperties: function(propertyDescriptors, prototype, base) {
       // reflected properties
       prototype.reflect = prototype.reflect || {};
       // ensure a prototype value for each property
-      // and update the property's reflect to attribute status 
+      // and update the property's reflect to attribute status
       for (var n in propertyDescriptors) {
         var propertyDescriptor = propertyDescriptors[n];
         var reflects = this.reflectHintForDescriptor(propertyDescriptor);
         if (prototype.reflect[n] === undefined && reflects !== undefined) {
           prototype.reflect[n] = reflects;
         }
         if (prototype[n] === undefined) {
-          prototype[n] = this.valueForDescriptor(propertyDescriptor); 
+          prototype[n] = this.valueForDescriptor(propertyDescriptor);
         }
       }
     },
     valueForDescriptor: function(propertyDescriptor) {
-      var value = typeof propertyDescriptor === 'object' && 
+      var value = typeof propertyDescriptor === 'object' &&
           propertyDescriptor ? propertyDescriptor.value : propertyDescriptor;
       return value !== undefined ? value : null;
     },
     // returns the value of the descriptor's 'reflect' property or undefined
     reflectHintForDescriptor: function(propertyDescriptor) {
       if (typeof propertyDescriptor === 'object' &&
           propertyDescriptor && propertyDescriptor.reflect !== undefined) {
         return propertyDescriptor.reflect;
       }
     },
     lowerCaseMap: function(properties) {
       var map = {};
       for (var n in properties) {
         map[n.toLowerCase()] = n;
       }
       return map;
     },
+    createPropertyAccessor: function(name) {
+      var proto = this.prototype;
+
+      var privateName = name + '_';
+      var privateObservable  = name + 'Observable_';
+      proto[privateName] = proto[name];
+
+      Object.defineProperty(proto, name, {
+        get: function() {
+          var observable = this[privateObservable];
+          if (observable)
+            observable.deliver();
+
+          return this[privateName];
+        },
+        set: function(value) {
+          var observable = this[privateObservable];
+          if (observable) {
+            observable.setValue(value);
+            return;
+          }
+
+          var oldValue = this[privateName];
+          this[privateName] = value;
+          this.emitPropertyChangeRecord(name, value, oldValue);
+
+          return value;
+        },
+        configurable: true
+      });
+    },
     createPropertyAccessors: function(prototype) {
       var n$ = prototype._publishNames;
       if (n$ && n$.length) {
         for (var i=0, l=n$.length, n, fn; (i<l) && (n=n$[i]); i++) {
-          Observer.createBindablePrototypeAccessor(prototype, n);
+          this.createPropertyAccessor(n);
         }
       }
+
+      var n$ = prototype._computedNames;
+      if (n$ && n$.length) {
+        for (var i=0, l=n$.length, n, fn; (i<l) && (n=n$[i]); i++) {
+          this.createPropertyAccessor(n);
+        }
+      }
+
     }
   };
 
   // exports
 
   scope.api.declaration.properties = properties;
 
 })(Polymer);
 
 /*
@@ skipping 27 matching lines @@
       var attributes = this.getAttribute(ATTRIBUTES_ATTRIBUTE);
       if (attributes) {
         // get properties to publish
         var publish = prototype.publish || (prototype.publish = {});
         // names='a b c' or names='a,b,c'
         var names = attributes.split(ATTRIBUTES_REGEX);
         // record each name for publishing
         for (var i=0, l=names.length, n; i<l; i++) {
           // remove excess ws
           n = names[i].trim();
-          // do not override explicit entries
-          if (n && publish[n] === undefined && base[n] === undefined) {
+          // if the user hasn't specified a value, we want to use the
+          // default, unless a superclass has already chosen one
+          if (n && publish[n] === undefined) {
+            // TODO(sjmiles): querying native properties on IE11 (and possibly
+            // on other browsers) throws an exception because there is no actual
+            // instance.
+            // In fact, trying to publish native properties is known bad for this
+            // and other reasons, and we need to solve this problem writ large.
+            try {
+              var hasValue = (base[n] !== undefined);
+            } catch(x) {
+              hasValue = false;
+            }
             // supply an empty 'descriptor' object and let the publishProperties
             // code determine a default
-            publish[n] = Polymer.nob;
+            if (!hasValue) {
+              publish[n] = Polymer.nob;
+            }
           }
         }
       }
     },
 
     // record clonable attributes from <element>
     accumulateInstanceAttributes: function() {
       // inherit instance attributes
       var clonable = this.prototype._instanceAttributes;
       // merge attributes from element
@@ skipping 773 matching lines @@
                prepareBinding.call(syntax, pathString, name, node);
       };
       return syntax;
     }
 
   });
 
 })();
 
 //# sourceMappingURL=polymer.concat.js.map