Update platform.js to latest.

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 3360 matching lines @@
       return wrapNodeList(this.impl[name].apply(this.impl, arguments));
     };
   }
 
   scope.wrappers.NodeList = NodeList;
   scope.addWrapNodeListMethod = addWrapNodeListMethod;
   scope.wrapNodeList = wrapNodeList;
 
 })(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';
+
+  // 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.
 
 (function(scope) {
   'use strict';
 
   var EventTarget = scope.wrappers.EventTarget;
   var NodeList = scope.wrappers.NodeList;
   var assert = scope.assert;
@@ skipping 1739 matching lines @@
       node.setAttribute('selected', '');
     node.selected = selected === true;
   }
 
   Option.prototype = HTMLOptionElement.prototype;
 
   scope.wrappers.HTMLOptionElement = HTMLOptionElement;
   scope.wrappers.Option = Option;
 })(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';
+
+  var HTMLElement = scope.wrappers.HTMLElement;
+  var mixin = scope.mixin;
+  var registerWrapper = scope.registerWrapper;
+  var unwrap = scope.unwrap;
+  var wrap = scope.wrap;
+
+  var OriginalHTMLSelectElement = window.HTMLSelectElement;
+
+  function HTMLSelectElement(node) {
+    HTMLElement.call(this, node);
+  }
+  HTMLSelectElement.prototype = Object.create(HTMLElement.prototype);
+  mixin(HTMLSelectElement.prototype, {
+    add: function(element, before) {
+      if (typeof before === 'object')  // also includes null
+        before = unwrap(before);
+      unwrap(this).add(unwrap(element), before);
+    },
+
+    remove: function(indexOrNode) {
+      // Spec only allows index but implementations allow index or node.
+      // remove() is also allowed which is same as remove(undefined)
+      if (typeof indexOrNode === 'object')
+        indexOrNode = unwrap(indexOrNode);
+      unwrap(this).remove(indexOrNode);
+    },
+
+    get form() {
+      return wrap(unwrap(this).form);
+    }
+  });
+
+  registerWrapper(OriginalHTMLSelectElement, HTMLSelectElement,
+                  document.createElement('select'));
+
+  scope.wrappers.HTMLSelectElement = HTMLSelectElement;
+})(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';
+
+  var HTMLElement = scope.wrappers.HTMLElement;
+  var mixin = scope.mixin;
+  var registerWrapper = scope.registerWrapper;
+  var unwrap = scope.unwrap;
+  var wrap = scope.wrap;
+  var wrapHTMLCollection = scope.wrapHTMLCollection;
+
+  var OriginalHTMLTableElement = window.HTMLTableElement;
+
+  function HTMLTableElement(node) {
+    HTMLElement.call(this, node);
+  }
+  HTMLTableElement.prototype = Object.create(HTMLElement.prototype);
+  mixin(HTMLTableElement.prototype, {
+    get caption() {
+      return wrap(unwrap(this).caption);
+    },
+    createCaption: function() {
+      return wrap(unwrap(this).createCaption());
+    },
+
+    get tHead() {
+      return wrap(unwrap(this).tHead);
+    },
+    createTHead: function() {
+      return wrap(unwrap(this).createTHead());
+    },
+
+    createTFoot: function() {
+      return wrap(unwrap(this).createTFoot());
+    },
+    get tFoot() {
+      return wrap(unwrap(this).tFoot);
+    },
+
+    get tBodies() {
+      return wrapHTMLCollection(unwrap(this).tBodies);
+    },
+    createTBody: function() {
+      return wrap(unwrap(this).createTBody());
+    },
+
+    get rows() {
+      return wrapHTMLCollection(unwrap(this).rows);
+    },
+    insertRow: function(index) {
+      return wrap(unwrap(this).insertRow(index));
+    }
+  });
+
+  registerWrapper(OriginalHTMLTableElement, HTMLTableElement,
+                  document.createElement('table'));
+
+  scope.wrappers.HTMLTableElement = HTMLTableElement;
+})(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';
+
+  var HTMLElement = scope.wrappers.HTMLElement;
+  var mixin = scope.mixin;
+  var registerWrapper = scope.registerWrapper;
+  var wrapHTMLCollection = scope.wrapHTMLCollection;
+  var unwrap = scope.unwrap;
+  var wrap = scope.wrap;
+
+  var OriginalHTMLTableSectionElement = window.HTMLTableSectionElement;
+
+  function HTMLTableSectionElement(node) {
+    HTMLElement.call(this, node);
+  }
+  HTMLTableSectionElement.prototype = Object.create(HTMLElement.prototype);
+  mixin(HTMLTableSectionElement.prototype, {
+    get rows() {
+      return wrapHTMLCollection(unwrap(this).rows);
+    },
+    insertRow: function(index) {
+      return wrap(unwrap(this).insertRow(index));
+    }
+  });
+
+  registerWrapper(OriginalHTMLTableSectionElement, HTMLTableSectionElement,
+                  document.createElement('thead'));
+
+  scope.wrappers.HTMLTableSectionElement = HTMLTableSectionElement;
+})(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';
+
+  var HTMLElement = scope.wrappers.HTMLElement;
+  var mixin = scope.mixin;
+  var registerWrapper = scope.registerWrapper;
+  var wrapHTMLCollection = scope.wrapHTMLCollection;
+  var unwrap = scope.unwrap;
+  var wrap = scope.wrap;
+
+  var OriginalHTMLTableRowElement = window.HTMLTableRowElement;
+
+  function HTMLTableRowElement(node) {
+    HTMLElement.call(this, node);
+  }
+  HTMLTableRowElement.prototype = Object.create(HTMLElement.prototype);
+  mixin(HTMLTableRowElement.prototype, {
+    get cells() {
+      return wrapHTMLCollection(unwrap(this).cells);
+    },
+
+    insertCell: function(index) {
+      return wrap(unwrap(this).insertCell(index));
+    }
+  });
+
+  registerWrapper(OriginalHTMLTableRowElement, HTMLTableRowElement,
+                  document.createElement('tr'));
+
+  scope.wrappers.HTMLTableRowElement = HTMLTableRowElement;
+})(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 HTMLContentElement = scope.wrappers.HTMLContentElement;
   var HTMLElement = scope.wrappers.HTMLElement;
   var HTMLShadowElement = scope.wrappers.HTMLShadowElement;
@@ skipping 545 matching lines @@
     if (!eventParents)
       eventParentsTable.set(child, eventParents = []);
     eventParents.push(insertionPoint);
   }
 
   function resetDistributedChildNodes(insertionPoint) {
     distributedChildNodesTable.set(insertionPoint, []);
   }
 
   function getDistributedChildNodes(insertionPoint) {
-    return distributedChildNodesTable.get(insertionPoint);
+    var rv = distributedChildNodesTable.get(insertionPoint);
+    if (!rv)
+      distributedChildNodesTable.set(insertionPoint, rv = []);
+    return rv;
   }
 
   function getChildNodesSnapshot(node) {
     var result = [], i = 0;
     for (var child = node.firstChild; child; child = child.nextSibling) {
       result[i++] = child;
     }
     return result;
   }
 
