Rolling packages to version 0.4.2

pkg/web_components/lib/platform.concat.js

 /**
  * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
  * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
  * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
  * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
  * Code distributed by Google as part of the polymer project is also
  * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
  */
 
 window.Platform = window.Platform || {};
@@ skipping 28 matching lines @@
   // other truthy value, or failure to detect native
   // ShadowDOM, results in polyfill
   flags.shadow = flags.shadow || flags.shadowdom || flags.polyfill;
   if (flags.shadow === 'native') {
     flags.shadow = false;
   } else {
     flags.shadow = flags.shadow || !HTMLElement.prototype.createShadowRoot;
   }
 
   if (flags.shadow && document.querySelectorAll('script').length > 1) {
-    console.warn('platform.js is not the first script on the page. ' +
+    console.log('Warning: platform.js is not the first script on the page. ' +
         'See http://www.polymer-project.org/docs/start/platform.html#setup ' +
         'for details.');
   }
 
   // CustomElements polyfill flag
   if (flags.register) {
     window.CustomElements = window.CustomElements || {flags: {}};
     window.CustomElements.flags.register = flags.register;
   }
 
@@ skipping 21 matching lines @@
       this.name = '__st' + (Math.random() * 1e9 >>> 0) + (counter++ + '__');
     };
 
     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});
