"Reverting 34633"

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 : ~handle;
+      return timeout ? handle : 1 / handle;
     },
     cancelAsync: function(handle) {
-      if (handle < 0) {
-        cancelAnimationFrame(~handle);
+      if (handle < 1) {
+        cancelAnimationFrame(Math.round(1 / 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.closeNamedObserver(name + '__array');
+          this.unregisterObserver(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.registerNamedObserver(name + '__array', observer);
+          this.registerObserver(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
-    registerNamedObserver: function(name, observer) {
-      var o$ = this._namedObservers || (this._namedObservers = {});
+    registerObserver: function(name, observer) {
+      var o$ = this._observers || (this._observers = {});
       o$[name] = observer;
     },
-    closeNamedObserver: function(name) {
-      var o$ = this._namedObservers;
+    unregisterObserver: function(name) {
+      var o$ = this._observers;
       if (o$ && o$[name]) {
         o$[name].close();
         o$[name] = null;
         return true;
       }
     },
-    closeNamedObservers: function() {
-      if (this._namedObservers) {
-        var keys=Object.keys(this._namedObservers);
+    unregisterObservers: function() {
+      if (this._observers) {
+        var keys=Object.keys(this._observers);
         for (var i=0, l=keys.length, k, o; (i < l) && (k=keys[i]); i++) {
-          o = this._namedObservers[k];
+          o = this._observers[k];
           o.close();
         }
-        this._namedObservers = {};
+        this._observers = {};
       }
     }
   };
 
   // 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) {
-      var dom = template.createInstance(this, this.syntax);
-      this.registerObservers(dom.bindings_);
-      return dom;
+      return template.createInstance(this, this.syntax);
     },
     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);
-        // 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;
+        return this.bindings[name] = 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.closeObservers();
-        this.closeNamedObservers();
+        this.unbindAllProperties();
+        this.super();
+        // unbind shadowRoot
+        var root = this.shadowRoot;
+        while (root) {
+          unbindNodeTree(root);
+          root = root.olderShadowRoot;
+        }
         this._unbound = true;
       }
     },
-    cancelUnbindAll: function() {
+    cancelUnbindAll: function(preventCascade) {
       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: 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);
-      }
-    },
+    job: Polymer.job,
     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.created();
-      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() {
-      this.cancelUnbindAll();
+      if (!this._elementPrepared) {
+        this.prepareElement();
+      }
+      this.cancelUnbindAll(true);
       // 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, refNode) {
+    lightFromTemplate: function(template) {
       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
-        if (refNode) {
-          this.insertBefore(dom, refNode);          
-        } else {
-          this.appendChild(dom);
-        }
+        this.appendChild(dom);
         // perform post-construction initialization tasks on ahem, light root
-        this.shadowRootReady(this);
+        this.shadowRootReady(this, template);
         // return the created shadow root
         return dom;
       }
     },
-    shadowRootReady: function(root) {
+    shadowRootReady: function(root, template) {
       // 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.
+     * 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.
     */
+    // TODO(sorvell): remove when spec issues are addressed
     installControllerStyles: function() {
       // apply controller styles, but only if they are not yet applied
-      var scope = this.findStyleScope();
-      if (scope && !this.scopeHasNamedStyle(scope, this.localName)) {
+      var scope = this.findStyleController();
+      if (scope && !this.scopeHasElementStyle(scope, STYLE_CONTROLLER_SCOPE)) {
         // 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) {
-          this.installScopeCssText(cssText, scope);
+          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);
         }
       }
     },
-    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;
+    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;
         }
-        this.installScopeCssText(cssText, scope, name);
+        return n === document ? document.head : n;
       }
     },
-    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];
+    scopeHasElementStyle: function(scope, descriptor) {
+      var rule = STYLE_SCOPE_ATTRIBUTE + '=' + this.localName + '-' + descriptor;
+      return scope.querySelector('style[' + rule + ']');
     }
   };
   
   // 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 !== 'href') {
+        if (a.name !== 'rel' && a.name !== 'src') {
           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);
       }
-      // 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);
+      scope.appendChild(clone);
     }
   }
 
   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