update TemplateBinding and Custom Elements polyfills

pkg/custom_element/lib/custom-elements.debug.js

 // Copyright (c) 2012 The Polymer Authors. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //    * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //    * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //    * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-window.CustomElements = {flags:{}};
-// SideTable is a weak map where possible. If WeakMap is not available the
-// association is stored as an expando property.
-var SideTable;
-// TODO(arv): WeakMap does not allow for Node etc to be keys in Firefox
-if (typeof WeakMap !== 'undefined' && navigator.userAgent.indexOf('Firefox/') < 0) {
-  SideTable = WeakMap;
-} else {
+if (typeof WeakMap === 'undefined') {
   (function() {
     var defineProperty = Object.defineProperty;
     var counter = Date.now() % 1e9;
 
-    SideTable = function() {
+    var WeakMap = function() {
       this.name = '__st' + (Math.random() * 1e9 >>> 0) + (counter++ + '__');
     };
 
-    SideTable.prototype = {
+    WeakMap.prototype = {
       set: function(key, value) {
         var entry = key[this.name];
         if (entry && entry[0] === key)
           entry[1] = value;
         else
           defineProperty(key, this.name, {value: [key, value], writable: true});
       },
       get: function(key) {
         var entry;
         return (entry = key[this.name]) && entry[0] === key ?
             entry[1] : undefined;
       },
       delete: function(key) {
         this.set(key, undefined);
       }
-    }
+    };
+
+    window.WeakMap = WeakMap;
   })();
 }
 
 (function(global) {
 
-  var registrationsTable = new SideTable();
+  var registrationsTable = new WeakMap();
 
   // We use setImmediate or postMessage for our future callback.
   var setImmediate = window.msSetImmediate;
 
   // Use post message to emulate setImmediate.
   if (!setImmediate) {
     var setImmediateQueue = [];
     var sentinel = String(Math.random());
     window.addEventListener('message', function(e) {
       if (e.data === sentinel) {
@@ skipping 512 matching lines @@
           });
 
       }
 
       clearRecords();
     }
   };
 
   global.JsMutationObserver = JsMutationObserver;
 
+  // Provide unprefixed MutationObserver with native or JS implementation
+  if (!global.MutationObserver && global.WebKitMutationObserver)
+    global.MutationObserver = global.WebKitMutationObserver;
+
+  if (!global.MutationObserver)
+    global.MutationObserver = JsMutationObserver;
+
+
 })(this);
 
-if (!window.MutationObserver) {
-  window.MutationObserver =
-      window.WebKitMutationObserver ||
-      window.JsMutationObserver;
-  if (!MutationObserver) {
-    throw new Error("no mutation observer support");
-  }
-}
-
+window.CustomElements = window.CustomElements || {flags:{}};
 (function(scope){
 
 var logFlags = window.logFlags || {};
 
 // walk the subtree rooted at node, applying 'find(element, data)' function
 // to each element
 // if 'find' returns true for 'element', do not search element's subtree
 function findAll(node, find, data) {
   var e = node.firstElementChild;
   if (!e) {
@@ skipping 155 matching lines @@
   }
 }
 
 function removedNode(node) {
   removed(node);
   forSubtree(node, function(e) {
     removed(e);
   });
 }
 
-
 function removed(element) {
   if (hasPolyfillMutations) {
     deferMutation(function() {
       _removed(element);
     });
   } else {
     _removed(element);
   }
 }
 
-function removed(element) {
+function _removed(element) {
   // TODO(sjmiles): temporary: do work on all custom elements so we can track
   // behavior even when callbacks not defined
   if (element.leftViewCallback || (element.__upgraded__ && logFlags.dom)) {
     logFlags.dom && console.log('removed:', element.localName);
     if (!inDocument(element)) {
       element.__inserted = (element.__inserted || 0) - 1;
       // if we are in a 'inserted' state, bluntly adjust to an 'removed' state
       if (element.__inserted > 0) {
         element.__inserted = 0;
       }
@@ skipping 32 matching lines @@
   }
 }
 
 function watchRoot(root) {
   if (!root.__watched) {
     observe(root);
     root.__watched = true;
   }
 }
 
-function filter(inNode) {
-  switch (inNode.localName) {
-    case 'style':
-    case 'script':
-    case 'template':
-    case undefined:
-      return true;
-  }
-}
-
 function handler(mutations) {
   //
   if (logFlags.dom) {
     var mx = mutations[0];
     if (mx && mx.type === 'childList' && mx.addedNodes) {
         if (mx.addedNodes) {
           var d = mx.addedNodes[0];
           while (d && d !== document && !d.host) {
             d = d.parentNode;
           }
           var u = d && (d.URL || d._URL || (d.host && d.host.localName)) || '';
           u = u.split('/?').shift().split('/').pop();
         }
     }
     console.group('mutations (%d) [%s]', mutations.length, u || '');
   }
   //
   mutations.forEach(function(mx) {
     //logFlags.dom && console.group('mutation');
     if (mx.type === 'childList') {
       forEach(mx.addedNodes, function(n) {
         //logFlags.dom && console.log(n.localName);
-        if (filter(n)) {
+        if (!n.localName) {
           return;
         }
         // nodes added may need lifecycle management
         addedNode(n);
       });
       // removed nodes may need lifecycle management
       forEach(mx.removedNodes, function(n) {
         //logFlags.dom && console.log(n.localName);
-        if (filter(n)) {
+        if (!n.localName) {
           return;
         }
         removedNode(n);
       });
     }
     //logFlags.dom && console.groupEnd();
   });
   logFlags.dom && console.groupEnd();
 };
 
@@ skipping 123 matching lines @@
     if (!name) {
       // TODO(sjmiles): replace with more appropriate error (EricB can probably
       // offer guidance)
       throw new Error('document.register: first argument `name` must not be empty');
     }
     if (name.indexOf('-') < 0) {
       // TODO(sjmiles): replace with more appropriate error (EricB can probably
       // offer guidance)
       throw new Error('document.register: first argument (\'name\') must contain a dash (\'-\'). Argument provided was \'' + String(name) + '\'.');
     }
-    // record name
-    definition.name = name;
+    // elements may only be registered once
+    if (getRegisteredDefinition(name)) {
+      throw new Error('DuplicateDefinitionError: a type with name \'' + String(name) + '\' is already registered');
+    }
     // must have a prototype, default to an extension of HTMLElement
     // TODO(sjmiles): probably should throw if no prototype, check spec
     if (!definition.prototype) {
       // TODO(sjmiles): replace with more appropriate error (EricB can probably
       // offer guidance)
       throw new Error('Options missing required prototype property');
     }
+    // record name
+    definition.name = name.toLowerCase();
     // ensure a lifecycle object so we don't have to null test it
     definition.lifecycle = definition.lifecycle || {};
     // build a list of ancestral custom elements (for native base detection)
     // TODO(sjmiles): we used to need to store this, but current code only
     // uses it in 'resolveTagName': it should probably be inlined
     definition.ancestry = ancestry(definition.extends);
     // extensions of native specializations of HTMLElement require localName
     // to remain native, and use secondary 'is' specifier for extension type
     resolveTagName(definition);
     // some platforms require modifications to the user-supplied prototype
     // chain
     resolvePrototypeChain(definition);
     // overrides to implement attributeChanged callback
     overrideAttributeApi(definition.prototype);
     // 7.1.5: Register the DEFINITION with DOCUMENT
-    registerDefinition(name, definition);
+    registerDefinition(definition.name, definition);
     // 7.1.7. Run custom element constructor generation algorithm with PROTOTYPE
     // 7.1.8. Return the output of the previous step.
     definition.ctor = generateConstructor(definition);
     definition.ctor.prototype = definition.prototype;
     // force our .constructor to be our actual constructor
     definition.prototype.constructor = definition.ctor;
     // if initial parsing is complete
     if (scope.ready || scope.performedInitialDocumentUpgrade) {
       // upgrade any pre-existing nodes of this type
       scope.upgradeAll(document);
     }
     return definition.ctor;
   }
 
   function ancestry(extnds) {
-    var extendee = registry[extnds];
+    var extendee = getRegisteredDefinition(extnds);
     if (extendee) {
       return ancestry(extendee.extends).concat([extendee]);
     }
     return [];
   }
 
   function resolveTagName(definition) {
     // if we are explicitly extending something, that thing is our
     // baseTag, unless it represents a custom component
     var baseTag = definition.extends;
@@ skipping 47 matching lines @@
     // output is a valid DOM element with the proper wrapper in place.
     //
     return upgrade(domCreateElement(definition.tag), definition);
   }
 
   function upgrade(element, definition) {
     // some definitions specify an 'is' attribute
     if (definition.is) {
       element.setAttribute('is', definition.is);
     }
+    // remove 'unresolved' attr, which is a standin for :unresolved.
+    element.removeAttribute('unresolved');
     // make 'element' implement definition.prototype
     implement(element, definition);
     // flag as upgraded
     element.__upgraded__ = true;
     // there should never be a shadow root on element at this point
     // we require child nodes be upgraded before `created`
     scope.upgradeSubtree(element);
     // lifecycle management
     created(element);
     // OUTPUT
@@ skipping 17 matching lines @@
     // 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 && p !== inNative && p !== HTMLUnknownElement.prototype) {
+    while (p !== inNative && p !== HTMLUnknownElement.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);
     }
   }
 
   function created(element) {
     // invoke createdCallback
     if (element.createdCallback) {
       element.createdCallback();
     }
   }
 
   // attribute watching
 
   function overrideAttributeApi(prototype) {
     // overrides to implement callbacks
     // TODO(sjmiles): should support access via .attributes NamedNodeMap
     // TODO(sjmiles): preserves user defined overrides, if any
+    if (prototype.setAttribute._polyfilled) {
+      return;
+    }
     var setAttribute = prototype.setAttribute;
     prototype.setAttribute = function(name, value) {
       changeAttribute.call(this, name, value, setAttribute);
     }
     var removeAttribute = prototype.removeAttribute;
     prototype.removeAttribute = function(name) {
       changeAttribute.call(this, name, null, removeAttribute);
     }
+    prototype.setAttribute._polyfilled = true;
   }
 
+  // https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/custom/
+  // index.html#dfn-attribute-changed-callback
   function changeAttribute(name, value, operation) {
     var oldValue = this.getAttribute(name);
     operation.apply(this, arguments);
+    var newValue = this.getAttribute(name);
     if (this.attributeChangedCallback
-        && (this.getAttribute(name) !== oldValue)) {
-      this.attributeChangedCallback(name, oldValue, value);
+        && (newValue !== oldValue)) {
+      this.attributeChangedCallback(name, oldValue, newValue);
     }
   }
 
   // element registry (maps tag names to definitions)
 
   var registry = {};
 
+  function getRegisteredDefinition(name) {
+    if (name) {
+      return registry[name.toLowerCase()];
+    }
+  }
+
   function registerDefinition(name, definition) {
-    if (registry[name]) {
-      throw new Error('Cannot register a tag more than once');
-    }
     registry[name] = definition;
   }
 
   function generateConstructor(definition) {
     return function() {
       return instantiate(definition);
     };
   }
 
   function createElement(tag, typeExtension) {
-    var definition = registry[typeExtension || tag];
+    // 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) {
         return new definition.ctor();
       }
     }
 
     if (typeExtension) {
       var element = createElement(tag);
       element.setAttribute('is', typeExtension);
       return element;
     }
     var element = domCreateElement(tag);
     // Custom tags should be HTMLElements even if not upgraded.
     if (tag.indexOf('-') >= 0) {
       implement(element, HTMLElement);
     }
     return element;
   }
 
   function upgradeElement(element) {
     if (!element.__upgraded__ && (element.nodeType === Node.ELEMENT_NODE)) {
-      var is = element.getAttribute('is');
-      var definition = registry[is || element.localName];
-      if (definition) {
-        if (is && definition.tag == element.localName) {
-          return upgrade(element, definition);
-        } else if (!is && !definition.extends) {
-          return upgrade(element, definition);
-        }
-      }
+      var type = element.getAttribute('is') || element.localName;
+      var definition = getRegisteredDefinition(type);
+      return definition && upgrade(element, definition);
     }
   }
 
   function cloneNode(deep) {
     // call original clone
     var n = domCloneNode.call(this, deep);
     // upgrade the element and subtree
     scope.upgradeAll(n);
     // return the clone
     return n;
@@ skipping 83 matching lines @@
       && inElt.getAttribute('rel') === IMPORT_LINK_TYPE);
 }
 
 var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
 
 // exports
 
 CustomElements.parser = parser;
 
 })();
