[web_components] update web_components and polymer.js

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

 /*
  * 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.
  */
 Polymer = {};
 
 /*
  * Copyright 2013 The Polymer Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style
@@ skipping 389 matching lines @@
       // second argument to `apply` must be an array
       args = (args && args.length) ? args : [args];
       // function to invoke
       var fn = function() {
         (this[method] || method).apply(this, args);
       }.bind(this);
       // execute `fn` sooner or later
       var handle = timeout ? setTimeout(fn, timeout) :
           requestAnimationFrame(fn);
       // NOTE: switch on inverting handle to determine which time is used.
-      return timeout ? handle : 1 / handle;
+      return timeout ? handle : ~handle;
     },
     cancelAsync: function(handle) {
-      if (handle < 1) {
-        cancelAnimationFrame(Math.round(1 / handle));
+      if (handle < 0) {
+        cancelAnimationFrame(~handle);
       } else {
         clearTimeout(handle);
       }
     },
     /**
       * Fire an event.
       * @method fire
       * @returns {Object} event
       * @param {string} type An event name.
       * @param {any} detail
@@ skipping 232 matching lines @@
   // element api
 
   var empty = [];
 
   var properties = {
     observeProperties: function() {
       var n$ = this._observeNames, pn$ = this._publishNames;
       if ((n$ && n$.length) || (pn$ && pn$.length)) {
         var self = this;
         var o = this._propertyObserver = new CompoundObserver();
+        // keep track of property observer so we can shut it down
+        this.registerObservers([o]);
         for (var i=0, l=n$.length, n; (i<l) && (n=n$[i]); i++) {
           o.addPath(this, n);
           // observer array properties
           var pd = Object.getOwnPropertyDescriptor(this.__proto__, n);
           if (pd && pd.value) {
             this.observeArrayValue(n, pd.value, null);
           }
         }
         for (var i=0, l=pn$.length, n; (i<l) && (n=pn$[i]); i++) {
           if (!this.observe || (this.observe[n] === undefined)) {
@@ skipping 22 matching lines @@
         }
       }
     },
     observeArrayValue: function(name, value, old) {
       // we only care if there are registered side-effects
       var callbackName = this.observe[name];
       if (callbackName) {
         // if we are observing the previous value, stop
         if (Array.isArray(old)) {
           log.observe && console.log('[%s] observeArrayValue: unregister observer [%s]', this.localName, name);
-          this.unregisterObserver(name + '__array');
+          this.closeNamedObserver(name + '__array');
         }
         // if the new value is an array, being observing it
         if (Array.isArray(value)) {
           log.observe && console.log('[%s] observeArrayValue: register observer [%s]', this.localName, name, value);
           var observer = new ArrayObserver(value);
           observer.open(function(value, old) {
             this.invokeMethod(callbackName, [old]);
           }, this);
-          this.registerObserver(name + '__array', observer);
+          this.registerNamedObserver(name + '__array', observer);
         }
       }
     },
     bindProperty: function(property, observable) {
       // apply Polymer two-way reference binding
       return bindProperties(this, property, observable);
     },
-    unbindAllProperties: function() {
-      if (this._propertyObserver) {
-        this._propertyObserver.close();
-      }
-      this.unregisterObservers();
-    },
-    unbindProperty: function(name) {
-      return this.unregisterObserver(name);
-    },
     invokeMethod: function(method, args) {
       var fn = this[method] || method;
       if (typeof fn === 'function') {
         fn.apply(this, args);
       }
     },
+    registerObservers: function(observers) {
+      this._observers.push(observers);
+    },
+    // observer array items are arrays of observers.
+    closeObservers: function() {
+      for (var i=0, l=this._observers.length; i<l; i++) {
+        this.closeObserverArray(this._observers[i]);
+      }
+      this._observers = [];
+    },
+    closeObserverArray: function(observerArray) {
+      for (var i=0, l=observerArray.length, o; i<l; i++) {
+        o = observerArray[i];
+        if (o && o.close) {
+          o.close();
+        }
+      }
+    },
     // bookkeeping observers for memory management
-    registerObserver: function(name, observer) {
-      var o$ = this._observers || (this._observers = {});
+    registerNamedObserver: function(name, observer) {
+      var o$ = this._namedObservers || (this._namedObservers = {});
       o$[name] = observer;
     },
-    unregisterObserver: function(name) {
-      var o$ = this._observers;
+    closeNamedObserver: function(name) {
+      var o$ = this._namedObservers;
       if (o$ && o$[name]) {
         o$[name].close();
         o$[name] = null;
         return true;
       }
     },
-    unregisterObservers: function() {
-      if (this._observers) {
-        var keys=Object.keys(this._observers);
+    closeNamedObservers: function() {
+      if (this._namedObservers) {
+        var keys=Object.keys(this._namedObservers);
         for (var i=0, l=keys.length, k, o; (i < l) && (k=keys[i]); i++) {
-          o = this._observers[k];
+          o = this._namedObservers[k];
           o.close();
         }
-        this._observers = {};
+        this._namedObservers = {};
       }
     }
   };
 
   // property binding
   // bind a property in A to a path in B by converting A[property] to a
   // getter/setter pair that accesses B[...path...]
   function bindProperties(inA, inProperty, observable) {
     log.bind && console.log(LOG_BIND_PROPS, inB.localName || 'object', inPath, inA.localName, inProperty);
     // capture A's value if B's value is null or undefined,
@@ skipping 52 matching lines @@
       node = node.parentNode;
     }
     return node.host;
   };
 
   // element api supporting mdv
 
   var mdv = {
     syntax: syntax,
     instanceTemplate: function(template) {
-      return template.createInstance(this, this.syntax);
+      var dom = template.createInstance(this, this.syntax);
+      this.registerObservers(dom.bindings_);
+      return dom;
     },
     bind: function(name, observable, oneTime) {
-      // note: binding is a prepare signal. This allows us to be sure that any
-      // property changes that occur as a result of binding will be observed.
-      if (!this._elementPrepared) {
-        this.prepareElement();
-      }
       var property = this.propertyForAttribute(name);
       if (!property) {
         // TODO(sjmiles): this mixin method must use the special form
         // of `super` installed by `mixinMethod` in declaration/prototype.js
         return this.mixinSuper(arguments);
       } else {
-        // clean out the closets
-        this.unbind(name);
         // use n-way Polymer binding
         var observer = this.bindProperty(property, observable);
-        // stick path on observer so it's available via this.bindings
-        observer.path = observable.path_;
-        // reflect bound property to attribute when binding
-        // to ensure binding is not left on attribute if property
-        // does not update due to not changing.
         this.reflectPropertyToAttribute(property);
-        return this.bindings[name] = observer;
+        // NOTE: reflecting binding information is typically required only for
+        // tooling. It has a performance cost so it's opt-in in Node.bind.
+        if (Platform.enableBindingsReflection) {
+          observer.path = observable.path_;
+          this.bindings_ = this.bindings_ || {};
+          this.bindings_[name] = observer;
+        }
+        return observer;
       }
     },
+    // TODO(sorvell): unbind/unbindAll has been removed, as public api, from
+    // TemplateBinding. We still need to close/dispose of observers but perhaps
+    // we should choose a more explicit name.
     asyncUnbindAll: function() {
       if (!this._unbound) {
         log.unbind && console.log('[%s] asyncUnbindAll', this.localName);
         this._unbindAllJob = this.job(this._unbindAllJob, this.unbindAll, 0);
       }
     },
     unbindAll: function() {
       if (!this._unbound) {
-        this.unbindAllProperties();
-        this.super();
-        // unbind shadowRoot
-        var root = this.shadowRoot;
-        while (root) {
-          unbindNodeTree(root);
-          root = root.olderShadowRoot;
-        }
+        this.closeObservers();
+        this.closeNamedObservers();
         this._unbound = true;
       }
     },
-    cancelUnbindAll: function(preventCascade) {
+    cancelUnbindAll: function() {
       if (this._unbound) {
         log.unbind && console.warn('[%s] already unbound, cannot cancel unbindAll', this.localName);
         return;
       }
       log.unbind && console.log('[%s] cancelUnbindAll', this.localName);
       if (this._unbindAllJob) {
         this._unbindAllJob = this._unbindAllJob.stop();
       }
-      // cancel unbinding our shadow tree iff we're not in the process of
-      // cascading our tree (as we do, for example, when the element is inserted).
-      if (!preventCascade) {
-        forNodeTree(this.shadowRoot, function(n) {
-          if (n.cancelUnbindAll) {
-            n.cancelUnbindAll();
-          }
-        });
-      }
     }
   };
 
   function unbindNodeTree(node) {
     forNodeTree(node, _nodeUnbindAll);
   }
 
   function _nodeUnbindAll(node) {
     node.unbindAll();
   }
@@ skipping 15 matching lines @@
   scope.api.instance.mdv = mdv;
 
 })(Polymer);
 
 /*
  * 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) {
-  var preparingElements = 0;
 
   var base = {
     PolymerBase: true,
-    job: Polymer.job,
+    job: function(job, callback, wait) {
+      if (typeof job === 'string') {
+        var n = '___' + job;
+        this[n] = Polymer.job.call(this, this[n], callback, wait);
+      } else {
+        return Polymer.job.call(this, job, callback, wait);
+      }
+    },
     super: Polymer.super,
     // user entry point for element has had its createdCallback called
     created: function() {
     },
     // user entry point for element has shadowRoot and is ready for
     // api interaction
     ready: function() {
     },
     createdCallback: function() {
+      if (this.templateInstance && this.templateInstance.model) {
+        console.warn('Attributes on ' + this.localName + ' were data bound ' +
+            'prior to Polymer upgrading the element. This may result in ' +
+            'incorrect binding types.');
+      }
       this.created();
-      if (this.ownerDocument.defaultView || this.alwaysPrepare ||
-          preparingElements > 0) {
-        this.prepareElement();
-      }
+      this.prepareElement();
     },
     // system entry point, do not override
     prepareElement: function() {
       this._elementPrepared = true;
       // install shadowRoots storage
       this.shadowRoots = {};
+      // storage for closeable observers.
+      this._observers = [];
       // install property observers
       this.observeProperties();
       // install boilerplate attributes
       this.copyInstanceAttributes();
       // process input attributes
       this.takeAttributes();
       // add event listeners
       this.addHostListeners();
-      // guarantees that while preparing, any
-      // sub-elements are also prepared
-      preparingElements++;
       // process declarative resources
       this.parseDeclarations(this.__proto__);
-      // decrement semaphore
-      preparingElements--;
       // TODO(sorvell): CE polyfill uses unresolved attribute to simulate
       // :unresolved; remove this attribute to be compatible with native
       // CE.
       this.removeAttribute('unresolved');
       // user entry point
       this.ready();
     },
     attachedCallback: function() {
-      if (!this._elementPrepared) {
-        this.prepareElement();
-      }
-      this.cancelUnbindAll(true);
+      this.cancelUnbindAll();
       // invoke user action
       if (this.attached) {
         this.attached();
       }
       // TODO(sorvell): bc
       if (this.enteredView) {
         this.enteredView();
       }
       // NOTE: domReady can be used to access elements in dom (descendants, 
       // ancestors, siblings) such that the developer is enured to upgrade
@@ skipping 40 matching lines @@
       if (p && p.element) {
         this.parseDeclarations(p.__proto__);
         p.parseDeclaration.call(this, p.element);
       }
     },
     // parse input <element> as needed, override for custom behavior
     parseDeclaration: function(elementElement) {
       var template = this.fetchTemplate(elementElement);
       if (template) {
         var root = this.shadowFromTemplate(template);
-        this.shadowRoots[elementElement.name] = root;        
+        this.shadowRoots[elementElement.name] = root;
       }
     },
     // return a shadow-root template (if desired), override for custom behavior
     fetchTemplate: function(elementElement) {
       return elementElement.querySelector('template');
     },
     // utility function that creates a shadow root from a <template>
     shadowFromTemplate: function(template) {
       if (template) {
         // make a shadow root
         var root = this.createShadowRoot();
-        // migrate flag(s)
-        root.resetStyleInheritance = this.resetStyleInheritance;
         // stamp template
         // which includes parsing and applying MDV bindings before being 
         // inserted (to avoid {{}} in attribute values)
         // e.g. to prevent <img src="images/{{icon}}"> from generating a 404.
         var dom = this.instanceTemplate(template);
         // append to shadow dom
         root.appendChild(dom);
         // perform post-construction initialization tasks on shadow root
         this.shadowRootReady(root, template);
         // return the created shadow root
         return root;
       }
     },
     // utility function that stamps a <template> into light-dom
-    lightFromTemplate: function(template) {
+    lightFromTemplate: function(template, refNode) {
       if (template) {
         // TODO(sorvell): mark this element as a lightDOMController so that
         // event listeners on bound nodes inside it will be called on it.
         // Note, the expectation here is that events on all descendants 
         // should be handled by this element.
         this.lightDomController = true;
         // stamp template
         // which includes parsing and applying MDV bindings before being 
         // inserted (to avoid {{}} in attribute values)
         // e.g. to prevent <img src="images/{{icon}}"> from generating a 404.
         var dom = this.instanceTemplate(template);
         // append to shadow dom
-        this.appendChild(dom);
+        if (refNode) {
+          this.insertBefore(dom, refNode);          
+        } else {
+          this.appendChild(dom);
+        }
         // perform post-construction initialization tasks on ahem, light root
-        this.shadowRootReady(this, template);
+        this.shadowRootReady(this);
         // return the created shadow root
         return dom;
       }
     },
-    shadowRootReady: function(root, template) {
+    shadowRootReady: function(root) {
       // locate nodes with id and store references to them in this.$ hash
       this.marshalNodeReferences(root);
       // set up pointer gestures
       PointerGestures.register(root);
     },
     // locate nodes with id and store references to them in this.$ hash
     marshalNodeReferences: function(root) {
       // establish $ instance variable
       var $ = this.$ = this.$ || {};
       // populate $ from nodes with ID from the LOCAL tree
@@ skipping 55 matching lines @@
   // magic words
   
   var STYLE_SCOPE_ATTRIBUTE = 'element';
   var STYLE_CONTROLLER_SCOPE = 'controller';
   
   var styles = {
     STYLE_SCOPE_ATTRIBUTE: STYLE_SCOPE_ATTRIBUTE,
     /**
      * Installs external stylesheets and <style> elements with the attribute 
      * polymer-scope='controller' into the scope of element. This is intended
-     * to be a called during custom element construction. Note, this incurs a 
-     * per instance cost and should be used sparingly.
-     *
-     * The need for this type of styling should go away when the shadowDOM spec
-     * addresses these issues:
-     * 
-     * https://www.w3.org/Bugs/Public/show_bug.cgi?id=21391
-     * https://www.w3.org/Bugs/Public/show_bug.cgi?id=21390
-     * https://www.w3.org/Bugs/Public/show_bug.cgi?id=21389
-     * 
-     * @param element The custom element instance into whose controller (parent)
-     * scope styles will be installed.
-     * @param elementElement The <element> containing controller styles.
+     * to be a called during custom element construction.
     */