@@ skipping 87 matching lines @@
     'requestAnimationFrame',
     'mozRequestAnimationFrame',
     'webkitRequestAnimationFrame',
     '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();
     }
+
     pendingDirtyRenderers = [];
   }
 
   function handleRequestAnimationFrame() {
     renderTimer = null;
     renderAllPending();
   }
 
   /**
    * Returns existing shadow renderer for a host or creates it if it is needed.
@@ skipping 153 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;
+        // renderNode.skip = !renderer.dirty;
+        renderer.invalidate();
         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 266 matching lines @@
   var elementsWithFormProperty = [
     'HTMLButtonElement',
     'HTMLFieldSetElement',
     'HTMLInputElement',
     'HTMLKeygenElement',
     'HTMLLabelElement',
     'HTMLLegendElement',
     'HTMLObjectElement',
     // HTMLOptionElement is handled in HTMLOptionElement.js
     'HTMLOutputElement',
-    'HTMLSelectElement',
+    // HTMLSelectElement is handled in HTMLSelectElement.js
     'HTMLTextAreaElement',
   ];
 
   function createWrapperConstructor(name) {
     if (!window[name])
       return;
 
     // Ensure we are not overriding an already existing constructor.
     assert(!scope.wrappers[name]);
 
@@ skipping 470 matching lines @@
 
 (function(scope) {
   'use strict';
 
   var isWrapperFor = scope.isWrapperFor;
 
   // This is a list of the elements we currently override the global constructor
   // for.
   var elements = {
     'a': 'HTMLAnchorElement',
-
     // Do not create an applet element by default since it shows a warning in
     // IE.
     // https://github.com/Polymer/polymer/issues/217
     // 'applet': 'HTMLAppletElement',
-
     'area': 'HTMLAreaElement',
-    'br': 'HTMLBRElement',
+    'audio': 'HTMLAudioElement',
     'base': 'HTMLBaseElement',
     'body': 'HTMLBodyElement',
+    'br': 'HTMLBRElement',
     'button': 'HTMLButtonElement',
+    'canvas': 'HTMLCanvasElement',
+    'caption': 'HTMLTableCaptionElement',
+    'col': 'HTMLTableColElement',
     // 'command': 'HTMLCommandElement',  // Not fully implemented in Gecko.
-    'dl': 'HTMLDListElement',
+    'content': 'HTMLContentElement',
+    'data': 'HTMLDataElement',
     'datalist': 'HTMLDataListElement',
-    'data': 'HTMLDataElement',
+    'del': 'HTMLModElement',
     'dir': 'HTMLDirectoryElement',
     'div': 'HTMLDivElement',
+    'dl': 'HTMLDListElement',
     'embed': 'HTMLEmbedElement',
     'fieldset': 'HTMLFieldSetElement',
     'font': 'HTMLFontElement',
     'form': 'HTMLFormElement',
     'frame': 'HTMLFrameElement',
     'frameset': 'HTMLFrameSetElement',
+    'h1': 'HTMLHeadingElement',
+    'head': 'HTMLHeadElement',
     'hr': 'HTMLHRElement',
-    'head': 'HTMLHeadElement',
-    'h1': 'HTMLHeadingElement',
     'html': 'HTMLHtmlElement',
     'iframe': 'HTMLIFrameElement',
+    'img': 'HTMLImageElement',
     'input': 'HTMLInputElement',
-    'li': 'HTMLLIElement',
+    'keygen': 'HTMLKeygenElement',
     'label': 'HTMLLabelElement',
     'legend': 'HTMLLegendElement',
+    'li': 'HTMLLIElement',
     'link': 'HTMLLinkElement',
     'map': 'HTMLMapElement',
     'marquee': 'HTMLMarqueeElement',
     'menu': 'HTMLMenuElement',
     'menuitem': 'HTMLMenuItemElement',
     'meta': 'HTMLMetaElement',
     'meter': 'HTMLMeterElement',
-    'del': 'HTMLModElement',
+    'object': 'HTMLObjectElement',
     'ol': 'HTMLOListElement',
-    'object': 'HTMLObjectElement',
     'optgroup': 'HTMLOptGroupElement',
     'option': 'HTMLOptionElement',
     'output': 'HTMLOutputElement',
     'p': 'HTMLParagraphElement',
     'param': 'HTMLParamElement',
     'pre': 'HTMLPreElement',
     'progress': 'HTMLProgressElement',
     'q': 'HTMLQuoteElement',
     'script': 'HTMLScriptElement',
     'select': 'HTMLSelectElement',
+    'shadow': 'HTMLShadowElement',
     'source': 'HTMLSourceElement',
     'span': 'HTMLSpanElement',
     'style': 'HTMLStyleElement',
-    'time': 'HTMLTimeElement',
-    'caption': 'HTMLTableCaptionElement',
+    'table': 'HTMLTableElement',
+    'tbody': 'HTMLTableSectionElement',
     // WebKit and Moz are wrong:
     // https://bugs.webkit.org/show_bug.cgi?id=111469
     // https://bugzilla.mozilla.org/show_bug.cgi?id=848096
     // 'td': 'HTMLTableCellElement',
-    'col': 'HTMLTableColElement',
-    'table': 'HTMLTableElement',
+    'template': 'HTMLTemplateElement',
+    'textarea': 'HTMLTextAreaElement',
+    'thead': 'HTMLTableSectionElement',
+    'time': 'HTMLTimeElement',
+    'title': 'HTMLTitleElement',
     'tr': 'HTMLTableRowElement',
-    'thead': 'HTMLTableSectionElement',
-    'tbody': 'HTMLTableSectionElement',
-    'textarea': 'HTMLTextAreaElement',
     'track': 'HTMLTrackElement',
-    'title': 'HTMLTitleElement',
     'ul': 'HTMLUListElement',
     'video': 'HTMLVideoElement',
   };
 
   function overrideConstructor(tagName) {
     var nativeConstructorName = elements[tagName];
     var nativeConstructor = window[nativeConstructorName];
     if (!nativeConstructor)
       return;
     var element = document.createElement(tagName);
     var wrapperConstructor = element.constructor;
     window[nativeConstructorName] = wrapperConstructor;
   }
 
   Object.keys(elements).forEach(overrideConstructor);
 
   Object.getOwnPropertyNames(scope.wrappers).forEach(function(name) {
     window[name] = scope.wrappers[name]
   });
 
-  // Export for testing.
-  scope.knownElements = elements;
-
 })(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() {
 
   // convenient global
@@ skipping 152 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) {
+  shimStyling: function(root, name, extendsName, ownSheet) {
     var typeExtension = this.isTypeExtension(extendsName);
     // 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...
     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++) {
       s.parentNode.removeChild(s);
     }
     // add style to document
-    addCssToDocument(cssText);
+    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);
@@ skipping 132 matching lines @@
       return this.convertScopedStyles(styles, name, typeExtension);
     }
   },
   convertScopedStyles: function(styles, name, typeExtension) {
     var cssText = stylesToCssText(styles);
     cssText = this.insertPolyfillHostInCssText(cssText);
     cssText = this.convertColonHost(cssText);
     cssText = this.convertColonAncestor(cssText);
     cssText = this.convertCombinators(cssText);
     if (name) {
-      var rules = cssToRules(cssText);
-      cssText = this.scopeRules(rules, name, typeExtension);
+      var self = this, cssText;
+      
+      withCssRules(cssText, function(rules) {
+        cssText = self.scopeRules(rules, name, typeExtension);
+      });
+
     }
     return cssText;
   },
   /*
    * convert a rule like :host(.foo) > .bar { }
    *
    * to
    *
    * scopeName.foo > .bar
   */