+        return this;
       },
       get: function(key) {
         var entry;
         return (entry = key[this.name]) && entry[0] === key ?
             entry[1] : undefined;
       },
       delete: function(key) {
         var entry = key[this.name];
         if (!entry) return false;
         var hasValue = entry[0] === key;
@@ skipping 4401 matching lines @@
       // are no shadow trees below or above the context node.
       var s = '';
       for (var child = this.firstChild; child; child = child.nextSibling) {
         if (child.nodeType != Node.COMMENT_NODE) {
           s += child.textContent;
         }
       }
       return s;
     },
     set textContent(textContent) {
+      if (textContent == null) textContent = '';
       var removedNodes = snapshotNodeList(this.childNodes);
 
       if (this.invalidateShadowRenderer()) {
         removeAllChildNodes(this);
         if (textContent !== '') {
           var textNode = unsafeUnwrap(this).ownerDocument.createTextNode(textContent);
           this.appendChild(textNode);
         }
       } else {
         clearChildNodes(this);
@@ skipping 4984 matching lines @@
       return this._isInvalid || !this._fragment || '#' == this._fragment ?
           '' : this._fragment;
     },
     set hash(hash) {
       if (this._isInvalid)
         return;
       this._fragment = '#';
       if ('#' == hash[0])
         hash = hash.slice(1);
       parse.call(this, hash, 'fragment');
+    },
+
+    get origin() {
+      var host;
+      if (this._isInvalid || !this._scheme) {
+        return '';
+      }
+      // javascript: Gecko returns String(""), WebKit/Blink String("null")
+      // Gecko throws error for "data://"
+      // data: Gecko returns "", Blink returns "data://", WebKit returns "null"
+      // Gecko returns String("") for file: mailto:
+      // WebKit/Blink returns String("SCHEME://") for file: mailto:
+      switch (this._scheme) {
+        case 'data':
+        case 'file':
+        case 'javascript':
+        case 'mailto':
+          return 'null';
+      }
+      host = this.host;
+      if (!host) {
+        return '';
+      }
+      return this._scheme + '://' + host;
     }
   };
 
   // Copy over the static methods
   var OriginalURL = scope.URL;
   if (OriginalURL) {
     jURL.createObjectURL = function(blob) {
       // IE extension allows a second optional options argument.
       // http://msdn.microsoft.com/en-us/library/ie/hh772302(v=vs.85).aspx
       return OriginalURL.createObjectURL.apply(OriginalURL, arguments);
@@ skipping 594 matching lines @@
  * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
  * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
  * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
  * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
  * Code distributed by Google as part of the polymer project is also
  * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
  */
 
 (function(scope) {
 
-var hasNative = ('import' in document.createElement('link'));
+var IMPORT_LINK_TYPE = 'import';
+var hasNative = (IMPORT_LINK_TYPE in document.createElement('link'));
 var useNative = hasNative;
-
-isIE = /Trident/.test(navigator.userAgent);
+var isIE = /Trident/.test(navigator.userAgent);
 
 // TODO(sorvell): SD polyfill intrusion
 var hasShadowDOMPolyfill = Boolean(window.ShadowDOMPolyfill);
 var wrap = function(node) {
   return hasShadowDOMPolyfill ? ShadowDOMPolyfill.wrapIfNeeded(node) : node;
 };
-var mainDoc = wrap(document);
+
+var rootDocument = wrap(document);
     
 // NOTE: We cannot polyfill document.currentScript because it's not possible
 // both to override and maintain the ability to capture the native value;
 // therefore we choose to expose _currentScript both when native imports
 // and the polyfill are in use.
 var currentScriptDescriptor = {
   get: function() {
     var script = HTMLImports.currentScript || document.currentScript ||
         // NOTE: only works when called in synchronously executing code.
         // readyState should check if `loading` but IE10 is 
         // interactive when scripts run so we cheat.
         (document.readyState !== 'complete' ? 
         document.scripts[document.scripts.length - 1] : null);
     return wrap(script);
   },
   configurable: true
 };
 
 Object.defineProperty(document, '_currentScript', currentScriptDescriptor);
-Object.defineProperty(mainDoc, '_currentScript', currentScriptDescriptor);
+Object.defineProperty(rootDocument, '_currentScript', currentScriptDescriptor);
 
 // call a callback when all HTMLImports in the document at call (or at least
 //  document ready) time have loaded.
 // 1. ensure the document is in a ready state (has dom), then 
 // 2. watch for loading of imports and call callback when done
-function whenImportsReady(callback, doc) {
-  doc = doc || mainDoc;
+function whenReady(callback, doc) {
+  doc = doc || rootDocument;
   // if document is loading, wait and try again
   whenDocumentReady(function() {
     watchImportsLoad(callback, doc);
   }, doc);
 }
 
 // call the callback when the document is in a ready state (has dom)
 var requiredReadyState = isIE ? 'complete' : 'interactive';
 var READY_EVENT = 'readystatechange';
 function isDocumentReady(doc) {
@@ skipping 19 matching lines @@
 
 function markTargetLoaded(event) {
   event.target.__loaded = true;
 }
 
 // call <callback> when we ensure all imports have loaded
 function watchImportsLoad(callback, doc) {
   var imports = doc.querySelectorAll('link[rel=import]');
   var loaded = 0, l = imports.length;
   function checkDone(d) { 
-    if (loaded == l) {
-      callback && callback();
+    if ((loaded == l) && callback) {
+       callback();
     }
   }
   function loadedImport(e) {
     markTargetLoaded(e);
     loaded++;
     checkDone();
   }
   if (l) {
     for (var i=0, imp; (i<l) && (imp=imports[i]); i++) {
       if (isImportLoaded(imp)) {
@@ skipping 72 matching lines @@
       }
     }
   })();
 
 }
 
 // Fire the 'HTMLImportsLoaded' event when imports in document at load time 
 // have loaded. This event is required to simulate the script blocking 
 // behavior of native imports. A main document script that needs to be sure
 // imports have loaded should wait for this event.
-whenImportsReady(function() {
+whenReady(function() {
   HTMLImports.ready = true;
   HTMLImports.readyTime = new Date().getTime();
-  mainDoc.dispatchEvent(
+  rootDocument.dispatchEvent(
     new CustomEvent('HTMLImportsLoaded', {bubbles: true})
   );
 });
 
 // exports
 scope.useNative = useNative;
 scope.isImportLoaded = isImportLoaded;
-scope.whenReady = whenImportsReady;
+scope.whenReady = whenReady;
+scope.rootDocument = rootDocument;
+scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;
 scope.isIE = isIE;
 
-// deprecated
-scope.whenImportsReady = whenImportsReady;
-
 })(window.HTMLImports);
 /*
  * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
  * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
  * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
  * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
  * Code distributed by Google as part of the polymer project is also
  * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
  */
 (function(scope) {
 
   // imports
   var path = scope.path;
   var xhr = scope.xhr;
   var flags = scope.flags;
 
   // TODO(sorvell): this loader supports a dynamic list of urls
   // and an oncomplete callback that is called when the loader is done.
   // The polyfill currently does *not* need this dynamism or the onComplete
   // concept. Because of this, the loader could be simplified quite a bit.
   var Loader = function(onLoad, onComplete) {
     this.cache = {};
     this.onload = onLoad;
     this.oncomplete = onComplete;
     this.inflight = 0;
     this.pending = {};
   };
 
   Loader.prototype = {
+
     addNodes: function(nodes) {
       // number of transactions to complete
       this.inflight += nodes.length;
       // commence transactions
       for (var i=0, l=nodes.length, n; (i<l) && (n=nodes[i]); i++) {
         this.require(n);
       }
       // anything to do?
       this.checkDone();
     },
+
     addNode: function(node) {
       // number of transactions to complete
       this.inflight++;
       // commence transactions
       this.require(node);
       // anything to do?
       this.checkDone();
     },
+
     require: function(elt) {
       var url = elt.src || elt.href;
       // ensure we have a standard url that can be used
       // reliably for deduping.
       // TODO(sjmiles): ad-hoc
       elt.__nodeUrl = url;
       // deduplication
       if (!this.dedupe(url, elt)) {
         // fetch this resource
         this.fetch(url, elt);
       }
     },
+
     dedupe: function(url, elt) {
       if (this.pending[url]) {
         // add to list of nodes waiting for inUrl
         this.pending[url].push(elt);
         // don't need fetch
         return true;
       }
       var resource;
       if (this.cache[url]) {
         this.onload(url, elt, this.cache[url]);
         // finished this transaction
         this.tail();
         // don't need fetch
         return true;
       }
       // first node waiting for inUrl
       this.pending[url] = [elt];
       // need fetch (not a dupe)
       return false;
     },
+
     fetch: function(url, elt) {
       flags.load && console.log('fetch', url, elt);
       if (url.match(/^data:/)) {
         // Handle Data URI Scheme
         var pieces = url.split(',');
         var header = pieces[0];
         var body = pieces[1];
         if(header.indexOf(';base64') > -1) {
           body = atob(body);
         } else {
@@ skipping 15 matching lines @@
         // to avoid the bug above.
         /*
         if (isDocumentLink(elt)) {
           xhr.loadDocument(url, receiveXhr);
         } else {
           xhr.load(url, receiveXhr);
         }
         */
       }
     },
+
     receive: function(url, elt, err, resource, redirectedUrl) {
       this.cache[url] = resource;
       var $p = this.pending[url];
       for (var i=0, l=$p.length, p; (i<l) && (p=$p[i]); i++) {
         // If url was redirected, use the redirected location so paths are
         // calculated relative to that.
         this.onload(url, p, resource, err, redirectedUrl);
         this.tail();
       }
       this.pending[url] = null;
     },
+
     tail: function() {
       --this.inflight;
       this.checkDone();
     },
+
     checkDone: function() {
       if (!this.inflight) {
         this.oncomplete();
       }
     }
+
   };
 
   xhr = xhr || {
     async: true,
+
     ok: function(request) {
       return (request.status >= 200 && request.status < 300)
           || (request.status === 304)
           || (request.status === 0);
     },
+
     load: function(url, next, nextContext) {
       var request = new XMLHttpRequest();
       if (scope.flags.debug || scope.flags.bust) {
         url += '?' + Math.random();
       }
       request.open('GET', url, xhr.async);
       request.addEventListener('readystatechange', function(e) {
         if (request.readyState === 4) {
           // Servers redirecting an import can add a Location header to help us
           // polyfill correctly.
           var locationHeader = request.getResponseHeader("Location");
           var redirectedUrl = null;
           if (locationHeader) {
             var redirectedUrl = (locationHeader.substr( 0, 1 ) === "/")
               ? location.origin + locationHeader  // Location is a relative path
               : locationHeader;                    // Full path
           }
           next.call(nextContext, !xhr.ok(request) && request,
               request.response || request.responseText, redirectedUrl);
         }
       });
       request.send();
       return request;
     },
+
     loadDocument: function(url, next, nextContext) {
       this.load(url, next, nextContext).responseType = 'document';
     }
+    
   };
 
   // exports
   scope.xhr = xhr;
   scope.Loader = Loader;
 
 })(window.HTMLImports);
 
 /*
  * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
  * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
  * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
  * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
  * Code distributed by Google as part of the polymer project is also
  * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
  */
 (function(scope) {
 
-var IMPORT_LINK_TYPE = 'import';
+// imports
+var rootDocument = scope.rootDocument;
 var flags = scope.flags;
 var isIE = scope.isIE;
-// TODO(sorvell): SD polyfill intrusion
-var mainDoc = window.ShadowDOMPolyfill ? 
-    window.ShadowDOMPolyfill.wrapIfNeeded(document) : document;
+var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;
 
 // importParser
 // highlander object to manage parsing of imports
 // parses import related elements
 // and ensures proper parse order
 // parse order is enforced by crawling the tree and monitoring which elements
 // have been parsed; async parsing is also supported.
 
 // highlander object for parsing a document tree
 var importParser = {
+
   // parse selectors for main document elements
   documentSelectors: 'link[rel=' + IMPORT_LINK_TYPE + ']',
+
   // parse selectors for import document elements
   importsSelectors: [
     'link[rel=' + IMPORT_LINK_TYPE + ']',
     'link[rel=stylesheet]',
     'style',
     'script:not([type])',
     'script[type="text/javascript"]'
   ].join(','),
+
   map: {
     link: 'parseLink',
     script: 'parseScript',
     style: 'parseStyle'
   },
+
+  dynamicElements: [],
+
   // try to parse the next import in the tree
   parseNext: function() {
     var next = this.nextToParse();
     if (next) {
       this.parse(next);
     }
   },
+
   parse: function(elt) {
     if (this.isParsed(elt)) {
       flags.parse && console.log('[%s] is already parsed', elt.localName);
       return;
     }
     var fn = this[this.map[elt.localName]];
     if (fn) {
       this.markParsing(elt);
       fn.call(this, elt);
     }
   },
+
+  parseDynamic: function(elt, quiet) {
+    this.dynamicElements.push(elt);
+    if (!quiet) {
+      this.parseNext();
+    }
+  },
+
   // only 1 element may be parsed at a time; parsing is async so each
   // parsing implementation must inform the system that parsing is complete
   // via markParsingComplete.
   // To prompt the system to parse the next element, parseNext should then be
   // called.
   // Note, parseNext used to be included at the end of markParsingComplete, but
   // we must not do this so that, for example, we can (1) mark parsing complete 
   // then (2) fire an import load event, and then (3) parse the next resource.
   markParsing: function(elt) {
     flags.parse && console.log('parsing', elt);
     this.parsingElement = elt;
   },
+
   markParsingComplete: function(elt) {
     elt.__importParsed = true;
+    this.markDynamicParsingComplete(elt);
     if (elt.__importElement) {
       elt.__importElement.__importParsed = true;
+      this.markDynamicParsingComplete(elt.__importElement);
     }
     this.parsingElement = null;
     flags.parse && console.log('completed', elt);
   },
-  invalidateParse: function(doc) {
-    if (doc && doc.__importLink) {
-      doc.__importParsed = doc.__importLink.__importParsed = false;
-      this.parseSoon();
+
+  markDynamicParsingComplete: function(elt) {
+    var i = this.dynamicElements.indexOf(elt);
+    if (i >= 0) {
+      this.dynamicElements.splice(i, 1);
     }
   },
-  parseSoon: function() {
-    if (this._parseSoon) {
-      cancelAnimationFrame(this._parseDelay);
-    }
-    var parser = this;
-    this._parseSoon = requestAnimationFrame(function() {
-      parser.parseNext();
-    });
-  },
+
   parseImport: function(elt) {
     // TODO(sorvell): consider if there's a better way to do this;
     // expose an imports parsing hook; this is needed, for example, by the
     // CustomElements polyfill.
     if (HTMLImports.__importsParsingHook) {
       HTMLImports.__importsParsingHook(elt);
     }
     if (elt.import) {
       elt.import.__importParsed = true;
     }
@@ skipping 10 matching lines @@
       var fn;
       while (elt.__pending.length) {
         fn = elt.__pending.shift();
         if (fn) {
           fn({target: elt});
         }
       }
     }
     this.parseNext();
   },
+
   parseLink: function(linkElt) {
     if (nodeIsImport(linkElt)) {
       this.parseImport(linkElt);
     } else {
       // make href absolute
       linkElt.href = linkElt.href;
       this.parseGeneric(linkElt);
     }
   },
+
   parseStyle: function(elt) {
     // TODO(sorvell): style element load event can just not fire so clone styles
     var src = elt;
     elt = cloneStyle(elt);
     elt.__importElement = src;
     this.parseGeneric(elt);
   },
+
   parseGeneric: function(elt) {
     this.trackElement(elt);
     this.addElementToDocument(elt);
   },
+
   rootImportForElement: function(elt) {
     var n = elt;
     while (n.ownerDocument.__importLink) {
       n = n.ownerDocument.__importLink;
     }
     return n;
   },
+
   addElementToDocument: function(elt) {
     var port = this.rootImportForElement(elt.__importElement || elt);
     var l = port.__insertedElements = port.__insertedElements || 0;
     var refNode = port.nextElementSibling;
     for (var i=0; i < l; i++) {
       refNode = refNode && refNode.nextElementSibling;
     }
     port.parentNode.insertBefore(elt, refNode);
   },
+
   // tracks when a loadable element has loaded
   trackElement: function(elt, callback) {
     var self = this;
     var done = function(e) {
       if (callback) {
         callback(e);
       }
       self.markParsingComplete(elt);
       self.parseNext();
     };
@@ skipping 19 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) {
     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;  
     });
     this.addElementToDocument(script);
   },
+
   // determine the next element in the tree which should be parsed
   nextToParse: function() {
     this._mayParse = [];
-    return !this.parsingElement && this.nextToParseInDoc(mainDoc);
+    return !this.parsingElement && (this.nextToParseInDoc(rootDocument) || 
+        this.nextToParseDynamic());
   },
+
   nextToParseInDoc: function(doc, link) {
     // use `marParse` list to avoid looping into the same document again
     // since it could cause an iloop.
     if (doc && this._mayParse.indexOf(doc) < 0) {
       this._mayParse.push(doc);
       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)) {
             return nodeIsImport(n) ? this.nextToParseInDoc(n.import, n) : n;
           } else {
             return;
           }
         }
       }
     }
     // all nodes have been parsed, ready to parse import, if any
     return link;
   },
+
+  nextToParseDynamic: function() {
+    return this.dynamicElements[0];
+  },
+
   // return the set of parse selectors relevant for this node.
   parseSelectorsForNode: function(node) {
     var doc = node.ownerDocument || node;
-    return doc === mainDoc ? this.documentSelectors : this.importsSelectors;
+    return doc === rootDocument ? this.documentSelectors :
+        this.importsSelectors;
   },
+
   isParsed: function(node) {
     return node.__importParsed;
   },
+
+  needsDynamicParsing: function(elt) {
+    return (this.dynamicElements.indexOf(elt) >= 0);
+  },
+
   hasResource: function(node) {
     if (nodeIsImport(node) && (node.import === undefined)) {
       return false;
     }
     return true;
   }
+
 };
 
 function nodeIsImport(elt) {
   return (elt.localName === 'link') && (elt.rel === IMPORT_LINK_TYPE);
 }
 
 function generateScriptDataUrl(script) {
   var scriptContent = generateScriptContent(script);
   return 'data:text/javascript;charset=utf-8,' + encodeURIComponent(scriptContent);
 }
@@ skipping 29 matching lines @@
   path.resolveUrlsInStyle(clone);
   return clone;
 }
 
 // path fixup: style elements in imports must be made relative to the main 
 // document. We fixup url's in url() and @import.
 var CSS_URL_REGEXP = /(url\()([^)]*)(\))/g;
 var CSS_IMPORT_REGEXP = /(@import[\s]+(?!url\())([^;]*)(;)/g;
 
 var path = {
+
   resolveUrlsInStyle: function(style) {
     var doc = style.ownerDocument;
     var resolver = doc.createElement('a');
     style.textContent = this.resolveUrlsInCssText(style.textContent, resolver);
     return style;  
   },
+
   resolveUrlsInCssText: function(cssText, urlObj) {
     var r = this.replaceUrls(cssText, urlObj, CSS_URL_REGEXP);
     r = this.replaceUrls(r, urlObj, CSS_IMPORT_REGEXP);
     return r;
   },
+
   replaceUrls: function(text, urlObj, regexp) {
     return text.replace(regexp, function(m, pre, url, post) {
       var urlPath = url.replace(/["']/g, '');
       urlObj.href = urlPath;
       urlPath = urlObj.href;
       return pre + '\'' + urlPath + '\'' + post;
     });    
   }
-}
+
+};
 
 // exports
 scope.parser = importParser;
 scope.path = path;
 
 })(HTMLImports);
 
 /*
  * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
  * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
  * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
  * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
  * Code distributed by Google as part of the polymer project is also
  * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
  */
  (function(scope) {
 
+// imports
 var useNative = scope.useNative;
 var flags = scope.flags;
-var IMPORT_LINK_TYPE = 'import';
-
-// TODO(sorvell): SD polyfill intrusion
-var mainDoc = window.ShadowDOMPolyfill ? 
-    ShadowDOMPolyfill.wrapIfNeeded(document) : document;
+var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;
 
 if (!useNative) {
 
   // imports
+  var rootDocument = scope.rootDocument;
   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)
 
   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 + ']'
     ].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);
     },
+    
     marshalNodes: function(parent) {
       // all preloadable nodes in inDocument
       return parent.querySelectorAll(this.loadSelectorsForNode(parent));
     },
+    
     // find the proper set of load selectors for a given node
     loadSelectorsForNode: function(node) {
       var doc = node.ownerDocument || node;
-      return doc === mainDoc ? this.documentPreloadSelectors :
+      return doc === rootDocument ? this.documentPreloadSelectors :
           this.importsPreloadSelectors;
     },
+    
     loaded: function(url, elt, resource, err, redirectedUrl) {
       flags.load && console.log('loaded', url, elt);
       // store generic resource
       // TODO(sorvell): fails for nodes inside <template>.content
       // see https://code.google.com/p/chromium/issues/detail?id=249381.
       elt.__resource = resource;
       elt.__error = err;
       if (isDocumentLink(elt)) {
         var doc = this.documents[url];
         // if we've never seen a document at this url
         if (doc === undefined) {
           // generate an HTMLDocument from data
           doc = err ? null : makeDocument(resource, redirectedUrl || url);
           if (doc) {
             doc.__importLink = elt;
             // note, we cannot use MO to detect parsed nodes because
             // SD polyfill does not report these as mutations.
             this.bootDocument(doc);
           }
           // cache document
           this.documents[url] = doc;
         }
         // don't store import record until we're actually loaded
         // store document resource
         elt.import = doc;
       }
       parser.parseNext();
     },
+    
     bootDocument: function(doc) {
       this.loadSubtree(doc);
       this.observe(doc);
       parser.parseNext();
     },
+    
     loadedAll: function() {
       parser.parseNext();
     }
+
   };
 
   // loader singleton
   var importLoader = new Loader(importer.loaded.bind(importer), 
       importer.loadedAll.bind(importer));
 
   function isDocumentLink(elt) {
     return isLinkRel(elt, IMPORT_LINK_TYPE);
   }
 
@@ skipping 47 matching lines @@
   if (!document.baseURI) {
     var baseURIDescriptor = {
       get: function() {
         var base = document.querySelector('base');
         return base ? base.href : window.location.href;
       },
       configurable: true
     };
 
     Object.defineProperty(document, 'baseURI', baseURIDescriptor);
-    Object.defineProperty(mainDoc, 'baseURI', baseURIDescriptor);
+    Object.defineProperty(rootDocument, 'baseURI', baseURIDescriptor);
   }
 
   // IE shim for CustomEvent
   if (typeof window.CustomEvent !== 'function') {
     window.CustomEvent = function(inType, dictionary) {
        var e = document.createEvent('HTMLEvents');
        e.initEvent(inType,
           dictionary.bubbles === false ? false : true,
           dictionary.cancelable === false ? false : true,
           dictionary.detail);
        return e;
     };
   }
 
 } else {
   // do nothing if using native imports
   var importer = {};
 }
 
 // exports
 scope.importer = importer;
 scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;
 scope.importLoader = importLoader;
 