-    // TODO(sorvell): remove when spec issues are addressed
     installControllerStyles: function() {
       // apply controller styles, but only if they are not yet applied
-      var scope = this.findStyleController();
-      if (scope && !this.scopeHasElementStyle(scope, STYLE_CONTROLLER_SCOPE)) {
+      var scope = this.findStyleScope();
+      if (scope && !this.scopeHasNamedStyle(scope, this.localName)) {
         // allow inherited controller styles
         var proto = getPrototypeOf(this), cssText = '';
         while (proto && proto.element) {
           cssText += proto.element.cssTextForScope(STYLE_CONTROLLER_SCOPE);
           proto = getPrototypeOf(proto);
         }
         if (cssText) {
-          var style = this.element.cssTextToScopeStyle(cssText,
-              STYLE_CONTROLLER_SCOPE);
-          // TODO(sorvell): for now these styles are not shimmed
-          // but we may need to shim them
-          Polymer.applyStyleToScope(style, scope);
+          this.installScopeCssText(cssText, scope);
         }
       }
     },
-    findStyleController: function() {
-      if (window.ShadowDOMPolyfill) {
-        return wrap(document.head);
-      } else {
-        // find the shadow root that contains this element
-        var n = this;
-        while (n.parentNode) {
-          n = n.parentNode;
+    installScopeStyle: function(style, name, scope) {
+      var scope = scope || this.findStyleScope(), name = name || '';
+      if (scope && !this.scopeHasNamedStyle(scope, this.localName + name)) {
+        var cssText = '';
+        if (style instanceof Array) {
+          for (var i=0, l=style.length, s; (i<l) && (s=style[i]); i++) {
+            cssText += s.textContent + '\n\n';
+          }
+        } else {
+          cssText = style.textContent;
         }
-        return n === document ? document.head : n;
+        this.installScopeCssText(cssText, scope, name);
       }
     },
-    scopeHasElementStyle: function(scope, descriptor) {
-      var rule = STYLE_SCOPE_ATTRIBUTE + '=' + this.localName + '-' + descriptor;
-      return scope.querySelector('style[' + rule + ']');
+    installScopeCssText: function(cssText, scope, name) {
+      scope = scope || this.findStyleScope();
+      name = name || '';
+      if (!scope) {
+        return;
+      }
+      if (window.ShadowDOMPolyfill) {
+        cssText = shimCssText(cssText, scope.host);
+      }
+      var style = this.element.cssTextToScopeStyle(cssText,
+          STYLE_CONTROLLER_SCOPE);
+      Polymer.applyStyleToScope(style, scope);
+      // cache that this style has been applied
+      scope._scopeStyles[this.localName + name] = true;
+    },
+    findStyleScope: function(node) {
+      // find the shadow root that contains this element
+      var n = node || this;
+      while (n.parentNode) {
+        n = n.parentNode;
+      }
+      return n;
+    },
+    scopeHasNamedStyle: function(scope, name) {
+      scope._scopeStyles = scope._scopeStyles || {};
+      return scope._scopeStyles[name];
     }
   };
   
   // NOTE: use raw prototype traversal so that we ensure correct traversal
   // on platforms where the protoype chain is simulated via __proto__ (IE10)
   function getPrototypeOf(prototype) {
     return prototype.__proto__;
   }
 
+  function shimCssText(cssText, host) {
+    var name = '', is = false;
+    if (host) {
+      name = host.localName;
+      is = host.hasAttribute('is');
+    }
+    var selector = Platform.ShadowCSS.makeScopeSelector(name, is);
+    return Platform.ShadowCSS.shimCssText(cssText, selector);
+  }
+
   // exports
 
   scope.api.instance.styles = styles;
   
 })(Polymer);
 
 /*
  * 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) {
 
   // imports
 
   var extend = scope.extend;
   var api = scope.api;
 
   // imperative implementation: Polymer()
 
   // specify an 'own' prototype for tag `name`
   function element(name, prototype) {
+    if (arguments.length === 1 && typeof arguments[0] !== 'string') {
+      prototype = name;
+      var script = document._currentScript;
+      name = script && script.parentNode && script.parentNode.getAttribute ?
+          script.parentNode.getAttribute('name') : '';
+      if (!name) {
+        throw 'Element name could not be inferred.';
+      }
+    }
     if (getRegisteredPrototype[name]) {
       throw 'Already registered (Polymer) prototype for element ' + name;
     }
     // cache the prototype
     registerPrototype(name, prototype);
     // notify the registrar waiting for 'name', if any
     notifyPrototype(name);
   }
 
   // async prototype source
@@ skipping 129 matching lines @@
       var s$ = root.querySelectorAll(SHEET_SELECTOR);
       for (var i=0, l=s$.length, s, c; (i<l) && (s=s$[i]); i++) {
         c = createStyleElement(importRuleForSheet(s, this.ownerDocument.baseURI),
             this.ownerDocument);
         this.copySheetAttributes(c, s);
         s.parentNode.replaceChild(c, s);
       }
     },
     copySheetAttributes: function(style, link) {
       for (var i=0, a$=link.attributes, l=a$.length, a; (a=a$[i]) && i<l; i++) {
-        if (a.name !== 'rel' && a.name !== 'src') {
+        if (a.name !== 'rel' && a.name !== 'href') {
           style.setAttribute(a.name, a.value);
         }
       }
     },
     findLoadableStyles: function(root) {
       var loadables = [];
       if (root) {
         var s$ = root.querySelectorAll(STYLE_SELECTOR);
         for (var i=0, l=s$.length, s; (i<l) && (s=s$[i]); i++) {
           if (s.textContent.match(STYLE_LOADABLE_MATCH)) {
             loadables.push(s);
           }
         }
       }
       return loadables;
     },
     /**
      * Install external stylesheets loaded in <polymer-element> elements into the 
      * element's template.
      * @param elementElement The <element> element to style.
      */
-    // TODO(sorvell): wip... caching and styles handling can probably be removed
-    // We need a scheme to ensure stylesheets are eagerly loaded without 
-    // the creation of an element instance. Here are 2 options for handling this:
-    // 1. create a dummy element with ShadowDOM in dom that includes ALL styles
-    // processed here.
-    // 2. place stylesheets outside the element template. This will allow 
-    // imports to naturally load the sheets. Then at load time, we can remove
-    // the stylesheet from dom.
     installSheets: function() {
       this.cacheSheets();
       this.cacheStyles();
       this.installLocalSheets();
       this.installGlobalStyles();
     },
     /**
      * Remove all sheets from element and store for later use.
      */
     cacheSheets: function() {
@@ skipping 90 matching lines @@
         var style = createStyleElement(cssText);
         style.setAttribute(STYLE_SCOPE_ATTRIBUTE, this.getAttribute('name') +
             '-' + scopeDescriptor);
         return style;
       }
     }
   };
 
   function importRuleForSheet(sheet, baseUrl) {
     var href = new URL(sheet.getAttribute('href'), baseUrl).href;
-    return '@import \'' + href + '\';'
+    return '@import \'' + href + '\';';
   }
 
   function applyStyleToScope(style, scope) {
     if (style) {
+      if (scope === document) {
+        scope = document.head;
+      }
+      if (window.ShadowDOMPolyfill) {
+        scope = document.head;
+      }
       // TODO(sorvell): necessary for IE
       // see https://connect.microsoft.com/IE/feedback/details/790212/
       // cloning-a-style-element-and-adding-to-document-produces
       // -unexpected-result#details
       // var clone = style.cloneNode(true);
       var clone = createStyleElement(style.textContent);
       var attr = style.getAttribute(STYLE_SCOPE_ATTRIBUTE);
       if (attr) {
         clone.setAttribute(STYLE_SCOPE_ATTRIBUTE, attr);
       }
-      scope.appendChild(clone);
+      // TODO(sorvell): probably too brittle; try to figure out 
+      // where to put the element.
+      var refNode = scope.firstElementChild;
+      if (scope === document.head) {
+        var selector = 'style[' + STYLE_SCOPE_ATTRIBUTE + ']';
+        var s$ = document.head.querySelectorAll(selector);
+        if (s$.length) {
+          refNode = s$[s$.length-1].nextElementSibling;
+        }
+      }
+      scope.insertBefore(clone, refNode);
     }
   }
 
   function createStyleElement(cssText, scope) {
     scope = scope || document;
     scope = scope.createElement ? scope : scope.ownerDocument;
     var style = scope.createElement('style');
     style.textContent = cssText;
     return style;
   }
