Update to polymer js version 0.4.1

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 97 matching lines @@
       }
     };
 
     window.WeakMap = WeakMap;
   })();
 }
 
 // select ShadowDOM impl
 if (Platform.flags.shadow) {
 
-// Copyright 2012 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * 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(global) {
   'use strict';
 
   var testingExposeCycleCount = global.testingExposeCycleCount;
 
   // Detect and do basic sanity checking on Object/Array.observe.
   function detectObjectObserve() {
     if (typeof Object.observe !== 'function' ||
         typeof Array.observe !== 'function') {
@@ skipping 39 matching lines @@
   function detectEval() {
     // Don't test for eval if we're running in a Chrome App environment.
     // We check for APIs set that only exist in a Chrome App context.
     if (typeof chrome !== 'undefined' && chrome.app && chrome.app.runtime) {
       return false;
     }
 
     // Firefox OS Apps do not allow eval. This feature detection is very hacky
     // but even if some other platform adds support for this function this code
     // will continue to work.
-    if (navigator.getDeviceStorage) {
+    if (typeof navigator != 'undefined' && navigator.getDeviceStorage) {
       return false;
     }
 
     try {
       var f = new Function('', 'return true;');
       return f();
     } catch (ex) {
       return false;
     }
   }
 
   var hasEval = detectEval();
 
   function isIndex(s) {
-    return +s === s >>> 0;
+    return +s === s >>> 0 && s !== '';
   }
 
   function toNumber(s) {
     return +s;
   }
 
   function isObject(obj) {
     return obj === Object(obj);
   }
 
@@ skipping 693 matching lines @@
 
     allObservers.push(observer);
   }
 
   function removeFromAll(observer) {
     Observer._allObserversCount--;
   }
 
   var runningMicrotaskCheckpoint = false;
 
-  var hasDebugForceFullDelivery = hasObserve && hasEval && (function() {
-    try {
-      eval('%RunMicrotasks()');
-      return true;
-    } catch (ex) {
-      return false;
-    }
-  })();
-
   global.Platform = global.Platform || {};
 
   global.Platform.performMicrotaskCheckpoint = function() {
     if (runningMicrotaskCheckpoint)
       return;
 
-    if (hasDebugForceFullDelivery) {
-      eval('%RunMicrotasks()');
-      return;
-    }
-
     if (!collectObservers)
       return;
 
     runningMicrotaskCheckpoint = true;
 
     var cycles = 0;
     var anyChanged, toCheck;
 
     do {
       cycles++;
@@ skipping 2062 matching lines @@
       return;
     handledEventsTable.set(originalEvent, true);
     dispatchEvent(wrap(originalEvent), wrap(originalEvent.target));
     if (pendingError) {
       var err = pendingError;
       pendingError = null;
       throw err;
     }
   }
 
+
+  function isLoadLikeEvent(event) {
+    switch (event.type) {
+      // http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#events-and-the-window-object
+      case 'load':
+      // http://www.whatwg.org/specs/web-apps/current-work/multipage/browsers.html#unloading-documents
+      case 'beforeunload':
+      case 'unload':
+        return true;
+    }
+    return false;
+  }
+
   function dispatchEvent(event, originalWrapperTarget) {
     if (currentlyDispatchingEvents.get(event))
       throw new Error('InvalidStateError');
 
     currentlyDispatchingEvents.set(event, true);
 
     // Render to ensure that the event path is correct.
     scope.renderAllPending();
     var eventPath;
 
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#events-and-the-window-object
     // All events dispatched on Nodes with a default view, except load events,
     // should propagate to the Window.
 
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#the-end
     var overrideTarget;
     var win;
-    var type = event.type;
 
     // Should really be not cancelable too but since Firefox has a bug there
     // we skip that check.
     // https://bugzilla.mozilla.org/show_bug.cgi?id=999456
-    if (type === 'load' && !event.bubbles) {
+    if (isLoadLikeEvent(event) && !event.bubbles) {
       var doc = originalWrapperTarget;
       if (doc instanceof wrappers.Document && (win = doc.defaultView)) {
         overrideTarget = doc;
         eventPath = [];
       }
     }
 
     if (!eventPath) {
       if (originalWrapperTarget instanceof wrappers.Window) {
         win = originalWrapperTarget;
         eventPath = [];
       } else {
         eventPath = getEventPath(originalWrapperTarget, event);
 
-        if (event.type !== 'load') {
+        if (!isLoadLikeEvent(event)) {
           var doc = eventPath[eventPath.length - 1];
           if (doc instanceof wrappers.Document)
             win = doc.defaultView;
         }
       }
     }
 
     eventPathTable.set(event, eventPath);
 
     if (dispatchCapturing(event, eventPath, win, overrideTarget)) {
@@ skipping 85 matching lines @@
           adjusted = null;
         }
         relatedTargetTable.set(event, adjusted);
       }
     }
 
     eventPhaseTable.set(event, phase);
     var type = event.type;
 
     var anyRemoved = false;
-    // targetTable.set(event, target);
     targetTable.set(event, target);
     currentTargetTable.set(event, currentTarget);
 
     // Keep track of the invoke depth so that we only clean up the removed
     // listeners if we are in the outermost invoke.
     listeners.depth++;
 
     for (var i = 0, len = listeners.length; i < len; i++) {
       var listener = listeners[i];
       if (listener.removed) {
@@ skipping 64 matching lines @@
 
   /**
    * Creates a new Event wrapper or wraps an existin native Event object.
    * @param {string|Event} type
    * @param {Object=} options
    * @constructor
    */
   function Event(type, options) {
     if (type instanceof OriginalEvent) {
       var impl = type;
-      if (!OriginalBeforeUnloadEvent && impl.type === 'beforeunload') {
+      // In browsers that do not correctly support BeforeUnloadEvent we get to
+      // the generic Event wrapper but we still want to ensure we create a
+      // BeforeUnloadEvent. Since BeforeUnloadEvent calls super, we need to
+      // prevent reentrancty.
+      if (!OriginalBeforeUnloadEvent && impl.type === 'beforeunload' &&
+          !(this instanceof BeforeUnloadEvent)) {
         return new BeforeUnloadEvent(impl);
       }
       setWrapper(impl, this);
     } else {
       return wrap(constructEvent(OriginalEvent, 'Event', type, options));
     }
   }
   Event.prototype = {
     get target() {
       return targetTable.get(this);
@@ skipping 1343 matching lines @@
   registerWrapper(OriginalNode, Node, document.createDocumentFragment());
   delete Node.prototype.querySelector;
   delete Node.prototype.querySelectorAll;
   Node.prototype = mixin(Object.create(EventTarget.prototype), Node.prototype);
 
   scope.cloneNode = cloneNode;
   scope.nodeWasAdded = nodeWasAdded;
   scope.nodeWasRemoved = nodeWasRemoved;
   scope.nodesWereAdded = nodesWereAdded;
   scope.nodesWereRemoved = nodesWereRemoved;
+  scope.originalInsertBefore = originalInsertBefore;
+  scope.originalRemoveChild = originalRemoveChild;
   scope.snapshotNodeList = snapshotNodeList;
   scope.wrappers.Node = Node;
 
 })(window.ShadowDOMPolyfill);
 
 // Copyright 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
@@ skipping 2084 matching lines @@
       var lastChildWrapper = wrap(parentNode.lastChild);
       if (lastChildWrapper)
         lastChildWrapper.nextSibling_ = lastChildWrapper.nextSibling;
     } else {
       if (parentNodeWrapper.firstChild === refChildWrapper)
         parentNodeWrapper.firstChild_ = refChildWrapper;
 
       refChildWrapper.previousSibling_ = refChildWrapper.previousSibling;
     }
 
-    parentNode.insertBefore(newChild, refChild);
+    scope.originalInsertBefore.call(parentNode, newChild, refChild);
   }
 
   function remove(nodeWrapper) {
     var node = unwrap(nodeWrapper)
     var parentNode = node.parentNode;
     if (!parentNode)
       return;
 
     var parentNodeWrapper = wrap(parentNode);
     updateWrapperUpAndSideways(nodeWrapper);
 
     if (nodeWrapper.previousSibling)
       nodeWrapper.previousSibling.nextSibling_ = nodeWrapper;
     if (nodeWrapper.nextSibling)
       nodeWrapper.nextSibling.previousSibling_ = nodeWrapper;
 
     if (parentNodeWrapper.lastChild === nodeWrapper)
       parentNodeWrapper.lastChild_ = nodeWrapper;
     if (parentNodeWrapper.firstChild === nodeWrapper)
       parentNodeWrapper.firstChild_ = nodeWrapper;
 
-    parentNode.removeChild(node);
+    scope.originalRemoveChild.call(parentNode, node);
   }
 
   var distributedNodesTable = new WeakMap();
   var destinationInsertionPointsTable = new WeakMap();
   var rendererForHostTable = new WeakMap();
 
   function resetDistributedNodes(insertionPoint) {
     distributedNodesTable.set(insertionPoint, []);
   }
 
@@ skipping 182 matching lines @@
           parentRenderer.invalidate();
         pendingDirtyRenderers.push(this);
         if (renderTimer)
           return;
         renderTimer = window[request](handleRequestAnimationFrame, 0);
       }
     },
 
     // http://w3c.github.io/webcomponents/spec/shadow/#distribution-algorithms
     distribution: function(root) {
-      this.resetAll(root);
+      this.resetAllSubtrees(root);
       this.distributionResolution(root);
     },
 
     resetAll: function(node) {
       if (isInsertionPoint(node))
         resetDistributedNodes(node);
       else
         resetDestinationInsertionPoints(node);
 
+      this.resetAllSubtrees(node);
+    },
+
+    resetAllSubtrees: function(node) {
       for (var child = node.firstChild; child; child = child.nextSibling) {
         this.resetAll(child);
       }
 
       if (node.shadowRoot)
         this.resetAll(node.shadowRoot);
 
       if (node.olderShadowRoot)
         this.resetAll(node.olderShadowRoot);
     },
@@ skipping 920 matching lines @@
  */
 
 (function(scope) {
   'use strict';
 
   var registerWrapper = scope.registerWrapper;
   var setWrapper = scope.setWrapper;
   var unwrap = scope.unwrap;
 
   var OriginalFormData = window.FormData;
+  if (!OriginalFormData) return;
 
   function FormData(formElement) {
     var impl;
     if (formElement instanceof OriginalFormData) {
       impl = formElement;
     } else {
       impl = new OriginalFormData(formElement && unwrap(formElement));
     }
     setWrapper(impl, this);
   }
 
   registerWrapper(OriginalFormData, FormData, new OriginalFormData());
 
   scope.wrappers.FormData = FormData;
 
 })(window.ShadowDOMPolyfill);
 
+/*
+ * Copyright 2014 The Polymer Authors. All rights reserved.
+ * Use of this source code is goverened by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+(function(scope) {
+  'use strict';
+
+  var unwrapIfNeeded = scope.unwrapIfNeeded;
+  var originalSend = XMLHttpRequest.prototype.send;
+
+  // Since we only need to adjust XHR.send, we just patch it instead of wrapping
+  // the entire object. This happens when FormData is passed.
+  XMLHttpRequest.prototype.send = function(obj) {
+    return originalSend.call(this, unwrapIfNeeded(obj));
+  };
+
+})(window.ShadowDOMPolyfill);
+
 // Copyright 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
 
   var isWrapperFor = scope.isWrapperFor;
 
   // This is a list of the elements we currently override the global constructor
@@ skipping 1607 matching lines @@
       var args2 = args.slice();
       args2.push.apply(args2, arguments);
       return self.apply(scope, args2);
     };
   };
 }
 
 })(window.Platform);
 
 /*
- * 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) {
-
-  'use strict';
-
-  // polyfill performance.now
-
-  if (!window.performance) {
-    var start = Date.now();
-    // only at millisecond precision
-    window.performance = {now: function(){ return Date.now() - start }};
-  }
-
-  // polyfill for requestAnimationFrame
-
-  if (!window.requestAnimationFrame) {
-    window.requestAnimationFrame = (function() {
-      var nativeRaf = window.webkitRequestAnimationFrame ||
-        window.mozRequestAnimationFrame;
-
-      return nativeRaf ?
-        function(callback) {
-          return nativeRaf(function() {
-            callback(performance.now());
-          });
-        } :
-        function( callback ){
-          return window.setTimeout(callback, 1000 / 60);
-        };
-    })();
-  }
-
-  if (!window.cancelAnimationFrame) {
-    window.cancelAnimationFrame = (function() {
-      return  window.webkitCancelAnimationFrame ||
-        window.mozCancelAnimationFrame ||
-        function(id) {
-          clearTimeout(id);
-        };
-    })();
-  }
-
-  // Make a stub for Polymer() for polyfill purposes; under the HTMLImports
-  // polyfill, scripts in the main document run before imports. That means
-  // if (1) polymer is imported and (2) Polymer() is called in the main document
-  // in a script after the import, 2 occurs before 1. We correct this here
-  // by specfiically patching Polymer(); this is not necessary under native
-  // HTMLImports.
-  var elementDeclarations = [];
-
-  var polymerStub = function(name, dictionary) {
-    Array.prototype.push.call(arguments, document._currentScript);
-    elementDeclarations.push(arguments);
-  };
-  window.Polymer = polymerStub;
-
-  // deliver queued delcarations
-  scope.consumeDeclarations = function(callback) {
-    scope.consumeDeclarations = function() {
-     throw 'Possible attempt to load Polymer twice';
-    };
-    if (callback) {
-      callback(elementDeclarations);
-    }
-    elementDeclarations = null;
-  };
-
-  // Once DOMContent has loaded, any main document scripts that depend on
-  // Polymer() should have run. Calling Polymer() now is an error until
-  // polymer is imported.
-  window.addEventListener('DOMContentLoaded', function() {
-    if (window.Polymer === polymerStub) {
-      window.Polymer = function() {
-        console.error('You tried to use polymer without loading it first. To ' +
-          'load polymer, <link rel="import" href="' + 
-          'components/polymer/polymer.html">');
-      };
-    }
-  });
-
-})(window.Platform);
-
-/*
  * Copyright 2012 The Polymer Authors. All rights reserved.
  * Use of this source code is goverened by a BSD-style
  * license that can be found in the LICENSE file.
  */
 
 (function(global) {
 
   var registrationsTable = new WeakMap();
 
   // We use setImmediate or postMessage for our future callback.
@@ skipping 648 matching lines @@
         imp.addEventListener('error', loadedImport);
       }
     }
   } else {
     checkDone();
   }
 }
 
 // NOTE: test for native imports loading is based on explicitly watching
 // all imports (see below).
+// We cannot rely on this entirely without watching the entire document
+// for import links. For perf reasons, currently only head is watched.
+// Instead, we fallback to checking if the import property is available 
+// and the document is not itself loading. 
 function isImportLoaded(link) {
-  return useNative ? link.__loaded : link.__importParsed;
+  return useNative ? link.__loaded || 
+      (link.import && link.import.readyState !== 'loading') :
+      link.__importParsed;
 }
 
 // TODO(sorvell): Workaround for 
 // https://www.w3.org/Bugs/Public/show_bug.cgi?id=25007, should be removed when
 // this bug is addressed.
 // (1) Install a mutation observer to see when HTMLImports have loaded
 // (2) if this script is run during document load it will watch any existing
 // imports for loading.
 //
 // NOTE: The workaround has restricted functionality: (1) it's only compatible
@@ skipping 455 matching lines @@
         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);
   },
   nextToParseInDoc: function(doc, link) {
-    if (doc) {
+    // 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;
           }
         }
       }