@@ skipping 48 matching lines @@
   },
   /*
    * 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) {
     var cssText = '';
-    Array.prototype.forEach.call(cssRules, function(rule) {
-      if (rule.selectorText && (rule.style && rule.style.cssText)) {
-        cssText += this.scopeSelector(rule.selectorText, name, typeExtension, 
-          this.strictStyling) + ' {\n\t';
-        cssText += this.propertiesFromRule(rule) + '\n}\n\n';
-      } else if (rule.media) {
-        cssText += '@media ' + rule.media.mediaText + ' {\n';
-        cssText += this.scopeRules(rule.cssRules, name, typeExtension);
-        cssText += '\n}\n\n';
-      } else if (rule.cssText) {
-        cssText += rule.cssText + '\n\n';
-      }
-    }, this);
+    if (cssRules) {
+      Array.prototype.forEach.call(cssRules, function(rule) {
+        if (rule.selectorText && (rule.style && rule.style.cssText)) {
+          cssText += this.scopeSelector(rule.selectorText, name, typeExtension, 
+            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 += '\n}\n\n';
+        } else if (rule.cssText) {
+          cssText += rule.cssText + '\n\n';
+        }
+      }, this);
+    }
     return cssText;
   },
   scopeSelector: function(selector, name, typeExtension, strict) {
     var r = [], parts = selector.split(',');
     parts.forEach(function(p) {
       p = p.trim();
       if (this.selectorNeedsScoping(p, name, typeExtension)) {
         p = (strict && !p.match(polyfillHostNoCombinator)) ? 
             this.applyStrictSelectorScope(p, name) :
             this.applySimpleSelectorScope(p, name, typeExtension);
@@ skipping 93 matching lines @@
 
 function cssTextToStyle(cssText) {
   var style = document.createElement('style');
   style.textContent = cssText;
   return style;
 }
 
 function cssToRules(cssText) {
   var style = cssTextToStyle(cssText);
   document.head.appendChild(style);
-  var rules = style.sheet.cssRules;
+  var rules = [];
+  if (style.sheet) {
+    // TODO(sorvell): Firefox throws when accessing the rules of a stylesheet
+    // with an @import
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=625013
+    try {
+      rules = style.sheet.cssRules;
+    } catch(e) {
+      //
+    }
+  } else {
+    console.warn('sheet not found', style);
+  }
   style.parentNode.removeChild(style);
   return rules;
 }
 
+var frame = document.createElement('iframe');
+frame.style.display = 'none';
+
+function initFrame() {
+  frame.initialized = true;
+  document.body.appendChild(frame);
+  var doc = frame.contentDocument;
+  var base = doc.createElement('base');
+  base.href = document.baseURI;
+  doc.head.appendChild(base);
+}
+
+function inFrame(fn) {
+  if (!frame.initialized) {
+    initFrame();
+  }
+  document.body.appendChild(frame);
+  fn(frame.contentDocument);
+  document.body.removeChild(frame);
+}
+
+// TODO(sorvell): use an iframe if the cssText contains an @import to workaround
+// https://code.google.com/p/chromium/issues/detail?id=345114
+var isChrome = navigator.userAgent.match('Chrome');
+function withCssRules(cssText, callback) {
+  if (!callback) {
+    return;
+  }
+  var rules;
+  if (cssText.match('@import') && isChrome) {
+    var style = cssTextToStyle(cssText);
+    inFrame(function(doc) {
+      doc.head.appendChild(style.impl);
+      rules = style.sheet.cssRules;
+      callback(rules);
+    });
+  } else {
+    rules = cssToRules(cssText);
+    callback(rules);
+  }
+}
+
 function rulesToCss(cssRules) {
   for (var i=0, css=[]; i < cssRules.length; i++) {
     css.push(cssRules[i].cssText);
   }
   return css.join('\n\n');
 }
 
 function addCssToDocument(cssText) {
   if (cssText) {
     getSheet().appendChild(document.createTextNode(cssText));
   }
 }
 
+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 sheet;
 function getSheet() {
   if (!sheet) {
     sheet = document.createElement("style");
     sheet.setAttribute(SHIMMED_ATTRIBUTE, '');
     sheet[SHIMMED_ATTRIBUTE] = true;
   }
@@ skipping 853 matching lines @@
   if (!window.cancelAnimationFrame) {
     window.cancelAnimationFrame = (function() {
       return  window.webkitCancelAnimationFrame ||
         window.mozCancelAnimationFrame ||
         function(id) {
           clearTimeout(id);
         };
     })();
   }
 
-  // TODO(sorvell): workaround for bug:
-  // https://code.google.com/p/chromium/issues/detail?id=229142
-  // remove when this bug is addressed
-  // give main document templates a base that allows them to fetch eagerly
-  // resolved paths relative to the main document
-  var template = document.createElement('template');
-  var base = document.createElement('base');
-  base.href = document.baseURI;
-  template.content.ownerDocument.appendChild(base);
-  
-
   // utility
 
   function createDOM(inTagOrNode, inHTML, inAttrs) {
     var dom = typeof inTagOrNode == 'string' ?
         document.createElement(inTagOrNode) : inTagOrNode.cloneNode(true);
     dom.innerHTML = inHTML;
     if (inAttrs) {
       for (var n in inAttrs) {
         dom.setAttribute(n, inAttrs[n]);
       }
     }
     return dom;
   }
   // Make a stub for Polymer() for polyfill purposes; under the HTMLImports
   // polyfill, scripts in the main document run before imports. That means
   // if (1) polymer is imported and (2) Polymer() is called in the main document
   // in a script after the import, 2 occurs before 1. We correct this here
   // by specfiically patching Polymer(); this is not necessary under native
   // HTMLImports.
   var elementDeclarations = [];
 
   var polymerStub = function(name, dictionary) {
     elementDeclarations.push(arguments);
   }
   window.Polymer = polymerStub;
 
   // deliver queued delcarations
   scope.deliverDeclarations = function() {
-    scope.deliverDeclarations = null;
+    scope.deliverDeclarations = function() {
+     throw 'Possible attempt to load Polymer twice';
+    };
     return elementDeclarations;
   }
 
   // Once DOMContent has loaded, any main document scripts that depend on
   // Polymer() should have run. Calling Polymer() now is an error until
   // polymer is imported.
   window.addEventListener('DOMContentLoaded', function() {
     if (window.Polymer === polymerStub) {
       window.Polymer = function() {
         console.error('You tried to use polymer without loading it first. To ' +
@@ skipping 333 matching lines @@
     // handle template.content
     var templates = root.querySelectorAll('template');
     if (templates) {
       for (var i = 0, l = templates.length, t; (i < l) && (t = templates[i]); i++) {
         if (t.content) {
           this.resolveDom(t.content, url);
         }
       }
     }
   },
+  resolveTemplate: function(template) {
+    this.resolveDom(template.content, template.ownerDocument.baseURI);
+  },
   resolveStyles: function(root, url) {
     var styles = root.querySelectorAll('style');
     if (styles) {
       for (var i = 0, l = styles.length, s; (i < l) && (s = styles[i]); i++) {
         this.resolveStyle(s, url);
       }
     }
   },
   resolveStyle: function(style, url) {
     url = url || style.ownerDocument.baseURI;
@@ skipping 895 matching lines @@
     var src = elt;
     elt = cloneStyle(elt);
     elt.__importElement = src;
     this.parseGeneric(elt);
   },
   parseGeneric: function(elt) {
     this.trackElement(elt);
     document.head.appendChild(elt);
   },
   // tracks when a loadable element has loaded
-  trackElement: function(elt) {
+  trackElement: function(elt, callback) {
     var self = this;
-    var done = function() {
+    var done = function(e) {
+      if (callback) {
+        callback(e);
+      }
       self.markParsingComplete(elt);
     };
     elt.addEventListener('load', done);
     elt.addEventListener('error', done);
 
     // NOTE: IE does not fire "load" event for styles that have already loaded
     // This is in violation of the spec, so we try our hardest to work around it
     if (isIe && elt.localName === 'style') {
       var fakeLoad = false;
       // If there's not @import in the textContent, assume it has loaded
@@ skipping 11 matching lines @@
             fakeLoad = fakeLoad && Boolean(r.styleSheet);
           }
         }
       }
       // dispatch a fake load event and continue parsing
       if (fakeLoad) {
         elt.dispatchEvent(new CustomEvent('load', {bubbles: false}));
       }
     }
   },
+  // NOTE: execute scripts by injecting them and watching for the load/error
+  // event. Inline scripts are handled via dataURL's because browsers tend to
+  // provide correct parsing errors in this case. If this has any compatibility
+  // issues, we can switch to injecting the inline script with textContent.
+  // Scripts with dataURL's do not appear to generate load events and therefore
+  // we assume they execute synchronously.
   parseScript: function(scriptElt) {
-    // acquire code to execute
-    var code = (scriptElt.__resource || scriptElt.textContent).trim();
-    if (code) {
-      // calculate source map hint
-      var moniker = scriptElt.__nodeUrl;
-      if (!moniker) {
-        moniker = scriptElt.ownerDocument.baseURI;
-        // there could be more than one script this url
-        var tag = '[' + Math.floor((Math.random()+1)*1000) + ']';
-        // TODO(sjmiles): Polymer hack, should be pluggable if we need to allow 
-        // this sort of thing
-        var matches = code.match(/Polymer\(['"]([^'"]*)/);
-        tag = matches && matches[1] || tag;
-        // tag the moniker
-        moniker += '/' + tag + '.js';
-      }
-      // source map hint
-      code += "\n//# sourceURL=" + moniker + "\n";
-      // evaluate the code
-      scope.currentScript = scriptElt;
-      eval.call(window, code);
-      scope.currentScript = null;
-    }
-    this.markParsingComplete(scriptElt);
+    var script = document.createElement('script');
+    script.__importElement = scriptElt;
+    script.src = scriptElt.src ? scriptElt.src : 
+        generateScriptDataUrl(scriptElt);
+    scope.currentScript = scriptElt;
+    this.trackElement(script, function(e) {
+      script.parentNode.removeChild(script);
+      scope.currentScript = null;  
+    });
+    document.head.appendChild(script);
   },
   // determine the next element in the tree which should be parsed
   nextToParse: function() {
     return !this.parsingElement && this.nextToParseInDoc(mainDoc);
   },
   nextToParseInDoc: function(doc, link) {
     var nodes = doc.querySelectorAll(this.parseSelectorsForNode(doc));
     for (var i=0, l=nodes.length, p=0, n; (i<l) && (n=nodes[i]); i++) {
       if (!this.isParsed(n)) {
         if (this.hasResource(n)) {
@@ skipping 11 matching lines @@
     var doc = node.ownerDocument || node;
     return doc === mainDoc ? this.documentSelectors : this.importsSelectors;
   },
   isParsed: function(node) {
     return node.__importParsed;
   },
   hasResource: function(node) {
     if (nodeIsImport(node) && !node.import) {
       return false;
     }
-    if (node.localName === 'script' && node.src && !node.__resource) {
-      return false;
-    }
     return true;
   }
 };
 
 function nodeIsImport(elt) {
   return (elt.localName === 'link') && (elt.rel === IMPORT_LINK_TYPE);
 }
 
+function generateScriptDataUrl(script) {
+  var scriptContent = generateScriptContent(script), b64;
+  try {
+    b64 = btoa(scriptContent);
+  } catch(e) {
+    b64 = btoa(unescape(encodeURIComponent(scriptContent)));
+    console.warn('Script contained non-latin characters that were forced ' +
+      'to latin. Some characters may be wrong.', script);
+  }
+  return 'data:text/javascript;base64,' + b64;
+}
+
+function generateScriptContent(script) {
+  return script.textContent + generateSourceMapHint(script);
+}
+
+// calculate source map hint
+function generateSourceMapHint(script) {
+  var moniker = script.__nodeUrl;
+  if (!moniker) {
+    moniker = script.ownerDocument.baseURI;
+    // there could be more than one script this url
+    var tag = '[' + Math.floor((Math.random()+1)*1000) + ']';
+    // TODO(sjmiles): Polymer hack, should be pluggable if we need to allow 
+    // this sort of thing
+    var matches = script.textContent.match(/Polymer\(['"]([^'"]*)/);
+    tag = matches && matches[1] || tag;
+    // tag the moniker
+    moniker += '/' + tag + '.js';
+  }
+  return '\n//# sourceURL=' + moniker + '\n';
+}
+
 // style/stylesheet handling
 
 // clone style with proper path resolution for main document
 // NOTE: styles are the only elements that require direct path fixup.
 function cloneStyle(style) {
   var clone = style.ownerDocument.createElement('style');
   clone.textContent = style.textContent;
   path.resolveUrlsInStyle(clone);
   return clone;
 }
@@ skipping 54 matching lines @@
   // imports
   var xhr = scope.xhr;
   var Loader = scope.Loader;
   var parser = scope.parser;
 
   // importer
   // highlander object to manage loading of imports
 
   // for any document, importer:
   // - loads any linked import documents (with deduping)
-  // for any import document, importer also:
-  // - loads text of external script tags
 
   var importer = {
     documents: {},
     // nodes to load in the mian document
     documentPreloadSelectors: 'link[rel=' + IMPORT_LINK_TYPE + ']',
     // nodes to load in imports
     importsPreloadSelectors: [
-        'link[rel=' + IMPORT_LINK_TYPE + ']',
-        'script[src]:not([type])',
-        'script[src][type="text/javascript"]'
+      'link[rel=' + IMPORT_LINK_TYPE + ']'
     ].join(','),
     loadNode: function(node) {
       importLoader.addNode(node);
     },
     // load all loadable elements within the parent element
     loadSubtree: function(parent) {
       var nodes = this.marshalNodes(parent);
       // add these nodes to loader's queue
       importLoader.addNodes(nodes);
     },
@@ skipping 66 matching lines @@
     }
     // cache the new document's source url
     doc._URL = url;
     // establish a relative path via <base>
     var base = doc.createElement('base');
     base.setAttribute('href', url);
     // add baseURI support to browsers (IE) that lack it.
     if (!doc.baseURI) {
       doc.baseURI = url;
     }
+    // ensure UTF-8 charset
+    var meta = doc.createElement('meta');
+    meta.setAttribute('charset', 'utf-8');
+
+    doc.head.appendChild(meta);
     doc.head.appendChild(base);
     // install HTML last as it may trigger CustomElement upgrades
     // TODO(sjmiles): problem wrt to template boostrapping below,
     // template bootstrapping must (?) come before element upgrade
     // but we cannot bootstrap templates until they are in a document
     // which is too late
     if (!(resource instanceof Document)) {
       // install html
       doc.body.innerHTML = resource;
     }
@@ skipping 550 matching lines @@
 }
 
 function upgradeDocument(doc) {
   logFlags.dom && console.group('upgradeDocument: ', (doc.baseURI).split('/').pop());
   addedNode(doc);
   logFlags.dom && console.groupEnd();
 }
 
 function upgradeDocumentTree(doc) {
   doc = wrapIfNeeded(doc);
-  upgradeDocument(doc);
   //console.log('upgradeDocumentTree: ', (doc.baseURI).split('/').pop());
   // upgrade contained imported documents
   var imports = doc.querySelectorAll('link[rel=' + IMPORT_LINK_TYPE + ']');
   for (var i=0, l=imports.length, n; (i<l) && (n=imports[i]); i++) {
     if (n.import && n.import.__parsed) {
       upgradeDocumentTree(n.import);
     }
   }
+  upgradeDocument(doc);
 }
 
 // exports
 scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;
 scope.watchShadow = watchShadow;
 scope.upgradeDocumentTree = upgradeDocumentTree;
 scope.upgradeAll = addedNode;
 scope.upgradeSubtree = addedSubtree;
 scope.insertedNode = insertedNode;
 
@@ skipping 253 matching lines @@
     }
   }
 
   function customMixin(inTarget, inSrc, inNative) {
     // TODO(sjmiles): 'used' allows us to only copy the 'youngest' version of
     // any property. This set should be precalculated. We also need to
     // consider this for supporting 'super'.
     var used = {};
     // start with inSrc
     var p = inSrc;
-    // sometimes the default is HTMLUnknownElement.prototype instead of
-    // HTMLElement.prototype, so we add a test
-    // the idea is to avoid mixing in native prototypes, so adding
-    // the second test is WLOG
-    while (p !== inNative && p !== HTMLUnknownElement.prototype) {
+    // The default is HTMLElement.prototype, so we add a test to avoid mixing in
+    // native prototypes
+    while (p !== inNative && p !== HTMLElement.prototype) {
       var keys = Object.getOwnPropertyNames(p);
       for (var i=0, k; k=keys[i]; i++) {
         if (!used[k]) {
           Object.defineProperty(inTarget, k,
               Object.getOwnPropertyDescriptor(p, k));
           used[k] = 1;
         }
       }
       p = Object.getPrototypeOf(p);
     }
@@ skipping 51 matching lines @@
   function registerDefinition(name, definition) {
     registry[name] = definition;
   }
 
   function generateConstructor(definition) {
     return function() {
       return instantiate(definition);
     };
   }
 
+  var HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+  function createElementNS(namespace, tag, typeExtension) {
+    // NOTE: we do not support non-HTML elements,
+    // just call createElementNS for non HTML Elements
+    if (namespace === HTML_NAMESPACE) {
+      return createElement(tag, typeExtension);
+    } else {
+      return domCreateElementNS(namespace, tag);
+    }
+  }
+
   function createElement(tag, typeExtension) {
     // TODO(sjmiles): ignore 'tag' when using 'typeExtension', we could
     // error check it, or perhaps there should only ever be one argument
     var definition = getRegisteredDefinition(typeExtension || tag);
     if (definition) {
       if (tag == definition.tag && typeExtension == definition.is) {
         return new definition.ctor();
       }
       // Handle empty string for type extension.
       if (!typeExtension && !definition.is) {
@@ skipping 32 matching lines @@
     // call original clone
     var n = domCloneNode.call(this, deep);
     // upgrade the element and subtree
     scope.upgradeAll(n);
     // return the clone
     return n;
   }
   // capture native createElement before we override it
 
   var domCreateElement = document.createElement.bind(document);
+  var domCreateElementNS = document.createElementNS.bind(document);
 
   // capture native cloneNode before we override it
 
   var domCloneNode = Node.prototype.cloneNode;
 
   // exports
 
   document.registerElement = register;
   document.createElement = createElement; // override
+  document.createElementNS = createElementNS; // override
   Node.prototype.cloneNode = cloneNode; // override
 
   scope.registry = registry;
 
   /**
    * Upgrade an element to a custom element. Upgrading an element
    * causes the custom prototype to be applied, an `is` attribute
    * to be attached (as needed), and invocation of the `readyCallback`.
    * `upgrade` does nothing if the element is already upgraded, or
    * if it matches no registered custom tag name.
    *
    * @method ugprade
    * @param {Element} element The element to upgrade.
    * @return {Element} The upgraded element.
    */
   scope.upgrade = upgradeElement;
 }
 
