[polymer] interop with polymer-element and polymer.js

pkg/web_components/lib/platform.concat.js

 /*
  * Copyright 2012 The Polymer Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the LICENSE file.
  */
 
 if (typeof WeakMap === 'undefined') {
   (function() {
     var defineProperty = Object.defineProperty;
     var counter = Date.now() % 1e9;
@@ skipping 476 matching lines @@
         objects.push(obj);
       } else if (objects.indexOf(obj) < 0) {
         objects.push(obj);
         Object.observe(obj, callback);
       }
 
       observe(Object.getPrototypeOf(obj));
     }
 
     function reset() {
-      resetScheduled = false;
-      if (!resetNeeded)
-        return;
-
       var objs = toRemove === emptyArray ? [] : toRemove;
       toRemove = objects;
       objects = objs;
 
       var observer;
       for (var id in observers) {
         observer = observers[id];
         if (!observer || observer.state_ != OPENED)
           continue;
 
         observer.iterateObjects_(observe);
       }
 
       for (var i = 0; i < toRemove.length; i++) {
         var obj = toRemove[i];
         if (obj)
           Object.unobserve(obj, callback);
       }
 
       toRemove.length = 0;
     }
 
+    function scheduledReset() {
+      resetScheduled = false;
+      if (!resetNeeded)
+        return;
+
+      reset();
+    }
+
     function scheduleReset() {
       if (resetScheduled)
         return;
 
       resetNeeded = true;
       resetScheduled = true;
-      runEOM(reset);
+      runEOM(scheduledReset);
     }
 
     function callback() {
+      reset();
+
       var observer;
 
       for (var id in observers) {
         observer = observers[id];
         if (!observer || observer.state_ != OPENED)
           continue;
 
         observer.check_();
       }
-
-      scheduleReset();
     }
 
     var record = {
       object: undefined,
       objects: objects,
       open: function(obs) {
         observers[obs.id_] = obs;
         observerCount++;
         obs.iterateObjects_(observe);
       },
@@ skipping 1360 matching lines @@
 
     addForwardingProperties(nativePrototype, wrapperPrototype);
     if (opt_instance)
       registerInstanceProperties(wrapperPrototype, opt_instance);
     defineProperty(wrapperPrototype, 'constructor', {
       value: wrapperConstructor,
       configurable: true,
       enumerable: false,
       writable: true
     });
+    // Set it again. Some VMs optimizes objects that are used as prototypes.
+    wrapperConstructor.prototype = wrapperPrototype;
   }
 
   function isWrapperFor(wrapperConstructor, nativeConstructor) {
     return constructorTable.get(nativeConstructor.prototype) ===
         wrapperConstructor;
   }
 
   /**
    * Creates a generic wrapper constructor based on |object| and its
    * constructor.
    * @param {Node} object
    * @return {Function} The generated constructor.
    */
   function registerObject(object) {
     var nativePrototype = Object.getPrototypeOf(object);
 
     var superWrapperConstructor = getWrapperConstructor(nativePrototype);
     var GeneratedWrapper = createWrapperConstructor(superWrapperConstructor);
     registerInternal(nativePrototype, GeneratedWrapper, object);
 
     return GeneratedWrapper;
   }
 
   function createWrapperConstructor(superWrapperConstructor) {
     function GeneratedWrapper(node) {
       superWrapperConstructor.call(this, node);
     }
-    GeneratedWrapper.prototype =
-        Object.create(superWrapperConstructor.prototype);
-    GeneratedWrapper.prototype.constructor = GeneratedWrapper;
+    var p = Object.create(superWrapperConstructor.prototype);
+    p.constructor = GeneratedWrapper;
+    GeneratedWrapper.prototype = p;
 
     return GeneratedWrapper;
   }
 
   var OriginalDOMImplementation = window.DOMImplementation;
   var OriginalEventTarget = window.EventTarget;
   var OriginalEvent = window.Event;
   var OriginalNode = window.Node;
   var OriginalWindow = window.Window;
   var OriginalRange = window.Range;
@@ skipping 553 matching lines @@
     }
   };
 
   scope.enqueueMutation = enqueueMutation;
   scope.registerTransientObservers = registerTransientObservers;
   scope.wrappers.MutationObserver = MutationObserver;
   scope.wrappers.MutationRecord = MutationRecord;
 
 })(window.ShadowDOMPolyfill);
 
+/**
+ * Copyright 2014 The Polymer Authors. All rights reserved.
+ * Use of this source code is goverened by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+(function(scope) {
+  'use strict';
+
+  /**
+   * A tree scope represents the root of a tree. All nodes in a tree point to
+   * the same TreeScope object. The tree scope of a node get set the first time
+   * it is accessed or when a node is added or remove to a tree.
+   * @constructor
+   */
+  function TreeScope(root, parent) {
+    this.root = root;
+    this.parent = parent;
+  }
+
+  TreeScope.prototype = {
+    get renderer() {
+      if (this.root instanceof scope.wrappers.ShadowRoot) {
+        return scope.getRendererForHost(this.root.host);
+      }
+      return null;
+    },
+
+    contains: function(treeScope) {
+      for (; treeScope; treeScope = treeScope.parent) {
+        if (treeScope === this)
+          return true;
+      }
+      return false;
+    }
+  };
+
+  function setTreeScope(node, treeScope) {
+    if (node.treeScope_ !== treeScope) {
+      node.treeScope_ = treeScope;
+      for (var child = node.firstChild; child; child = child.nextSibling) {
+        setTreeScope(child, treeScope);
+      }
+    }
+  }
+
+  function getTreeScope(node) {
+    if (node.treeScope_)
+      return node.treeScope_;
+    var parent = node.parentNode;
+    var treeScope;
+    if (parent)
+      treeScope = getTreeScope(parent);
+    else
+      treeScope = new TreeScope(node, null);
+    return node.treeScope_ = treeScope;
+  }
+
+  scope.TreeScope = TreeScope;
+  scope.getTreeScope = getTreeScope;
+  scope.setTreeScope = setTreeScope;
+
+})(window.ShadowDOMPolyfill);
+
 // Copyright 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
 
   var forwardMethodsToWrapper = scope.forwardMethodsToWrapper;
+  var getTreeScope = scope.getTreeScope;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
   var unwrap = scope.unwrap;
   var wrap = scope.wrap;
   var wrappers = scope.wrappers;
 
   var wrappedFuns = new WeakMap();
   var listenersTable = new WeakMap();
   var handledEventsTable = new WeakMap();
   var currentlyDispatchingEvents = new WeakMap();
@@ skipping 134 matching lines @@
   }
 
   function getInsertionParent(node) {
     return scope.insertionParentTable.get(node);
   }
 
   function isDistributed(node) {
     return getInsertionParent(node);
   }
 
