update polymer to 0.3.5

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 77 matching lines @@
           entry[1] = value;
         else
           defineProperty(key, this.name, {value: [key, value], writable: true});
       },
       get: function(key) {
         var entry;
         return (entry = key[this.name]) && entry[0] === key ?
             entry[1] : undefined;
       },
       delete: function(key) {
-        this.set(key, undefined);
+        var entry = key[this.name];
+        if (!entry) return false;
+        var hasValue = entry[0] === key;
+        entry[0] = entry[1] = undefined;
+        return hasValue;
+      },
+      has: function(key) {
+        var entry = key[this.name];
+        if (!entry) return false;
+        return entry[0] === key;
       }
     };
 
     window.WeakMap = WeakMap;
   })();
 }
 
 // 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.
 
 (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') {
       return false;
     }
 
     var records = [];
 
     function callback(recs) {
@@ skipping 30 matching lines @@
 
   var hasObserve = detectObjectObserve();
 
   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) {
+      return false;
+    }
+
     try {
       var f = new Function('', 'return true;');
       return f();
     } catch (ex) {
       return false;
     }
   }
 
   var hasEval = detectEval();
 
@@ skipping 354 matching lines @@
   invalidPath.valid = false;
   invalidPath.getValueFrom = invalidPath.setValueFrom = function() {};
 
   var MAX_DIRTY_CHECK_CYCLES = 1000;
 
   function dirtyCheck(observer) {
     var cycles = 0;
     while (cycles < MAX_DIRTY_CHECK_CYCLES && observer.check_()) {
       cycles++;
     }
-    if (global.testingExposeCycleCount)
+    if (testingExposeCycleCount)
       global.dirtyCheckCycleCount = cycles;
 
     return cycles > 0;
   }
 
   function objectIsEmpty(object) {
     for (var prop in object)
       return false;
     return true;
   }
@@ skipping 378 matching lines @@
 
         if (observer.check_())
           anyChanged = true;
 
         allObservers.push(observer);
       }
       if (runEOMTasks())
         anyChanged = true;
     } while (cycles < MAX_DIRTY_CHECK_CYCLES && anyChanged);
 
-    if (global.testingExposeCycleCount)
+    if (testingExposeCycleCount)
       global.dirtyCheckCycleCount = cycles;
 
     runningMicrotaskCheckpoint = false;
   };
 
   if (collectObservers) {
     global.Platform.clearObservers = function() {
       allObservers = [];
     };
   }
@@ skipping 881 matching lines @@
   var nativePrototypeTable = new WeakMap();
   var wrappers = Object.create(null);
 
   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) {
+      return false;
+    }
+
     try {
       var f = new Function('return true;');
       return f();
     } catch (ex) {
       return false;
     }
   }
 
   var hasEval = detectEval();
 
@@ skipping 91 matching lines @@
   };
 
   function isEventHandlerName(name) {
     return /^on[a-z]+$/.test(name);
   }
 
   function isIdentifierName(name) {
     return /^\w[a-zA-Z_0-9]*$/.test(name);
   }
 
+  // The name of the implementation property is intentionally hard to
+  // remember. Unfortunately, browsers are slower doing obj[expr] than
+  // obj.foo so we resort to repeat this ugly name. This ugly name is never
+  // used outside of this file though.
+
   function getGetter(name) {
     return hasEval && isIdentifierName(name) ?
-        new Function('return this.impl.' + name) :
-        function() { return this.impl[name]; };
+        new Function('return this.__impl4cf1e782hg__.' + name) :
+        function() { return this.__impl4cf1e782hg__[name]; };
   }
 
   function getSetter(name) {
     return hasEval && isIdentifierName(name) ?
-        new Function('v', 'this.impl.' + name + ' = v') :
-        function(v) { this.impl[name] = v; };
+        new Function('v', 'this.__impl4cf1e782hg__.' + name + ' = v') :
+        function(v) { this.__impl4cf1e782hg__[name] = v; };
   }
 
   function getMethod(name) {
     return hasEval && isIdentifierName(name) ?
-        new Function('return this.impl.' + name +
-                     '.apply(this.impl, arguments)') :
-        function() { return this.impl[name].apply(this.impl, arguments); };
+        new Function('return this.__impl4cf1e782hg__.' + name +
+                     '.apply(this.__impl4cf1e782hg__, arguments)') :
+        function() {
+          return this.__impl4cf1e782hg__[name].apply(
+              this.__impl4cf1e782hg__, arguments);
+        };
   }
 
   function getDescriptor(source, name) {
     try {
       return Object.getOwnPropertyDescriptor(source, name);
     } catch (ex) {
       // JSC and V8 both use data properties instead of accessors which can
       // cause getting the property desciptor to throw an exception.
       // https://bugs.webkit.org/show_bug.cgi?id=49739
       return dummyDescriptor;
@@ skipping 100 matching lines @@
     function GeneratedWrapper(node) {
       superWrapperConstructor.call(this, node);
     }
     var p = Object.create(superWrapperConstructor.prototype);
     p.constructor = GeneratedWrapper;
     GeneratedWrapper.prototype = p;
 
     return GeneratedWrapper;
   }
 
-  var OriginalDOMImplementation = window.DOMImplementation;
-  var OriginalEventTarget = window.EventTarget;
-  var OriginalEvent = window.Event;
-  var OriginalNode = window.Node;
-  var OriginalWindow = window.Window;
-  var OriginalRange = window.Range;
-  var OriginalCanvasRenderingContext2D = window.CanvasRenderingContext2D;
-  var OriginalWebGLRenderingContext = window.WebGLRenderingContext;
-  var OriginalSVGElementInstance = window.SVGElementInstance;
-
   function isWrapper(object) {
-    return object instanceof wrappers.EventTarget ||
-           object instanceof wrappers.Event ||
-           object instanceof wrappers.Range ||
-           object instanceof wrappers.DOMImplementation ||
-           object instanceof wrappers.CanvasRenderingContext2D ||
-           wrappers.WebGLRenderingContext &&
-               object instanceof wrappers.WebGLRenderingContext;
+    return object && object.__impl4cf1e782hg__;
   }
 
   function isNative(object) {
-    return OriginalEventTarget && object instanceof OriginalEventTarget ||
-           object instanceof OriginalNode ||
-           object instanceof OriginalEvent ||
-           object instanceof OriginalWindow ||
-           object instanceof OriginalRange ||
-           object instanceof OriginalDOMImplementation ||
-           object instanceof OriginalCanvasRenderingContext2D ||
-           OriginalWebGLRenderingContext &&
-               object instanceof OriginalWebGLRenderingContext ||
-           OriginalSVGElementInstance &&
-               object instanceof OriginalSVGElementInstance;
+    return !isWrapper(object);
   }
 
   /**
    * Wraps a node in a WrapperNode. If there already exists a wrapper for the
    * |node| that wrapper is returned instead.
    * @param {Node} node
    * @return {WrapperNode}
    */
   function wrap(impl) {
     if (impl === null)
       return null;
 
     assert(isNative(impl));
-    return impl.polymerWrapper_ ||
-        (impl.polymerWrapper_ = new (getWrapperConstructor(impl))(impl));
+    return impl.__wrapper8e3dd93a60__ ||
+        (impl.__wrapper8e3dd93a60__ = new (getWrapperConstructor(impl))(impl));
   }
 
   /**
    * Unwraps a wrapper and returns the node it is wrapping.
    * @param {WrapperNode} wrapper
    * @return {Node}
    */
   function unwrap(wrapper) {
     if (wrapper === null)
       return null;
     assert(isWrapper(wrapper));
-    return wrapper.impl;
+    return wrapper.__impl4cf1e782hg__;
+  }
+
+  function unsafeUnwrap(wrapper) {
+    return wrapper.__impl4cf1e782hg__;
+  }
+
+  function setWrapper(impl, wrapper) {
+    wrapper.__impl4cf1e782hg__ = impl;
+    impl.__wrapper8e3dd93a60__ = wrapper;
   }
 
   /**
    * Unwraps object if it is a wrapper.
    * @param {Object} object
    * @return {Object} The native implementation object.
    */
   function unwrapIfNeeded(object) {
     return object && isWrapper(object) ? unwrap(object) : object;
   }
@@ skipping 11 matching lines @@
    * Overrides the current wrapper (if any) for node.
    * @param {Node} node
    * @param {WrapperNode=} wrapper If left out the wrapper will be created as
    *     needed next time someone wraps the node.
    */
   function rewrap(node, wrapper) {
     if (wrapper === null)
       return;
     assert(isNative(node));
     assert(wrapper === undefined || isWrapper(wrapper));
-    node.polymerWrapper_ = wrapper;
+    node.__wrapper8e3dd93a60__ = wrapper;
   }
 
   var getterDescriptor = {
     get: undefined,
     configurable: true,
     enumerable: true
   };
 
   function defineGetter(constructor, name, getter) {
     getterDescriptor.get = getter;
     defineProperty(constructor.prototype, name, getterDescriptor);
   }
 
   function defineWrapGetter(constructor, name) {
     defineGetter(constructor, name, function() {
-      return wrap(this.impl[name]);
+      return wrap(this.__impl4cf1e782hg__[name]);
     });
   }
 
   /**
    * Forwards existing methods on the native object to the wrapper methods.
    * This does not wrap any of the arguments or the return value since the
    * wrapper implementation already takes care of that.
    * @param {Array.<Function>} constructors
    * @parem {Array.<string>} names
    */
@@ skipping 14 matching lines @@
   scope.defineWrapGetter = defineWrapGetter;
   scope.forwardMethodsToWrapper = forwardMethodsToWrapper;
   scope.isWrapper = isWrapper;
   scope.isWrapperFor = isWrapperFor;
   scope.mixin = mixin;
   scope.nativePrototypeTable = nativePrototypeTable;
   scope.oneOf = oneOf;
   scope.registerObject = registerObject;
   scope.registerWrapper = register;
   scope.rewrap = rewrap;
+  scope.setWrapper = setWrapper;
+  scope.unsafeUnwrap = unsafeUnwrap;
   scope.unwrap = unwrap;
   scope.unwrapIfNeeded = unwrapIfNeeded;
   scope.wrap = wrap;
   scope.wrapIfNeeded = wrapIfNeeded;
   scope.wrappers = wrappers;
 
 })(window.ShadowDOMPolyfill);
 
 /*
  * Copyright 2013 The Polymer Authors. All rights reserved.
@@ skipping 295 matching lines @@
     this.callback_ = callback;
     this.nodes_ = [];
     this.records_ = [];
     this.uid_ = ++uidCounter;
 
     // This will leak. There is no way to implement this without WeakRefs :'(
     globalMutationObservers.push(this);
   }
 
   MutationObserver.prototype = {
+    constructor: MutationObserver,
+
     // http://dom.spec.whatwg.org/#dom-mutationobserver-observe
     observe: function(target, options) {
       target = wrapIfNeeded(target);
 
       var newOptions = new MutationObserverOptions(options);
 
       // 6.
       var registration;
       var registrations = registrationsTable.get(target);
       if (!registrations)
@@ skipping 189 matching lines @@
 // 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 forwardMethodsToWrapper = scope.forwardMethodsToWrapper;
   var getTreeScope = scope.getTreeScope;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
+  var setWrapper = scope.setWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var unwrap = scope.unwrap;
   var wrap = scope.wrap;
   var wrappers = scope.wrappers;
 
   var wrappedFuns = new WeakMap();
   var listenersTable = new WeakMap();
   var handledEventsTable = new WeakMap();
   var currentlyDispatchingEvents = new WeakMap();
   var targetTable = new WeakMap();
   var currentTargetTable = new WeakMap();
@@ skipping 434 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')
+      if (!OriginalBeforeUnloadEvent && impl.type === 'beforeunload') {
         return new BeforeUnloadEvent(impl);
-      this.impl = impl;
+      }
+      setWrapper(impl, this);
     } else {
       return wrap(constructEvent(OriginalEvent, 'Event', type, options));
     }
   }
   Event.prototype = {
     get target() {
       return targetTable.get(this);
     },
     get currentTarget() {
       return currentTargetTable.get(this);
@@ skipping 23 matching lines @@
       return options;
     return Object.create(options, {
       relatedTarget: {value: unwrap(options.relatedTarget)}
     });
   }
 
   function registerGenericEvent(name, SuperEvent, prototype) {
     var OriginalEvent = window[name];
     var GenericEvent = function(type, options) {
       if (type instanceof OriginalEvent)
-        this.impl = type;
+        setWrapper(type, this);
       else
         return wrap(constructEvent(OriginalEvent, name, type, options));
     };
     GenericEvent.prototype = Object.create(SuperEvent.prototype);
     if (prototype)
       mixin(GenericEvent.prototype, prototype);
     if (OriginalEvent) {
       // - Old versions of Safari fails on new FocusEvent (and others?).
       // - IE does not support event constructors.
       // - createEvent('FocusEvent') throws in Firefox.
@@ skipping 110 matching lines @@
   // Safari 7 does not yet have BeforeUnloadEvent.
   // https://bugs.webkit.org/show_bug.cgi?id=120849
   var OriginalBeforeUnloadEvent = window.BeforeUnloadEvent;
 
   function BeforeUnloadEvent(impl) {
     Event.call(this, impl);
   }
   BeforeUnloadEvent.prototype = Object.create(Event.prototype);
   mixin(BeforeUnloadEvent.prototype, {
     get returnValue() {
-      return this.impl.returnValue;
+      return unsafeUnwrap(this).returnValue;
     },
     set returnValue(v) {
-      this.impl.returnValue = v;
+      unsafeUnwrap(this).returnValue = v;
     }
   });
 
   if (OriginalBeforeUnloadEvent)
     registerWrapper(OriginalBeforeUnloadEvent, BeforeUnloadEvent);
 
   function isValidListener(fun) {
     if (typeof fun === 'function')
       return true;
     return fun && fun.handleEvent;
@@ skipping 16 matching lines @@
   }
 
   var OriginalEventTarget = window.EventTarget;
 
   /**
    * This represents a wrapper for an EventTarget.
    * @param {!EventTarget} impl The original event target.
    * @constructor
    */
   function EventTarget(impl) {
-    this.impl = impl;
+    setWrapper(impl, this);
   }
 
   // Node and Window have different internal type checks in WebKit so we cannot
   // use the same method as the original function.
   var methodNames = [
     'addEventListener',
     'removeEventListener',
     'dispatchEvent'
   ];
 