@@ skipping 709 matching lines @@
 function observeDocument(doc) {
   observe(doc);
 }
 
 function upgradeDocument(doc) {
   logFlags.dom && console.group('upgradeDocument: ', (doc.baseURI).split('/').pop());
   addedNode(doc);
   logFlags.dom && console.groupEnd();
 }
 
+/*
+This method is intended to be called when the document tree (including imports)
+has pending custom elements to upgrade. It can be called multiple times and 
+should do nothing if no elements are in need of upgrade.
+
+Note that the import tree can consume itself and therefore special care
+must be taken to avoid recursion.
+*/
+var upgradedDocuments;
 function upgradeDocumentTree(doc) {
+  upgradedDocuments = [];
+  _upgradeDocumentTree(doc);
+  upgradedDocuments = null;
+}
+
+
+function _upgradeDocumentTree(doc) {
   doc = wrapIfNeeded(doc);
+  if (upgradedDocuments.indexOf(doc) >= 0) {
+    return;
+  }
+  upgradedDocuments.push(doc);
   //console.log('upgradeDocumentTree: ', (doc.baseURI).split('/').pop());
   // upgrade contained imported documents
   var imports = doc.querySelectorAll('link[rel=' + IMPORT_LINK_TYPE + ']');
   for (var i=0, l=imports.length, n; (i<l) && (n=imports[i]); i++) {
     if (n.import && n.import.__parsed) {
-      upgradeDocumentTree(n.import);
+      _upgradeDocumentTree(n.import);
     }
   }
   upgradeDocument(doc);
 }
 
 // exports
 scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;
 scope.watchShadow = watchShadow;
 scope.upgradeDocumentTree = upgradeDocumentTree;
 scope.upgradeAll = addedNode;