@@ skipping 105 matching lines @@
     },
     optimizePropertyMaps: function(prototype) {
       if (prototype.observe) {
         // construct name list
         var a = prototype._observeNames = [];
         for (var n in prototype.observe) {
           var names = n.split(' ');
           for (var i=0, ni; ni=names[i]; i++) {
             a.push(ni);
           }
-          //a.push(n);
         }
       }
       if (prototype.publish) {
         // construct name list
         var a = prototype._publishNames = [];
         for (var n in prototype.publish) {
           a.push(n);
         }
       }
     },
@@ skipping 366 matching lines @@
       }
       return (this.indexOf(element) !== 0);
     },
     add: function(element) {
       //console.log('queueing', element.name);
       queueForElement(element).push(element);
     },
     indexOf: function(element) {
       var i = queueForElement(element).indexOf(element);
       if (i >= 0 && document.contains(element)) {
-        i += (HTMLImports.useNative || HTMLImports.ready) ? importQueue.length :
-            1e9;
+        i += (HTMLImports.useNative || HTMLImports.ready) ? 
+          importQueue.length : 1e9;
       }
       return i;  
     },
     // tell the queue an element is ready to be registered
     go: function(element) {
       var readied = this.remove(element);
       if (readied) {
         readied.__go.call(readied);
         readied.__check = readied.__go = null;
         this.check();
       }
     },
     remove: function(element) {
       var i = this.indexOf(element);
       if (i !== 0) {
         //console.warn('queue order wrong', i);
         return;
       }
-      return queueForElement(element).shift();  
+      return queueForElement(element).shift();
     },
     check: function() {
       // next
       var element = this.nextElement();
       if (element) {
         element.__check.call(element);
       }
       if (this.canReady()) {
         this.ready();
         return true;
@@ skipping 143 matching lines @@
       this.registerWhenReady();
     },
 
     registerWhenReady: function() {
      if (this.registered
        || this.waitingForPrototype(this.name)
        || this.waitingForQueue()
        || this.waitingForResources()) {
           return;
       }
+      // TODO(sorvell): ends up calling '_register' by virtue
+      // of `waitingForQueue` (see below)
       queue.go(this);
     },
 
-
     // TODO(sorvell): refactor, this method is private-ish, but it's being
     // called by the queue object.
     _register: function() {
       //console.log('registering', this.name);
       //console.group('registering', this.name);
       // warn if extending from a custom element not registered via Polymer
       if (isCustomTag(this.extends) && !isRegistered(this.extends)) {
         console.warn('%s is attempting to extend %s, an unregistered element ' +
             'or one that was not registered with Polymer.', this.name,
             this.extends);
@@ skipping 84 matching lines @@
     );
   });
 
   // register polymer-element with document
 
   document.registerElement('polymer-element', {prototype: prototype});
 
 })(Polymer);
 
 //# sourceMappingURL=polymer.concat.js.map