@@ skipping 117 matching lines @@
 
   function wrapEventTargetMethods(constructors) {
     forwardMethodsToWrapper(constructors, methodNames);
   }
 
   var originalElementFromPoint = document.elementFromPoint;
 
   function elementFromPoint(self, document, x, y) {
     scope.renderAllPending();
 
-    var element = wrap(originalElementFromPoint.call(document.impl, x, y));
+    var element =
+        wrap(originalElementFromPoint.call(unsafeUnwrap(document), x, y));
     if (!element)
       return null;
     var path = getEventPath(element, null);
 
     // scope the path to this TreeScope
     var idx = path.lastIndexOf(self);
     if (idx == -1)
       return null;
     else
       path = path.slice(0, idx);
@@ skipping 72 matching lines @@
  * 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 UIEvent = scope.wrappers.UIEvent;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
-  var unwrap = scope.unwrap;
+  var setWrapper = scope.setWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var wrap = scope.wrap;
 
   // TouchEvent is WebKit/Blink only.
   var OriginalTouchEvent = window.TouchEvent;
   if (!OriginalTouchEvent)
     return;
 
   var nativeEvent;
   try {
     nativeEvent = document.createEvent('TouchEvent');
   } catch (ex) {
     // In Chrome creating a TouchEvent fails if the feature is not turned on
     // which it isn't on desktop Chrome.
     return;
   }
 
   var nonEnumDescriptor = {enumerable: false};
 
   function nonEnum(obj, prop) {
     Object.defineProperty(obj, prop, nonEnumDescriptor);
   }
 
   function Touch(impl) {
-    this.impl = impl;
+    setWrapper(impl, this);
   }
 
   Touch.prototype = {
     get target() {
-      return wrap(this.impl.target);
+      return wrap(unsafeUnwrap(this).target);
     }
   };
 
   var descr = {
     configurable: true,
     enumerable: true,
     get: null
   };
 
   [
     'clientX',
     'clientY',
     'screenX',
     'screenY',
     'pageX',
     'pageY',
     'identifier',
     'webkitRadiusX',
     'webkitRadiusY',
     'webkitRotationAngle',
     'webkitForce'
   ].forEach(function(name) {
     descr.get = function() {
-      return this.impl[name];
+      return unsafeUnwrap(this)[name];
     };
     Object.defineProperty(Touch.prototype, name, descr);
   });
 
   function TouchList() {
     this.length = 0;
     nonEnum(this, 'length');
   }
 
   TouchList.prototype = {
@@ skipping 12 matching lines @@
   }
 
   function TouchEvent(impl) {
     UIEvent.call(this, impl);
   }
 
   TouchEvent.prototype = Object.create(UIEvent.prototype);
 
   mixin(TouchEvent.prototype, {
     get touches() {
-      return wrapTouchList(unwrap(this).touches);
+      return wrapTouchList(unsafeUnwrap(this).touches);
     },
 
     get targetTouches() {
-      return wrapTouchList(unwrap(this).targetTouches);
+      return wrapTouchList(unsafeUnwrap(this).targetTouches);
     },
 
     get changedTouches() {
-      return wrapTouchList(unwrap(this).changedTouches);
+      return wrapTouchList(unsafeUnwrap(this).changedTouches);
     },
 
     initTouchEvent: function() {
       // The only way to use this is to reuse the TouchList from an existing
       // TouchEvent. Since this is WebKit/Blink proprietary API we will not
       // implement this until someone screams.
       throw new Error('Not implemented');
     }
   });
 
   registerWrapper(OriginalTouchEvent, TouchEvent, nativeEvent);
 
   scope.wrappers.Touch = Touch;
   scope.wrappers.TouchEvent = TouchEvent;
   scope.wrappers.TouchList = TouchList;
 
 })(window.ShadowDOMPolyfill);
 
 
 // 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(scope) {
   'use strict';
 
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var wrap = scope.wrap;
 
   var nonEnumDescriptor = {enumerable: false};
 
   function nonEnum(obj, prop) {
     Object.defineProperty(obj, prop, nonEnumDescriptor);
   }
 
   function NodeList() {
     this.length = 0;
@@ skipping 12 matching lines @@
     var wrapperList = new NodeList();
     for (var i = 0, length = list.length; i < length; i++) {
       wrapperList[i] = wrap(list[i]);
     }
     wrapperList.length = length;
     return wrapperList;
   }
 
   function addWrapNodeListMethod(wrapperConstructor, name) {
     wrapperConstructor.prototype[name] = function() {
-      return wrapNodeList(this.impl[name].apply(this.impl, arguments));
+      return wrapNodeList(
+          unsafeUnwrap(this)[name].apply(unsafeUnwrap(this), arguments));
     };
   }
 
   scope.wrappers.NodeList = NodeList;
   scope.addWrapNodeListMethod = addWrapNodeListMethod;
   scope.wrapNodeList = wrapNodeList;
 
 })(window.ShadowDOMPolyfill);
 
 /*
@@ skipping 26 matching lines @@
   var TreeScope = scope.TreeScope;
   var assert = scope.assert;
   var defineWrapGetter = scope.defineWrapGetter;
   var enqueueMutation = scope.enqueueMutation;
   var getTreeScope = scope.getTreeScope;
   var isWrapper = scope.isWrapper;
   var mixin = scope.mixin;
   var registerTransientObservers = scope.registerTransientObservers;
   var registerWrapper = scope.registerWrapper;
   var setTreeScope = scope.setTreeScope;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var unwrap = scope.unwrap;
   var unwrapIfNeeded = scope.unwrapIfNeeded;
   var wrap = scope.wrap;
   var wrapIfNeeded = scope.wrapIfNeeded;
   var wrappers = scope.wrappers;
 
   function assertIsNodeWrapper(node) {
     assert(node instanceof Node);
   }
 
@@ skipping 213 matching lines @@
       n.parentNode.removeChild(n);
     }
   }
 
   var originalImportNode = document.importNode;
   var originalCloneNode = window.Node.prototype.cloneNode;
 
   function cloneNode(node, deep, opt_doc) {
     var clone;
     if (opt_doc)
-      clone = wrap(originalImportNode.call(opt_doc, node.impl, false));
+      clone = wrap(originalImportNode.call(opt_doc, unsafeUnwrap(node), false));
     else
-      clone = wrap(originalCloneNode.call(node.impl, false));
+      clone = wrap(originalCloneNode.call(unsafeUnwrap(node), false));
 
     if (deep) {
       for (var child = node.firstChild; child; child = child.nextSibling) {
         clone.appendChild(cloneNode(child, true, opt_doc));
       }
 
       if (node instanceof wrappers.HTMLTemplateElement) {
         var cloneContent = clone.content;
         for (var child = node.content.firstChild;
              child;
@@ skipping 122 matching lines @@
                       !invalidateParent(childWrapper);
 
       if (useNative)
         nodes = collectNodesNative(childWrapper);
       else
         nodes = collectNodes(childWrapper, this, previousNode, refWrapper);
 
       if (useNative) {
         ensureSameOwnerDocument(this, childWrapper);
         clearChildNodes(this);
-        originalInsertBefore.call(this.impl, unwrap(childWrapper), refNode);
+        originalInsertBefore.call(unsafeUnwrap(this), unwrap(childWrapper), refNode);
       } else {
         if (!previousNode)
           this.firstChild_ = nodes[0];
         if (!refWrapper) {
           this.lastChild_ = nodes[nodes.length - 1];
           if (this.firstChild_ === undefined)
             this.firstChild_ = this.firstChild;
         }
 
-        var parentNode = refNode ? refNode.parentNode : this.impl;
+        var parentNode = refNode ? refNode.parentNode : unsafeUnwrap(this);
 
         // insertBefore refWrapper no matter what the parent is?
         if (parentNode) {
           originalInsertBefore.call(parentNode,
               unwrapNodesForInsertion(this, nodes), refNode);
         } else {
           adoptNodesIfNeeded(this, nodes);
         }
       }
 
@@ skipping 50 matching lines @@
           childWrapperPreviousSibling.nextSibling_ = childWrapperNextSibling;
         if (childWrapperNextSibling) {
           childWrapperNextSibling.previousSibling_ =
               childWrapperPreviousSibling;
         }
 
         childWrapper.previousSibling_ = childWrapper.nextSibling_ =
             childWrapper.parentNode_ = undefined;
       } else {
         clearChildNodes(this);
-        removeChildOriginalHelper(this.impl, childNode);
+        removeChildOriginalHelper(unsafeUnwrap(this), childNode);
       }
 
       if (!surpressMutations) {
         enqueueMutation(this, 'childList', {
           removedNodes: createOneElementNodeList(childWrapper),
           nextSibling: childWrapperNextSibling,
           previousSibling: childWrapperPreviousSibling
         });
       }
 
@@ skipping 45 matching lines @@
         // replaceChild no matter what the parent is?
         if (oldChildNode.parentNode) {
           originalReplaceChild.call(
               oldChildNode.parentNode,
               unwrapNodesForInsertion(this, nodes),
               oldChildNode);
         }
       } else {
         ensureSameOwnerDocument(this, newChildWrapper);
         clearChildNodes(this);
-        originalReplaceChild.call(this.impl, unwrap(newChildWrapper),
+        originalReplaceChild.call(unsafeUnwrap(this), unwrap(newChildWrapper),
                                   oldChildNode);
       }
 
       enqueueMutation(this, 'childList', {
         addedNodes: nodes,
         removedNodes: createOneElementNodeList(oldChildWrapper),
         nextSibling: nextNode,
         previousSibling: previousNode
       });
 
@@ skipping 15 matching lines @@
     },
 
     hasChildNodes: function() {
       return this.firstChild !== null;
     },
 
     /** @type {Node} */
     get parentNode() {
       // If the parentNode has not been overridden, use the original parentNode.
       return this.parentNode_ !== undefined ?
-          this.parentNode_ : wrap(this.impl.parentNode);
+          this.parentNode_ : wrap(unsafeUnwrap(this).parentNode);
     },
 
     /** @type {Node} */
     get firstChild() {
       return this.firstChild_ !== undefined ?
-          this.firstChild_ : wrap(this.impl.firstChild);
+          this.firstChild_ : wrap(unsafeUnwrap(this).firstChild);
     },
 
     /** @type {Node} */
     get lastChild() {
       return this.lastChild_ !== undefined ?
-          this.lastChild_ : wrap(this.impl.lastChild);
+          this.lastChild_ : wrap(unsafeUnwrap(this).lastChild);
     },
 
     /** @type {Node} */
     get nextSibling() {
       return this.nextSibling_ !== undefined ?
-          this.nextSibling_ : wrap(this.impl.nextSibling);
+          this.nextSibling_ : wrap(unsafeUnwrap(this).nextSibling);
     },
 
     /** @type {Node} */
     get previousSibling() {
       return this.previousSibling_ !== undefined ?
-          this.previousSibling_ : wrap(this.impl.previousSibling);
+          this.previousSibling_ : wrap(unsafeUnwrap(this).previousSibling);
     },
 
     get parentElement() {
       var p = this.parentNode;
       while (p && p.nodeType !== Node.ELEMENT_NODE) {
         p = p.parentNode;
       }
       return p;
     },
 
     get textContent() {
-      // TODO(arv): This should fallback to this.impl.textContent if there
+      // TODO(arv): This should fallback to unsafeUnwrap(this).textContent if there
       // 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) {
       var removedNodes = snapshotNodeList(this.childNodes);
 
       if (this.invalidateShadowRenderer()) {
         removeAllChildNodes(this);
         if (textContent !== '') {
-          var textNode = this.impl.ownerDocument.createTextNode(textContent);
+          var textNode = unsafeUnwrap(this).ownerDocument.createTextNode(textContent);
           this.appendChild(textNode);
         }
       } else {
         clearChildNodes(this);
-        this.impl.textContent = textContent;
+        unsafeUnwrap(this).textContent = textContent;
       }
 
       var addedNodes = snapshotNodeList(this.childNodes);
 
       enqueueMutation(this, 'childList', {
         addedNodes: addedNodes,
         removedNodes: removedNodes
       });
 
       nodesWereRemoved(removedNodes);
@@ skipping 14 matching lines @@
       return cloneNode(this, deep);
     },
 
     contains: function(child) {
       return contains(this, wrapIfNeeded(child));
     },
 
     compareDocumentPosition: function(otherNode) {
       // This only wraps, it therefore only operates on the composed DOM and not
       // the logical DOM.
-      return originalCompareDocumentPosition.call(this.impl,
+      return originalCompareDocumentPosition.call(unsafeUnwrap(this),
                                                   unwrapIfNeeded(otherNode));
     },
 
     normalize: function() {
       var nodes = snapshotNodeList(this.childNodes);
       var remNodes = [];
       var s = '';
       var modNode;
 
       for (var i = 0, n; i < nodes.length; i++) {
@@ skipping 50 matching lines @@
 
 // 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) {
   'use strict';
 
   var HTMLCollection = scope.wrappers.HTMLCollection;
   var NodeList = scope.wrappers.NodeList;
+  var getTreeScope = scope.getTreeScope;
+  var unsafeUnwrap = scope.unsafeUnwrap;
+  var wrap = scope.wrap;
+
+  var originalDocumentQuerySelector = document.querySelector;
+  var originalElementQuerySelector = document.documentElement.querySelector;
+
+  var originalDocumentQuerySelectorAll = document.querySelectorAll;
+  var originalElementQuerySelectorAll = document.documentElement.querySelectorAll;
+
+  var originalDocumentGetElementsByTagName = document.getElementsByTagName;
+  var originalElementGetElementsByTagName = document.documentElement.getElementsByTagName;
+
+  var originalDocumentGetElementsByTagNameNS = document.getElementsByTagNameNS;
+  var originalElementGetElementsByTagNameNS = document.documentElement.getElementsByTagNameNS;
+
+  var OriginalElement = window.Element;
+  var OriginalDocument = window.HTMLDocument || window.Document;
+
+  function filterNodeList(list, index, result, deep) {
+    var wrappedItem = null;
+    var root = null;
+    for (var i = 0, length = list.length; i < length; i++) {
+      wrappedItem = wrap(list[i]);
+      if (!deep && (root = getTreeScope(wrappedItem).root)) {
+        if (root instanceof scope.wrappers.ShadowRoot) {
+          continue;
+        }
+      }
+      result[index++] = wrappedItem;
+    }
+
+    return index;
+  }
+
+  function shimSelector(selector) {
+    return String(selector).replace(/\/deep\//g, ' ');
+  }
 
   function findOne(node, selector) {
     var m, el = node.firstElementChild;
     while (el) {
       if (el.matches(selector))
         return el;
       m = findOne(el, selector);
       if (m)
         return m;
       el = el.nextElementSibling;
@@ skipping 10 matching lines @@
   function matchesTagName(el, localName, localNameLowerCase) {
     var ln = el.localName;
     return ln === localName ||
         ln === localNameLowerCase && el.namespaceURI === XHTML_NS;
   }
 
   function matchesEveryThing() {
     return true;
   }
 
-  function matchesLocalName(el, localName) {
+  function matchesLocalNameOnly(el, ns, localName) {
     return el.localName === localName;
   }
 
   function matchesNameSpace(el, ns) {
     return el.namespaceURI === ns;
   }
 
   function matchesLocalNameNS(el, ns, localName) {
     return el.namespaceURI === ns && el.localName === localName;
   }
 
-  function findElements(node, result, p, arg0, arg1) {
+  function findElements(node, index, result, p, arg0, arg1) {
     var el = node.firstElementChild;
     while (el) {
       if (p(el, arg0, arg1))
-        result[result.length++] = el;
-      findElements(el, result, p, arg0, arg1);
+        result[index++] = el;
+      index = findElements(el, index, result, p, arg0, arg1);
       el = el.nextElementSibling;
     }
-    return result;
+    return index;
   }
 
   // find and findAll will only match Simple Selectors,
   // Structural Pseudo Classes are not guarenteed to be correct
   // http://www.w3.org/TR/css3-selectors/#simple-selectors
 
+  function querySelectorAllFiltered(p, index, result, selector, deep) {
+    var target = unsafeUnwrap(this);
+    var list;
+    var root = getTreeScope(this).root;
+    if (root instanceof scope.wrappers.ShadowRoot) {
+      // We are in the shadow tree and the logical tree is
+      // going to be disconnected so we do a manual tree traversal
+      return findElements(this, index, result, p, selector, null);
+    } else if (target instanceof OriginalElement) {
+      list = originalElementQuerySelectorAll.call(target, selector);
+    } else if (target instanceof OriginalDocument) {
+      list = originalDocumentQuerySelectorAll.call(target, selector);
+    } else {
+      // When we get a ShadowRoot the logical tree is going to be disconnected
+      // so we do a manual tree traversal
+      return findElements(this, index, result, p, selector, null);
+    }
+
+    return filterNodeList(list, index, result, deep);
+  }
+
   var SelectorsInterface = {
     querySelector: function(selector) {
-      return findOne(this, selector);
+      var shimmed = shimSelector(selector);
+      var deep = shimmed !== selector;
+      selector = shimmed;
+
+      var target = unsafeUnwrap(this);
+      var wrappedItem;
+      var root = getTreeScope(this).root;
+      if (root instanceof scope.wrappers.ShadowRoot) {
+        // We are in the shadow tree and the logical tree is
+        // going to be disconnected so we do a manual tree traversal
+        return findOne(this, selector);
+      } else if (target instanceof OriginalElement) {
+        wrappedItem = wrap(originalElementQuerySelector.call(target, selector));
+      } else if (target instanceof OriginalDocument) {
+        wrappedItem = wrap(originalDocumentQuerySelector.call(target, selector));
+      } else {
+        // When we get a ShadowRoot the logical tree is going to be disconnected
+        // so we do a manual tree traversal
+        return findOne(this, selector);
+      }
+
+      if (!wrappedItem) {
+        // When the original query returns nothing
+        // we return nothing (to be consistent with the other wrapped calls)
+        return wrappedItem;
+      } else if (!deep && (root = getTreeScope(wrappedItem).root)) {
+        if (root instanceof scope.wrappers.ShadowRoot) {
+          // When the original query returns an element in the ShadowDOM
+          // we must do a manual tree traversal
+          return findOne(this, selector);
+        }
+      }
+
+      return wrappedItem;
     },
     querySelectorAll: function(selector) {
-      return findElements(this, new NodeList(), matchesSelector, selector);
+      var shimmed = shimSelector(selector);
+      var deep = shimmed !== selector;
+      selector = shimmed;
+
+      var result = new NodeList();
+
+      result.length = querySelectorAllFiltered.call(this,
+          matchesSelector,
+          0,
+          result,
+          selector,
+          deep);
+
+      return result;
     }
   };
 
+  function getElementsByTagNameFiltered(p, index, result, localName,
+                                        lowercase) {
+    var target = unsafeUnwrap(this);
+    var list;
+    var root = getTreeScope(this).root;
+    if (root instanceof scope.wrappers.ShadowRoot) {
+      // We are in the shadow tree and the logical tree is
+      // going to be disconnected so we do a manual tree traversal
+      return findElements(this, index, result, p, localName, lowercase);
+    } else if (target instanceof OriginalElement) {
+      list = originalElementGetElementsByTagName.call(target, localName,
+                                                      lowercase);
+    } else if (target instanceof OriginalDocument) {
+      list = originalDocumentGetElementsByTagName.call(target, localName,
+                                                       lowercase);
+    } else {
+      // When we get a ShadowRoot the logical tree is going to be disconnected
+      // so we do a manual tree traversal
+      return findElements(this, index, result, p, localName, lowercase);
+    }
+
+    return filterNodeList(list, index, result, false);
+  }
+
+  function getElementsByTagNameNSFiltered(p, index, result, ns, localName) {
+    var target = unsafeUnwrap(this);
+    var list;
+    var root = getTreeScope(this).root;
+    if (root instanceof scope.wrappers.ShadowRoot) {
+      // We are in the shadow tree and the logical tree is
+      // going to be disconnected so we do a manual tree traversal
+      return findElements(this, index, result, p, ns, localName);
+    } else if (target instanceof OriginalElement) {
+      list = originalElementGetElementsByTagNameNS.call(target, ns, localName);
+    } else if (target instanceof OriginalDocument) {
+      list = originalDocumentGetElementsByTagNameNS.call(target, ns, localName);
+    } else {
+      // When we get a ShadowRoot the logical tree is going to be disconnected
+      // so we do a manual tree traversal
+      return findElements(this, index, result, p, ns, localName);
+    }
+
+    return filterNodeList(list, index, result, false);
+  }
+
   var GetElementsByInterface = {
     getElementsByTagName: function(localName) {
       var result = new HTMLCollection();
-      if (localName === '*')
-        return findElements(this, result, matchesEveryThing);
+      var match = localName === '*' ? matchesEveryThing : matchesTagName;
 
-      return findElements(this, result,
-          matchesTagName,
+      result.length = getElementsByTagNameFiltered.call(this,
+          match,
+          0,
+          result,
           localName,
           localName.toLowerCase());
+
+      return result;
     },
 
     getElementsByClassName: function(className) {
       // TODO(arv): Check className?
       return this.querySelectorAll('.' + className);
     },
 
     getElementsByTagNameNS: function(ns, localName) {
       var result = new HTMLCollection();
+      var match = null;
 
-      if (ns === '') {
-        ns = null;
-      } else if (ns === '*') {
-        if (localName === '*')
-          return findElements(this, result, matchesEveryThing);
-        return findElements(this, result, matchesLocalName, localName);
+      if (ns === '*') {
+        match = localName === '*' ? matchesEveryThing : matchesLocalNameOnly;
+      } else {
+        match = localName === '*' ? matchesNameSpace : matchesLocalNameNS;
       }
 
-      if (localName === '*')
-        return findElements(this, result, matchesNameSpace, ns);
+      result.length = getElementsByTagNameNSFiltered.call(this,
+          match,
+          0,
+          result,
+          ns || null,
+          localName);
 
-      return findElements(this, result, matchesLocalNameNS, ns, localName);
+      return result;
     }
   };
 
   scope.GetElementsByInterface = GetElementsByInterface;
   scope.SelectorsInterface = SelectorsInterface;
 
 })(window.ShadowDOMPolyfill);
 
 // Copyright 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
@@ skipping 76 matching lines @@
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
 
   var ChildNodeInterface = scope.ChildNodeInterface;
   var Node = scope.wrappers.Node;
   var enqueueMutation = scope.enqueueMutation;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
 
   var OriginalCharacterData = window.CharacterData;
 
   function CharacterData(node) {
     Node.call(this, node);
   }
   CharacterData.prototype = Object.create(Node.prototype);
   mixin(CharacterData.prototype, {
     get textContent() {
       return this.data;
     },
     set textContent(value) {
       this.data = value;
     },
     get data() {
-      return this.impl.data;
+      return unsafeUnwrap(this).data;
     },
     set data(value) {
-      var oldValue = this.impl.data;
+      var oldValue = unsafeUnwrap(this).data;
       enqueueMutation(this, 'characterData', {
         oldValue: oldValue
       });
-      this.impl.data = value;
+      unsafeUnwrap(this).data = value;
     }
   });
 
   mixin(CharacterData.prototype, ChildNodeInterface);
 
   registerWrapper(OriginalCharacterData, CharacterData,
                   document.createTextNode(''));
 
   scope.wrappers.CharacterData = CharacterData;
 })(window.ShadowDOMPolyfill);
@@ skipping 41 matching lines @@
   scope.wrappers.Text = Text;
 })(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 setWrapper = scope.setWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
+
   function invalidateClass(el) {
     scope.invalidateRendererBasedOnAttribute(el, 'class');
   }
 
   function DOMTokenList(impl, ownerElement) {
-    this.impl = impl;
+    setWrapper(impl, this);
     this.ownerElement_ = ownerElement;
   }
 
   DOMTokenList.prototype = {
+    constructor: DOMTokenList,
     get length() {
-      return this.impl.length;
+      return unsafeUnwrap(this).length;
     },
     item: function(index) {
-      return this.impl.item(index);
+      return unsafeUnwrap(this).item(index);
     },
     contains: function(token) {
-      return this.impl.contains(token);
+      return unsafeUnwrap(this).contains(token);
     },
     add: function() {
-      this.impl.add.apply(this.impl, arguments);
+      unsafeUnwrap(this).add.apply(unsafeUnwrap(this), arguments);
       invalidateClass(this.ownerElement_);
     },
     remove: function() {
-      this.impl.remove.apply(this.impl, arguments);
+      unsafeUnwrap(this).remove.apply(unsafeUnwrap(this), arguments);
       invalidateClass(this.ownerElement_);
     },
     toggle: function(token) {
-      var rv = this.impl.toggle.apply(this.impl, arguments);
+      var rv = unsafeUnwrap(this).toggle.apply(unsafeUnwrap(this), arguments);
       invalidateClass(this.ownerElement_);
       return rv;
     },
     toString: function() {
-      return this.impl.toString();
+      return unsafeUnwrap(this).toString();
     }
   };
 
   scope.wrappers.DOMTokenList = DOMTokenList;
 })(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 ChildNodeInterface = scope.ChildNodeInterface;
   var GetElementsByInterface = scope.GetElementsByInterface;
   var Node = scope.wrappers.Node;
   var DOMTokenList = scope.wrappers.DOMTokenList;
   var ParentNodeInterface = scope.ParentNodeInterface;
   var SelectorsInterface = scope.SelectorsInterface;
   var addWrapNodeListMethod = scope.addWrapNodeListMethod;
   var enqueueMutation = scope.enqueueMutation;
   var mixin = scope.mixin;
   var oneOf = scope.oneOf;
   var registerWrapper = scope.registerWrapper;
-  var unwrap = scope.unwrap;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var wrappers = scope.wrappers;
 
   var OriginalElement = window.Element;
 
   var matchesNames = [
     'matches',  // needs to come first.
     'mozMatchesSelector',
     'msMatchesSelector',
     'webkitMatchesSelector',
   ].filter(function(name) {
@@ skipping 28 matching lines @@
 
   var classListTable = new WeakMap();
 
   function Element(node) {
     Node.call(this, node);
   }
   Element.prototype = Object.create(Node.prototype);
   mixin(Element.prototype, {
     createShadowRoot: function() {
       var newShadowRoot = new wrappers.ShadowRoot(this);
-      this.impl.polymerShadowRoot_ = newShadowRoot;
+      unsafeUnwrap(this).polymerShadowRoot_ = newShadowRoot;
 
       var renderer = scope.getRendererForHost(this);
       renderer.invalidate();
 
       return newShadowRoot;
     },
 
     get shadowRoot() {
-      return this.impl.polymerShadowRoot_ || null;
+      return unsafeUnwrap(this).polymerShadowRoot_ || null;
     },
 
     // getDestinationInsertionPoints added in ShadowRenderer.js
 
     setAttribute: function(name, value) {
-      var oldValue = this.impl.getAttribute(name);
-      this.impl.setAttribute(name, value);
+      var oldValue = unsafeUnwrap(this).getAttribute(name);
+      unsafeUnwrap(this).setAttribute(name, value);
       enqueAttributeChange(this, name, oldValue);
       invalidateRendererBasedOnAttribute(this, name);
     },
 
     removeAttribute: function(name) {
-      var oldValue = this.impl.getAttribute(name);
-      this.impl.removeAttribute(name);
+      var oldValue = unsafeUnwrap(this).getAttribute(name);
+      unsafeUnwrap(this).removeAttribute(name);
       enqueAttributeChange(this, name, oldValue);
       invalidateRendererBasedOnAttribute(this, name);
     },
 
     matches: function(selector) {
-      return originalMatches.call(this.impl, selector);
+      return originalMatches.call(unsafeUnwrap(this), selector);
     },
 
     get classList() {
       var list = classListTable.get(this);
       if (!list) {
         classListTable.set(this,
-            list = new DOMTokenList(unwrap(this).classList, this));
+            list = new DOMTokenList(unsafeUnwrap(this).classList, this));
       }
       return list;
     },
 
     get className() {
-      return unwrap(this).className;
+      return unsafeUnwrap(this).className;
     },
 
     set className(v) {
       this.setAttribute('class', v);
     },
 
     get id() {
-      return unwrap(this).id;
+      return unsafeUnwrap(this).id;
     },
 
     set id(v) {
       this.setAttribute('id', v);
     }
   });
 
   matchesNames.forEach(function(name) {
     if (name !== 'matches') {
       Element.prototype[name] = function(selector) {
@@ skipping 28 matching lines @@
   'use strict';
 
   var Element = scope.wrappers.Element;
   var defineGetter = scope.defineGetter;
   var enqueueMutation = scope.enqueueMutation;
   var mixin = scope.mixin;
   var nodesWereAdded = scope.nodesWereAdded;
   var nodesWereRemoved = scope.nodesWereRemoved;
   var registerWrapper = scope.registerWrapper;
   var snapshotNodeList = scope.snapshotNodeList;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var unwrap = scope.unwrap;
   var wrap = scope.wrap;
   var wrappers = scope.wrappers;
 
   /////////////////////////////////////////////////////////////////////////////
   // innerHTML and outerHTML
 
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString
   var escapeAttrRegExp = /[&\u00A0"]/g;
   var escapeDataRegExp = /[&\u00A0<>]/g;
@@ skipping 146 matching lines @@
         else
           setInnerHTML(this, value, this.tagName);
 
       // If we have a non native template element we need to handle this
       // manually since setting impl.innerHTML would add the html as direct
       // children and not be moved over to the content fragment.
       } else if (!OriginalHTMLTemplateElement &&
                  this instanceof wrappers.HTMLTemplateElement) {
         setInnerHTML(this.content, value);
       } else {
-        this.impl.innerHTML = value;
+        unsafeUnwrap(this).innerHTML = value;
       }
 
       var addedNodes = snapshotNodeList(this.childNodes);
 
       enqueueMutation(this, 'childList', {
         addedNodes: addedNodes,
         removedNodes: removedNodes
       });
 
       nodesWereRemoved(removedNodes);
@@ skipping 30 matching lines @@
         case 'beforeend':
           contextElement = this;
           refNode = null;
           break;
         default:
           return;
       }
 
       var df = frag(contextElement, text);
       contextElement.insertBefore(df, refNode);
+    },
+
+    get hidden() {
+      return this.hasAttribute('hidden');
+    },
+    set hidden(v) {
+      if (v) {
+        this.setAttribute('hidden', '');
+      } else {
+        this.removeAttribute('hidden');
+      }
     }
   });
 
   function frag(contextElement, html) {
     // TODO(arv): This does not work with SVG and other non HTML elements.
     var p = unwrap(contextElement.cloneNode(false));
     p.innerHTML = html;
     var df = unwrap(document.createDocumentFragment());
     var c;
     while (c = p.firstChild) {
       df.appendChild(c);
     }
     return wrap(df);
   }
 
   function getter(name) {
     return function() {
       scope.renderAllPending();
-      return this.impl[name];
+      return unsafeUnwrap(this)[name];
     };
   }
 
   function getterRequiresRendering(name) {
     defineGetter(HTMLElement, name, getter(name));
   }
 
   [
     'clientHeight',
     'clientLeft',
     'clientTop',
     'clientWidth',
     'offsetHeight',
     'offsetLeft',
     'offsetTop',
     'offsetWidth',
     'scrollHeight',
     'scrollWidth',
   ].forEach(getterRequiresRendering);
 
   function getterAndSetterRequiresRendering(name) {
     Object.defineProperty(HTMLElement.prototype, name, {
       get: getter(name),
       set: function(v) {
         scope.renderAllPending();
-        this.impl[name] = v;
+        unsafeUnwrap(this)[name] = v;
       },
       configurable: true,
       enumerable: true
     });
   }
 
   [
     'scrollLeft',
     'scrollTop',
   ].forEach(getterAndSetterRequiresRendering);
 
   function methodRequiresRendering(name) {
     Object.defineProperty(HTMLElement.prototype, name, {
       value: function() {
         scope.renderAllPending();
-        return this.impl[name].apply(this.impl, arguments);
+        return unsafeUnwrap(this)[name].apply(unsafeUnwrap(this), arguments);
       },
       configurable: true,
       enumerable: true
     });
   }
 
   [
     'getBoundingClientRect',
     'getClientRects',
     'scrollIntoView'
@@ skipping 13 matching lines @@
 // 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 HTMLElement = scope.wrappers.HTMLElement;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var wrap = scope.wrap;
 
   var OriginalHTMLCanvasElement = window.HTMLCanvasElement;
 
   function HTMLCanvasElement(node) {
     HTMLElement.call(this, node);
   }
   HTMLCanvasElement.prototype = Object.create(HTMLElement.prototype);
 
   mixin(HTMLCanvasElement.prototype, {
     getContext: function() {
-      var context = this.impl.getContext.apply(this.impl, arguments);
+      var context = unsafeUnwrap(this).getContext.apply(unsafeUnwrap(this), arguments);
       return context && wrap(context);
     }
   });
 
   registerWrapper(OriginalHTMLCanvasElement, HTMLCanvasElement,
                   document.createElement('canvas'));
 
   scope.wrappers.HTMLCanvasElement = HTMLCanvasElement;
 })(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 HTMLElement = scope.wrappers.HTMLElement;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
 
   var OriginalHTMLContentElement = window.HTMLContentElement;
 
   function HTMLContentElement(node) {
     HTMLElement.call(this, node);
   }
   HTMLContentElement.prototype = Object.create(HTMLElement.prototype);
   mixin(HTMLContentElement.prototype, {
+    constructor: HTMLContentElement,
+
     get select() {
       return this.getAttribute('select');
     },
     set select(value) {
       this.setAttribute('select', value);
     },
 
     setAttribute: function(n, v) {
       HTMLElement.prototype.setAttribute.call(this, n, v);
       if (String(n).toLowerCase() === 'select')
@@ skipping 100 matching lines @@
   var mixin = scope.mixin;
   var NodeList = scope.wrappers.NodeList;
   var registerWrapper = scope.registerWrapper;
 
   var OriginalHTMLShadowElement = window.HTMLShadowElement;
 
   function HTMLShadowElement(node) {
     HTMLElement.call(this, node);
   }
   HTMLShadowElement.prototype = Object.create(HTMLElement.prototype);
+  HTMLShadowElement.prototype.constructor = HTMLShadowElement;
 
   // getDistributedNodes is added in ShadowRenderer
 
   if (OriginalHTMLShadowElement)
     registerWrapper(OriginalHTMLShadowElement, HTMLShadowElement);
 
   scope.wrappers.HTMLShadowElement = HTMLShadowElement;
 })(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 HTMLElement = scope.wrappers.HTMLElement;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var unwrap = scope.unwrap;
   var wrap = scope.wrap;
 
   var contentTable = new WeakMap();
   var templateContentsOwnerTable = new WeakMap();
 
   // http://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/templates/index.html#dfn-template-contents-owner
   function getTemplateContentsOwner(doc) {
     if (!doc.defaultView)
       return doc;
@@ skipping 26 matching lines @@
   function HTMLTemplateElement(node) {
     HTMLElement.call(this, node);
     if (!OriginalHTMLTemplateElement) {
       var content = extractContent(node);
       contentTable.set(this, wrap(content));
     }
   }
   HTMLTemplateElement.prototype = Object.create(HTMLElement.prototype);
 
   mixin(HTMLTemplateElement.prototype, {
+    constructor: HTMLTemplateElement,
     get content() {
       if (OriginalHTMLTemplateElement)
-        return wrap(this.impl.content);
+        return wrap(unsafeUnwrap(this).content);
       return contentTable.get(this);
     },
 
     // TODO(arv): cloneNode needs to clone content.
 
   });
 
   if (OriginalHTMLTemplateElement)
     registerWrapper(OriginalHTMLTemplateElement, HTMLTemplateElement);
 
   scope.wrappers.HTMLTemplateElement = HTMLTemplateElement;
 })(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 HTMLElement = scope.wrappers.HTMLElement;
   var registerWrapper = scope.registerWrapper;
 
   var OriginalHTMLMediaElement = window.HTMLMediaElement;
 
+  if (!OriginalHTMLMediaElement) return;
+
   function HTMLMediaElement(node) {
     HTMLElement.call(this, node);
   }
   HTMLMediaElement.prototype = Object.create(HTMLElement.prototype);
 
   registerWrapper(OriginalHTMLMediaElement, HTMLMediaElement,
                   document.createElement('audio'));
 
   scope.wrappers.HTMLMediaElement = HTMLMediaElement;
 })(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 HTMLMediaElement = scope.wrappers.HTMLMediaElement;
   var registerWrapper = scope.registerWrapper;
   var unwrap = scope.unwrap;
   var rewrap = scope.rewrap;
 
   var OriginalHTMLAudioElement = window.HTMLAudioElement;
 
+  if (!OriginalHTMLAudioElement) return;
+
   function HTMLAudioElement(node) {
     HTMLMediaElement.call(this, node);
   }
   HTMLAudioElement.prototype = Object.create(HTMLMediaElement.prototype);
 
   registerWrapper(OriginalHTMLAudioElement, HTMLAudioElement,
                   document.createElement('audio'));
 
   function Audio(src) {
     if (!(this instanceof Audio)) {
@@ skipping 212 matching lines @@
   var unwrap = scope.unwrap;
   var wrap = scope.wrap;
 
   var OriginalHTMLTableSectionElement = window.HTMLTableSectionElement;
 
   function HTMLTableSectionElement(node) {
     HTMLElement.call(this, node);
   }
   HTMLTableSectionElement.prototype = Object.create(HTMLElement.prototype);
   mixin(HTMLTableSectionElement.prototype, {
+    constructor: HTMLTableSectionElement,
     get rows() {
       return wrapHTMLCollection(unwrap(this).rows);
     },
     insertRow: function(index) {
       return wrap(unwrap(this).insertRow(index));
     }
   });
 
   registerWrapper(OriginalHTMLTableSectionElement, HTMLTableSectionElement,
                   document.createElement('thead'));
@@ skipping 150 matching lines @@
 // 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 EventTarget = scope.wrappers.EventTarget;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var wrap = scope.wrap;
 
   var OriginalSVGElementInstance = window.SVGElementInstance;
   if (!OriginalSVGElementInstance)
     return;
 
   function SVGElementInstance(impl) {
     EventTarget.call(this, impl);
   }
 
   SVGElementInstance.prototype = Object.create(EventTarget.prototype);
   mixin(SVGElementInstance.prototype, {
     /** @type {SVGElement} */
     get correspondingElement() {
-      return wrap(this.impl.correspondingElement);
+      return wrap(unsafeUnwrap(this).correspondingElement);
     },
 
     /** @type {SVGUseElement} */
     get correspondingUseElement() {
-      return wrap(this.impl.correspondingUseElement);
+      return wrap(unsafeUnwrap(this).correspondingUseElement);
     },
 
     /** @type {SVGElementInstance} */
     get parentNode() {
-      return wrap(this.impl.parentNode);
+      return wrap(unsafeUnwrap(this).parentNode);
     },
 
     /** @type {SVGElementInstanceList} */
     get childNodes() {
       throw new Error('Not implemented');
     },
 
     /** @type {SVGElementInstance} */
     get firstChild() {
-      return wrap(this.impl.firstChild);
+      return wrap(unsafeUnwrap(this).firstChild);
     },
 
     /** @type {SVGElementInstance} */
     get lastChild() {
-      return wrap(this.impl.lastChild);
+      return wrap(unsafeUnwrap(this).lastChild);
     },
 
     /** @type {SVGElementInstance} */
     get previousSibling() {
-      return wrap(this.impl.previousSibling);
+      return wrap(unsafeUnwrap(this).previousSibling);
     },
 
     /** @type {SVGElementInstance} */
     get nextSibling() {
-      return wrap(this.impl.nextSibling);
+      return wrap(unsafeUnwrap(this).nextSibling);
     }
   });
 
   registerWrapper(OriginalSVGElementInstance, SVGElementInstance);
 
   scope.wrappers.SVGElementInstance = SVGElementInstance;
 })(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 mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
+  var setWrapper = scope.setWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var unwrap = scope.unwrap;
   var unwrapIfNeeded = scope.unwrapIfNeeded;
   var wrap = scope.wrap;
 
   var OriginalCanvasRenderingContext2D = window.CanvasRenderingContext2D;
 
   function CanvasRenderingContext2D(impl) {
-    this.impl = impl;
+    setWrapper(impl, this);
   }
 
   mixin(CanvasRenderingContext2D.prototype, {
     get canvas() {
-      return wrap(this.impl.canvas);
+      return wrap(unsafeUnwrap(this).canvas);
     },
 
     drawImage: function() {
       arguments[0] = unwrapIfNeeded(arguments[0]);
-      this.impl.drawImage.apply(this.impl, arguments);
+      unsafeUnwrap(this).drawImage.apply(unsafeUnwrap(this), arguments);
     },
 
     createPattern: function() {
       arguments[0] = unwrap(arguments[0]);
-      return this.impl.createPattern.apply(this.impl, arguments);
+      return unsafeUnwrap(this).createPattern.apply(unsafeUnwrap(this), arguments);
     }
   });
 
   registerWrapper(OriginalCanvasRenderingContext2D, CanvasRenderingContext2D,
                   document.createElement('canvas').getContext('2d'));
 
   scope.wrappers.CanvasRenderingContext2D = CanvasRenderingContext2D;
 })(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 mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
+  var setWrapper = scope.setWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var unwrapIfNeeded = scope.unwrapIfNeeded;
   var wrap = scope.wrap;
 
   var OriginalWebGLRenderingContext = window.WebGLRenderingContext;
 
   // IE10 does not have WebGL.
   if (!OriginalWebGLRenderingContext)
     return;
 
   function WebGLRenderingContext(impl) {
-    this.impl = impl;
+    setWrapper(impl, this);
   }
 
   mixin(WebGLRenderingContext.prototype, {
     get canvas() {
-      return wrap(this.impl.canvas);
+      return wrap(unsafeUnwrap(this).canvas);
     },
 
     texImage2D: function() {
       arguments[5] = unwrapIfNeeded(arguments[5]);
-      this.impl.texImage2D.apply(this.impl, arguments);
+      unsafeUnwrap(this).texImage2D.apply(unsafeUnwrap(this), arguments);
     },
 
     texSubImage2D: function() {
       arguments[6] = unwrapIfNeeded(arguments[6]);
-      this.impl.texSubImage2D.apply(this.impl, arguments);
+      unsafeUnwrap(this).texSubImage2D.apply(unsafeUnwrap(this), arguments);
     }
   });
 
   // Blink/WebKit has broken DOM bindings. Usually we would create an instance
   // of the object and pass it into registerWrapper as a "blueprint" but
   // creating WebGL contexts is expensive and might fail so we use a dummy
   // object with dummy instance properties for these broken browsers.
   var instanceProperties = /WebKit/.test(navigator.userAgent) ?
       {drawingBufferHeight: null, drawingBufferWidth: null} : {};
 
   registerWrapper(OriginalWebGLRenderingContext, WebGLRenderingContext,
       instanceProperties);
 
   scope.wrappers.WebGLRenderingContext = WebGLRenderingContext;
 })(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 registerWrapper = scope.registerWrapper;
+  var setWrapper = scope.setWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var unwrap = scope.unwrap;
   var unwrapIfNeeded = scope.unwrapIfNeeded;
   var wrap = scope.wrap;
 
   var OriginalRange = window.Range;
 
   function Range(impl) {
-    this.impl = impl;
+    setWrapper(impl, this);
   }
   Range.prototype = {
     get startContainer() {
-      return wrap(this.impl.startContainer);
+      return wrap(unsafeUnwrap(this).startContainer);
     },
     get endContainer() {
-      return wrap(this.impl.endContainer);
+      return wrap(unsafeUnwrap(this).endContainer);
     },
     get commonAncestorContainer() {
-      return wrap(this.impl.commonAncestorContainer);
+      return wrap(unsafeUnwrap(this).commonAncestorContainer);
     },
     setStart: function(refNode,offset) {
-      this.impl.setStart(unwrapIfNeeded(refNode), offset);
+      unsafeUnwrap(this).setStart(unwrapIfNeeded(refNode), offset);
     },
     setEnd: function(refNode,offset) {
-      this.impl.setEnd(unwrapIfNeeded(refNode), offset);
+      unsafeUnwrap(this).setEnd(unwrapIfNeeded(refNode), offset);
     },
     setStartBefore: function(refNode) {
-      this.impl.setStartBefore(unwrapIfNeeded(refNode));
+      unsafeUnwrap(this).setStartBefore(unwrapIfNeeded(refNode));
     },
     setStartAfter: function(refNode) {
-      this.impl.setStartAfter(unwrapIfNeeded(refNode));
+      unsafeUnwrap(this).setStartAfter(unwrapIfNeeded(refNode));
     },
     setEndBefore: function(refNode) {
-      this.impl.setEndBefore(unwrapIfNeeded(refNode));
+      unsafeUnwrap(this).setEndBefore(unwrapIfNeeded(refNode));
     },
     setEndAfter: function(refNode) {
-      this.impl.setEndAfter(unwrapIfNeeded(refNode));
+      unsafeUnwrap(this).setEndAfter(unwrapIfNeeded(refNode));
     },
     selectNode: function(refNode) {
-      this.impl.selectNode(unwrapIfNeeded(refNode));
+      unsafeUnwrap(this).selectNode(unwrapIfNeeded(refNode));
     },
     selectNodeContents: function(refNode) {
-      this.impl.selectNodeContents(unwrapIfNeeded(refNode));
+      unsafeUnwrap(this).selectNodeContents(unwrapIfNeeded(refNode));
     },
     compareBoundaryPoints: function(how, sourceRange) {
-      return this.impl.compareBoundaryPoints(how, unwrap(sourceRange));
+      return unsafeUnwrap(this).compareBoundaryPoints(how, unwrap(sourceRange));
     },
     extractContents: function() {
-      return wrap(this.impl.extractContents());
+      return wrap(unsafeUnwrap(this).extractContents());
     },
     cloneContents: function() {
-      return wrap(this.impl.cloneContents());
+      return wrap(unsafeUnwrap(this).cloneContents());
     },
     insertNode: function(node) {
-      this.impl.insertNode(unwrapIfNeeded(node));
+      unsafeUnwrap(this).insertNode(unwrapIfNeeded(node));
     },
     surroundContents: function(newParent) {
-      this.impl.surroundContents(unwrapIfNeeded(newParent));
+      unsafeUnwrap(this).surroundContents(unwrapIfNeeded(newParent));
     },
     cloneRange: function() {
-      return wrap(this.impl.cloneRange());
+      return wrap(unsafeUnwrap(this).cloneRange());
     },
     isPointInRange: function(node, offset) {
-      return this.impl.isPointInRange(unwrapIfNeeded(node), offset);
+      return unsafeUnwrap(this).isPointInRange(unwrapIfNeeded(node), offset);
     },
     comparePoint: function(node, offset) {
-      return this.impl.comparePoint(unwrapIfNeeded(node), offset);
+      return unsafeUnwrap(this).comparePoint(unwrapIfNeeded(node), offset);
     },
     intersectsNode: function(node) {
-      return this.impl.intersectsNode(unwrapIfNeeded(node));
+      return unsafeUnwrap(this).intersectsNode(unwrapIfNeeded(node));
     },
     toString: function() {
-      return this.impl.toString();
+      return unsafeUnwrap(this).toString();
     }
   };
 
   // IE9 does not have createContextualFragment.
   if (OriginalRange.prototype.createContextualFragment) {
     Range.prototype.createContextualFragment = function(html) {
-      return wrap(this.impl.createContextualFragment(html));
+      return wrap(unsafeUnwrap(this).createContextualFragment(html));
     };
   }
 
   registerWrapper(window.Range, Range, document.createRange());
 
   scope.wrappers.Range = Range;
 
 })(window.ShadowDOMPolyfill);
 
 // Copyright 2013 The Polymer Authors. All rights reserved.
@@ skipping 29 matching lines @@
   'use strict';
 
   var DocumentFragment = scope.wrappers.DocumentFragment;
   var TreeScope = scope.TreeScope;
   var elementFromPoint = scope.elementFromPoint;
   var getInnerHTML = scope.getInnerHTML;
   var getTreeScope = scope.getTreeScope;
   var mixin = scope.mixin;
   var rewrap = scope.rewrap;
   var setInnerHTML = scope.setInnerHTML;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var unwrap = scope.unwrap;
 
   var shadowHostTable = new WeakMap();
   var nextOlderShadowTreeTable = new WeakMap();
 
   var spaceCharRe = /[ \t\n\r\f]/;
 
   function ShadowRoot(hostWrapper) {
-    var node = unwrap(hostWrapper.impl.ownerDocument.createDocumentFragment());
+    var node = unwrap(unsafeUnwrap(hostWrapper).ownerDocument.createDocumentFragment());
     DocumentFragment.call(this, node);
 
     // createDocumentFragment associates the node with a wrapper
     // DocumentFragment instance. Override that.
     rewrap(node, this);
 
     var oldShadowRoot = hostWrapper.shadowRoot;
     nextOlderShadowTreeTable.set(this, oldShadowRoot);
 
     this.treeScope_ =
         new TreeScope(this, getTreeScope(oldShadowRoot || hostWrapper));
 
     shadowHostTable.set(this, hostWrapper);
   }
   ShadowRoot.prototype = Object.create(DocumentFragment.prototype);
   mixin(ShadowRoot.prototype, {
+    constructor: ShadowRoot,
+
     get innerHTML() {
       return getInnerHTML(this);
     },
     set innerHTML(value) {
       setInnerHTML(this, value);
       this.invalidateShadowRenderer();
     },
 
     get olderShadowRoot() {
       return nextOlderShadowTreeTable.get(this) || null;
@@ skipping 31 matching lines @@
 
   var Element = scope.wrappers.Element;
   var HTMLContentElement = scope.wrappers.HTMLContentElement;
   var HTMLShadowElement = scope.wrappers.HTMLShadowElement;
   var Node = scope.wrappers.Node;
   var ShadowRoot = scope.wrappers.ShadowRoot;
   var assert = scope.assert;
   var getTreeScope = scope.getTreeScope;
   var mixin = scope.mixin;
   var oneOf = scope.oneOf;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var unwrap = scope.unwrap;
   var wrap = scope.wrap;
 
   /**
    * Updates the fields of a wrapper to a snapshot of the logical DOM as needed.
    * Up means parentNode
    * Sideways means previous and next sibling.
    * @param {!Node} wrapper
    */
   function updateWrapperUpAndSideways(wrapper) {
@@ skipping 450 matching lines @@
       });
 
       // Pseudo selectors have been removed from the spec.
     },
 
     dependsOnAttribute: function(name) {
       return this.attributes[name];
     },
 
     associateNode: function(node) {
-      node.impl.polymerShadowRenderer_ = this;
+      unsafeUnwrap(node).polymerShadowRenderer_ = this;
     }
   };
 
   // http://w3c.github.io/webcomponents/spec/shadow/#dfn-pool-population-algorithm
   function poolPopulation(node) {
     var pool = [];
     for (var child = node.firstChild; child; child = child.nextSibling) {
       if (isInsertionPoint(child)) {
         pool.push.apply(pool, getDistributedNodes(child));
       } else {
@@ skipping 33 matching lines @@
     // IE11 crashes when delete is used.
     destinationInsertionPointsTable.set(node, undefined);
   }
 
   // AllowedSelectors :
   //   TypeSelector
   //   *
   //   ClassSelector
   //   IDSelector
   //   AttributeSelector
-  var selectorStartCharRe = /^[*.#[a-zA-Z_|]/;
+  //   negation
+  var selectorStartCharRe = /^(:not\()?[*.#[a-zA-Z_|]/;
 
   function matches(node, contentElement) {
     var select = contentElement.getAttribute('select');
     if (!select)
       return true;
 
     // Here we know the select attribute is a non empty string.
     select = select.trim();
     if (!select)
       return true;
@@ skipping 48 matching lines @@
   // - a new shadow root is created
   // - a direct child to a content/shadow element is added or removed
   // - a sibling to a content/shadow element is added or removed
   // - content[select] is changed
   // - an attribute in a direct child to a host is modified
 
   /**
    * This gets called when a node was added or removed to it.
    */
   Node.prototype.invalidateShadowRenderer = function(force) {
-    var renderer = this.impl.polymerShadowRenderer_;
+    var renderer = unsafeUnwrap(this).polymerShadowRenderer_;
     if (renderer) {
       renderer.invalidate();
       return true;
     }
 
     return false;
   };
 
   HTMLContentElement.prototype.getDistributedNodes =
   HTMLShadowElement.prototype.getDistributedNodes = function() {
@@ skipping 10 matching lines @@
 
   HTMLContentElement.prototype.nodeIsInserted_ =
   HTMLShadowElement.prototype.nodeIsInserted_ = function() {
     // Invalidate old renderer if any.
     this.invalidateShadowRenderer();
 
     var shadowRoot = getShadowRootAncestor(this);
     var renderer;
     if (shadowRoot)
       renderer = getRendererForShadowRoot(shadowRoot);
-    this.impl.polymerShadowRenderer_ = renderer;
+    unsafeUnwrap(this).polymerShadowRenderer_ = renderer;
     if (renderer)
       renderer.invalidate();
   };
 
   scope.getRendererForHost = getRendererForHost;
   scope.getShadowTrees = getShadowTrees;
   scope.renderAllPending = renderAllPending;
 
   scope.getDestinationInsertionPoints = getDestinationInsertionPoints;
 
@@ skipping 61 matching lines @@
 })(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 registerWrapper = scope.registerWrapper;
+  var setWrapper = scope.setWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var unwrap = scope.unwrap;
   var unwrapIfNeeded = scope.unwrapIfNeeded;
   var wrap = scope.wrap;
 
   var OriginalSelection = window.Selection;
 
   function Selection(impl) {
-    this.impl = impl;
+    setWrapper(impl, this);
   }
   Selection.prototype = {
     get anchorNode() {
-      return wrap(this.impl.anchorNode);
+      return wrap(unsafeUnwrap(this).anchorNode);
     },
     get focusNode() {
-      return wrap(this.impl.focusNode);
+      return wrap(unsafeUnwrap(this).focusNode);
     },
     addRange: function(range) {
-      this.impl.addRange(unwrap(range));
+      unsafeUnwrap(this).addRange(unwrap(range));
     },
     collapse: function(node, index) {
-      this.impl.collapse(unwrapIfNeeded(node), index);
+      unsafeUnwrap(this).collapse(unwrapIfNeeded(node), index);
     },
     containsNode: function(node, allowPartial) {
-      return this.impl.containsNode(unwrapIfNeeded(node), allowPartial);
+      return unsafeUnwrap(this).containsNode(unwrapIfNeeded(node), allowPartial);
     },
     extend: function(node, offset) {
-      this.impl.extend(unwrapIfNeeded(node), offset);
+      unsafeUnwrap(this).extend(unwrapIfNeeded(node), offset);
     },
     getRangeAt: function(index) {
-      return wrap(this.impl.getRangeAt(index));
+      return wrap(unsafeUnwrap(this).getRangeAt(index));
     },
     removeRange: function(range) {
-      this.impl.removeRange(unwrap(range));
+      unsafeUnwrap(this).removeRange(unwrap(range));
     },
     selectAllChildren: function(node) {
-      this.impl.selectAllChildren(unwrapIfNeeded(node));
+      unsafeUnwrap(this).selectAllChildren(unwrapIfNeeded(node));
     },
     toString: function() {
-      return this.impl.toString();
+      return unsafeUnwrap(this).toString();
     }
   };
 
   // WebKit extensions. Not implemented.
   // readonly attribute Node baseNode;
   // readonly attribute long baseOffset;
   // readonly attribute Node extentNode;
   // readonly attribute long extentOffset;
   // [RaisesException] void setBaseAndExtent([Default=Undefined] optional Node baseNode,
   //                       [Default=Undefined] optional long baseOffset,
@@ skipping 24 matching lines @@
   var TreeScope = scope.TreeScope;
   var cloneNode = scope.cloneNode;
   var defineWrapGetter = scope.defineWrapGetter;
   var elementFromPoint = scope.elementFromPoint;
   var forwardMethodsToWrapper = scope.forwardMethodsToWrapper;
   var matchesNames = scope.matchesNames;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
   var renderAllPending = scope.renderAllPending;
   var rewrap = scope.rewrap;
+  var setWrapper = scope.setWrapper;
+  var unsafeUnwrap = scope.unsafeUnwrap;
   var unwrap = scope.unwrap;
   var wrap = scope.wrap;
   var wrapEventTargetMethods = scope.wrapEventTargetMethods;
   var wrapNodeList = scope.wrapNodeList;
 
   var implementationTable = new WeakMap();
 
   function Document(node) {
     Node.call(this, node);
     this.treeScope_ = new TreeScope(this, null);
   }
   Document.prototype = Object.create(Node.prototype);
 
   defineWrapGetter(Document, 'documentElement');
 
   // Conceptually both body and head can be in a shadow but suporting that seems
   // overkill at this point.
   defineWrapGetter(Document, 'body');
   defineWrapGetter(Document, 'head');
 
   // document cannot be overridden so we override a bunch of its methods
   // directly on the instance.
 
   function wrapMethod(name) {
     var original = document[name];
     Document.prototype[name] = function() {
-      return wrap(original.apply(this.impl, arguments));
+      return wrap(original.apply(unsafeUnwrap(this), arguments));
     };
   }
 
   [
     'createComment',
     'createDocumentFragment',
     'createElement',
     'createElementNS',
     'createEvent',
     'createEventNS',
     'createRange',
     'createTextNode',
     'getElementById'
   ].forEach(wrapMethod);
 
   var originalAdoptNode = document.adoptNode;
 
   function adoptNodeNoRemove(node, doc) {
-    originalAdoptNode.call(doc.impl, unwrap(node));
+    originalAdoptNode.call(unsafeUnwrap(doc), unwrap(node));
     adoptSubtree(node, doc);
   }
 
   function adoptSubtree(node, doc) {
     if (node.shadowRoot)
       doc.adoptNode(node.shadowRoot);
     if (node instanceof ShadowRoot)
       adoptOlderShadowRoots(node, doc);
     for (var child = node.firstChild; child; child = child.nextSibling) {
       adoptSubtree(child, doc);
@@ skipping 12 matching lines @@
     adoptNode: function(node) {
       if (node.parentNode)
         node.parentNode.removeChild(node);
       adoptNodeNoRemove(node, this);
       return node;
     },
     elementFromPoint: function(x, y) {
       return elementFromPoint(this, this, x, y);
     },
     importNode: function(node, deep) {
-      return cloneNode(node, deep, this.impl);
+      return cloneNode(node, deep, unsafeUnwrap(this));
     },
     getSelection: function() {
       renderAllPending();
       return new Selection(originalGetSelection.call(unwrap(this)));
     },
     getElementsByName: function(name) {
       return SelectorsInterface.querySelectorAll.call(this,
           '[name=' + JSON.stringify(String(name)) + ']');
     }
   });
@@ skipping 74 matching lines @@
         p.extends = extendsOption;
 
       function CustomElementConstructor(node) {
         if (!node) {
           if (extendsOption) {
             return document.createElement(extendsOption, tagName);
           } else {
             return document.createElement(tagName);
           }
         }
-        this.impl = node;
+        setWrapper(node, this);
       }
       CustomElementConstructor.prototype = prototype;
       CustomElementConstructor.prototype.constructor = CustomElementConstructor;
 
       scope.constructorTable.set(newPrototype, CustomElementConstructor);
       scope.nativePrototypeTable.set(prototype, newPrototype);
 
       // registration is synchronous so do it last
       var nativeConstructor = originalRegisterElement.call(unwrap(this),
           tagName, p);
@@ skipping 76 matching lines @@
   if (window.HTMLDocument)
     registerWrapper(window.HTMLDocument, Document);
 
   wrapEventTargetMethods([
     window.HTMLBodyElement,
     window.HTMLDocument || window.Document,  // Gecko adds these to HTMLDocument
     window.HTMLHeadElement,
   ]);
 
   function DOMImplementation(impl) {
-    this.impl = impl;
+    setWrapper(impl, this);
   }
 
   function wrapImplMethod(constructor, name) {
     var original = document.implementation[name];
     constructor.prototype[name] = function() {
-      return wrap(original.apply(this.impl, arguments));
+      return wrap(original.apply(unsafeUnwrap(this), arguments));
     };
   }
 
   function forwardImplMethod(constructor, name) {
     var original = document.implementation[name];
     constructor.prototype[name] = function() {
-      return original.apply(this.impl, arguments);
+      return original.apply(unsafeUnwrap(this), arguments);
     };
   }
 
   wrapImplMethod(DOMImplementation, 'createDocumentType');
   wrapImplMethod(DOMImplementation, 'createDocument');
   wrapImplMethod(DOMImplementation, 'createHTMLDocument');
   forwardImplMethod(DOMImplementation, 'hasFeature');
 
   registerWrapper(window.DOMImplementation, DOMImplementation);
 
@@ skipping 23 matching lines @@
   var Selection = scope.wrappers.Selection;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
   var renderAllPending = scope.renderAllPending;
   var unwrap = scope.unwrap;
   var unwrapIfNeeded = scope.unwrapIfNeeded;
   var wrap = scope.wrap;
 
   var OriginalWindow = window.Window;
   var originalGetComputedStyle = window.getComputedStyle;
+  var originalGetDefaultComputedStyle = window.getDefaultComputedStyle;
   var originalGetSelection = window.getSelection;
 
   function Window(impl) {
     EventTarget.call(this, impl);
   }
   Window.prototype = Object.create(EventTarget.prototype);
 
   OriginalWindow.prototype.getComputedStyle = function(el, pseudo) {
     return wrap(this || window).getComputedStyle(unwrapIfNeeded(el), pseudo);
   };
 
+  // Mozilla proprietary extension.
+  if (originalGetDefaultComputedStyle) {
+    OriginalWindow.prototype.getDefaultComputedStyle = function(el, pseudo) {
+      return wrap(this || window).getDefaultComputedStyle(
+          unwrapIfNeeded(el), pseudo);
+    };
+  }
+
   OriginalWindow.prototype.getSelection = function() {
     return wrap(this || window).getSelection();
   };
 
   // Work around for https://bugzilla.mozilla.org/show_bug.cgi?id=943065
   delete window.getComputedStyle;
   delete window.getSelection;
 
   ['addEventListener', 'removeEventListener', 'dispatchEvent'].forEach(
       function(name) {
@@ skipping 15 matching lines @@
     getSelection: function() {
       renderAllPending();
       return new Selection(originalGetSelection.call(unwrap(this)));
     },
 
     get document() {
       return wrap(unwrap(this).document);
     }
   });
 
+  // Mozilla proprietary extension.
+  if (originalGetDefaultComputedStyle) {
+    Window.prototype.getDefaultComputedStyle = function(el, pseudo) {
+      renderAllPending();
+      return originalGetDefaultComputedStyle.call(unwrap(this),
+          unwrapIfNeeded(el),pseudo);
+    };
+  }
+
   registerWrapper(OriginalWindow, Window, window);
 
   scope.wrappers.Window = Window;
 
 })(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.
@@ skipping 23 matching lines @@
 /**
  * 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 registerWrapper = scope.registerWrapper;
+  var setWrapper = scope.setWrapper;
   var unwrap = scope.unwrap;
 
   var OriginalFormData = window.FormData;
 
   function FormData(formElement) {
-    this.impl = new OriginalFormData(formElement && unwrap(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 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
@@ skipping 743 matching lines @@
     } else {
       addCssToDocument(cssText);
     }
   }
 };
 
 var selectorRe = /([^{]*)({[\s\S]*?})/gim,
     cssCommentRe = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,
     // TODO(sorvell): remove either content or comment
     cssCommentNextSelectorRe = /\/\*\s*@polyfill ([^*]*\*+([^/*][^*]*\*+)*\/)([^{]*?){/gim,
-    cssContentNextSelectorRe = /polyfill-next-selector[^}]*content\:[\s]*['|"]([^'"]*)['|"][^}]*}([^{]*?){/gim,
+    cssContentNextSelectorRe = /polyfill-next-selector[^}]*content\:[\s]*?['"](.*?)['"][;\s]*}([^{]*?){/gim,  
     // TODO(sorvell): remove either content or comment
     cssCommentRuleRe = /\/\*\s@polyfill-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
-    cssContentRuleRe = /(polyfill-rule)[^}]*(content\:[\s]*['|"]([^'"]*)['|"][^;]*;)[^}]*}/gim,
+    cssContentRuleRe = /(polyfill-rule)[^}]*(content\:[\s]*['"](.*?)['"])[;\s]*[^}]*}/gim,
     // TODO(sorvell): remove either content or comment
     cssCommentUnscopedRuleRe = /\/\*\s@polyfill-unscoped-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
-    cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content\:[\s]*['|"]([^'"]*)['|"][^;]*;)[^}]*}/gim,
+    cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content\:[\s]*['"](.*?)['"])[;\s]*[^}]*}/gim,
     cssPseudoRe = /::(x-[^\s{,(]*)/gim,
     cssPartRe = /::part\(([^)]*)\)/gim,
     // note: :host pre-processed to -shadowcsshost.
     polyfillHost = '-shadowcsshost',
     // note: :host-context pre-processed to -shadowcsshostcontext.
     polyfillHostContext = '-shadowcsscontext',
     parenSuffix = ')(?:\\((' +
         '(?:\\([^)(]*\\)|[^)(]*)+?' +
         ')\\))?([^,{]*)';
     cssColonHostRe = new RegExp('(' + polyfillHost + parenSuffix, 'gim'),
@@ skipping 175 matching lines @@
         style.textContent = ShadowCSS.shimStyle(style);
         style.removeAttribute(SHIM_ATTRIBUTE, '');
         style.setAttribute(SHIMMED_ATTRIBUTE, '');
         style[SHIMMED_ATTRIBUTE] = true;
         // place in document
         if (style.parentNode !== head) {
           // replace links in head
           if (elt.parentNode === head) {
             head.replaceChild(style, elt);
           } else {
-            head.appendChild(style);
+            this.addElementToDocument(style);
           }
         }
         style.__importParsed = true;
         this.markParsingComplete(elt);
         this.parseNext();
       }
 
       var hasResource = HTMLImports.parser.hasResource;
       HTMLImports.parser.hasResource = function(node) {
         if (node.localName === 'link' && node.rel === 'stylesheet' &&
@@ skipping 616 matching lines @@
     set hash(hash) {
       if (this._isInvalid)
         return;
       this._fragment = '#';
       if ('#' == hash[0])
         hash = hash.slice(1);
       parse.call(this, hash, 'fragment');
     }
   };
 
+  // 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);
+    };
+    jURL.revokeObjectURL = function(url) {
+      OriginalURL.revokeObjectURL(url);
+    };
+  }
+
   scope.URL = jURL;
 
-})(window);
+})(this);
 
 /*
  * 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
  */
 
@@ skipping 1207 matching lines @@
 
   global.JsMutationObserver = JsMutationObserver;
 
   if (!global.MutationObserver)
     global.MutationObserver = JsMutationObserver;
 
 
 })(this);
 
 /*
- * 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.
+ * 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.HTMLImports = window.HTMLImports || {flags:{}};
 /*
- * 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.
+ * 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 useNative = hasNative;
+
+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);
+    
+// 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);
+
+// 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;
+  // 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) {
+  return (doc.readyState === 'complete' ||
+      doc.readyState === requiredReadyState);
+}
+
+// call <callback> when we ensure the document is in a ready state
+function whenDocumentReady(callback, doc) {
+  if (!isDocumentReady(doc)) {
+    var checkReady = function() {
+      if (doc.readyState === 'complete' || 
+          doc.readyState === requiredReadyState) {
+        doc.removeEventListener(READY_EVENT, checkReady);
+        whenDocumentReady(callback, doc);
+      }
+    }
+    doc.addEventListener(READY_EVENT, checkReady);
+  } else if (callback) {
+    callback();
+  }
+}
+
+// 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();
+    }
+  }
+  function loadedImport(e) {
+    loaded++;
+    checkDone();
+  }
+  if (l) {
+    for (var i=0, imp; (i<l) && (imp=imports[i]); i++) {
+      if (isImportLoaded(imp)) {
+        loadedImport.call(imp);
+      } else {
+        imp.addEventListener('load', loadedImport);
+        imp.addEventListener('error', loadedImport);
+      }
+    }
+  } else {
+    checkDone();
+  }
+}
+
+// NOTE: test for native imports loading is based on explicitly watching
+// all imports (see below).
+function isImportLoaded(link) {
+  return useNative ? link.__loaded : link.__importParsed;
+}
+
+// TODO(sorvell): install a mutation observer to see if HTMLImports have loaded
+// this is a workaround for https://www.w3.org/Bugs/Public/show_bug.cgi?id=25007
+// and should be removed when this bug is addressed.
+if (useNative) {
+  new MutationObserver(function(mxns) {
+    for (var i=0, l=mxns.length, m; (i < l) && (m=mxns[i]); i++) {
+      if (m.addedNodes) {
+        handleImports(m.addedNodes);
+      }
+    }
+  }).observe(document.head, {childList: true});
+
+  function handleImports(nodes) {
+    for (var i=0, l=nodes.length, n; (i<l) && (n=nodes[i]); i++) {
+      if (isImport(n)) {
+        handleImport(n);  
+      }
+    }
+  }
+
+  function isImport(element) {
+    return element.localName === 'link' && element.rel === 'import';
+  }
+
+  function handleImport(element) {
+    var loaded = element.import;
+    if (loaded) {
+      markTargetLoaded({target: element});
+    } else {
+      element.addEventListener('load', markTargetLoaded);
+      element.addEventListener('error', markTargetLoaded);
+    }
+  }
+
+  function markTargetLoaded(event) {
+    event.target.__loaded = true;
+  }
+
+}
+
+// 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() {
+  HTMLImports.ready = true;
+  HTMLImports.readyTime = new Date().getTime();
+  mainDoc.dispatchEvent(
+    new CustomEvent('HTMLImportsLoaded', {bubbles: true})
+  );
+});
+
+// exports
+scope.useNative = useNative;
+scope.isImportLoaded = isImportLoaded;
+scope.whenReady = whenImportsReady;
+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
@@ skipping 88 matching lines @@
           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];
-      if ( redirectedUrl && redirectedUrl !== url ) {
-        this.cache[redirectedUrl] = resource;
-        $p = $p.concat(this.pending[redirectedUrl]);
-      }
       for (var i=0, l=$p.length, p; (i<l) && (p=$p[i]); i++) {
-        //if (!err) {
-          // If url was redirected, use the redirected location so paths are
-          // calculated relative to that.
-          this.onload(redirectedUrl || url, p, resource);
-        //}
+        // 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;
-      if ( redirectedUrl && redirectedUrl !== url ) {
-        this.pending[redirectedUrl] = null;
-      }
     },
     tail: function() {
       --this.inflight;
       this.checkDone();
     },
     checkDone: function() {
       if (!this.inflight) {
         this.oncomplete();
       }
     }
@@ skipping 14 matching lines @@
       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
-              : redirectedUrl;                    // Full 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 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.
+ * 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';
 var flags = scope.flags;
-var isIe = /Trident/.test(navigator.userAgent);
+var isIE = scope.isIE;
 // TODO(sorvell): SD polyfill intrusion
 var mainDoc = window.ShadowDOMPolyfill ? 
     window.ShadowDOMPolyfill.wrapIfNeeded(document) : document;
 
 // 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.
@@ skipping 68 matching lines @@
       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);
     }
-    elt.import.__importParsed = true;
+    if (elt.import) {
+      elt.import.__importParsed = true;
+    }
     this.markParsingComplete(elt);
     // fire load event
-    if (elt.__resource) {
+    if (elt.__resource && !elt.__error) {
       elt.dispatchEvent(new CustomEvent('load', {bubbles: false}));    
     } else {
       elt.dispatchEvent(new CustomEvent('error', {bubbles: false}));
     }
     // TODO(sorvell): workaround for Safari addEventListener not working
     // for elements not in the main document.
     if (elt.__pending) {
       var fn;
       while (elt.__pending.length) {
         fn = elt.__pending.shift();
@@ skipping 15 matching lines @@
   },
   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);
-    document.head.appendChild(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();
     };
     elt.addEventListener('load', done);
     elt.addEventListener('error', done);
 
     // NOTE: IE does not fire "load" event for styles that have already loaded
     // This is in violation of the spec, so we try our hardest to work around it
-    if (isIe && elt.localName === 'style') {
+    if (isIE && elt.localName === 'style') {
       var fakeLoad = false;
       // If there's not @import in the textContent, assume it has loaded
       if (elt.textContent.indexOf('@import') == -1) {
         fakeLoad = true;
       // if we have a sheet, we have been parsed
       } else if (elt.sheet) {
         fakeLoad = true;
         var csr = elt.sheet.cssRules;
         var len = csr ? csr.length : 0;
         // search the rules for @import's
@@ skipping 19 matching lines @@
   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;  
     });
-    document.head.appendChild(script);
+    this.addElementToDocument(script);
   },
   // determine the next element in the tree which should be parsed
   nextToParse: function() {
     return !this.parsingElement && this.nextToParseInDoc(mainDoc);
   },
   nextToParseInDoc: function(doc, link) {
-    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;
+    if (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;
   },
   // 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;
   },
   isParsed: function(node) {
     return node.__importParsed;
   },
   hasResource: function(node) {
-    if (nodeIsImport(node) && !node.import) {
+    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);
-  var b64 = 'data:text/javascript';
-  // base64 may be smaller, but does not handle unicode characters
-  // attempt base64 first, fall back to escaped text
-  try {
-    b64 += (';base64,' + btoa(scriptContent));
-  } catch(e) {
-    b64 += (';charset=utf-8,' + encodeURIComponent(scriptContent));
-  }
-  return b64;
+  return 'data:text/javascript;charset=utf-8,' + encodeURIComponent(scriptContent);
 }
 
 function generateScriptContent(script) {
   return script.textContent + generateSourceMapHint(script);
 }
 
 // calculate source map hint
 function generateSourceMapHint(script) {
   var moniker = script.__nodeUrl;
   if (!moniker) {
@@ skipping 44 matching lines @@
       urlObj.href = urlPath;
       urlPath = urlObj.href;
       return pre + '\'' + urlPath + '\'' + post;
     });    
   }
 }
 
 // exports
 scope.parser = importParser;
 scope.path = path;
-scope.isIE = isIe;
 
 })(HTMLImports);
 
 /*
- * 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.
+ * 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) {
 
-(function(scope) {
-
-var hasNative = ('import' in document.createElement('link'));
-var useNative = hasNative;
+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;
 
 if (!useNative) {
 
   // imports
@@ skipping 27 matching lines @@
     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 :
           this.importsPreloadSelectors;
     },
-    loaded: function(url, elt, resource) {
+    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) {
+        if (doc === undefined) {
           // generate an HTMLDocument from data
-          doc = makeDocument(resource, url);
-          doc.__importLink = elt;
-          // TODO(sorvell): we cannot use MO to detect parsed nodes because
-          // SD polyfill does not report these as mutations.
-          this.bootDocument(doc);
+          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) {
@@ skipping 52 matching lines @@
       // install html
       doc.body.innerHTML = resource;
     }
     // TODO(sorvell): ideally this code is not aware of Template polyfill,
     // but for now the polyfill needs help to bootstrap these templates
     if (window.HTMLTemplateElement && HTMLTemplateElement.bootstrap) {
       HTMLTemplateElement.bootstrap(doc);
     }
     return doc;
   }
+
+  // Polyfill document.baseURI for browsers without it.
+  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);
+  }
+
+  // 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 = {};
 }
 
-// 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() {
-    return HTMLImports.currentScript || document.currentScript;
-  },
-  configurable: true
-};
-
-Object.defineProperty(document, '_currentScript', currentScriptDescriptor);
-Object.defineProperty(mainDoc, '_currentScript', currentScriptDescriptor);
-
-// Polyfill document.baseURI for browsers without it.
-if (!document.baseURI) {
-  var baseURIDescriptor = {
-    get: function() {
-      return window.location.href;
-    },
-    configurable: true
-  };
-
-  Object.defineProperty(document, 'baseURI', baseURIDescriptor);
-  Object.defineProperty(mainDoc, 'baseURI', baseURIDescriptor);
-}
-
-// 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;
-  // 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 = HTMLImports.isIE ? 'complete' : 'interactive';
-var READY_EVENT = 'readystatechange';
-function isDocumentReady(doc) {
-  return (doc.readyState === 'complete' ||
-      doc.readyState === requiredReadyState);
-}
-
-// call <callback> when we ensure the document is in a ready state
-function whenDocumentReady(callback, doc) {
-  if (!isDocumentReady(doc)) {
-    var checkReady = function() {
-      if (doc.readyState === 'complete' || 
-          doc.readyState === requiredReadyState) {
-        doc.removeEventListener(READY_EVENT, checkReady);
-        whenDocumentReady(callback, doc);
-      }
-    }
-    doc.addEventListener(READY_EVENT, checkReady);
-  } else if (callback) {
-    callback();
-  }
-}
-
-// 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();
-    }
-  }
-  function loadedImport(e) {
-    loaded++;
-    checkDone();
-  }
-  if (l) {
-    for (var i=0, imp; (i<l) && (imp=imports[i]); i++) {
-      if (isImportLoaded(imp)) {
-        loadedImport.call(imp);
-      } else {
-        imp.addEventListener('load', loadedImport);
-        imp.addEventListener('error', loadedImport);
-      }
-    }
-  } else {
-    checkDone();
-  }
-}
-
-function isImportLoaded(link) {
-  return useNative ? (link.import && (link.import.readyState !== 'loading')) || link.__loaded :
-      link.__importParsed;
-}
-
-// TODO(sorvell): install a mutation observer to see if HTMLImports have loaded
-// this is a workaround for https://www.w3.org/Bugs/Public/show_bug.cgi?id=25007
-// and should be removed when this bug is addressed.
-if (useNative) {
-  new MutationObserver(function(mxns) {
-    for (var i=0, l=mxns.length, m; (i < l) && (m=mxns[i]); i++) {
-      if (m.addedNodes) {
-        handleImports(m.addedNodes);
-      }
-    }
-  }).observe(document.head, {childList: true});
-
-  function handleImports(nodes) {
-    for (var i=0, l=nodes.length, n; (i<l) && (n=nodes[i]); i++) {
-      if (isImport(n)) {
-        handleImport(n);  
-      }
-    }
-  }
-
-  function isImport(element) {
-    return element.localName === 'link' && element.rel === 'import';
-  }
-
-  function handleImport(element) {
-    var loaded = element.import;
-    if (loaded) {
-      markTargetLoaded({target: element});
-    } else {
-      element.addEventListener('load', markTargetLoaded);
-      element.addEventListener('error', markTargetLoaded);
-    }
-  }
-
-  function markTargetLoaded(event) {
-    event.target.__loaded = true;
-  }
-
-}
-
 // exports
-scope.hasNative = hasNative;
-scope.useNative = useNative;
 scope.importer = importer;
 scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;
-scope.isImportLoaded = isImportLoaded;
 scope.importLoader = importLoader;
-scope.whenReady = whenImportsReady;
 
-// deprecated
-scope.whenImportsReady = whenImportsReady;
 
 })(window.HTMLImports);
 
- /*
-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.
-*/
-
+/*
+ * 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 = scope.IMPORT_LINK_TYPE;
 var importSelector = 'link[rel=' + IMPORT_LINK_TYPE + ']';
 var importer = scope.importer;
 var parser = scope.parser;
 
 // 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++) {
@@ skipping 45 matching lines @@
 }
 
 // exports
 // TODO(sorvell): factor so can put on scope
 scope.observe = observe;
 importer.observe = observe;
 
 })(HTMLImports);
 
 /*
- * 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.
+ * 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(){
 
 // bootstrap
 
-// 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;
-  };
-}
-
 // TODO(sorvell): SD polyfill intrusion
 var doc = window.ShadowDOMPolyfill ? 
     window.ShadowDOMPolyfill.wrapIfNeeded(document) : document;
 
-// 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.
-HTMLImports.whenImportsReady(function() {
-  HTMLImports.ready = true;
-  HTMLImports.readyTime = new Date().getTime();
-  doc.dispatchEvent(
-    new CustomEvent('HTMLImportsLoaded', {bubbles: true})
-  );
-});
-
-
 // no need to bootstrap the polyfill when native imports is available.
 if (!HTMLImports.useNative) {
   function bootstrap() {
     HTMLImports.importer.bootDocument(doc);
   }
     
   // TODO(sorvell): SD polyfill does *not* generate mutations for nodes added
   // by the parser. For this reason, we must wait until the dom exists to 
   // bootstrap.
   if (document.readyState === 'complete' ||
       (document.readyState === 'interactive' && !window.attachEvent)) {
     bootstrap();
   } else {
     document.addEventListener('DOMContentLoaded', bootstrap);
   }
 }
 
 })();
 
 /*
- * 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.
+ * 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.CustomElements = window.CustomElements || {flags:{}};
- /*
-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.
-*/
+/*
+ * 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 logFlags = window.logFlags || {};
 var IMPORT_LINK_TYPE = window.HTMLImports ? HTMLImports.IMPORT_LINK_TYPE : 'none';
 
 // walk the subtree rooted at node, applying 'find(element, data)' function
 // to each element
 // if 'find' returns true for 'element', do not search element's subtree
 function findAll(node, find, data) {
@@ skipping 321 matching lines @@
 scope.insertedNode = insertedNode;
 
 scope.observeDocument = observeDocument;
 scope.upgradeDocument = upgradeDocument;
 
 scope.takeRecords = takeRecords;
 
 })(window.CustomElements);
 
 /*
- * 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.
+ * 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
  */
 
 /**
- * Implements `document.register`
+ * Implements `document.registerElement`
  * @module CustomElements
 */
 
 /**
  * Polyfilled extensions to the `document` object.
  * @class Document
 */
 
 (function(scope) {
 
@@ skipping 211 matching lines @@
     // output is a valid DOM element with the proper wrapper in place.
     //
     return upgrade(domCreateElement(definition.tag), definition);
   }
 
   function upgrade(element, definition) {
     // some definitions specify an 'is' attribute
     if (definition.is) {
       element.setAttribute('is', definition.is);
     }
-    // remove 'unresolved' attr, which is a standin for :unresolved.
-    element.removeAttribute('unresolved');
     // make 'element' implement definition.prototype
     implement(element, definition);
     // flag as upgraded
     element.__upgraded__ = true;
     // lifecycle management
     created(element);
     // attachedCallback fires in tree order, call before recursing
     scope.insertedNode(element);
     // there should never be a shadow root on element at this point
     scope.upgradeSubtree(element);
@@ skipping 217 matching lines @@
 
 // bc
 document.register = document.registerElement;
 
 scope.hasNative = hasNative;
 scope.useNative = useNative;
 
 })(window.CustomElements);
 
 /*
- * 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.
+ * 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) {
 
 // import
 
 var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;
 
 // highlander object for parsing a document tree
 
@@ skipping 41 matching lines @@
 
 var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
 
 // exports
 
 scope.parser = parser;
 scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;
 
 })(window.CustomElements);
 /*
- * 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.
+ * 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){
 
 // bootstrap parsing
 function bootstrap() {
   // parse document
   CustomElements.parser.parse(document);
   // one more pass before register is 'live'
   CustomElements.upgradeDocument(document);
-  // choose async
-  var async = window.Platform && Platform.endOfMicrotask ? 
-    Platform.endOfMicrotask :
-    setTimeout;
-  async(function() {
-    // set internal 'ready' flag, now document.registerElement will trigger 
-    // synchronous upgrades
-    CustomElements.ready = true;
+  // install upgrade hook if HTMLImports are available
+  if (window.HTMLImports) {
+    HTMLImports.__importsParsingHook = function(elt) {
+      CustomElements.parser.parse(elt.import);
+    }
+  }
+  // set internal 'ready' flag, now document.registerElement will trigger 
+  // synchronous upgrades
+  CustomElements.ready = true;
+  // async to ensure *native* custom elements upgrade prior to this
+  // DOMContentLoaded can fire before elements upgrade (e.g. when there's
+  // an external script)
+  setTimeout(function() {
     // capture blunt profiling data
     CustomElements.readyTime = Date.now();
     if (window.HTMLImports) {
       CustomElements.elapsed = CustomElements.readyTime - HTMLImports.readyTime;
     }
     // notify the system that we are bootstrapped
     document.dispatchEvent(
       new CustomEvent('WebComponentsReady', {bubbles: true})
     );
-
-    // install upgrade hook if HTMLImports are available
-    if (window.HTMLImports) {
-      HTMLImports.__importsParsingHook = function(elt) {
-        CustomElements.parser.parse(elt.import);
-      }
-    }
   });
 }
 
 // CustomEvent shim for IE
 if (typeof window.CustomEvent !== 'function') {
-  window.CustomEvent = function(inType) {
-    var e = document.createEvent('HTMLEvents');
-    e.initEvent(inType, true, true);
+  window.CustomEvent = function(inType, params) {
+    params = params || {};
+    var e = document.createEvent('CustomEvent');
+    e.initCustomEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable), params.detail);
     return e;
   };
+  window.CustomEvent.prototype = window.Event.prototype;
 }
 
 // When loading at readyState complete time (or via flag), boot custom elements
 // immediately.
 // If relevant, HTMLImports must already be loaded.
 if (document.readyState === 'complete' || scope.flags.eager) {
   bootstrap();
 // When loading at readyState interactive time, bootstrap only if HTMLImports
 // are not pending. Also avoid IE as the semantics of this state are unreliable.
 } else if (document.readyState === 'interactive' && !window.attachEvent &&
@@ skipping 1144 matching lines @@
     get bindingDelegate() {
       return this.delegate_ && this.delegate_.raw;
     },
 
     refChanged_: function() {
       if (!this.iterator_ || this.refContent_ === this.ref_.content)
         return;
 
       this.refContent_ = undefined;
       this.iterator_.valueChanged();
-      this.iterator_.updateIteratedValue();
+      this.iterator_.updateIteratedValue(this.iterator_.getUpdatedValue());
     },
 
     clear: function() {
       this.model_ = undefined;
       this.delegate_ = undefined;
       if (this.bindings_ && this.bindings_.ref)
         this.bindings_.ref.close()
       this.refContent_ = undefined;
       if (!this.iterator_)
         return;
@@ skipping 383 matching lines @@
           deps.value.close();
       }
     },
 
     updateDependencies: function(directives, model) {
       this.closeDeps();
 
       var deps = this.deps = {};
       var template = this.templateElement_;
 
+      var ifValue = true;
       if (directives.if) {
         deps.hasIf = true;
         deps.ifOneTime = directives.if.onlyOneTime;
         deps.ifValue = processBinding(IF, directives.if, template, model);
 
+        ifValue = deps.ifValue;
+
         // oneTime if & predicate is false. nothing else to do.
-        if (deps.ifOneTime && !deps.ifValue) {
-          this.updateIteratedValue();
+        if (deps.ifOneTime && !ifValue) {
+          this.valueChanged();
           return;
         }
 
         if (!deps.ifOneTime)
-          deps.ifValue.open(this.updateIteratedValue, this);
+          ifValue = ifValue.open(this.updateIfValue, this);
       }
 
       if (directives.repeat) {
         deps.repeat = true;
         deps.oneTime = directives.repeat.onlyOneTime;
         deps.value = processBinding(REPEAT, directives.repeat, template, model);
       } else {
         deps.repeat = false;
         deps.oneTime = directives.bind.onlyOneTime;
         deps.value = processBinding(BIND, directives.bind, template, model);
       }
 
+      var value = deps.value;
       if (!deps.oneTime)
-        deps.value.open(this.updateIteratedValue, this);
+        value = value.open(this.updateIteratedValue, this);
 
-      this.updateIteratedValue();
+      if (!ifValue) {
+        this.valueChanged();
+        return;
+      }
+
+      this.updateValue(value);
     },
 
-    updateIteratedValue: function() {
+    /**
+     * Gets the updated value of the bind/repeat. This can potentially call
+     * user code (if a bindingDelegate is set up) so we try to avoid it if we
+     * already have the value in hand (from Observer.open).
+     */
+    getUpdatedValue: function() {
+      var value = this.deps.value;
+      if (!this.deps.oneTime)
+        value = value.discardChanges();
+      return value;
+    },
+
+    updateIfValue: function(ifValue) {
+      if (!ifValue) {
+        this.valueChanged();
+        return;
+      }
+
+      this.updateValue(this.getUpdatedValue());
+    },
+
+    updateIteratedValue: function(value) {
       if (this.deps.hasIf) {
         var ifValue = this.deps.ifValue;
         if (!this.deps.ifOneTime)
           ifValue = ifValue.discardChanges();
         if (!ifValue) {
           this.valueChanged();
           return;
         }
       }
 
-      var value = this.deps.value;
-      if (!this.deps.oneTime)
-        value = value.discardChanges();
+      this.updateValue(value);
+    },
+
+    updateValue: function(value) {
       if (!this.deps.repeat)
         value = [value];
       var observe = this.deps.repeat &&
                     !this.deps.oneTime &&
                     Array.isArray(value);
       this.valueChanged(value, observe);
     },
 
     valueChanged: function(value, observeValue) {
       if (!Array.isArray(value))
@@ skipping 269 matching lines @@
     return imported;
   }
 }
 
 // exports
 scope.flush = flush;
 
 })(window.Platform);
 
 
-//# sourceMappingURL=platform.concat.js.map
+//# sourceMappingURL=platform.concat.js.map