-
 })(window.HTMLImports);
 
 /*
  * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
  * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
  * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
  * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
  * Code distributed by Google as part of the polymer project is also
  * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
  */
 (function(scope){
 
+// imports
 var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;
-var importSelector = 'link[rel=' + IMPORT_LINK_TYPE + ']';
 var importer = scope.importer;
 var parser = scope.parser;
 
+var importSelector = 'link[rel=' + IMPORT_LINK_TYPE + ']';
+
+
 // we track mutations for addedNodes, looking for imports
 function handler(mutations) {
   for (var i=0, l=mutations.length, m; (i<l) && (m=mutations[i]); i++) {
     if (m.type === 'childList' && m.addedNodes.length) {
       addedNodes(m.addedNodes);
     }
   }
 }
 
 // find loadable elements and add them to the importer
+// IFF the owning document has already parsed, then parsable elements
+// need to be marked for dynamic parsing.
 function addedNodes(nodes) {
-  var owner;
-  for (var i=0, l=nodes.length, n; (i<l) && (n=nodes[i]); i++) {
-    owner = owner || n.ownerDocument;
-    if (shouldLoadNode(n)) {
+  var owner, parsed;
+  for (var i=0, l=nodes.length, n, loading; (i<l) && (n=nodes[i]); i++) {
+    if (!owner) {
+      owner = n.ownerDocument;
+      parsed = parser.isParsed(owner);
+    }
+    // note: the act of loading kicks the parser, so we use parseDynamic's
+    // 2nd argument to control if this added node needs to kick the parser.
+    loading = shouldLoadNode(n);
+    if (loading) {
       importer.loadNode(n);
     }
+    if (shouldParseNode(n) && parsed) {
+      parser.parseDynamic(n, loading);
+    }
     if (n.children && n.children.length) {
       addedNodes(n.children);
     }
   }
-  // TODO(sorvell): This is not the right approach here. We shouldn't need to
-  // invalidate parsing when an element is added. Disabling this code 
-  // until a better approach is found.
-  /*
-  if (owner) {
-    parser.invalidateParse(owner);
-  }
-  */
 }
 
 function shouldLoadNode(node) {
   return (node.nodeType === 1) && matches.call(node,
       importer.loadSelectorsForNode(node));
 }
 
+function shouldParseNode(node) {
+  return (node.nodeType === 1) && matches.call(node,
+      parser.parseSelectorsForNode(node));  
+}
+
 // x-plat matches
 var matches = HTMLElement.prototype.matches || 
     HTMLElement.prototype.matchesSelector || 
     HTMLElement.prototype.webkitMatchesSelector ||
     HTMLElement.prototype.mozMatchesSelector ||
     HTMLElement.prototype.msMatchesSelector;
 
 var observer = new MutationObserver(handler);
 
 // observe the given root for loadable elements
@@ skipping 1268 matching lines @@
   // exports
 
   scope.marshal = marshal;
   // `module` confuses commonjs detectors
   scope.modularize = module;
   scope.using = using;
 
 })(window);
 
 //# sourceMappingURL=platform.concat.js.map