-  function rootOfNode(node) {
-    var p;
-    while (p = node.parentNode) {
-      node = p;
-    }
-    return node;
+  function inSameTree(a, b) {
+    return getTreeScope(a) === getTreeScope(b);
   }
 
-  function inSameTree(a, b) {
-    return rootOfNode(a) === rootOfNode(b);
-  }
-
-  function enclosedBy(a, b) {
-    if (a === b)
-      return true;
-    if (a instanceof wrappers.ShadowRoot)
-      return enclosedBy(rootOfNode(a.host), b);
-    return false;
-  }
-
-
   function dispatchOriginalEvent(originalEvent) {
     // Make sure this event is only dispatched once.
     if (handledEventsTable.get(originalEvent))
       return;
     handledEventsTable.set(originalEvent, true);
 
     return dispatchEvent(wrap(originalEvent), wrap(originalEvent.target));
   }
 
   function dispatchEvent(event, originalWrapperTarget) {
@@ skipping 194 matching lines @@
     },
     get eventPhase() {
       return eventPhaseTable.get(this);
     },
     get path() {
       var nodeList = new wrappers.NodeList();
       var eventPath = eventPathTable.get(this);
       if (eventPath) {
         var index = 0;
         var lastIndex = eventPath.length - 1;
-        var baseRoot = rootOfNode(currentTargetTable.get(this));
+        var baseRoot = getTreeScope(currentTargetTable.get(this));
 
         for (var i = 0; i <= lastIndex; i++) {
           var currentTarget = eventPath[i].currentTarget;
-          var currentRoot = rootOfNode(currentTarget);
-          if (enclosedBy(baseRoot, currentRoot) &&
+          var currentRoot = getTreeScope(currentTarget);
+          if (currentRoot.contains(baseRoot) &&
               // Make sure we do not add Window to the path.
               (i !== lastIndex || currentTarget instanceof wrappers.Node)) {
             nodeList[index++] = currentTarget;
           }
         }
         nodeList.length = index;
       }
       return nodeList;
     },
     stopPropagation: function() {
@@ skipping 447 matching lines @@
 (function(scope) {
   'use strict';
 
   // TODO(arv): Implement.
 
   scope.wrapHTMLCollection = scope.wrapNodeList;
   scope.wrappers.HTMLCollection = scope.wrappers.NodeList;
 
 })(window.ShadowDOMPolyfill);
 
-// Copyright 2012 The Polymer Authors. All rights reserved.
-// Use of this source code is goverened by a BSD-style
-// license that can be found in the LICENSE file.
+/**
+ * Copyright 2012 The Polymer Authors. All rights reserved.
+ * Use of this source code is goverened by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
 
 (function(scope) {
   'use strict';
 
   var EventTarget = scope.wrappers.EventTarget;
   var NodeList = scope.wrappers.NodeList;
+  var TreeScope = scope.TreeScope;
   var assert = scope.assert;
   var defineWrapGetter = scope.defineWrapGetter;
   var enqueueMutation = scope.enqueueMutation;
+  var getTreeScope = scope.getTreeScope;
   var isWrapper = scope.isWrapper;
   var mixin = scope.mixin;
   var registerTransientObservers = scope.registerTransientObservers;
   var registerWrapper = scope.registerWrapper;
+  var setTreeScope = scope.setTreeScope;
   var unwrap = scope.unwrap;
   var wrap = scope.wrap;
   var wrapIfNeeded = scope.wrapIfNeeded;
   var wrappers = scope.wrappers;
 
   function assertIsNodeWrapper(node) {
     assert(node instanceof Node);
   }
 
   function createOneElementNodeList(node) {
@@ skipping 96 matching lines @@
     enqueueRemovalForInsertedDocumentFragment(node, nodes);
     return nodes;
   }
 
   function snapshotNodeList(nodeList) {
     // NodeLists are not live at the moment so just return the same object.
     return nodeList;
   }
 
   // http://dom.spec.whatwg.org/#node-is-inserted
-  function nodeWasAdded(node) {
+  function nodeWasAdded(node, treeScope) {
+    setTreeScope(node, treeScope);
     node.nodeIsInserted_();
   }
 
-  function nodesWereAdded(nodes) {
+  function nodesWereAdded(nodes, parent) {
+    var treeScope = getTreeScope(parent);
     for (var i = 0; i < nodes.length; i++) {
-      nodeWasAdded(nodes[i]);
+      nodeWasAdded(nodes[i], treeScope);
     }
   }
 
   // http://dom.spec.whatwg.org/#node-is-removed
   function nodeWasRemoved(node) {
-    // Nothing at this point in time.
+    setTreeScope(node, new TreeScope(node, null));
   }
 
   function nodesWereRemoved(nodes) {
-    // Nothing at this point in time.
+    for (var i = 0; i < nodes.length; i++) {
+      nodeWasRemoved(nodes[i]);
+    }
   }
 
   function ensureSameOwnerDocument(parent, child) {
     var ownerDoc = parent.nodeType === Node.DOCUMENT_NODE ?
         parent : parent.ownerDocument;
     if (ownerDoc !== child.ownerDocument)
       ownerDoc.adoptNode(child);
   }
 
   function adoptNodesIfNeeded(owner, nodes) {
@@ skipping 97 matching lines @@
              child;
              child = child.nextSibling) {
          cloneContent.appendChild(cloneNode(child, true, opt_doc));
         }
       }
     }
     // TODO(arv): Some HTML elements also clone other data like value.
     return clone;
   }
 
+  function contains(self, child) {
+    if (!child || getTreeScope(self) !== getTreeScope(child))
+      return false;
+
+    for (var node = child; node; node = node.parentNode) {
+      if (node === self)
+        return true;
+    }
+    return false;
+  }
+
   var OriginalNode = window.Node;
 
   /**
    * This represents a wrapper of a native DOM node.
    * @param {!Node} original The original DOM node, aka, the visual DOM node.
    * @constructor
    * @extends {EventTarget}
    */
   function Node(original) {
     assert(original instanceof OriginalNode);
@@ skipping 26 matching lines @@
      * @type {Node|undefined}
      * @private
      */
     this.nextSibling_ = undefined;
 
     /**
      * @type {Node|undefined}
      * @private
      */
     this.previousSibling_ = undefined;
+
+    this.treeScope_ = undefined;
   }
 
   var OriginalDocumentFragment = window.DocumentFragment;
   var originalAppendChild = OriginalNode.prototype.appendChild;
   var originalCompareDocumentPosition =
       OriginalNode.prototype.compareDocumentPosition;
   var originalInsertBefore = OriginalNode.prototype.insertBefore;
   var originalRemoveChild = OriginalNode.prototype.removeChild;
   var originalReplaceChild = OriginalNode.prototype.replaceChild;
 
@@ skipping 68 matching lines @@
           adoptNodesIfNeeded(this, nodes);
         }
       }
 
       enqueueMutation(this, 'childList', {
         addedNodes: nodes,
         nextSibling: refWrapper,
         previousSibling: previousNode
       });
 
-      nodesWereAdded(nodes);
+      nodesWereAdded(nodes, this);
 
       return childWrapper;
     },
 
     removeChild: function(childWrapper) {
       assertIsNodeWrapper(childWrapper);
       if (childWrapper.parentNode !== this) {
         // IE has invalid DOM trees at times.
         var found = false;
         var childNodes = this.childNodes;
@@ skipping 111 matching lines @@
       }
 
       enqueueMutation(this, 'childList', {
         addedNodes: nodes,
         removedNodes: createOneElementNodeList(oldChildWrapper),
         nextSibling: nextNode,
         previousSibling: previousNode
       });
 
       nodeWasRemoved(oldChildWrapper);
-      nodesWereAdded(nodes);
+      nodesWereAdded(nodes, this);
 
       return oldChildWrapper;
     },
 
     /**
      * Called after a node was inserted. Subclasses override this to invalidate
      * the renderer as needed.
      * @private
      */
     nodeIsInserted_: function() {
@@ skipping 71 matching lines @@
       }
 
       var addedNodes = snapshotNodeList(this.childNodes);
 
       enqueueMutation(this, 'childList', {
         addedNodes: addedNodes,
         removedNodes: removedNodes
       });
 
       nodesWereRemoved(removedNodes);