-(function(){
+(function(scope){
 
 // bootstrap parsing
 function bootstrap() {
   // parse document
   CustomElements.parser.parse(document);
   // one more pass before register is 'live'
   CustomElements.upgradeDocument(document);
   CustomElements.performedInitialDocumentUpgrade = true;
   // choose async
   var async = window.Platform && Platform.endOfMicrotask ?
@@ skipping 11 matching lines @@
     // notify the system that we are bootstrapped
     document.body.dispatchEvent(
       new CustomEvent('WebComponentsReady', {bubbles: true})
     );
   });
 }
 
 // CustomEvent shim for IE
 if (typeof window.CustomEvent !== 'function') {
   window.CustomEvent = function(inType) {
-     var e = document.createEvent('HTMLEvents');
-     e.initEvent(inType, true, true);
-     return e;
+    var e = document.createEvent('HTMLEvents');
+    e.initEvent(inType, true, true);
+    return e;
   };
 }
 
-if (document.readyState === 'complete') {
+// When loading at readyState complete time (or via flag), boot custom elements
+// immediately.
+// If relevant, HTMLImports must already be loaded.
+if (document.readyState === 'complete' || scope.flags.eager) {
   bootstrap();
+// When loading at readyState interactive time, bootstrap only if HTMLImports
+// are not pending. Also avoid IE as the semantics of this state are unreliable.
+} else if (document.readyState === 'interactive' && !window.attachEvent &&
+    (!window.HTMLImports || window.HTMLImports.ready)) {
+  bootstrap();
+// When loading at other readyStates, wait for the appropriate DOM event to
+// bootstrap.
 } else {
   var loadEvent = window.HTMLImports ? 'HTMLImportsLoaded' :
       document.readyState == 'loading' ? 'DOMContentLoaded' : 'load';
   window.addEventListener(loadEvent, bootstrap);
 }
 
-})();
+})(window.CustomElements);
 
 (function() {
 // Patch to allow custom element and shadow dom to work together, from:
 // https://github.com/Polymer/platform/blob/master/src/patches-shadowdom-polyfill.js
 // include .host reference
 if (HTMLElement.prototype.createShadowRoot) {
   var originalCreateShadowRoot = HTMLElement.prototype.createShadowRoot;
   HTMLElement.prototype.createShadowRoot = function() {
     var root = originalCreateShadowRoot.call(this);
     root.host = this;
     return root;
   }
 }
 
 
 // Patch to allow custom elements and shadow dom to work together, from:
-// https://github.com/Polymer/platform/blob/master/src/patches-custom-elements.js
+// https://github.com/Polymer/platform-dev/blob/2bb9c56d90f9ac19c2e65cdad368668aff514f14/src/patches-custom-elements.js
 if (window.ShadowDOMPolyfill) {
-  function nop() {};
-
-  // disable shadow dom watching
-  CustomElements.watchShadow = nop;
-  CustomElements.watchAllShadows = nop;
 
   // 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](ShadowDOMPolyfill.wrapIfNeeded(inNode));
+      return original[fn](window.ShadowDOMPolyfill.wrapIfNeeded(inNode));
     };
   });
+
+}
+
+// Patch to make importNode work.
+// https://github.com/Polymer/platform-dev/blob/64a92f273462f04a84abbe2f054294f2b62dbcd6/src/patches-mdv.js
+if (window.CustomElements && !CustomElements.useNative) {
+  var originalImportNode = Document.prototype.importNode;
+  Document.prototype.importNode = function(node, deep) {
+    var imported = originalImportNode.call(this, node, deep);
+    CustomElements.upgradeAll(imported);
+    return imported;
+  }
 }
 
 })();