Roll polymer to 0.3.5

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 = {
-  hasSDPolyfill: Boolean(window.ShadowDOMPolyfill)
-};
-PolymerGestures.wrap = PolymerGestures.hasSDPolyfill ? ShadowDOMPolyfill.wrapIfNeeded : function(a){ return a; };
+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 HAS_FULL_PATH = false;
 
   // test for full event path support
   var pathTest = document.createElement('meta');
-  if (!scope.hasSDPolyfill && pathTest.createShadowRoot) {
+  if (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();
     });
@@ skipping 75 matching lines @@
       }
       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) {
+    findTouchAction: 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;
+          if (n.nodeType === Node.ELEMENT_NODE && n.hasAttribute('touch-action')) {
+            return n.getAttribute('touch-action');
           }
         }
       } else {
-        n = scope.wrap(inEvent.currentTarget);
+        n = inEvent.target;
         while(n) {
-          if (n._scrollType) {
-            return n._scrollType;
+          if (n.hasAttribute('touch-action')) {
+            return n.getAttribute('touch-action');
           }
           n = n.parentNode || n.host;
         }
       }
+      // auto is default
+      return "auto";
     },
     LCA: function(a, b) {
       if (a === b) {
         return a;
       }
       if (a && !b) {
         return a;
       }
       if (b && !a) {
         return b;
@@ skipping 92 matching lines @@
  * 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() {
   function shadowSelector(v) {
-    return 'body /deep/ ' + selector(v);
+    return 'html /deep/ ' + selector(v);
   }
   function selector(v) {
     return '[touch-action="' + v + '"]';
   }
   function rule(v) {
     return '{ -ms-touch-action: ' + v + '; touch-action: ' + v + ';}';
   }
   var attrib2css = [
     '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) {
       if (String(r) === r) {
         styles += selector(r) + rule(r) + '\n';
         if (hasShadowRoot) {
           styles += shadowSelector(r) + rule(r) + '\n';
@@ skipping 295 matching lines @@
     0,
     0,
     function(){},
     false
   ];
 
   var HAS_SVG_INSTANCE = (typeof SVGElementInstance !== 'undefined');
 
   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
    *   - pointercancel: a pointer will no longer generate events
    */
   var dispatcher = {
     pointermap: new scope.PointerMap(),
     eventMap: Object.create(null),
     // Scope objects for native events.
     // This exists for ease of testing.
     eventSources: Object.create(null),
     eventSourceList: [],
     gestures: [],
+    // map gesture event -> {listeners: int, index: gestures[int]}
+    dependencyMap: {
+      // make sure down and up are in the map to trigger "register"
+      down: {listeners: 0, index: -1},
+      up: {listeners: 0, index: -1}
+    },
     gestureQueue: [],
     /**
      * Add a new event source that will generate pointer events.
      *
      * `inSource` must contain an array of event names named `events`, and
      * functions with the names specified in the `events` array.
      * @param {string} name A name for the event source
      * @param {Object} source A new source of platform events.
      */
     registerSource: function(name, source) {
       var s = source;
       var newEvents = s.events;
       if (newEvents) {
         newEvents.forEach(function(e) {
           if (s[e]) {
             this.eventMap[e] = s[e].bind(s);
           }
         }, this);
         this.eventSources[name] = s;
         this.eventSourceList.push(s);
       }
     },
     registerGesture: function(name, source) {
+      var obj = Object.create(null);
+      obj.listeners = 0;
+      obj.index = this.gestures.length;
+      for (var i = 0, g; i < source.exposes.length; i++) {
+        g = source.exposes[i].toLowerCase();
+        this.dependencyMap[g] = obj;
+      }
       this.gestures.push(source);
     },
-    register: function(element) {
+    register: function(element, initial) {
       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);
+        es.register.call(es, element, initial);
       }
     },
     unregister: function(element) {
       var l = this.eventSourceList.length;
       for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) {
         // call eventsource register
         es.unregister.call(es, element);
       }
     },
     // EVENTS
@@ skipping 10 matching lines @@
     },
     cancel: function(inEvent) {
       inEvent.tapPrevented = true;
       this.fireEvent('up', inEvent);
     },
     // LISTENER LOGIC
     eventHandler: function(inEvent) {
       // This is used to prevent multiple dispatch of events from
       // platform events. This can happen when two elements in different scopes
       // are set up to create pointer events, which is relevant to Shadow DOM.
+
+      // TODO(dfreedm): make this check more granular, allow for minimal event generation
+      // e.g inEvent._handledByPG['tap'] and inEvent._handledByPG['track'], etc
       if (inEvent._handledByPG) {
         return;
       }
       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) {
       for (var i = 0, l = events.length, e; (i < l) && (e = events[i]); i++) {
         this.addEvent(target, e);
       }
     },
     // remove event listeners
     unlisten: function(target, events) {
       for (var i = 0, l = events.length, e; (i < l) && (e = events[i]); i++) {
         this.removeEvent(target, e);
       }
     },
     addEvent: function(target, eventName) {
-      // NOTE: Work around for #4, use native event listener in SD Polyfill
-      if (hasSDPolyfill) {
-        target.addEventListener_(eventName, this.boundHandler);
-      } else {
-        target.addEventListener(eventName, this.boundHandler);
-      }
+      target.addEventListener(eventName, this.boundHandler);
     },
     removeEvent: function(target, eventName) {
-      // NOTE: Work around for #4, use native event listener in SD Polyfill
-      if (hasSDPolyfill) {
-        target.removeEventListener_(eventName, this.boundHandler);
-      } else {
-        target.removeEventListener(eventName, this.boundHandler);
-      }
+      target.removeEventListener(eventName, this.boundHandler);
     },
     // EVENT CREATION AND TRACKING
     /**
      * Creates a new Event of type `inType`, based on the information in
      * `inEvent`.
      *
      * @param {string} inType A string representing the type of event to create
      * @param {Event} inEvent A platform event with a target
      * @return {Event} A PointerEvent of type `inType`
      */
@@ skipping 21 matching lines @@
       for (var i = 0; i < CLONE_PROPS.length; i++) {
         p = CLONE_PROPS[i];
         eventCopy[p] = inEvent[p] || CLONE_DEFAULTS[i];
         // Work around SVGInstanceElement shadow tree
         // Return the <use> element that is represented by the instance for Safari, Chrome, IE.
         // This is the behavior implemented by Firefox.
         if (p === 'target' || p === 'relatedTarget') {
           if (HAS_SVG_INSTANCE && eventCopy[p] instanceof SVGElementInstance) {
             eventCopy[p] = eventCopy[p].correspondingUseElement;
           }
-          eventCopy[p] = wrap(eventCopy[p]);
         }
       }
       // keep the semantics of preventDefault
-      eventCopy.preventDefault = inEvent.preventDefault;
+      eventCopy.preventDefault = function() {
+        inEvent.preventDefault();
+      };
       return eventCopy;
     },
     /**
      * Dispatches the event to its target.
      *
      * @param {Event} inEvent The event to be dispatched.
      * @return {Boolean} True if an event handler returns true, false otherwise.
      */
     dispatchEvent: function(inEvent) {
       var t = inEvent._target;
       if (t) {
         t.dispatchEvent(inEvent);
         // clone the event for the gesture system to process
         // 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, fn; j < this.gestures.length; j++) {
           g = this.gestures[j];
           fn = g[e.type];
-          if (fn) {
+          if (g.enabled && 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 = function(root) {
-    dispatcher.register(root);
+
+  /**
+   * Listen for `gesture` on `node` with the `handler` function
+   *
+   * If `handler` is the first listener for `gesture`, the underlying gesture recognizer is then enabled.
+   *
+   * @param {Element} node
+   * @param {string} gesture
+   * @return Boolean `gesture` is a valid gesture
+   */
+  scope.activateGesture = function(node, gesture) {
+    var g = gesture.toLowerCase();
+    var dep = dispatcher.dependencyMap[g];
+    if (dep) {
+      var recognizer = dispatcher.gestures[dep.index];
+      if (dep.listeners === 0) {
+        if (recognizer) {
+          recognizer.enabled = true;
+        }
+      }
+      dep.listeners++;
+      if (!node._pgListeners) {
+        dispatcher.register(node);
+        node._pgListeners = 0;
+      }
+      // TODO(dfreedm): re-evaluate bookkeeping to avoid using attributes
+      if (recognizer) {
+        var touchAction = recognizer.defaultActions && recognizer.defaultActions[g];
+        var actionNode;
+        switch(node.nodeType) {
+          case Node.ELEMENT_NODE:
+            actionNode = node;
+          break;
+          case Node.DOCUMENT_FRAGMENT_NODE:
+            actionNode = node.host;
+          break;
+          default:
+            actionNode = null;
+          break;
+        }
+        if (touchAction && actionNode && !actionNode.hasAttribute('touch-action')) {
+          actionNode.setAttribute('touch-action', touchAction);
+        }
+      }
+      node._pgListeners++;
+    }
+    return Boolean(dep);
   };
-  scope.unregister = dispatcher.unregister.bind(dispatcher);
-  scope.wrap = wrap;
+
+  /**
+   *
+   * Listen for `gesture` from `node` with `handler` function.
+   *
+   * @param {Element} node
+   * @param {string} gesture
+   * @param {Function} handler
+   * @param {Boolean} capture
+   */
+  scope.addEventListener = function(node, gesture, handler, capture) {
+    if (handler) {
+      scope.activateGesture(node, gesture);
+      node.addEventListener(gesture, handler, capture);
+    }
+  };
+
+  /**
+   * Tears down the gesture configuration for `node`
+   *
+   * If `handler` is the last listener for `gesture`, the underlying gesture recognizer is disabled.
+   *
+   * @param {Element} node
+   * @param {string} gesture
+   * @return Boolean `gesture` is a valid gesture
+   */
+  scope.deactivateGesture = function(node, gesture) {
+    var g = gesture.toLowerCase();
+    var dep = dispatcher.dependencyMap[g];
+    if (dep) {
+      if (dep.listeners > 0) {
+        dep.listeners--;
+      }
+      if (dep.listeners === 0) {
+        var recognizer = dispatcher.gestures[dep.index];
+        if (recognizer) {
+          recognizer.enabled = false;
+        }
+      }
+      if (node._pgListeners > 0) {
+        node._pgListeners--;
+      }
+      if (node._pgListeners === 0) {
+        dispatcher.unregister(node);
+      }
+    }
+    return Boolean(dep);
+  };
+
+  /**
+   * Stop listening for `gesture` from `node` with `handler` function.
+   *
+   * @param {Element} node
+   * @param {string} gesture
+   * @param {Function} handler
+   * @param {Boolean} capture
+   */
+  scope.removeEventListener = function(node, gesture, handler, capture) {
+    if (handler) {
+      scope.deactivateGesture(node, gesture);
+      node.removeEventListener(gesture, handler, capture);
+    }
+  };
 })(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
- */
-
-/**
- * This module uses Mutation Observers to dynamically adjust which nodes will
- * generate Pointer Events.
- *
- * All nodes that wish to generate Pointer Events must have the attribute
- * `touch-action` set to `none`.
- */
-(function(scope) {
-  var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
-  var map = Array.prototype.map.call.bind(Array.prototype.map);
-  var toArray = Array.prototype.slice.call.bind(Array.prototype.slice);
-  var filter = Array.prototype.filter.call.bind(Array.prototype.filter);
-  var MO = window.MutationObserver || window.WebKitMutationObserver;
-  var SELECTOR = '[touch-action]';
-  var OBSERVER_INIT = {
-    subtree: true,
-    childList: true,
-    attributes: true,
-    attributeOldValue: true,
-    attributeFilter: ['touch-action']
-  };
-
-  function Installer(add, remove, changed, binder) {
-    this.addCallback = add.bind(binder);
-    this.removeCallback = remove.bind(binder);
-    this.changedCallback = changed.bind(binder);
-    if (MO) {
-      this.observer = new MO(this.mutationWatcher.bind(this));
-    }
-  }
-
-  Installer.prototype = {
-    watchSubtree: function(target) {
-      // Only watch scopes that can target find, as these are top-level.
-      // Otherwise we can see duplicate additions and removals that add noise.
-      //
-      // TODO(dfreedman): For some instances with ShadowDOMPolyfill, we can see
-      // a removal without an insertion when a node is redistributed among
-      // shadows. Since it all ends up correct in the document, watching only
-      // the document will yield the correct mutations to watch.
-      if (scope.targetFinding.canTarget(target)) {
-        this.observer.observe(target, OBSERVER_INIT);
-      }
-    },
-    enableOnSubtree: function(target) {
-      this.watchSubtree(target);
-      if (target === document && document.readyState !== 'complete') {
-        this.installOnLoad();
-      } else {
-        this.installNewSubtree(target);
-      }
-    },
-    installNewSubtree: function(target) {
-      forEach(this.findElements(target), this.addElement, this);
-    },
-    findElements: function(target) {
-      if (target.querySelectorAll) {
-        return target.querySelectorAll(SELECTOR);
-      }
-      return [];
-    },
-    removeElement: function(el) {
-      this.removeCallback(el);
-    },
-    addElement: function(el) {
-      this.addCallback(el);
-    },
-    elementChanged: function(el, oldValue) {
-      this.changedCallback(el, oldValue);
-    },
-    concatLists: function(accum, list) {
-      return accum.concat(toArray(list));
-    },
-    // register all touch-action = none nodes on document load
-    installOnLoad: function() {
-      document.addEventListener('readystatechange', function() {
-        if (document.readyState === 'complete') {
-          this.installNewSubtree(document);
-        }
-      }.bind(this));
-    },
-    isElement: function(n) {
-      return n.nodeType === Node.ELEMENT_NODE;
-    },
-    flattenMutationTree: function(inNodes) {
-      // find children with touch-action
-      var tree = map(inNodes, this.findElements, this);
-      // make sure the added nodes are accounted for
-      tree.push(filter(inNodes, this.isElement));
-      // flatten the list
-      return tree.reduce(this.concatLists, []);
-    },
-    mutationWatcher: function(mutations) {
-      mutations.forEach(this.mutationHandler, this);
-    },
-    mutationHandler: function(m) {
-      if (m.type === 'childList') {
-        var added = this.flattenMutationTree(m.addedNodes);
-        added.forEach(this.addElement, this);
-        var removed = this.flattenMutationTree(m.removedNodes);
-        removed.forEach(this.removeElement, this);
-      } else if (m.type === 'attributes') {
-        this.elementChanged(m.target, m.oldValue);
-      }
-    }
-  };
-
-  if (!MO) {
-    Installer.prototype.watchSubtree = function(){
-      console.warn('PolymerGestures: MutationObservers not found, touch-action will not be dynamically detected');
-    };
-  }
-
-  scope.Installer = Installer;
-})(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;
@@ skipping 10 matching lines @@
 
   // handler block for native mouse events
   var mouseEvents = {
     POINTER_ID: 1,
     POINTER_TYPE: 'mouse',
     events: [
       'mousedown',
       'mousemove',
       'mouseup'
     ],
+    exposes: [
+      'down',
+      'up',
+      'move'
+    ],
     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;
@@ skipping 18 matching lines @@
     },
     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));
+        e.target = 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);
+        var target = pointermap.get(this.POINTER_ID);
+        if (target) {
+          var e = this.prepareEvent(inEvent);
+          e.target = target;
+          // handle case where we missed a mouseup
+          if (e.buttons === 0) {
+            dispatcher.cancel(e);
+            this.cleanupMouse();
+          } else {
+            dispatcher.move(e);
+          }
+        }
       }
     },
     mouseup: function(inEvent) {
       if (!this.isEventSimulatedFromTouch(inEvent)) {
         var e = this.prepareEvent(inEvent);
-        e.relatedTarget = scope.wrap(scope.findTarget(inEvent));
+        e.relatedTarget = scope.findTarget(inEvent);
         e.target = pointermap.get(this.POINTER_ID);
         dispatcher.up(e);
         this.cleanupMouse();
       }
     },
     cleanupMouse: function() {
       pointermap['delete'](this.POINTER_ID);
     }
   };
 
@@ skipping 12 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;
-  // maybe one day...
-  // var CAN_USE_GLOBAL = ATTRIB in document.head.style;
-  var CAN_USE_GLOBAL = false;
+  // TODO(dfreedm): disable until http://crbug.com/399765 is resolved
+  // var HAS_TOUCH_ACTION = ATTRIB in document.head.style;
+  var HAS_TOUCH_ACTION = false;
 
   // handler block for native touch events
   var touchEvents = {
     events: [
       'touchstart',
       'touchmove',
       'touchend',
       'touchcancel'
     ],
-    register: function(target) {
-      if (CAN_USE_GLOBAL) {
-        dispatcher.listen(target, this.events);
-      } else {
-        INSTALLER.enableOnSubtree(target);
+    exposes: [
+      'down',
+      'up',
+      'move'
+    ],
+    register: function(target, initial) {
+      if (initial) {
+        return;
       }
+      dispatcher.listen(target, this.events);
     },
     unregister: function(target) {
-      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;
-        dispatcher.listen(el, this.events);
-        // set touch-action on shadows as well
-        allShadows(el).forEach(function(s) {
-          s._scrollType = st;
-          dispatcher.listen(s, this.events);
-        }, this);
-      }
-    },
-    elementRemoved: function(el) {
-      el._scrollType = undefined;
-      dispatcher.unlisten(el, this.events);
-      // remove touch-action from shadow
-      allShadows(el).forEach(function(s) {
-        s._scrollType = undefined;
-        dispatcher.unlisten(s, this.events);
-      }, this);
-    },
-    elementChanged: function(el, oldValue) {
-      var a = el.getAttribute(ATTRIB);
-      var st = this.touchActionToScrollType(a);
-      var oldSt = this.touchActionToScrollType(oldValue);
-      // simply update scrollType if listeners are already established
-      if (st && oldSt) {
-        el._scrollType = st;
-        allShadows(el).forEach(function(s) {
-          s._scrollType = st;
-        }, this);
-      } else if (oldSt) {
-        this.elementRemoved(el);
-      } else if (st) {
-        this.elementAdded(el);
-      }
+      dispatcher.unlisten(target, this.events);
     },
     scrollTypes: {
       EMITTER: 'none',
       XSCROLLER: 'pan-x',
       YSCROLLER: 'pan-y',
-      SCROLLER: /^(?:pan-x pan-y)|(?:pan-y pan-x)|auto|manipulation$/
     },
     touchActionToScrollType: function(touchAction) {
       var t = touchAction;
       var st = this.scrollTypes;
-      if (t === 'none') {
+      if (t === st.EMITTER) {
         return 'none';
       } else if (t === st.XSCROLLER) {
         return 'X';
       } else if (t === st.YSCROLLER) {
         return 'Y';
-      } else if (st.SCROLLER.exec(t)) {
+      } else {
         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
@@ skipping 32 matching lines @@
       }
       return ret;
     },
     findTarget: function(touch, id) {
       if (this.currentTouchEvent.type === 'touchstart') {
         if (this.isPrimaryTouch(touch)) {
           var fastPath = {
             clientX: touch.clientX,
             clientY: touch.clientY,
             path: this.currentTouchEvent.path,
-            target: scope.wrap(this.currentTouchEvent.target)
+            target: 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 = scope.wrap(this.findTarget(inTouch, id));
+      e.target = 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';
@@ skipping 21 matching lines @@
         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 = scope.targetFinding.findScrollAxis(inEvent);
+        var touchAction = scope.targetFinding.findTouchAction(inEvent);
+        var scrollAxis = this.touchActionToScrollType(touchAction);
         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;
@@ skipping 47 matching lines @@
       this.dedupSynthMouse(inEvent);
       if (!this.scrolling) {
         this.clickCount++;
         this.processTouches(inEvent, this.down);
       }
     },
     down: function(inPointer) {
       dispatcher.down(inPointer);
     },
     touchmove: function(inEvent) {
-      if (CAN_USE_GLOBAL) {
-        this.processTouches(inEvent, this.move);
+      if (HAS_TOUCH_ACTION) {
+        // touchevent.cancelable == false is sent when the page is scrolling under native Touch Action in Chrome 36
+        // https://groups.google.com/a/chromium.org/d/msg/input-dev/wHnyukcYBcA/b9kmtwM1jJQJ
+        if (inEvent.cancelable) {
+          this.processTouches(inEvent, this.move);
+        }
       } else {
         if (!this.scrolling) {
           if (this.scrolling === null && this.shouldScroll(inEvent)) {
             this.scrolling = true;
           } else {
             this.scrolling = false;
             inEvent.preventDefault();
             this.processTouches(inEvent, this.move);
           }
         } else if (this.firstXY) {
@@ skipping 10 matching lines @@
       }
     },
     move: function(inPointer) {
       dispatcher.move(inPointer);
     },
     touchend: function(inEvent) {
       this.dedupSynthMouse(inEvent);
       this.processTouches(inEvent, this.up);
     },
     up: function(inPointer) {
-      inPointer.relatedTarget = scope.wrap(scope.findTarget(inPointer));
+      inPointer.relatedTarget = scope.findTarget(inPointer);
       dispatcher.up(inPointer);
     },
     cancel: function(inPointer) {
       dispatcher.cancel(inPointer);
     },
     touchcancel: function(inEvent) {
       inEvent._cancel = true;
       this.processTouches(inEvent, this.cancel);
     },
     cleanUpPointer: function(inPointer) {
@@ skipping 13 matching lines @@
           var i = lts.indexOf(lt);
           if (i > -1) {
             lts.splice(i, 1);
           }
         }).bind(null, lts, lt);
         setTimeout(fn, DEDUP_TIMEOUT);
       }
     }
   };
 
-  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
@@ skipping 33 matching lines @@
         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));
+      e.target = 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 = scope.wrap(scope.findTarget(inEvent));
+      e.relatedTarget = 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 = scope.wrap(scope.findTarget(inEvent));
+      e.relatedTarget = scope.findTarget(inEvent);
       e.target = pointermap.get(e.pointerId);
       dispatcher.cancel(e);
       this.cleanup(inEvent.pointerId);
     }
   };
 
   scope.msEvents = msEvents;
 })(window.PolymerGestures);
 
 /*
@@ skipping 27 matching lines @@
       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));
+      e.target = 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 = scope.wrap(scope.findTarget(inEvent));
+      e.relatedTarget = 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 = scope.wrap(scope.findTarget(inEvent));
+      e.relatedTarget = scope.findTarget(inEvent);
       e.target = pointermap.get(e.pointerId);
       dispatcher.cancel(e);
       this.cleanup(inEvent.pointerId);
     }
   };
 
   scope.pointerEvents = pointerEvents;
 })(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
  */
 
 /**
  * This module contains the handlers for native platform events.
  * From here, the dispatcher is called to create unified pointer events.
  * Included are touch events (v1), mouse events, and MSPointerEvents.
  */
 (function(scope) {
   var dispatcher = scope.dispatcher;
+  var nav = window.navigator;
 
   if (window.PointerEvent) {
     dispatcher.registerSource('pointer', scope.pointerEvents);
-  } else if (window.navigator.msPointerEnabled) {
+  } else if (nav.msPointerEnabled) {
     dispatcher.registerSource('ms', scope.msEvents);
   } else {
     dispatcher.registerSource('mouse', scope.mouseEvents);
     if (window.ontouchstart !== undefined) {
       dispatcher.registerSource('touch', scope.touchEvents);
+      /*
+       * NOTE: an empty touch listener on body will reactivate nodes imported from templates with touch listeners
+       * Removing it will re-break the nodes
+       *
+       * Work around for https://bugs.webkit.org/show_bug.cgi?id=135628
+       */
+      var isSafari = nav.userAgent.match('Safari') && !nav.userAgent.match('Chrome');
+      if (isSafari) {
+        document.body.addEventListener('touchstart', function(){});
+      }
     }
   }
-
-  dispatcher.register(document);
+  dispatcher.register(document, true);
 })(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 97 matching lines @@
  (function(scope) {
    var dispatcher = scope.dispatcher;
    var eventFactory = scope.eventFactory;
    var pointermap = new scope.PointerMap();
    var track = {
      events: [
        'down',
        'move',
        'up',
      ],
+     exposes: [
+      'trackstart',
+      'track',
+      'trackx',
+      'tracky',
+      'trackend'
+     ],
+     defaultActions: {
+       'track': 'none',
+       'trackx': 'pan-y',
+       'tracky': 'pan-x'
+     },
      WIGGLE_THRESHOLD: 4,
      clampDir: function(inDelta) {
        return inDelta > 0 ? 1 : -1;
      },
      calcPositionDelta: function(inA, inB) {
        var x = 0, y = 0;
        if (inA && inB) {
          x = inB.pageX - inA.pageX;
          y = inB.pageY - inA.pageY;
        }
        return {x: x, y: y};
      },
      fireTrack: function(inType, inEvent, inTrackingData) {
        var t = inTrackingData;
        var d = this.calcPositionDelta(t.downEvent, inEvent);
        var dd = this.calcPositionDelta(t.lastMoveEvent, inEvent);
        if (dd.x) {
          t.xDirection = this.clampDir(dd.x);
+       } else if (inType === 'trackx') {
+         return;
        }
        if (dd.y) {
          t.yDirection = this.clampDir(dd.y);
+       } else if (inType === 'tracky') {
+         return;
        }
-       var e = eventFactory.makeGestureEvent(inType, {
+       var gestureProto = {
          bubbles: true,
          cancelable: true,
-         dx: d.x,
-         dy: d.y,
-         ddx: dd.x,
-         ddy: dd.y,
-         x: inEvent.x,
-         y: inEvent.y,
-         clientX: inEvent.clientX,
-         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,
          _source: 'track'
-       });
+       };
+       if (inType !== 'tracky') {
+         gestureProto.x = inEvent.x;
+         gestureProto.dx = d.x;
+         gestureProto.ddx = dd.x;
+         gestureProto.clientX = inEvent.clientX;
+         gestureProto.pageX = inEvent.pageX;
+         gestureProto.screenX = inEvent.screenX;
+         gestureProto.xDirection = t.xDirection;
+       }
+       if (inType !== 'trackx') {
+         gestureProto.dy = d.y;
+         gestureProto.ddy = dd.y;
+         gestureProto.y = inEvent.y;
+         gestureProto.clientY = inEvent.clientY;
+         gestureProto.pageY = inEvent.pageY;
+         gestureProto.screenY = inEvent.screenY;
+         gestureProto.yDirection = t.yDirection;
+       }
+       var e = eventFactory.makeGestureEvent(inType, gestureProto);
        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,
            xDirection: 0,
            yDirection: 0,
            tracking: false
          };
          pointermap.set(inEvent.pointerId, p);
        }
      },
      move: function(inEvent) {
        var p = pointermap.get(inEvent.pointerId);
        if (p) {
          if (!p.tracking) {
            var d = this.calcPositionDelta(p.downEvent, inEvent);
            var move = d.x * d.x + d.y * d.y;
            // start tracking only if finger moves more than WIGGLE_THRESHOLD
            if (move > this.WIGGLE_THRESHOLD) {
              p.tracking = true;
-             this.fireTrack('trackstart', p.downEvent, p);
-             this.fireTrack('track', inEvent, p);
+             p.lastMoveEvent = p.downEvent;
+             this.fireTrack('trackstart', inEvent, p);
            }
-         } else {
+         }
+         if (p.tracking) {
            this.fireTrack('track', inEvent, p);
+           this.fireTrack('trackx', inEvent, p);
+           this.fireTrack('tracky', inEvent, p);
          }
          p.lastMoveEvent = inEvent;
        }
      },
      up: function(inEvent) {
        var p = pointermap.get(inEvent.pointerId);
        if (p) {
          if (p.tracking) {
            this.fireTrack('trackend', inEvent, p);
          }
@@ skipping 63 matching lines @@
   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,
     events: [
       'down',
       'move',
       'up',
     ],
+    exposes: [
+      'hold',
+      'holdpulse',
+      'release'
+    ],
     heldPointer: null,
     holdJob: null,
     pulse: function() {
       var hold = Date.now() - this.heldPointer.timeStamp;
       var type = this.held ? 'holdpulse' : 'hold';
       this.fireHold(type, hold);
       this.held = true;
     },
     cancel: function() {
       clearInterval(this.holdJob);
@@ skipping 86 matching lines @@
  */
 (function(scope) {
   var dispatcher = scope.dispatcher;
   var eventFactory = scope.eventFactory;
   var pointermap = new scope.PointerMap();
   var tap = {
     events: [
       'down',
       'up'
     ],
+    exposes: [
+      'tap'
+    ],
     down: function(inEvent) {
       if (inEvent.isPrimary && !inEvent.tapPrevented) {
         pointermap.set(inEvent.pointerId, {
           target: inEvent.target,
           buttons: inEvent.buttons,
           x: inEvent.clientX,
           y: inEvent.clientY
         });
       }
     },
@@ skipping 1364 matching lines @@
       };
     },
 
     createBinaryExpression: function(op, left, right) {
       if (!binaryOperators[op])
         throw Error('Disallowed operator: ' + op);
 
       left = getFn(left);
       right = getFn(right);
 
+      switch (op) {
+        case '||':
+          this.dynamicDeps = true;
+          return function(model, observer, filterRegistry) {
+            return left(model, observer, filterRegistry) ||
+                right(model, observer, filterRegistry);
+          };
+        case '&&':
+          this.dynamicDeps = true;
+          return function(model, observer, filterRegistry) {
+            return left(model, observer, filterRegistry) &&
+                right(model, observer, filterRegistry);
+          };
+      }
+
       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);
 
+      this.dynamicDeps = true;
+
       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';
@@ skipping 295 matching lines @@
 })(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.5-5d00e4b'
+};
+
+/*
+ * 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
+ */
 
 // TODO(sorvell): this ensures Polymer is an object and not a function
 // Platform is currently defining it as a function to allow for async loading
 // of polymer; once we refine the loading process this likely goes away.
 if (typeof window.Polymer === 'function') {
   Polymer = {};
 }
 
 
 /*
@@ skipping 281 matching lines @@
  * 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) {
 
+  function noopHandler(value) {
+    return value;
+  }
+
   var typeHandlers = {
-    string: function(value) {
-      return value;
-    },
+    string: noopHandler,
+    'undefined': noopHandler,
     date: function(value) {
       return new Date(Date.parse(value) || Date.now());
     },
     boolean: function(value) {
       if (value === '') {
         return true;
       }
       return value === 'false' ? false : !!value;
     },
     number: function(value) {
@@ skipping 120 matching lines @@
         clearTimeout(handle);
       }
     },
     /**
       * Fire an event.
       * @method fire
       * @returns {Object} event
       * @param {string} type An event name.
       * @param {any} detail
       * @param {Node} onNode Target node.
+      * @param {Boolean} bubbles Set false to prevent bubbling, defaults to true
+      * @param {Boolean} cancelable Set false to prevent cancellation, defaults to true
       */
     fire: function(type, detail, onNode, bubbles, cancelable) {
       var node = onNode || this;
-      var detail = detail || {};
+      var detail = detail === null || detail === undefined ? {} : detail;
       var event = new CustomEvent(type, {
-        bubbles: (bubbles !== undefined ? bubbles : true), 
-        cancelable: (cancelable !== undefined ? cancelable : true), 
+        bubbles: bubbles !== undefined ? bubbles : true,
+        cancelable: cancelable !== undefined ? cancelable : true,
         detail: detail
       });
       node.dispatchEvent(event);
       return event;
     },
     /**
       * Fire an event asynchronously.
       * @method asyncFire
       * @param {string} type An event name.
       * @param detail
@@ skipping 76 matching lines @@
     // event listeners on host
     addHostListeners: function() {
       var events = this.eventDelegates;
       log.events && (Object.keys(events).length > 0) && console.log('[%s] addHostListeners:', this.localName, events);
       // NOTE: host events look like bindings but really are not;
       // (1) we don't want the attribute to be set and (2) we want to support
       // multiple event listeners ('host' and 'instance') and Node.bind
       // by default supports 1 thing being bound.
       for (var type in events) {
         var methodName = events[type];
-        this.addEventListener(type, this.element.getEventHandler(this, this,
-                                                                 methodName));
+        PolymerGestures.addEventListener(this, type, this.element.getEventHandler(this, this, methodName));
       }
     },
     // call 'method' or function method on 'obj' with 'args', if the method exists
     dispatchMethod: function(obj, method, args) {
       if (obj) {
         log.events && console.group('[%s] dispatch [%s]', obj.localName, method);
         var fn = typeof method === 'function' ? method : obj[method];
         if (fn) {
           fn[args ? 'apply' : 'call'](obj, args);
         }
         log.events && console.groupEnd();
         Platform.flush();
       }
     }
   };
 
   // exports
 
   scope.api.instance.events = events;
 
+  // alias PolymerGestures event listener logic
+  scope.addEventListener = PolymerGestures.addEventListener;
+  scope.removeEventListener = PolymerGestures.removeEventListener;
+
 })(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 496 matching lines @@
     ready: function() {
     },
     createdCallback: function() {
       if (this.templateInstance && this.templateInstance.model) {
         console.warn('Attributes on ' + this.localName + ' were data bound ' +
             'prior to Polymer upgrading the element. This may result in ' +
             'incorrect binding types.');
       }
       this.created();
       this.prepareElement();
-      // TODO(sorvell): replace when ShadowDOMPolyfill issue is corrected
-      // https://github.com/Polymer/ShadowDOM/issues/420
-      if (!this.ownerDocument.isStagingDocument || window.ShadowDOMPolyfill) {
+      if (!this.ownerDocument.isStagingDocument) {
         this.makeElementReady();
       }
     },
     // system entry point, do not override
     prepareElement: function() {
       if (this._elementPrepared) {
         console.warn('Element already prepared', this.localName);
         return;
       }
       this._elementPrepared = true;
       // storage for shadowRoots info
       this.shadowRoots = {};
       // install property observers
       this.createPropertyObserver();
-      // TODO (sorvell): temporarily open observer when created
       this.openPropertyObserver();
       // install boilerplate attributes
       this.copyInstanceAttributes();
       // 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();
@@ skipping 96 matching lines @@
         }
         // perform post-construction initialization tasks on ahem, light root
         this.shadowRootReady(this);
         // return the created shadow root
         return dom;
       }
     },
     shadowRootReady: function(root) {
       // locate nodes with id and store references to them in this.$ hash
       this.marshalNodeReferences(root);
-      // set up polymer gestures
-      PolymerGestures.register(root);
     },
     // locate nodes with id and store references to them in this.$ hash
     marshalNodeReferences: function(root) {
       // establish $ instance variable
       var $ = this.$ = this.$ || {};
       // populate $ from nodes with ID from the LOCAL tree
       if (root) {
         var n$ = root.querySelectorAll("[id]");
         for (var i=0, l=n$.length, n; (i<l) && (n=n$[i]); i++) {
           $[n.id] = n;
@@ skipping 44 matching lines @@
  * 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) {
 
   // imports
 
   var log = window.logFlags || {};
-  
+  var hasShadowDOMPolyfill = window.ShadowDOMPolyfill;
+
   // magic words
   
   var STYLE_SCOPE_ATTRIBUTE = 'element';
   var STYLE_CONTROLLER_SCOPE = 'controller';
   
   var styles = {
     STYLE_SCOPE_ATTRIBUTE: STYLE_SCOPE_ATTRIBUTE,
     /**
      * Installs external stylesheets and <style> elements with the attribute 
      * polymer-scope='controller' into the scope of element. This is intended
@@ skipping 27 matching lines @@
         }
         this.installScopeCssText(cssText, scope, name);
       }
     },
     installScopeCssText: function(cssText, scope, name) {
       scope = scope || this.findStyleScope();
       name = name || '';
       if (!scope) {
         return;
       }
-      if (window.ShadowDOMPolyfill) {
+      if (hasShadowDOMPolyfill) {
         cssText = shimCssText(cssText, scope.host);
       }
       var style = this.element.cssTextToScopeStyle(cssText,
           STYLE_CONTROLLER_SCOPE);
       Polymer.applyStyleToScope(style, scope);
       // cache that this style has been applied
       this.styleCacheForScope(scope)[this.localName + name] = true;
     },
     findStyleScope: function(node) {
       // find the shadow root that contains this element
       var n = node || this;
       while (n.parentNode) {
         n = n.parentNode;
       }
       return n;
     },
     scopeHasNamedStyle: function(scope, name) {
       var cache = this.styleCacheForScope(scope);
       return cache[name];
     },
     styleCacheForScope: function(scope) {
-      if (window.ShadowDOMPolyfill) {
+      if (hasShadowDOMPolyfill) {
         var scopeName = scope.host ? scope.host.localName : scope.localName;
         return polyfillScopeStyleCache[scopeName] || (polyfillScopeStyleCache[scopeName] = {});
       } else {
         return scope._scopeStyles = (scope._scopeStyles || {});
       }
     }
   };
 
   var polyfillScopeStyleCache = {};
   
@@ skipping 164 matching lines @@
  */
 
 (function(scope) {
 
   // imports
 
   var log = window.logFlags || {};
   var api = scope.api.instance.styles;
   var STYLE_SCOPE_ATTRIBUTE = api.STYLE_SCOPE_ATTRIBUTE;
 
+  var hasShadowDOMPolyfill = window.ShadowDOMPolyfill;
+
   // magic words
 
   var STYLE_SELECTOR = 'style';
   var STYLE_LOADABLE_MATCH = '@import';
   var SHEET_SELECTOR = 'link[rel=stylesheet]';
   var STYLE_GLOBAL_SCOPE = 'global';
   var SCOPE_ATTR = 'polymer-scope';
 
   var styles = {
     // returns true if resources are loading
@@ skipping 152 matching lines @@
   function importRuleForSheet(sheet, baseUrl) {
     var href = new URL(sheet.getAttribute('href'), baseUrl).href;
     return '@import \'' + href + '\';';
   }
 
   function applyStyleToScope(style, scope) {
     if (style) {
       if (scope === document) {
         scope = document.head;
       }
-      if (window.ShadowDOMPolyfill) {
+      if (hasShadowDOMPolyfill) {
         scope = document.head;
       }
       // TODO(sorvell): necessary for IE
       // see https://connect.microsoft.com/IE/feedback/details/790212/
       // cloning-a-style-element-and-adding-to-document-produces
       // -unexpected-result#details
       // var clone = style.cloneNode(true);
       var clone = createStyleElement(style.textContent);
       var attr = style.getAttribute(STYLE_SCOPE_ATTRIBUTE);
       if (attr) {
@@ skipping 120 matching lines @@
       if (!this.hasEventPrefix(name))
         return;
 
       var eventType = this.removeEventPrefix(name);
       eventType = mixedCaseEventTypes[eventType] || eventType;
 
       var events = this;
 
       return function(model, node, oneTime) {
         var handler = events.getEventHandler(undefined, node, pathString);
-        node.addEventListener(eventType, handler);
+        PolymerGestures.addEventListener(node, eventType, handler);
 
         if (oneTime)
           return;
 
         // TODO(rafaelw): This is really pointless work. Aside from the cost
         // of these allocations, NodeBind is going to setAttribute back to its
         // current value. Fixing this would mean changing the TemplateBinding
         // binding delegate API.
         function bindingValue() {
           return '{{ ' + pathString + ' }}';
         }
 
         return {
           open: bindingValue,
           discardChanges: bindingValue,
           close: function() {
-            node.removeEventListener(eventType, handler);
+            PolymerGestures.removeEventListener(node, eventType, handler);
           }
         };
       };
     }
   };
 
   var prefixLength = EVENT_PREFIX.length;
 
   // exports
   scope.api.declaration.events = events;
@@ skipping 70 matching lines @@
     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
-    // 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
+    // `name: value` entries in the `publish` object may need to generate 
+    // matching properties on the prototype.
+    //
+    // Values that are objects may have a `reflect` property, which
+    // signals that the value describes property control metadata.
+    // In metadata objects, the prototype default value (if any)
+    // is encoded in the `value` property.
+    //
+    // publish: {
+    //   foo: 5, 
+    //   bar: {value: true, reflect: true},
+    //   zot: {}
+    // }
+    //
+    // `reflect` metadata property controls whether changes to the property
+    // are reflected back to the attribute (default false). 
+    //
+    // A value is stored on the prototype unless it's === `undefined`,
+    // in which case the base chain is checked for a value.
+    // If the basal value is also undefined, `null` is stored on the prototype.
+    //
+    // The reflection data is stored on another prototype object, `reflect`
+    // which also can be specified directly.
+    //
+    // reflect: {
+    //   foo: true
+    // }
+    //
+    requireProperties: function(propertyInfos, prototype, base) {
+      // per-prototype storage for reflected properties
       prototype.reflect = prototype.reflect || {};
       // ensure a prototype value for each property
       // 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;
+      for (var n in propertyInfos) {
+        var value = propertyInfos[n];
+        // value has metadata if it has a `reflect` property
+        if (value && value.reflect !== undefined) {
+          prototype.reflect[n] = Boolean(value.reflect);
+          value = value.value;
         }
-        if (prototype[n] === undefined) {
-          prototype[n] = this.valueForDescriptor(propertyDescriptor);
+        // only set a value if one is specified
+        if (value !== undefined) {
+          prototype[n] = value;
         }
       }
     },
-    valueForDescriptor: function(propertyDescriptor) {
-      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;
 
@@ skipping 25 matching lines @@
         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++) {
           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 16 matching lines @@
   var attributes = {
     
     inheritAttributesObjects: function(prototype) {
       // chain our lower-cased publish map to the inherited version
       this.inheritObject(prototype, 'publishLC');
       // chain our instance attributes map to the inherited version
       this.inheritObject(prototype, '_instanceAttributes');
     },
 
     publishAttributes: function(prototype, base) {
-      // merge names from 'attributes' attribute
+      // merge names from 'attributes' attribute into the 'publish' object
       var attributes = this.getAttribute(ATTRIBUTES_ATTRIBUTE);
       if (attributes) {
-        // get properties to publish
-        var publish = prototype.publish || (prototype.publish = {});
+        // create a `publish` object if needed.
+        // the `publish` object is only relevant to this prototype, the 
+        // publishing logic in `declaration/properties.js` is responsible for
+        // managing property values on the prototype chain.
+        // TODO(sjmiles): the `publish` object is later chained to it's 
+        //                ancestor object, presumably this is only for 
+        //                reflection or other non-library uses. 
+        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();
-          // if the user hasn't specified a value, we want to use the
-          // default, unless a superclass has already chosen one
+          // looks weird, but causes n to exist on `publish` if it does not;
+          // a more careful test would need expensive `in` operator
           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
-            if (!hasValue) {
-              publish[n] = Polymer.nob;
-            }
+            publish[n] = undefined;
           }
         }
       }
     },
 
     // record clonable attributes from <element>
     accumulateInstanceAttributes: function() {
       // inherit instance attributes
       var clonable = this.prototype._instanceAttributes;
       // merge attributes from element
@@ skipping 86 matching lines @@
  */
 
 (function(scope) {
 
   // imports
   
   var api = scope.api;
   var isBase = scope.isBase;
   var extend = scope.extend;
 
+  var hasShadowDOMPolyfill = window.ShadowDOMPolyfill;
+
   // prototype api
 
   var prototype = {
 
     register: function(name, extendeeName) {
       // build prototype combining extendee, Polymer base, and named api
       this.buildPrototype(name, extendeeName);
       // register our custom element with the platform
       this.registerPrototype(name, extendeeName);
       // reference constructor in a global named by 'constructor' attribute
@@ skipping 66 matching lines @@
       // compile list of attributes to copy to instances
       this.accumulateInstanceAttributes();
       // parse on-* delegates declared on `this` element
       this.parseHostEvents();
       //
       // install a helper method this.resolvePath to aid in 
       // setting resource urls. e.g.
       // this.$.image.src = this.resolvePath('images/foo.png')
       this.addResolvePathApi();
       // under ShadowDOMPolyfill, transforms to approximate missing CSS features
-      if (window.ShadowDOMPolyfill) {
+      if (hasShadowDOMPolyfill) {
         Platform.ShadowCSS.shimStyling(this.templateContent(), name, extendee);
       }
       // allow custom element access to the declarative context
       if (this.prototype.registerCallback) {
         this.prototype.registerCallback(this);
       }
     },
 
     // if a named constructor is requested in element, map a reference
     // to the constructor to the given symbol
@@ skipping 249 matching lines @@
 
     addToFlushQueue: function(element) {
       flushQueue.push(element);  
     },
 
     flush: function() {
       // prevent re-entrance
       if (this.flushing) {
         return;
       }
-      if (flushQueue.length) {
-        console.warn('flushing %s elements', flushQueue.length);
-      }
       this.flushing = true;
       var element;
       while (flushQueue.length) {
         element = flushQueue.shift();
         element.__queue.go.call(element);
         element.__queue = null;
       }
       this.flushing = false;
     },
 
@@ skipping 331 matching lines @@
                prepareBinding.call(syntax, pathString, name, node);
       };
       return syntax;
     }
 
   });
 
 })();
 
 //# sourceMappingURL=polymer.concat.js.map