-      nodesWereAdded(addedNodes);
+      nodesWereAdded(addedNodes, this);
     },
 
     get childNodes() {
       var wrapperList = new NodeList();
       var i = 0;
       for (var child = this.firstChild; child; child = child.nextSibling) {
         wrapperList[i++] = child;
       }
       wrapperList.length = i;
       return wrapperList;
     },
 
     cloneNode: function(deep) {
       return cloneNode(this, deep);
     },
 
     contains: function(child) {
-      if (!child)
-        return false;
-
-      child = wrapIfNeeded(child);
-
-      // TODO(arv): Optimize using ownerDocument etc.
-      if (child === this)
-        return true;
-      var parentNode = child.parentNode;
-      if (!parentNode)
-        return false;
-      return this.contains(parentNode);
+      return contains(this, wrapIfNeeded(child));
     },
 
     compareDocumentPosition: function(otherNode) {
       // This only wraps, it therefore only operates on the composed DOM and not
       // the logical DOM.
       return originalCompareDocumentPosition.call(this.impl, unwrap(otherNode));
     },
 
     normalize: function() {
       var nodes = snapshotNodeList(this.childNodes);
@@ skipping 36 matching lines @@
   defineWrapGetter(Node, 'ownerDocument');
 
   // We use a DocumentFragment as a base and then delete the properties of
   // DocumentFragment.prototype from the wrapper Node. Since delete makes
   // objects slow in some JS engines we recreate the prototype object.
   registerWrapper(OriginalNode, Node, document.createDocumentFragment());
   delete Node.prototype.querySelector;
   delete Node.prototype.querySelectorAll;
   Node.prototype = mixin(Object.create(EventTarget.prototype), Node.prototype);
 
+  scope.cloneNode = cloneNode;
   scope.nodeWasAdded = nodeWasAdded;
   scope.nodeWasRemoved = nodeWasRemoved;
   scope.nodesWereAdded = nodesWereAdded;
   scope.nodesWereRemoved = nodesWereRemoved;
   scope.snapshotNodeList = snapshotNodeList;
   scope.wrappers.Node = Node;
-  scope.cloneNode = cloneNode;
 
 })(window.ShadowDOMPolyfill);
 
 // Copyright 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
 
@@ skipping 551 matching lines @@
       }
 
       var addedNodes = snapshotNodeList(this.childNodes);
 
       enqueueMutation(this, 'childList', {
         addedNodes: addedNodes,
         removedNodes: removedNodes
       });
 
       nodesWereRemoved(removedNodes);
-      nodesWereAdded(addedNodes);
+      nodesWereAdded(addedNodes, this);
     },
 
     get outerHTML() {
       return getOuterHTML(this, this.parentNode);
     },
     set outerHTML(value) {
       var p = this.parentNode;
       if (p) {
         p.invalidateShadowRenderer();
         var df = frag(p, value);
@@ skipping 1020 matching lines @@
 })(window.ShadowDOMPolyfill);
 
 // Copyright 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
 
   var DocumentFragment = scope.wrappers.DocumentFragment;
+  var TreeScope = scope.TreeScope;
   var elementFromPoint = scope.elementFromPoint;
   var getInnerHTML = scope.getInnerHTML;