@@ skipping 662 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) {
 
-  // TODO(sorvell): It's desireable to provide a default stylesheet 
+  'use strict';
+
+  // polyfill performance.now
+
+  if (!window.performance) {
+    var start = Date.now();
+    // only at millisecond precision
+    window.performance = {now: function(){ return Date.now() - start }};
+  }
+
+  // polyfill for requestAnimationFrame
+
+  if (!window.requestAnimationFrame) {
+    window.requestAnimationFrame = (function() {
+      var nativeRaf = window.webkitRequestAnimationFrame ||
+        window.mozRequestAnimationFrame;
+
+      return nativeRaf ?
+        function(callback) {
+          return nativeRaf(function() {
+            callback(performance.now());
+          });
+        } :
+        function( callback ){
+          return window.setTimeout(callback, 1000 / 60);
+        };
+    })();
+  }
+
+  if (!window.cancelAnimationFrame) {
+    window.cancelAnimationFrame = (function() {
+      return  window.webkitCancelAnimationFrame ||
+        window.mozCancelAnimationFrame ||
+        function(id) {
+          clearTimeout(id);
+        };
+    })();
+  }
+
+  // Make a stub for Polymer() for polyfill purposes; under the HTMLImports
+  // polyfill, scripts in the main document run before imports. That means
+  // if (1) polymer is imported and (2) Polymer() is called in the main document
+  // in a script after the import, 2 occurs before 1. We correct this here
+  // by specfiically patching Polymer(); this is not necessary under native
+  // HTMLImports.
+  var elementDeclarations = [];
+
+  var polymerStub = function(name, dictionary) {
+    if ((typeof name !== 'string') && (arguments.length === 1)) {
+      Array.prototype.push.call(arguments, document._currentScript);
+    }
+    elementDeclarations.push(arguments);
+  };
+  window.Polymer = polymerStub;
+
+  // deliver queued delcarations
+  scope.consumeDeclarations = function(callback) {
+    scope.consumeDeclarations = function() {
+     throw 'Possible attempt to load Polymer twice';
+    };
+    if (callback) {
+      callback(elementDeclarations);
+    }
+    elementDeclarations = null;
+  };
+
+  function installPolymerWarning() {
+    if (window.Polymer === polymerStub) {
+      window.Polymer = function() {
+        throw new Error('You tried to use polymer without loading it first. To ' +
+          'load polymer, <link rel="import" href="' + 
+          'components/polymer/polymer.html">');
+      };
+    }
+  }
+
+  // Once DOMContent has loaded, any main document scripts that depend on
+  // Polymer() should have run. Calling Polymer() now is an error until
+  // polymer is imported.
+  if (HTMLImports.useNative) {
+    installPolymerWarning();
+  } else {
+    addEventListener('DOMContentLoaded', installPolymerWarning);
+  }
+
+})(window.Platform);
+
+/*
+ * 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) {
+
+  // It's desireable to provide a default stylesheet 
   // that's convenient for styling unresolved elements, but
   // it's cumbersome to have to include this manually in every page.
   // It would make sense to put inside some HTMLImport but 
   // the HTMLImports polyfill does not allow loading of stylesheets 
   // that block rendering. Therefore this injection is tolerated here.
-
+  //
+  // NOTE: position: relative fixes IE's failure to inherit opacity 
+  // when a child is not statically positioned.
   var style = document.createElement('style');
   style.textContent = ''
       + 'body {'
       + 'transition: opacity ease-in 0.2s;' 
       + ' } \n'
       + 'body[unresolved] {'
-      + 'opacity: 0; display: block; overflow: hidden;' 
+      + 'opacity: 0; display: block; overflow: hidden; position: relative;' 
       + ' } \n'
       ;
   var head = document.querySelector('head');
   head.insertBefore(style, head.firstChild);
 
 })(Platform);
 
 /*
  * 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
@@ skipping 48 matching lines @@
   // exports
 
   scope.marshal = marshal;
   // `module` confuses commonjs detectors
   scope.modularize = module;
   scope.using = using;
 
 })(window);
 
 //# sourceMappingURL=platform.concat.js.map