+// Create a custom 'instanceof'. This is necessary when CustomElements
+// are implemented via a mixin strategy, as for example on IE10.
+var isInstance;
+if (!Object.__proto__ && !useNative) {
+  isInstance = function(obj, ctor) {
+    var p = obj;
+    while (p) {
+      // NOTE: this is not technically correct since we're not checking if
+      // an object is an instance of a constructor; however, this should
+      // be good enough for the mixin strategy.
+      if (p === ctor.prototype) {
+        return true;
+      }
+      p = p.__proto__;
+    }
+    return false;
+  }
+} else {
+  isInstance = function(obj, base) {
+    return obj instanceof base;
+  }
+}
+
+// exports
+scope.instanceof = isInstance;
+
 // bc
 document.register = document.registerElement;
 
 scope.hasNative = hasNative;
 scope.useNative = useNative;
 
 })(window.CustomElements);
 
 /*
  * Copyright 2013 The Polymer Authors. All rights reserved.
@@ skipping 128 matching lines @@
 
 })(window.CustomElements);
 
 /*
  * 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() {
 
-// inject style sheet
-var style = document.createElement('style');
-style.textContent = 'element {display: none !important;} /* injected by platform.js */';
-var head = document.querySelector('head');
-head.insertBefore(style, head.firstChild);
-
 if (window.ShadowDOMPolyfill) {
 
   // ensure wrapped inputs for these functions
   var fns = ['upgradeAll', 'upgradeSubtree', 'observeDocument',
       'upgradeDocument'];
 
   // cache originals
   var original = {};
   fns.forEach(function(fn) {
     original[fn] = CustomElements[fn];
   });
 
   // override
   fns.forEach(function(fn) {
     CustomElements[fn] = function(inNode) {
       return original[fn](wrap(inNode));
     };
   });
 
 }
 
 })();
 
 /*
  * 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.
  */
 (function(scope) {
+  var endOfMicrotask = scope.endOfMicrotask;
+
+  // Generic url loader
+  function Loader(regex) {
+    this.regex = regex;
+  }
+  Loader.prototype = {
+    // TODO(dfreedm): there may be a better factoring here
+    // extract absolute urls from the text (full of relative urls)
+    extractUrls: function(text, base) {
+      var matches = [];
+      var matched, u;
+      while ((matched = this.regex.exec(text))) {
+        u = new URL(matched[1], base);
+        matches.push({matched: matched[0], url: u.href});
+      }
+      return matches;
+    },
+    // take a text blob, a root url, and a callback and load all the urls found within the text
+    // returns a map of absolute url to text
+    process: function(text, root, callback) {
+      var matches = this.extractUrls(text, root);
+      this.fetch(matches, {}, callback);
+    },
+    // build a mapping of url -> text from matches
+    fetch: function(matches, map, callback) {
+      var inflight = matches.length;
+
+      // return early if there is no fetching to be done
+      if (!inflight) {
+        return callback(map);
+      }
+
+      var done = function() {
+        if (--inflight === 0) {
+          callback(map);
+        }
+      };
+
+      // map url -> responseText
+      var handleXhr = function(err, request) {
+        var match = request.match;
+        var key = match.url;
+        // handle errors with an empty string
+        if (err) {
+          map[key] = '';
+          return done();
+        }
+        var response = request.response || request.responseText;
+        map[key] = response;
+        this.fetch(this.extractUrls(response, key), map, done);
+      };
+
+      var m, req, url;
+      for (var i = 0; i < inflight; i++) {
+        m = matches[i];
+        url = m.url;
+        // if this url has already been requested, skip requesting it again
+        if (map[url]) {
+          // Async call to done to simplify the inflight logic
+          endOfMicrotask(done);
+          continue;
+        }
+        req = this.xhr(url, handleXhr, this);
+        req.match = m;
+        // tag the map with an XHR request to deduplicate at the same level
+        map[url] = req;
+      }
+    },
+    xhr: function(url, callback, scope) {
+      var request = new XMLHttpRequest();
+      request.open('GET', url, true);
+      request.send();
+      request.onload = function() {
+        callback.call(scope, null, request);
+      };
+      request.onerror = function() {
+        callback.call(scope, null, request);
+      };
+      return request;
+    }
+  };
+
+  scope.Loader = Loader;
+})(window.Platform);
+
+/*
+ * 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.
+ */
+(function(scope) {
 
-var STYLE_SELECTOR = 'style';
+var urlResolver = scope.urlResolver;
+var Loader = scope.Loader;
 
-var urlResolver = scope.urlResolver;
-
-var loader = {
-  cacheStyles: function(styles, callback) {
-    var css = [];
-    for (var i=0, l=styles.length, s; (i<l) && (s=styles[i]); i++) {
-      css.push(s.textContent);
+function StyleResolver() {
+  this.loader = new Loader(this.regex);
+}
+StyleResolver.prototype = {
+  regex: /@import\s+(?:url)?["'\(]*([^'"\)]*)['"\)]*;/g,
+  // Recursively replace @imports with the text at that url
+  resolve: function(text, url, callback) {
+    var done = function(map) {
+      callback(this.flatten(text, url, map));
+    }.bind(this);
+    this.loader.process(text, url, done);
+  },
+  // resolve the textContent of a style node
+  resolveNode: function(style, callback) {
+    var text = style.textContent;
+    var url = style.ownerDocument.baseURI;
+    var done = function(text) {
+      style.textContent = text;
+      callback(style);
+    };
+    this.resolve(text, url, done);
+  },
+  // flatten all the @imports to text
+  flatten: function(text, base, map) {
+    var matches = this.loader.extractUrls(text, base);
+    var match, url, intermediate;
+    for (var i = 0; i < matches.length; i++) {
+      match = matches[i];
+      url = match.url;
+      // resolve any css text to be relative to the importer
+      intermediate = urlResolver.resolveCssText(map[url], url);
+      // flatten intermediate @imports
+      intermediate = this.flatten(intermediate, url, map);
+      text = text.replace(match.matched, intermediate);
     }
-    cacheCssText(css.join('\n'), callback);
+    return text;
   },
-  xhrStyles: function(styles, callback) {
+  loadStyles: function(styles, callback) {
     var loaded=0, l = styles.length;
     // called in the context of the style
     function loadedStyle(style) {
-      //console.log(style.textContent);
       loaded++;
       if (loaded === l && callback) {
         callback();
       }
     }
     for (var i=0, s; (i<l) && (s=styles[i]); i++) {
-      xhrLoadStyle(s, loadedStyle);
+      this.resolveNode(s, loadedStyle);
     }
   }
 };
 
-// use the platform to preload styles
-var preloadElement = document.createElement('preloader');
-preloadElement.style.display = 'none';
-var preloadRoot = preloadElement.createShadowRoot();
-document.head.appendChild(preloadElement);
-
-function cacheCssText(cssText, callback) {
-  var style = createStyleElement(cssText);
-  if (callback) {
-    style.addEventListener('load', callback);
-    style.addEventListener('error', callback);
-  }
-  preloadRoot.appendChild(style);
-}
-
-function createStyleElement(cssText, scope) {
-  scope = scope || document;
-  scope = scope.createElement ? scope : scope.ownerDocument;
-  var style = scope.createElement('style');
-  style.textContent = cssText;
-  return style;
-}
-
-// TODO(sorvell): use a common loader shared with HTMLImports polyfill
-// currently, this just loads the first @import per style element 
-// and does not recurse into loaded elements; we'll address this with a 
-// generalized loader that's built out of the one in the HTMLImports polyfill.
-// polyfill the loading of a style element's @import via xhr
-function xhrLoadStyle(style, callback) {
-  HTMLImports.xhr.load(atImportUrlFromStyle(style), function (err, resource,
-      url) {
-    replaceAtImportWithCssText(this, url, resource);
-    this.textContent = urlResolver.resolveCssText(this.textContent, url);
-    callback && callback(this);
-  }, style);
-}
-
-var atImportRe = /@import\s[(]?['"]?([^\s'";)]*)/;
-
-// get the first @import rule from a style
-function atImportUrlFromStyle(style) {
-  var matches = style.textContent.match(atImportRe);
-  return matches && matches[1];
-}
-
-function replaceAtImportWithCssText(style, url, cssText) {
-  var re = new RegExp('@import[^;]*' + url + '[^;]*;', 'i');
-  style.textContent = style.textContent.replace(re, cssText);
-}
+var styleResolver = new StyleResolver();
 
 // exports
-scope.loader = loader;
+scope.styleResolver = styleResolver;
 
 })(window.Platform);
 
 /*
  * 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) {
@@ skipping 488 matching lines @@
       for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) {
         // call eventsource register
         es.unregister.call(es, element);
       }
     },
     contains: scope.external.contains || function(container, contained) {
       return container.contains(contained);
     },
     // EVENTS
     down: function(inEvent) {
+      inEvent.bubbles = true;
       this.fireEvent('pointerdown', inEvent);
     },
     move: function(inEvent) {
+      inEvent.bubbles = true;
       this.fireEvent('pointermove', inEvent);
     },
     up: function(inEvent) {
+      inEvent.bubbles = true;
       this.fireEvent('pointerup', inEvent);
     },
     enter: function(inEvent) {
       inEvent.bubbles = false;
       this.fireEvent('pointerenter', inEvent);
     },
     leave: function(inEvent) {
       inEvent.bubbles = false;
       this.fireEvent('pointerleave', inEvent);
     },
     over: function(inEvent) {
       inEvent.bubbles = true;
       this.fireEvent('pointerover', inEvent);
     },
     out: function(inEvent) {
       inEvent.bubbles = true;
       this.fireEvent('pointerout', inEvent);
     },
     cancel: function(inEvent) {
+      inEvent.bubbles = true;
       this.fireEvent('pointercancel', inEvent);
     },
     leaveOut: function(event) {
       this.out(event);
       if (!this.contains(event.target, event.relatedTarget)) {
         this.leave(event);
       }
     },
     enterOver: function(event) {
       this.over(event);
@@ skipping 1303 matching lines @@
  */
 
 /**
  * This event is fired when a pointer is held down for 200ms.
  *
  * @module PointerGestures
  * @submodule Events
  * @class hold
  */
 /**
- * Milliseconds pointer has been held down.
+ * Type of pointer that made the holding event.
+ * @type String
+ * @property pointerType
+ */
+/**
+ * Screen X axis position of the held pointer
  * @type Number
- * @property holdTime
+ * @property clientX
+ */
+/**
+ * Screen Y axis position of the held pointer
+ * @type Number
+ * @property clientY
  */
 /**
  * Type of pointer that made the holding event.
  * @type String
  * @property pointerType
  */
 /**
  * This event is fired every 200ms while a pointer is held down.
  *
  * @class holdpulse
  * @extends hold
  */
 /**
+ * Milliseconds pointer has been held down.
+ * @type Number
+ * @property holdTime
+ */
+/**
  * This event is fired when a held pointer is released or moved.
  *
  * @class released
  */
-/**
- * Type of pointer that made the holding event.
- * @type String
- * @property pointerType
- */
 
 (function(scope) {
   var dispatcher = scope.dispatcher;
   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: [
       'pointerdown',
@@ skipping 38 matching lines @@
       if (this.heldPointer && this.heldPointer.pointerId === inEvent.pointerId) {
         var x = inEvent.clientX - this.heldPointer.clientX;
         var y = inEvent.clientY - this.heldPointer.clientY;
         if ((x * x + y * y) > this.WIGGLE_THRESHOLD) {
           this.cancel();
         }
       }
     },
     fireHold: function(inType, inHoldTime) {
       var p = {
-        pointerType: this.heldPointer.pointerType
+        pointerType: this.heldPointer.pointerType,
+        clientX: this.heldPointer.clientX,
+        clientY: this.heldPointer.clientY
       };
       if (inHoldTime) {
         p.holdTime = inHoldTime;
       }
       var e = dispatcher.makeEvent(inType, p);
       dispatcher.dispatchEvent(e, this.target);
       if (e.tapPrevented) {
         dispatcher.preventTap(this.heldPointer.pointerId);
       }
     }
@@ skipping 546 matching lines @@
     pointermove: function(inEvent) {
       if (inEvent.isPrimary) {
         var start = pointermap.get(inEvent.pointerId);
         if (start) {
           if (inEvent.tapPrevented) {
             pointermap.delete(inEvent.pointerId);
           }
         }
       }
     },
+    shouldTap: function(e) {
+      if (!e.tapPrevented) {
+        // only allow left click to tap for mouse
+        return e.pointerType === 'mouse' ? e.buttons === 1 : true;
+      }
+    },
     pointerup: function(inEvent) {
       var start = pointermap.get(inEvent.pointerId);
-      if (start && !inEvent.tapPrevented) {
+      if (start && this.shouldTap(inEvent)) {
         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 205 matching lines @@
   })();
 
   function getEventForInputType(element) {
     switch (element.type) {
       case 'checkbox':
         return checkboxEventType;
       case 'radio':
       case 'select-multiple':
       case 'select-one':
         return 'change';
+      case 'range':
+        if (/Trident|MSIE/.test(navigator.userAgent))
+          return 'change';
       default:
         return 'input';
     }
   }
 
   function updateInput(input, property, value, santizeFn) {
     input[property] = (santizeFn || sanitizeValue)(value);
   }
 
   function inputBinding(input, property, santizeFn) {
@@ skipping 332 matching lines @@
     'TR': true,
     'TD': true,
     'COLGROUP': true,
     'COL': true,
     'CAPTION': true,
     'OPTION': true,
     'OPTGROUP': true
   };
 
   var hasTemplateElement = typeof HTMLTemplateElement !== 'undefined';
+  if (hasTemplateElement) {
+    // TODO(rafaelw): Remove when fix for
+    // https://codereview.chromium.org/164803002/
+    // makes it to Chrome release.
+    (function() {
+      var t = document.createElement('template');
+      var d = t.content.ownerDocument;
+      var html = d.appendChild(d.createElement('html'));
+      var head = html.appendChild(d.createElement('head'));
+      var base = d.createElement('base');
+      base.href = document.baseURI;
+      head.appendChild(base);
+    })();
+  }
 
   var allTemplatesSelectors = 'template, ' +
       Object.keys(semanticTemplateElements).map(function(tagName) {
         return tagName.toLowerCase() + '[template]';
       }).join(', ');
 
   function isSVGTemplate(el) {
     return el.tagName == 'template' &&
            el.namespaceURI == 'http://www.w3.org/2000/svg';
   }
@@ skipping 77 matching lines @@
       doc.templateContentsOwner_ = d;
     }
     return d;
   }
 
   function getTemplateStagingDocument(template) {
     if (!template.stagingDocument_) {
       var owner = template.ownerDocument;
       if (!owner.stagingDocument_) {
         owner.stagingDocument_ = owner.implementation.createHTMLDocument('');
+
+        // TODO(rafaelw): Remove when fix for
+        // https://codereview.chromium.org/164803002/
+        // makes it to Chrome release.
+        var base = owner.stagingDocument_.createElement('base');
+        base.href = document.baseURI;
+        owner.stagingDocument_.head.appendChild(base);
+
         owner.stagingDocument_.stagingDocument_ = owner.stagingDocument_;
       }
 
       template.stagingDocument_ = owner.stagingDocument_;
     }
 
     return template.stagingDocument_;
   }
 
   // For non-template browsers, the parser will disallow <template> in certain
@@ skipping 2688 matching lines @@
   }
 }
 
 // exports
 scope.flush = flush;
 
 })(window.Platform);
 
 
 //# sourceMappingURL=platform.concat.js.map