+  var getTreeScope = scope.getTreeScope;
   var mixin = scope.mixin;
   var rewrap = scope.rewrap;
   var setInnerHTML = scope.setInnerHTML;
   var unwrap = scope.unwrap;
 
   var shadowHostTable = new WeakMap();
   var nextOlderShadowTreeTable = new WeakMap();
 
   var spaceCharRe = /[ \t\n\r\f]/;
 
   function ShadowRoot(hostWrapper) {
     var node = unwrap(hostWrapper.impl.ownerDocument.createDocumentFragment());
     DocumentFragment.call(this, node);
 
     // createDocumentFragment associates the node with a wrapper
     // DocumentFragment instance. Override that.
     rewrap(node, this);
 
+    this.treeScope_ = new TreeScope(this, getTreeScope(hostWrapper));
+
     var oldShadowRoot = hostWrapper.shadowRoot;
     nextOlderShadowTreeTable.set(this, oldShadowRoot);
 
     shadowHostTable.set(this, hostWrapper);
   }
   ShadowRoot.prototype = Object.create(DocumentFragment.prototype);
   mixin(ShadowRoot.prototype, {
     get innerHTML() {
       return getInnerHTML(this);
     },
@@ skipping 35 matching lines @@
 
 (function(scope) {
   'use strict';
 
   var Element = scope.wrappers.Element;
   var HTMLContentElement = scope.wrappers.HTMLContentElement;
   var HTMLShadowElement = scope.wrappers.HTMLShadowElement;
   var Node = scope.wrappers.Node;
   var ShadowRoot = scope.wrappers.ShadowRoot;
   var assert = scope.assert;
+  var getTreeScope = scope.getTreeScope;
   var mixin = scope.mixin;
   var oneOf = scope.oneOf;
   var unwrap = scope.unwrap;
   var wrap = scope.wrap;
 
   /**
    * Updates the fields of a wrapper to a snapshot of the logical DOM as needed.
    * Up means parentNode
    * Sideways means previous and next sibling.
    * @param {!Node} wrapper
@@ skipping 199 matching lines @@
     'setTimeout'
   ]);
 
   var pendingDirtyRenderers = [];
   var renderTimer;
 
   function renderAllPending() {
     // TODO(arv): Order these in document order. That way we do not have to
     // render something twice.
     for (var i = 0; i < pendingDirtyRenderers.length; i++) {
-      pendingDirtyRenderers[i].render();
+      var renderer = pendingDirtyRenderers[i];
+      var parentRenderer = renderer.parentRenderer;
+      if (parentRenderer && parentRenderer.dirty)
+        continue;
+      renderer.render();
     }
 
     pendingDirtyRenderers = [];
   }
 
   function handleRequestAnimationFrame() {
     renderTimer = null;
     renderAllPending();
   }
 
   /**
    * Returns existing shadow renderer for a host or creates it if it is needed.
    * @params {!Element} host
    * @return {!ShadowRenderer}
    */
   function getRendererForHost(host) {
     var renderer = rendererForHostTable.get(host);
     if (!renderer) {
       renderer = new ShadowRenderer(host);
       rendererForHostTable.set(host, renderer);
     }
     return renderer;
   }
 
   function getShadowRootAncestor(node) {
-    for (; node; node = node.parentNode) {
-      if (node instanceof ShadowRoot)
-        return node;
-    }
+    var root = getTreeScope(node).root;
+    if (root instanceof ShadowRoot)
+      return root;
     return null;
   }
 
   function getRendererForShadowRoot(shadowRoot) {
     return getRendererForHost(shadowRoot.host);
   }
 
   var spliceDiff = new ArraySplice();
   spliceDiff.equals = function(renderNode, rawNode) {
     return unwrap(renderNode.node) === rawNode;
@@ skipping 96 matching lines @@
       for (var node = shadowRoot.firstChild; node; node = node.nextSibling) {
         this.renderNode(shadowRoot, renderNode, node, false);
       }
 
       if (topMostRenderer)
         renderNode.sync();
 
       this.dirty = false;
     },
 
+    get parentRenderer() {
+      return getTreeScope(this.host).renderer;
+    },
+
     invalidate: function() {
       if (!this.dirty) {
         this.dirty = true;
         pendingDirtyRenderers.push(this);
         if (renderTimer)
           return;
         renderTimer = window[request](handleRequestAnimationFrame, 0);
       }
     },
 
@@ skipping 10 matching lines @@
       } else {
         this.renderAsAnyDomTree(shadowRoot, renderNode, node, isNested);
       }
     },
 
     renderAsAnyDomTree: function(shadowRoot, renderNode, node, isNested) {
       renderNode = renderNode.append(node);
 
       if (isShadowHost(node)) {
         var renderer = getRendererForHost(node);
-        // renderNode.skip = !renderer.dirty;
-        renderer.invalidate();
+        renderNode.skip = !renderer.dirty;
         renderer.render(renderNode);
       } else {
         for (var child = node.firstChild; child; child = child.nextSibling) {
           this.renderNode(shadowRoot, renderNode, child, isNested);
         }
       }
     },
 
     renderInsertionPoint: function(shadowRoot, renderNode, insertionPoint,
                                    isNested) {
@@ skipping 378 matching lines @@
 
 (function(scope) {
   'use strict';
 
   var GetElementsByInterface = scope.GetElementsByInterface;
   var Node = scope.wrappers.Node;
   var ParentNodeInterface = scope.ParentNodeInterface;
   var Selection = scope.wrappers.Selection;
   var SelectorsInterface = scope.SelectorsInterface;
   var ShadowRoot = scope.wrappers.ShadowRoot;
+  var TreeScope = scope.TreeScope;
   var cloneNode = scope.cloneNode;
   var defineWrapGetter = scope.defineWrapGetter;
   var elementFromPoint = scope.elementFromPoint;
   var forwardMethodsToWrapper = scope.forwardMethodsToWrapper;
   var matchesNames = scope.matchesNames;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
   var renderAllPending = scope.renderAllPending;
   var rewrap = scope.rewrap;
   var unwrap = scope.unwrap;
   var wrap = scope.wrap;
   var wrapEventTargetMethods = scope.wrapEventTargetMethods;
   var wrapNodeList = scope.wrapNodeList;
 
   var implementationTable = new WeakMap();
 
   function Document(node) {
     Node.call(this, node);
+    this.treeScope_ = new TreeScope(this, null);
   }
   Document.prototype = Object.create(Node.prototype);
 
   defineWrapGetter(Document, 'documentElement');
 
   // Conceptually both body and head can be in a shadow but suporting that seems
   // overkill at this point.
   defineWrapGetter(Document, 'body');
   defineWrapGetter(Document, 'head');
 
@@ skipping 607 matching lines @@
 (function(scope) {
 
 var ShadowCSS = {
   strictStyling: false,
   registry: {},
   // Shim styles for a given root associated with a name and extendsName
   // 1. cache root styles by name
   // 2. optionally tag root nodes with scope name
   // 3. shim polyfill directives /* @polyfill */ and /* @polyfill-rule */
   // 4. shim :host and scoping
-  shimStyling: function(root, name, extendsName, ownSheet) {
+  shimStyling: function(root, name, extendsName) {
+    var scopeStyles = this.prepareRoot(root, name, extendsName);
     var typeExtension = this.isTypeExtension(extendsName);
+    var scopeSelector = this.makeScopeSelector(name, typeExtension);
     // use caching to make working with styles nodes easier and to facilitate
     // lookup of extendee
-    var def = this.registerDefinition(root, name, extendsName);
-    // find styles and apply shimming...
+    var cssText = stylesToCssText(scopeStyles, true);
+    cssText = this.scopeCssText(cssText, scopeSelector);
+    // cache shimmed css on root for user extensibility
+    if (root) {
+      root.shimmedStyle = cssText;
+    }
+    // add style to document
+    this.addCssToDocument(cssText, name);
+  },
+  /*
+  * Shim a style element with the given selector. Returns cssText that can
+  * be included in the document via Platform.ShadowCSS.addCssToDocument(css).
+  */
+  shimStyle: function(style, selector) {
+    return this.shimCssText(style.textContent, selector);
+  },
+  /*
+  * Shim some cssText with the given selector. Returns cssText that can
+  * be included in the document via Platform.ShadowCSS.addCssToDocument(css).
+  */
+  shimCssText: function(cssText, selector) {
+    cssText = this.insertDirectives(cssText);
+    return this.scopeCssText(cssText, selector);
+  },
+  makeScopeSelector: function(name, typeExtension) {
+    if (name) {
+      return typeExtension ? '[is=' + name + ']' : name;
+    }
+    return '';
+  },
+  isTypeExtension: function(extendsName) {
+    return extendsName && extendsName.indexOf('-') < 0;
+  },
+  prepareRoot: function(root, name, extendsName) {
+    var def = this.registerRoot(root, name, extendsName);
+    this.replaceTextInStyles(def.rootStyles, this.insertDirectives);
+    // remove existing style elements
+    this.removeStyles(root, def.rootStyles);
+    // apply strict attr
     if (this.strictStyling) {
       this.applyScopeToContent(root, name);
     }
-    var cssText = this.stylesToShimmedCssText(def.rootStyles, def.scopeStyles,
-        name, typeExtension);
-    // provide shimmedStyle for user extensibility
-    def.shimmedStyle = cssTextToStyle(cssText);
-    if (root) {
-      root.shimmedStyle = def.shimmedStyle;
-    }
-    // remove existing style elements
-    for (var i=0, l=def.rootStyles.length, s; (i<l) && (s=def.rootStyles[i]); 
-        i++) {
+    return def.scopeStyles;
+  },
+  removeStyles: function(root, styles) {
+    for (var i=0, l=styles.length, s; (i<l) && (s=styles[i]); i++) {
       s.parentNode.removeChild(s);
     }
-    // add style to document
-    if (ownSheet) {
-      addOwnSheet(cssText, name);
-    } else {
-      addCssToDocument(cssText);
-    }
   },
-  // apply @polyfill rules + :host and scope shimming
-  stylesToShimmedCssText: function(rootStyles, scopeStyles, name,
-      typeExtension) {
-    name = name || '';
-    // insert @polyfill and @polyfill-rule rules into style elements
-    // scoping process takes care of shimming these
-    this.insertPolyfillDirectives(rootStyles);
-    this.insertPolyfillRules(rootStyles);
-    var cssText = this.shimScoping(scopeStyles, name, typeExtension);
-    // note: we only need to do rootStyles since these are unscoped.
-    cssText += this.extractPolyfillUnscopedRules(rootStyles);
-    return cssText.trim();
-  },
-  registerDefinition: function(root, name, extendsName) {
+  registerRoot: function(root, name, extendsName) {
     var def = this.registry[name] = {
       root: root,
       name: name,
       extendsName: extendsName
     }
-    var styles = root ? root.querySelectorAll('style') : [];
-    styles = styles ? Array.prototype.slice.call(styles, 0) : [];
+    var styles = this.findStyles(root);
     def.rootStyles = styles;
     def.scopeStyles = def.rootStyles;
     var extendee = this.registry[def.extendsName];
     if (extendee && (!root || root.querySelector('shadow'))) {
       def.scopeStyles = extendee.scopeStyles.concat(def.scopeStyles);
     }
     return def;
   },
-  isTypeExtension: function(extendsName) {
-    return extendsName && extendsName.indexOf('-') < 0;
+  findStyles: function(root) {
+    if (!root) {
+      return [];
+    }
+    var styles = root.querySelectorAll('style');
+    return Array.prototype.filter.call(styles, function(s) {
+      return !s.hasAttribute(NO_SHIM_ATTRIBUTE);
+    });
   },
   applyScopeToContent: function(root, name) {
     if (root) {
       // add the name attribute to each node in root.
       Array.prototype.forEach.call(root.querySelectorAll('*'),
           function(node) {
             node.setAttribute(name, '');
           });
       // and template contents too
       Array.prototype.forEach.call(root.querySelectorAll('template'),
           function(template) {
             this.applyScopeToContent(template.content, name);
           },
           this);
     }
   },
+  insertDirectives: function(cssText) {
+    cssText = this.insertPolyfillDirectivesInCssText(cssText);
+    return this.insertPolyfillRulesInCssText(cssText);
+  },
   /*
    * Process styles to convert native ShadowDOM rules that will trip
-   * up the css parser; we rely on decorating the stylesheet with comments.
+   * up the css parser; we rely on decorating the stylesheet with inert rules.
    * 
    * For example, we convert this rule:
    * 
-   * (comment start) @polyfill :host menu-item (comment end)
-   * shadow::-webkit-distributed(menu-item) {
+   * polyfill-next-selector { content: ':host menu-item'; }
+   * ::content menu-item {
    * 
    * to this:
    * 
    * scopeName menu-item {
    *
   **/
-  insertPolyfillDirectives: function(styles) {
-    if (styles) {
-      Array.prototype.forEach.call(styles, function(s) {
-        s.textContent = this.insertPolyfillDirectivesInCssText(s.textContent);
-      }, this);
-    }
-  },
   insertPolyfillDirectivesInCssText: function(cssText) {
-    return cssText.replace(cssPolyfillCommentRe, function(match, p1) {
+    // TODO(sorvell): remove either content or comment
+    cssText = cssText.replace(cssCommentNextSelectorRe, function(match, p1) {
       // remove end comment delimiter and add block start
       return p1.slice(0, -2) + '{';
     });
+    return cssText.replace(cssContentNextSelectorRe, function(match, p1) {
+      return p1 + ' {';
+    });
   },
   /*
    * Process styles to add rules which will only apply under the polyfill
    * 
    * For example, we convert this rule:
    * 
-   * (comment start) @polyfill-rule :host menu-item { 
-   * ... } (comment end)
+   * polyfill-rule {
+   *   content: ':host menu-item';
+   * ...
+   * }
    * 
    * to this:
    * 
    * scopeName menu-item {...}
    *
   **/
-  insertPolyfillRules: function(styles) {
-    if (styles) {
-      Array.prototype.forEach.call(styles, function(s) {
-        s.textContent = this.insertPolyfillRulesInCssText(s.textContent);
-      }, this);
-    }
-  },
   insertPolyfillRulesInCssText: function(cssText) {
-    return cssText.replace(cssPolyfillRuleCommentRe, function(match, p1) {
+    // TODO(sorvell): remove either content or comment
+    cssText = cssText.replace(cssCommentRuleRe, function(match, p1) {
       // remove end comment delimiter
       return p1.slice(0, -1);
     });
-  },
-  /*
-   * Process styles to add rules which will only apply under the polyfill
-   * and do not process via CSSOM. (CSSOM is destructive to rules on rare 
-   * occasions, e.g. -webkit-calc on Safari.)
-   * For example, we convert this rule:
-   * 
-   * (comment start) @polyfill-unscoped-rule menu-item { 
-   * ... } (comment end)
-   * 
-   * to this:
-   * 
-   * menu-item {...}
-   *
-  **/
-  extractPolyfillUnscopedRules: function(styles) {
-    var cssText = '';
-    if (styles) {
-      Array.prototype.forEach.call(styles, function(s) {
-        cssText += this.extractPolyfillUnscopedRulesFromCssText(
-            s.textContent) + '\n\n';
-      }, this);
-    }
-    return cssText;
-  },
-  extractPolyfillUnscopedRulesFromCssText: function(cssText) {
-    var r = '', matches;
-    while (matches = cssPolyfillUnscopedRuleCommentRe.exec(cssText)) {
-      r += matches[1].slice(0, -1) + '\n\n';
-    }
-    return r;
+    return cssText.replace(cssContentRuleRe, function(match, p1, p2, p3) {
+      var rule = match.replace(p1, '').replace(p2, '');
+      return p3 + rule;
+    });
   },
   /* Ensure styles are scoped. Pseudo-scoping takes a rule like:
    * 
    *  .foo {... } 
    *  
    *  and converts this to
    *  
    *  scopeName .foo { ... }
   */
-  shimScoping: function(styles, name, typeExtension) {
-    if (styles) {
-      return this.convertScopedStyles(styles, name, typeExtension);
-    }
-  },
-  convertScopedStyles: function(styles, name, typeExtension) {
-    var cssText = stylesToCssText(styles);
+  scopeCssText: function(cssText, scopeSelector) {
+    var unscoped = this.extractUnscopedRulesFromCssText(cssText);
     cssText = this.insertPolyfillHostInCssText(cssText);
     cssText = this.convertColonHost(cssText);
     cssText = this.convertColonAncestor(cssText);
     cssText = this.convertCombinators(cssText);
-    if (name) {
+    if (scopeSelector) {
       var self = this, cssText;
-      
       withCssRules(cssText, function(rules) {
-        cssText = self.scopeRules(rules, name, typeExtension);
+        cssText = self.scopeRules(rules, scopeSelector);
       });
 
     }
-    return cssText;
+    cssText = cssText + '\n' + unscoped;
+    return cssText.trim();
+  },
+  /*
+   * Process styles to add rules which will only apply under the polyfill
+   * and do not process via CSSOM. (CSSOM is destructive to rules on rare 
+   * occasions, e.g. -webkit-calc on Safari.)
+   * For example, we convert this rule:
+   * 
+   * (comment start) @polyfill-unscoped-rule menu-item { 
+   * ... } (comment end)
+   * 
+   * to this:
+   * 
+   * menu-item {...}
+   *
+  **/
+  extractUnscopedRulesFromCssText: function(cssText) {
+    // TODO(sorvell): remove either content or comment
+    var r = '', m;
+    while (m = cssCommentUnscopedRuleRe.exec(cssText)) {
+      r += m[1].slice(0, -1) + '\n\n';
+    }
+    while (m = cssContentUnscopedRuleRe.exec(cssText)) {
+      r += m[0].replace(m[2], '').replace(m[1], m[3]) + '\n\n';
+    }
+    return r;
   },
   /*
    * convert a rule like :host(.foo) > .bar { }
    *
    * to
    *
    * scopeName.foo > .bar
   */
   convertColonHost: function(cssText) {
     return this.convertColonRule(cssText, cssColonHostRe,
@@ skipping 44 matching lines @@
   colonHostPartReplacer: function(host, part, suffix) {
     return host + part.replace(polyfillHost, '') + suffix;
   },
   /*
    * Convert ^ and ^^ combinators by replacing with space.
   */
   convertCombinators: function(cssText) {
     return cssText.replace(/\^\^/g, ' ').replace(/\^/g, ' ');
   },
   // change a selector like 'div' to 'name div'
-  scopeRules: function(cssRules, name, typeExtension) {
+  scopeRules: function(cssRules, scopeSelector) {
     var cssText = '';
     if (cssRules) {
       Array.prototype.forEach.call(cssRules, function(rule) {
         if (rule.selectorText && (rule.style && rule.style.cssText)) {
-          cssText += this.scopeSelector(rule.selectorText, name, typeExtension, 
+          cssText += this.scopeSelector(rule.selectorText, scopeSelector, 
             this.strictStyling) + ' {\n\t';
           cssText += this.propertiesFromRule(rule) + '\n}\n\n';
         } else if (rule.type === CSSRule.MEDIA_RULE) {
           cssText += '@media ' + rule.media.mediaText + ' {\n';
-          cssText += this.scopeRules(rule.cssRules, name, typeExtension);
+          cssText += this.scopeRules(rule.cssRules, scopeSelector);
           cssText += '\n}\n\n';
         } else if (rule.cssText) {
           cssText += rule.cssText + '\n\n';
         }
       }, this);
     }
     return cssText;
   },
-  scopeSelector: function(selector, name, typeExtension, strict) {
+  scopeSelector: function(selector, scopeSelector, strict) {
     var r = [], parts = selector.split(',');
     parts.forEach(function(p) {
       p = p.trim();
-      if (this.selectorNeedsScoping(p, name, typeExtension)) {
+      if (this.selectorNeedsScoping(p, scopeSelector)) {
         p = (strict && !p.match(polyfillHostNoCombinator)) ? 
-            this.applyStrictSelectorScope(p, name) :
-            this.applySimpleSelectorScope(p, name, typeExtension);
+            this.applyStrictSelectorScope(p, scopeSelector) :
+            this.applySimpleSelectorScope(p, scopeSelector);
       }
       r.push(p);
     }, this);
     return r.join(', ');
   },
-  selectorNeedsScoping: function(selector, name, typeExtension) {
-    var re = this.makeScopeMatcher(name, typeExtension);
+  selectorNeedsScoping: function(selector, scopeSelector) {
+    var re = this.makeScopeMatcher(scopeSelector);
     return !selector.match(re);
   },
-  makeScopeMatcher: function(name, typeExtension) {
-    var matchScope = typeExtension ? '\\[is=[\'"]?' + name + '[\'"]?\\]' : name;
-    return new RegExp('^(' + matchScope + ')' + selectorReSuffix, 'm');
+  makeScopeMatcher: function(scopeSelector) {
+    scopeSelector = scopeSelector.replace(/\[/g, '\\[').replace(/\[/g, '\\]');
+    return new RegExp('^(' + scopeSelector + ')' + selectorReSuffix, 'm');
   },
   // scope via name and [is=name]
-  applySimpleSelectorScope: function(selector, name, typeExtension) {
-    var scoper = typeExtension ? '[is=' + name + ']' : name;
+  applySimpleSelectorScope: function(selector, scopeSelector) {
     if (selector.match(polyfillHostRe)) {
-      selector = selector.replace(polyfillHostNoCombinator, scoper);
-      return selector.replace(polyfillHostRe, scoper + ' ');
+      selector = selector.replace(polyfillHostNoCombinator, scopeSelector);
+      return selector.replace(polyfillHostRe, scopeSelector + ' ');
     } else {
-      return scoper + ' ' + selector;
+      return scopeSelector + ' ' + selector;
     }
   },
   // return a selector with [name] suffix on each simple selector
   // e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name]
-  applyStrictSelectorScope: function(selector, name) {
+  applyStrictSelectorScope: function(selector, scopeSelector) {
+    scopeSelector = scopeSelector.replace(/\[is=([^\]]*)\]/g, '$1');
     var splits = [' ', '>', '+', '~'],
       scoped = selector,
-      attrName = '[' + name + ']';
+      attrName = '[' + scopeSelector + ']';
     splits.forEach(function(sep) {
       var parts = scoped.split(sep);
       scoped = parts.map(function(p) {
         // remove :host since it should be unnecessary
         var t = p.trim().replace(polyfillHostRe, '');
         if (t && (splits.indexOf(t) < 0) && (t.indexOf(attrName) < 0)) {
           p = t.replace(/([^:]*)(:*)(.*)/, '$1' + attrName + '$2$3')
         }
         return p;
       }).join(sep);
     });
     return scoped;
   },
   insertPolyfillHostInCssText: function(selector) {
     return selector.replace(hostRe, polyfillHost).replace(colonHostRe,
         polyfillHost).replace(colonAncestorRe, polyfillAncestor);
   },
   propertiesFromRule: function(rule) {
     // TODO(sorvell): Safari cssom incorrectly removes quotes from the content
     // property. (https://bugs.webkit.org/show_bug.cgi?id=118045)
     if (rule.style.content && !rule.style.content.match(/['"]+/)) {
       return rule.style.cssText.replace(/content:[^;]*;/g, 'content: \'' + 
           rule.style.content + '\';');
     }
     return rule.style.cssText;
+  },
+  replaceTextInStyles: function(styles, action) {
+    if (styles && action) {
+      if (!(styles instanceof Array)) {
+        styles = [styles];
+      }
+      Array.prototype.forEach.call(styles, function(s) {
+        s.textContent = action.call(this, s.textContent);
+      }, this);
+    }
+  },
+  addCssToDocument: function(cssText, name) {
+    if (cssText.match('@import')) {
+      addOwnSheet(cssText, name);
+    } else {
+      addCssToDocument(cssText);
+    }
   }
 };
 
 var selectorRe = /([^{]*)({[\s\S]*?})/gim,
     cssCommentRe = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,
-    cssPolyfillCommentRe = /\/\*\s*@polyfill ([^*]*\*+([^/*][^*]*\*+)*\/)([^{]*?){/gim,
-    cssPolyfillRuleCommentRe = /\/\*\s@polyfill-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
-    cssPolyfillUnscopedRuleCommentRe = /\/\*\s@polyfill-unscoped-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
+    // TODO(sorvell): remove either content or comment
+    cssCommentNextSelectorRe = /\/\*\s*@polyfill ([^*]*\*+([^/*][^*]*\*+)*\/)([^{]*?){/gim,
+    cssContentNextSelectorRe = /polyfill-next-selector[^}]*content\:[\s]*'([^']*)'[^}]*}([^{]*?){/gim,
+    // TODO(sorvell): remove either content or comment
+    cssCommentRuleRe = /\/\*\s@polyfill-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
+    cssContentRuleRe = /(polyfill-rule)[^}]*(content\:[\s]*'([^']*)'[^;]*;)[^}]*}/gim,
+    // TODO(sorvell): remove either content or comment
+    cssCommentUnscopedRuleRe = /\/\*\s@polyfill-unscoped-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
+    cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content\:[\s]*'([^']*)'[^;]*;)[^}]*}/gim,
     cssPseudoRe = /::(x-[^\s{,(]*)/gim,
     cssPartRe = /::part\(([^)]*)\)/gim,
     // note: :host pre-processed to -shadowcsshost.
     polyfillHost = '-shadowcsshost',
     // note: :ancestor pre-processed to -shadowcssancestor.
     polyfillAncestor = '-shadowcssancestor',
     parenSuffix = ')(?:\\((' +
         '(?:\\([^)(]*\\)|[^)(]*)+?' +
         ')\\))?([^,{]*)';
     cssColonHostRe = new RegExp('(' + polyfillHost + parenSuffix, 'gim'),
     cssColonAncestorRe = new RegExp('(' + polyfillAncestor + parenSuffix, 'gim'),
     selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$',
     hostRe = /@host/gim,
     colonHostRe = /\:host/gim,
     colonAncestorRe = /\:ancestor/gim,
     /* host name without combinator */
     polyfillHostNoCombinator = polyfillHost + '-no-combinator',
-    polyfillHostRe = new RegExp(polyfillHost, 'gim');
+    polyfillHostRe = new RegExp(polyfillHost, 'gim'),
     polyfillAncestorRe = new RegExp(polyfillAncestor, 'gim');
 
 function stylesToCssText(styles, preserveComments) {
   var cssText = '';
   Array.prototype.forEach.call(styles, function(s) {
     cssText += s.textContent + '\n\n';
   });
   // strip comments for easier processing
   if (!preserveComments) {
     cssText = cssText.replace(cssCommentRe, '');
@@ skipping 84 matching lines @@
 
 function addOwnSheet(cssText, name) {
   var style = cssTextToStyle(cssText);
   style.setAttribute(name, '');
   style.setAttribute(SHIMMED_ATTRIBUTE, '');
   document.head.appendChild(style);
 }
 
 var SHIM_ATTRIBUTE = 'shim-shadowdom';
 var SHIMMED_ATTRIBUTE = 'shim-shadowdom-css';
+var NO_SHIM_ATTRIBUTE = 'no-shim';
 
 var sheet;
 function getSheet() {
   if (!sheet) {
     sheet = document.createElement("style");
     sheet.setAttribute(SHIMMED_ATTRIBUTE, '');
     sheet[SHIMMED_ATTRIBUTE] = true;
   }
   return sheet;
 }
@@ skipping 34 matching lines @@
           originalParseGeneric.call(this, elt);
           return;
         }
         if (elt.__resource) {
           style = elt.ownerDocument.createElement('style');
           style.textContent = urlResolver.resolveCssText(
               elt.__resource, elt.href);
         } else {
           urlResolver.resolveStyle(style);  
         }
-        var styles = [style];
-        style.textContent = ShadowCSS.stylesToShimmedCssText(styles, styles);
+        style.textContent = ShadowCSS.shimStyle(style);
         style.removeAttribute(SHIM_ATTRIBUTE, '');
         style.setAttribute(SHIMMED_ATTRIBUTE, '');
         style[SHIMMED_ATTRIBUTE] = true;
         // place in document
         if (style.parentNode !== head) {
           // replace links in head
           if (elt.parentNode === head) {
             head.replaceChild(style, elt);
           } else {
             head.appendChild(style);
@@ skipping 3936 matching lines @@
  * @return {Event} A new PointerEvent of type `inType` and initialized with properties from `inDict`.
  */
 (function(scope) {
   // test for DOM Level 4 Events
   var NEW_MOUSE_EVENT = false;
   var HAS_BUTTONS = false;
   try {
     var ev = new MouseEvent('click', {buttons: 1});
     NEW_MOUSE_EVENT = true;
     HAS_BUTTONS = ev.buttons === 1;
+    ev = null;
   } catch(e) {
   }
 
   var MOUSE_PROPS = [
     'bubbles',
     'cancelable',
     'view',
     'detail',
     'screenX',
     'screenY',
@@ skipping 40 matching lines @@
     // but initMouseEvent does not expose an argument with which to set
     // MouseEvent.which. Calling initMouseEvent with a buttonArg of 0 will set
     // MouseEvent.button == 0 and MouseEvent.which == 1, breaking the expectations
     // of app developers.
     //
     // The only way to propagate the correct state of MouseEvent.which and
     // MouseEvent.button to a new MouseEvent.button == 0 and MouseEvent.which == 0
     // is to call initMouseEvent with a buttonArg value of -1.
     //
     // This is fixed with DOM Level 4's use of buttons
-    var buttons;
-    if (inDict.buttons || HAS_BUTTONS) {
-      buttons = inDict.buttons;
-    } else {
+    var buttons = inDict.buttons;
+    // touch has two possible buttons state: 0 and 1, rely on being told the right one
+    if (!HAS_BUTTONS && !buttons && inType !== 'touch') {
       switch (inDict.which) {
         case 1: buttons = 1; break;
         case 2: buttons = 4; break;
         case 3: buttons = 2; break;
         default: buttons = 0;
       }
     }
 
     var e;
     if (NEW_MOUSE_EVENT) {
@@ skipping 524 matching lines @@
       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('DOMContentLoaded', this.installNewSubtree.bind(this, document));
+      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
@@ skipping 264 matching lines @@
         this.clickCount = 0;
         this.resetId = null;
       }.bind(this);
       this.resetId = setTimeout(fn, CLICK_COUNT_TIMEOUT);
     },
     cancelResetClickCount: function() {
       if (this.resetId) {
         clearTimeout(this.resetId);
       }
     },
+    typeToButtons: function(type) {
+      var ret = 0;
+      if (type === 'touchstart' || type === 'touchmove') {
+        ret = 1;
+      }
+      return ret;
+    },
     touchToPointer: function(inTouch) {
       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.
       e.pointerId = inTouch.identifier + 2;
       e.target = findTarget(e);
       e.bubbles = true;
       e.cancelable = true;
       e.detail = this.clickCount;
       e.button = 0;
-      e.buttons = 1;
+      e.buttons = this.typeToButtons(this.currentTouchEvent);
       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;
       return e;
     },
     processTouches: function(inEvent, inFunction) {
       var tl = inEvent.changedTouches;
+      this.currentTouchEvent = inEvent.type;
       var pointers = touchMap(tl, this.touchToPointer, this);
       // forward touch preventDefaults
       pointers.forEach(function(p) {
         p.preventDefault = function() {
           this.scrolling = false;
           this.firstXY = null;
           inEvent.preventDefault();
         };
       }, this);
       pointers.forEach(inFunction, this);
@@ skipping 714 matching lines @@
       setTimeout(fn, 0);
     },
     preventTap: function(inPointerId) {
       var t = this.recognizers.tap;
       if (t){
         t.preventTap(inPointerId);
       }
     }
   };
   dispatcher.boundHandler = dispatcher.eventHandler.bind(dispatcher);
+  // recognizers call into the dispatcher and load later
+  // solve the chicken and egg problem by having registerScopes module run last
+  dispatcher.registerQueue = [];
+  dispatcher.immediateRegister = false;
   scope.dispatcher = dispatcher;
-  var registerQueue = [];
-  var immediateRegister = false;
   /**
    * Enable gesture events for a given scope, typically
    * [ShadowRoots](https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#shadow-root-object).
    *
    * @for PointerGestures
    * @method register
    * @param {ShadowRoot} scope A top level scope to enable gesture
    * support on.
    */
   scope.register = function(inScope) {
-    if (immediateRegister) {
+    if (dispatcher.immediateRegister) {
       var pe = window.PointerEventsPolyfill;
       if (pe) {
         pe.register(inScope);
       }
       scope.dispatcher.registerTarget(inScope);
     } else {
-      registerQueue.push(inScope);
+      dispatcher.registerQueue.push(inScope);
     }
   };
-  // wait to register scopes until recognizers load
-  document.addEventListener('DOMContentLoaded', function() {
-    immediateRegister = true;
-    registerQueue.push(document);
-    registerQueue.forEach(scope.register);
-  });
+  scope.register(document);
 })(window.PointerGestures);
 
 /*
  * Copyright 2013 The Polymer Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the LICENSE file.
  */
 
 /**
  * This event is fired when a pointer is held down for 200ms.
@@ skipping 643 matching lines @@
       'pointerdown',
       'pointermove',
       'pointerup',
       'pointercancel',
       'keyup'
     ],
     pointerdown: function(inEvent) {
       if (inEvent.isPrimary && !inEvent.tapPrevented) {
         pointermap.set(inEvent.pointerId, {
           target: inEvent.target,
+          buttons: inEvent.buttons,
           x: inEvent.clientX,
           y: inEvent.clientY
         });
       }
     },
     pointermove: function(inEvent) {
       if (inEvent.isPrimary) {
         var start = pointermap.get(inEvent.pointerId);
         if (start) {
           if (inEvent.tapPrevented) {
             pointermap.delete(inEvent.pointerId);
           }
         }
       }
     },
-    shouldTap: function(e) {
+    shouldTap: function(e, downState) {
       if (!e.tapPrevented) {
-        // only allow left click to tap for mouse
-        return e.pointerType === 'mouse' ? e.buttons === 1 : true;
+        if (e.pointerType === 'mouse') {
+          // only allow left click to tap for mouse
+          return downState.buttons === 1;
+        } else {
+          return true;
+        }
       }
     },
     pointerup: function(inEvent) {
       var start = pointermap.get(inEvent.pointerId);
-      if (start && this.shouldTap(inEvent)) {
+      if (start && this.shouldTap(inEvent, start)) {
         var t = scope.findLCA(start.target, inEvent.target);
         if (t) {
           var e = dispatcher.makeEvent('tap', {
             x: inEvent.clientX,
             y: inEvent.clientY,
             detail: inEvent.detail,
             pointerType: inEvent.pointerType
           });
           dispatcher.dispatchEvent(e, t);
         }
@@ skipping 18 matching lines @@
         }
       }
     },
     preventTap: function(inPointerId) {
       pointermap.delete(inPointerId);
     }
   };
   dispatcher.registerRecognizer('tap', tap);
 })(window.PointerGestures);
 
+/*
+ * Copyright 2014 The Polymer Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+/**
+ * Because recognizers are loaded after dispatcher, we have to wait to register
+ * scopes until after all the recognizers.
+ */
+(function(scope) {
+  var dispatcher = scope.dispatcher;
+  function registerScopes() {
+    dispatcher.immediateRegister = true;
+    var rq = dispatcher.registerQueue;
+    rq.forEach(scope.register);
+    rq.length = 0;
+  }
+  if (document.readyState === 'complete') {
+    registerScopes();
+  } else {
+    // register scopes after a steadystate is reached
+    // less MutationObserver churn
+    document.addEventListener('readystatechange', function() {
+      if (document.readyState === 'complete') {
+        registerScopes();
+      }
+    });
+  }
+})(window.PointerGestures);
+
 // Copyright 2011 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 (function(global) {
   'use strict';
 
   var filter = Array.prototype.filter.call.bind(Array.prototype.filter);
 
   function getTreeScope(node) {
     while (node.parentNode) {
       node = node.parentNode;
     }
 
     return typeof node.getElementById === 'function' ? node : null;
   }
 
-  // JScript does not have __proto__. We wrap all object literals with
-  // createObject which uses Object.create, Object.defineProperty and
-  // Object.getOwnPropertyDescriptor to create a new object that does the exact
-  // same thing. The main downside to this solution is that we have to extract
-  // all those property descriptors for IE.
-  var createObject = ('__proto__' in {}) ?
-      function(obj) { return obj; } :
-      function(obj) {
-        var proto = obj.__proto__;
-        if (!proto)
-          return obj;
-        var newObject = Object.create(proto);
-        Object.getOwnPropertyNames(obj).forEach(function(name) {
-          Object.defineProperty(newObject, name,
-                               Object.getOwnPropertyDescriptor(obj, name));
-        });
-        return newObject;
-      };
-
-  // IE does not support have Document.prototype.contains.
-  if (typeof document.contains != 'function') {
-    Document.prototype.contains = function(node) {
-      if (node === this || node.parentNode === this)
-        return true;
-      return this.documentElement.contains(node);
-    }
-  }
 
   Node.prototype.bind = function(name, observable) {
     console.error('Unhandled binding to Node: ', this, name, observable);
   };
 
   function unbind(node, name) {
     var bindings = node.bindings;
     if (!bindings) {
       node.bindings = {};
       return;
@@ skipping 3295 matching lines @@
   }
 }
 
 // exports
 scope.flush = flush;
 
 })(window.Platform);
 
 
 //# sourceMappingURL=platform.concat.js.map