trace-viewer/tracing/third_party/components/webcomponentsjs/CustomElements.js - platform/external/chromium-trace - Git at Google

 /**
  * @license
  * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
  * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
  * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
  * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
  * Code distributed by Google as part of the polymer project is also
  * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
  */
 // @version 0.5.5
 if (typeof WeakMap === "undefined") {
   (function() {
     var defineProperty = Object.defineProperty;
     var counter = Date.now() % 1e9;
     var WeakMap = function() {
       this.name = "__st" + (Math.random() * 1e9 >>> 0) + (counter++ + "__");
     };
     WeakMap.prototype = {
       set: function(key, value) {
         var entry = key[this.name];
         if (entry && entry[0] === key) entry[1] = value; else defineProperty(key, this.name, {
           value: [ key, value ],
           writable: true
         });
         return this;
       },
       get: function(key) {
         var entry;
         return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined;
       },
       "delete": function(key) {
         var entry = key[this.name];
         if (!entry || entry[0] !== key) return false;
         entry[0] = entry[1] = undefined;
         return true;
       },
       has: function(key) {
         var entry = key[this.name];
         if (!entry) return false;
         return entry[0] === key;
       }
     };
     window.WeakMap = WeakMap;
   })();
 }

 window.CustomElements = window.CustomElements || {
   flags: {}
 };

 (function(scope) {
   var flags = scope.flags;
   var modules = [];
   var addModule = function(module) {
     modules.push(module);
   };
   var initializeModules = function() {
     modules.forEach(function(module) {
       module(scope);
     });
   };
   scope.addModule = addModule;
   scope.initializeModules = initializeModules;
   scope.hasNative = Boolean(document.registerElement);
   scope.useNative = !flags.register && scope.hasNative && !window.ShadowDOMPolyfill && (!window.HTMLImports || HTMLImports.useNative);
 })(CustomElements);

 CustomElements.addModule(function(scope) {
   var IMPORT_LINK_TYPE = window.HTMLImports ? HTMLImports.IMPORT_LINK_TYPE : "none";
   function forSubtree(node, cb) {
     findAllElements(node, function(e) {
       if (cb(e)) {
         return true;
       }
       forRoots(e, cb);
     });
     forRoots(node, cb);
   }
   function findAllElements(node, find, data) {
     var e = node.firstElementChild;
     if (!e) {
       e = node.firstChild;
       while (e && e.nodeType !== Node.ELEMENT_NODE) {
         e = e.nextSibling;
       }
     }
     while (e) {
       if (find(e, data) !== true) {
         findAllElements(e, find, data);
       }
       e = e.nextElementSibling;
     }
     return null;
   }
   function forRoots(node, cb) {
     var root = node.shadowRoot;
     while (root) {
       forSubtree(root, cb);
       root = root.olderShadowRoot;
     }
   }
   var processingDocuments;
   function forDocumentTree(doc, cb) {
     processingDocuments = [];
     _forDocumentTree(doc, cb);
     processingDocuments = null;
   }
   function _forDocumentTree(doc, cb) {
     doc = wrap(doc);
     if (processingDocuments.indexOf(doc) >= 0) {
       return;
     }
     processingDocuments.push(doc);
     var imports = doc.querySelectorAll("link[rel=" + IMPORT_LINK_TYPE + "]");
     for (var i = 0, l = imports.length, n; i < l && (n = imports[i]); i++) {
       if (n.import) {
         _forDocumentTree(n.import, cb);
       }
     }
     cb(doc);
   }
   scope.forDocumentTree = forDocumentTree;
   scope.forSubtree = forSubtree;
 });

 CustomElements.addModule(function(scope) {
   var flags = scope.flags;
   var forSubtree = scope.forSubtree;
   var forDocumentTree = scope.forDocumentTree;
   function addedNode(node) {
     return added(node) || addedSubtree(node);
   }
   function added(node) {
     if (scope.upgrade(node)) {
       return true;
     }
     attached(node);
   }
   function addedSubtree(node) {
     forSubtree(node, function(e) {
       if (added(e)) {
         return true;
       }
     });
   }
   function attachedNode(node) {
     attached(node);
     if (inDocument(node)) {
       forSubtree(node, function(e) {
         attached(e);
       });
     }
   }
   var hasPolyfillMutations = !window.MutationObserver || window.MutationObserver === window.JsMutationObserver;
   scope.hasPolyfillMutations = hasPolyfillMutations;
   var isPendingMutations = false;
   var pendingMutations = [];
   function deferMutation(fn) {
     pendingMutations.push(fn);
     if (!isPendingMutations) {
       isPendingMutations = true;
       setTimeout(takeMutations);
     }
   }
   function takeMutations() {
     isPendingMutations = false;
     var $p = pendingMutations;
     for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) {
       p();
     }
     pendingMutations = [];
   }
   function attached(element) {
     if (hasPolyfillMutations) {
       deferMutation(function() {
         _attached(element);
       });
     } else {
       _attached(element);
     }
   }
   function _attached(element) {
     if (element.__upgraded__ && (element.attachedCallback || element.detachedCallback)) {
       if (!element.__attached && inDocument(element)) {
         element.__attached = true;
         if (element.attachedCallback) {
           element.attachedCallback();
         }
       }
     }
   }
   function detachedNode(node) {
     detached(node);
     forSubtree(node, function(e) {
       detached(e);
     });
   }
   function detached(element) {
     if (hasPolyfillMutations) {
       deferMutation(function() {
         _detached(element);
       });
     } else {
       _detached(element);
     }
   }
   function _detached(element) {
     if (element.__upgraded__ && (element.attachedCallback || element.detachedCallback)) {
       if (element.__attached && !inDocument(element)) {
         element.__attached = false;
         if (element.detachedCallback) {
           element.detachedCallback();
         }
       }
     }
   }
   function inDocument(element) {
     var p = element;
     var doc = wrap(document);
     while (p) {
       if (p == doc) {
         return true;
       }
       p = p.parentNode || p.host;
     }
   }
   function watchShadow(node) {
     if (node.shadowRoot && !node.shadowRoot.__watched) {
       flags.dom && console.log("watching shadow-root for: ", node.localName);
       var root = node.shadowRoot;
       while (root) {
         observe(root);
         root = root.olderShadowRoot;
       }
     }
   }
   function handler(mutations) {
     if (flags.dom) {
       var mx = mutations[0];
       if (mx && mx.type === "childList" && mx.addedNodes) {
         if (mx.addedNodes) {
           var d = mx.addedNodes[0];
           while (d && d !== document && !d.host) {
             d = d.parentNode;
           }
           var u = d && (d.URL || d._URL || d.host && d.host.localName) || "";
           u = u.split("/?").shift().split("/").pop();
         }
       }
       console.group("mutations (%d) [%s]", mutations.length, u || "");
     }
     mutations.forEach(function(mx) {
       if (mx.type === "childList") {
         forEach(mx.addedNodes, function(n) {
           if (!n.localName) {
             return;
           }
           addedNode(n);
         });
         forEach(mx.removedNodes, function(n) {
           if (!n.localName) {
             return;
           }
           detachedNode(n);
         });
       }
     });
     flags.dom && console.groupEnd();
   }
   function takeRecords(node) {
     node = wrap(node);
     if (!node) {
       node = wrap(document);
     }
     while (node.parentNode) {
       node = node.parentNode;
     }
     var observer = node.__observer;
     if (observer) {
       handler(observer.takeRecords());
       takeMutations();
     }
   }
   var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
   function observe(inRoot) {
     if (inRoot.__observer) {
       return;
     }
     var observer = new MutationObserver(handler);
     observer.observe(inRoot, {
       childList: true,
       subtree: true
     });
     inRoot.__observer = observer;
   }
   function upgradeDocument(doc) {
     doc = wrap(doc);
     flags.dom && console.group("upgradeDocument: ", doc.baseURI.split("/").pop());
     addedNode(doc);
     observe(doc);
     flags.dom && console.groupEnd();
   }
   function upgradeDocumentTree(doc) {
     forDocumentTree(doc, upgradeDocument);
   }
   var originalCreateShadowRoot = Element.prototype.createShadowRoot;
   if (originalCreateShadowRoot) {
     Element.prototype.createShadowRoot = function() {
       var root = originalCreateShadowRoot.call(this);
       CustomElements.watchShadow(this);
       return root;
     };
   }
   scope.watchShadow = watchShadow;
   scope.upgradeDocumentTree = upgradeDocumentTree;
   scope.upgradeSubtree = addedSubtree;
   scope.upgradeAll = addedNode;
   scope.attachedNode = attachedNode;
   scope.takeRecords = takeRecords;
 });

 CustomElements.addModule(function(scope) {
   var flags = scope.flags;
   function upgrade(node) {
     if (!node.__upgraded__ && node.nodeType === Node.ELEMENT_NODE) {
       var is = node.getAttribute("is");
       var definition = scope.getRegisteredDefinition(is || node.localName);
       if (definition) {
         if (is && definition.tag == node.localName) {
           return upgradeWithDefinition(node, definition);
         } else if (!is && !definition.extends) {
           return upgradeWithDefinition(node, definition);
         }
       }
     }
   }
   function upgradeWithDefinition(element, definition) {
     flags.upgrade && console.group("upgrade:", element.localName);
     if (definition.is) {
       element.setAttribute("is", definition.is);
     }
     implementPrototype(element, definition);
     element.__upgraded__ = true;
     created(element);
     scope.attachedNode(element);
     scope.upgradeSubtree(element);
     flags.upgrade && console.groupEnd();
     return element;
   }
   function implementPrototype(element, definition) {
     if (Object.__proto__) {
       element.__proto__ = definition.prototype;
     } else {
       customMixin(element, definition.prototype, definition.native);
       element.__proto__ = definition.prototype;
     }
   }
   function customMixin(inTarget, inSrc, inNative) {
     var used = {};
     var p = inSrc;
     while (p !== inNative && p !== HTMLElement.prototype) {
       var keys = Object.getOwnPropertyNames(p);
       for (var i = 0, k; k = keys[i]; i++) {
         if (!used[k]) {
           Object.defineProperty(inTarget, k, Object.getOwnPropertyDescriptor(p, k));
           used[k] = 1;
         }
       }
       p = Object.getPrototypeOf(p);
     }
   }
   function created(element) {
     if (element.createdCallback) {
       element.createdCallback();
     }
   }
   scope.upgrade = upgrade;
   scope.upgradeWithDefinition = upgradeWithDefinition;
   scope.implementPrototype = implementPrototype;
 });

 CustomElements.addModule(function(scope) {
   var upgradeDocumentTree = scope.upgradeDocumentTree;
   var upgrade = scope.upgrade;
   var upgradeWithDefinition = scope.upgradeWithDefinition;
   var implementPrototype = scope.implementPrototype;
   var useNative = scope.useNative;
   function register(name, options) {
     var definition = options || {};
     if (!name) {
       throw new Error("document.registerElement: first argument `name` must not be empty");
     }
     if (name.indexOf("-") < 0) {
       throw new Error("document.registerElement: first argument ('name') must contain a dash ('-'). Argument provided was '" + String(name) + "'.");
     }
     if (isReservedTag(name)) {
       throw new Error("Failed to execute 'registerElement' on 'Document': Registration failed for type '" + String(name) + "'. The type name is invalid.");
     }
     if (getRegisteredDefinition(name)) {
       throw new Error("DuplicateDefinitionError: a type with name '" + String(name) + "' is already registered");
     }
     if (!definition.prototype) {
       definition.prototype = Object.create(HTMLElement.prototype);
     }
     definition.__name = name.toLowerCase();
     definition.lifecycle = definition.lifecycle || {};
     definition.ancestry = ancestry(definition.extends);
     resolveTagName(definition);
     resolvePrototypeChain(definition);
     overrideAttributeApi(definition.prototype);
     registerDefinition(definition.__name, definition);
     definition.ctor = generateConstructor(definition);
     definition.ctor.prototype = definition.prototype;
     definition.prototype.constructor = definition.ctor;
     if (scope.ready) {
       upgradeDocumentTree(document);
     }
     return definition.ctor;
   }
   function overrideAttributeApi(prototype) {
     if (prototype.setAttribute._polyfilled) {
       return;
     }
     var setAttribute = prototype.setAttribute;
     prototype.setAttribute = function(name, value) {
       changeAttribute.call(this, name, value, setAttribute);
     };
     var removeAttribute = prototype.removeAttribute;
     prototype.removeAttribute = function(name) {
       changeAttribute.call(this, name, null, removeAttribute);
     };
     prototype.setAttribute._polyfilled = true;
   }
   function changeAttribute(name, value, operation) {
     name = name.toLowerCase();
     var oldValue = this.getAttribute(name);
     operation.apply(this, arguments);
     var newValue = this.getAttribute(name);
     if (this.attributeChangedCallback && newValue !== oldValue) {
       this.attributeChangedCallback(name, oldValue, newValue);
     }
   }
   function isReservedTag(name) {
     for (var i = 0; i < reservedTagList.length; i++) {
       if (name === reservedTagList[i]) {
         return true;
       }
     }
   }
   var reservedTagList = [ "annotation-xml", "color-profile", "font-face", "font-face-src", "font-face-uri", "font-face-format", "font-face-name", "missing-glyph" ];
   function ancestry(extnds) {
     var extendee = getRegisteredDefinition(extnds);
     if (extendee) {
       return ancestry(extendee.extends).concat([ extendee ]);
     }
     return [];
   }
   function resolveTagName(definition) {
     var baseTag = definition.extends;
     for (var i = 0, a; a = definition.ancestry[i]; i++) {
       baseTag = a.is && a.tag;
     }
     definition.tag = baseTag || definition.__name;
     if (baseTag) {
       definition.is = definition.__name;
     }
   }
   function resolvePrototypeChain(definition) {
     if (!Object.__proto__) {
       var nativePrototype = HTMLElement.prototype;
       if (definition.is) {
         var inst = document.createElement(definition.tag);
         var expectedPrototype = Object.getPrototypeOf(inst);
         if (expectedPrototype === definition.prototype) {
           nativePrototype = expectedPrototype;
         }
       }
       var proto = definition.prototype, ancestor;
       while (proto && proto !== nativePrototype) {
         ancestor = Object.getPrototypeOf(proto);
         proto.__proto__ = ancestor;
         proto = ancestor;
       }
       definition.native = nativePrototype;
     }
   }
   function instantiate(definition) {
     return upgradeWithDefinition(domCreateElement(definition.tag), definition);
   }
   var registry = {};
   function getRegisteredDefinition(name) {
     if (name) {
       return registry[name.toLowerCase()];
     }
   }
   function registerDefinition(name, definition) {
     registry[name] = definition;
   }
   function generateConstructor(definition) {
     return function() {
       return instantiate(definition);
     };
   }
   var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
   function createElementNS(namespace, tag, typeExtension) {
     if (namespace === HTML_NAMESPACE) {
       return createElement(tag, typeExtension);
     } else {
       return domCreateElementNS(namespace, tag);
     }
   }
   function createElement(tag, typeExtension) {
     var definition = getRegisteredDefinition(typeExtension || tag);
     if (definition) {
       if (tag == definition.tag && typeExtension == definition.is) {
         return new definition.ctor();
       }
       if (!typeExtension && !definition.is) {
         return new definition.ctor();
       }
     }
     var element;
     if (typeExtension) {
       element = createElement(tag);
       element.setAttribute("is", typeExtension);
       return element;
     }
     element = domCreateElement(tag);
     if (tag.indexOf("-") >= 0) {
       implementPrototype(element, HTMLElement);
     }
     return element;
   }
   function cloneNode(deep) {
     var n = domCloneNode.call(this, deep);
     upgrade(n);
     return n;
   }
   var domCreateElement = document.createElement.bind(document);
   var domCreateElementNS = document.createElementNS.bind(document);
   var domCloneNode = Node.prototype.cloneNode;
   var isInstance;
   if (!Object.__proto__ && !useNative) {
     isInstance = function(obj, ctor) {
       var p = obj;
       while (p) {
         if (p === ctor.prototype) {
           return true;
         }
         p = p.__proto__;
       }
       return false;
     };
   } else {
     isInstance = function(obj, base) {
       return obj instanceof base;
     };
   }
   document.registerElement = register;
   document.createElement = createElement;
   document.createElementNS = createElementNS;
   Node.prototype.cloneNode = cloneNode;
   scope.registry = registry;
   scope.instanceof = isInstance;
   scope.reservedTagList = reservedTagList;
   scope.getRegisteredDefinition = getRegisteredDefinition;
   document.register = document.registerElement;
 });

 (function(scope) {
   var useNative = scope.useNative;
   var initializeModules = scope.initializeModules;
   var isIE11OrOlder = /Trident/.test(navigator.userAgent);
   if (useNative) {
     var nop = function() {};
     scope.watchShadow = nop;
     scope.upgrade = nop;
     scope.upgradeAll = nop;
     scope.upgradeDocumentTree = nop;
     scope.upgradeSubtree = nop;
     scope.takeRecords = nop;
     scope.instanceof = function(obj, base) {
       return obj instanceof base;
     };
   } else {
     initializeModules();
   }
   var upgradeDocumentTree = scope.upgradeDocumentTree;
   if (!window.wrap) {
     if (window.ShadowDOMPolyfill) {
       window.wrap = ShadowDOMPolyfill.wrapIfNeeded;
       window.unwrap = ShadowDOMPolyfill.unwrapIfNeeded;
     } else {
       window.wrap = window.unwrap = function(node) {
         return node;
       };
     }
   }
   function bootstrap() {
     upgradeDocumentTree(wrap(document));
     if (window.HTMLImports) {
       HTMLImports.__importsParsingHook = function(elt) {
         upgradeDocumentTree(wrap(elt.import));
       };
     }
     CustomElements.ready = true;
     setTimeout(function() {
       CustomElements.readyTime = Date.now();
       if (window.HTMLImports) {
         CustomElements.elapsed = CustomElements.readyTime - HTMLImports.readyTime;
       }
       document.dispatchEvent(new CustomEvent("WebComponentsReady", {
         bubbles: true
       }));
     });
   }
   if (isIE11OrOlder && typeof window.CustomEvent !== "function") {
     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;
   }
   if (document.readyState === "complete" || scope.flags.eager) {
     bootstrap();
   } else if (document.readyState === "interactive" && !window.attachEvent && (!window.HTMLImports || window.HTMLImports.ready)) {
     bootstrap();
   } else {
     var loadEvent = window.HTMLImports && !HTMLImports.ready ? "HTMLImportsLoaded" : "DOMContentLoaded";
     window.addEventListener(loadEvent, bootstrap);
   }
 })(window.CustomElements);
	/**
	* @license
	* Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
	* This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
	* The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
	* The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
	* Code distributed by Google as part of the polymer project is also
	* subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
	*/
	// @version 0.5.5
	if (typeof WeakMap === "undefined") {
	(function() {
	var defineProperty = Object.defineProperty;
	var counter = Date.now() % 1e9;
	var WeakMap = function() {
	this.name = "__st" + (Math.random() * 1e9 >>> 0) + (counter++ + "__");
	};
	WeakMap.prototype = {
	set: function(key, value) {
	var entry = key[this.name];
	if (entry && entry[0] === key) entry[1] = value; else defineProperty(key, this.name, {
	value: [ key, value ],
	writable: true
	});
	return this;
	},
	get: function(key) {
	var entry;
	return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined;
	},
	"delete": function(key) {
	var entry = key[this.name];
	if (!entry \|\| entry[0] !== key) return false;
	entry[0] = entry[1] = undefined;
	return true;
	},
	has: function(key) {
	var entry = key[this.name];
	if (!entry) return false;
	return entry[0] === key;
	}
	};
	window.WeakMap = WeakMap;
	})();
	}

	window.CustomElements = window.CustomElements \|\| {
	flags: {}
	};

	(function(scope) {
	var flags = scope.flags;
	var modules = [];
	var addModule = function(module) {
	modules.push(module);
	};
	var initializeModules = function() {
	modules.forEach(function(module) {
	module(scope);
	});
	};
	scope.addModule = addModule;
	scope.initializeModules = initializeModules;
	scope.hasNative = Boolean(document.registerElement);
	scope.useNative = !flags.register && scope.hasNative && !window.ShadowDOMPolyfill && (!window.HTMLImports \|\| HTMLImports.useNative);
	})(CustomElements);

	CustomElements.addModule(function(scope) {
	var IMPORT_LINK_TYPE = window.HTMLImports ? HTMLImports.IMPORT_LINK_TYPE : "none";
	function forSubtree(node, cb) {
	findAllElements(node, function(e) {
	if (cb(e)) {
	return true;
	}
	forRoots(e, cb);
	});
	forRoots(node, cb);
	}
	function findAllElements(node, find, data) {
	var e = node.firstElementChild;
	if (!e) {
	e = node.firstChild;
	while (e && e.nodeType !== Node.ELEMENT_NODE) {
	e = e.nextSibling;
	}
	}
	while (e) {
	if (find(e, data) !== true) {
	findAllElements(e, find, data);
	}
	e = e.nextElementSibling;
	}
	return null;
	}
	function forRoots(node, cb) {
	var root = node.shadowRoot;
	while (root) {
	forSubtree(root, cb);
	root = root.olderShadowRoot;
	}
	}
	var processingDocuments;
	function forDocumentTree(doc, cb) {
	processingDocuments = [];
	_forDocumentTree(doc, cb);
	processingDocuments = null;
	}
	function _forDocumentTree(doc, cb) {
	doc = wrap(doc);
	if (processingDocuments.indexOf(doc) >= 0) {
	return;
	}
	processingDocuments.push(doc);
	var imports = doc.querySelectorAll("link[rel=" + IMPORT_LINK_TYPE + "]");
	for (var i = 0, l = imports.length, n; i < l && (n = imports[i]); i++) {
	if (n.import) {
	_forDocumentTree(n.import, cb);
	}
	}
	cb(doc);
	}
	scope.forDocumentTree = forDocumentTree;
	scope.forSubtree = forSubtree;
	});

	CustomElements.addModule(function(scope) {
	var flags = scope.flags;
	var forSubtree = scope.forSubtree;
	var forDocumentTree = scope.forDocumentTree;
	function addedNode(node) {
	return added(node) \|\| addedSubtree(node);
	}
	function added(node) {
	if (scope.upgrade(node)) {
	return true;
	}
	attached(node);
	}
	function addedSubtree(node) {
	forSubtree(node, function(e) {
	if (added(e)) {
	return true;
	}
	});
	}
	function attachedNode(node) {
	attached(node);
	if (inDocument(node)) {
	forSubtree(node, function(e) {
	attached(e);
	});
	}
	}
	var hasPolyfillMutations = !window.MutationObserver \|\| window.MutationObserver === window.JsMutationObserver;
	scope.hasPolyfillMutations = hasPolyfillMutations;
	var isPendingMutations = false;
	var pendingMutations = [];
	function deferMutation(fn) {
	pendingMutations.push(fn);
	if (!isPendingMutations) {
	isPendingMutations = true;
	setTimeout(takeMutations);
	}
	}
	function takeMutations() {
	isPendingMutations = false;
	var $p = pendingMutations;
	for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) {
	p();
	}
	pendingMutations = [];
	}
	function attached(element) {
	if (hasPolyfillMutations) {
	deferMutation(function() {
	_attached(element);
	});
	} else {
	_attached(element);
	}
	}
	function _attached(element) {
	if (element.__upgraded__ && (element.attachedCallback \|\| element.detachedCallback)) {
	if (!element.__attached && inDocument(element)) {
	element.__attached = true;
	if (element.attachedCallback) {
	element.attachedCallback();
	}
	}
	}
	}
	function detachedNode(node) {
	detached(node);
	forSubtree(node, function(e) {
	detached(e);
	});
	}
	function detached(element) {
	if (hasPolyfillMutations) {
	deferMutation(function() {
	_detached(element);
	});
	} else {
	_detached(element);
	}
	}
	function _detached(element) {
	if (element.__upgraded__ && (element.attachedCallback \|\| element.detachedCallback)) {
	if (element.__attached && !inDocument(element)) {
	element.__attached = false;
	if (element.detachedCallback) {
	element.detachedCallback();
	}
	}
	}
	}
	function inDocument(element) {
	var p = element;
	var doc = wrap(document);
	while (p) {
	if (p == doc) {
	return true;
	}
	p = p.parentNode \|\| p.host;
	}
	}
	function watchShadow(node) {
	if (node.shadowRoot && !node.shadowRoot.__watched) {
	flags.dom && console.log("watching shadow-root for: ", node.localName);
	var root = node.shadowRoot;
	while (root) {
	observe(root);
	root = root.olderShadowRoot;
	}
	}
	}
	function handler(mutations) {
	if (flags.dom) {
	var mx = mutations[0];
	if (mx && mx.type === "childList" && mx.addedNodes) {
	if (mx.addedNodes) {
	var d = mx.addedNodes[0];
	while (d && d !== document && !d.host) {
	d = d.parentNode;
	}
	var u = d && (d.URL \|\| d._URL \|\| d.host && d.host.localName) \|\| "";
	u = u.split("/?").shift().split("/").pop();
	}
	}
	console.group("mutations (%d) [%s]", mutations.length, u \|\| "");
	}
	mutations.forEach(function(mx) {
	if (mx.type === "childList") {
	forEach(mx.addedNodes, function(n) {
	if (!n.localName) {
	return;
	}
	addedNode(n);
	});
	forEach(mx.removedNodes, function(n) {
	if (!n.localName) {
	return;
	}
	detachedNode(n);
	});
	}
	});
	flags.dom && console.groupEnd();
	}
	function takeRecords(node) {
	node = wrap(node);
	if (!node) {
	node = wrap(document);
	}
	while (node.parentNode) {
	node = node.parentNode;
	}
	var observer = node.__observer;
	if (observer) {
	handler(observer.takeRecords());
	takeMutations();
	}
	}
	var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
	function observe(inRoot) {
	if (inRoot.__observer) {
	return;
	}
	var observer = new MutationObserver(handler);
	observer.observe(inRoot, {
	childList: true,
	subtree: true
	});
	inRoot.__observer = observer;
	}
	function upgradeDocument(doc) {
	doc = wrap(doc);
	flags.dom && console.group("upgradeDocument: ", doc.baseURI.split("/").pop());
	addedNode(doc);
	observe(doc);
	flags.dom && console.groupEnd();
	}
	function upgradeDocumentTree(doc) {
	forDocumentTree(doc, upgradeDocument);
	}
	var originalCreateShadowRoot = Element.prototype.createShadowRoot;
	if (originalCreateShadowRoot) {
	Element.prototype.createShadowRoot = function() {
	var root = originalCreateShadowRoot.call(this);
	CustomElements.watchShadow(this);
	return root;
	};
	}
	scope.watchShadow = watchShadow;
	scope.upgradeDocumentTree = upgradeDocumentTree;
	scope.upgradeSubtree = addedSubtree;
	scope.upgradeAll = addedNode;
	scope.attachedNode = attachedNode;
	scope.takeRecords = takeRecords;
	});

	CustomElements.addModule(function(scope) {
	var flags = scope.flags;
	function upgrade(node) {
	if (!node.__upgraded__ && node.nodeType === Node.ELEMENT_NODE) {
	var is = node.getAttribute("is");
	var definition = scope.getRegisteredDefinition(is \|\| node.localName);
	if (definition) {
	if (is && definition.tag == node.localName) {
	return upgradeWithDefinition(node, definition);
	} else if (!is && !definition.extends) {
	return upgradeWithDefinition(node, definition);
	}
	}
	}
	}
	function upgradeWithDefinition(element, definition) {
	flags.upgrade && console.group("upgrade:", element.localName);
	if (definition.is) {
	element.setAttribute("is", definition.is);
	}
	implementPrototype(element, definition);
	element.__upgraded__ = true;
	created(element);
	scope.attachedNode(element);
	scope.upgradeSubtree(element);
	flags.upgrade && console.groupEnd();
	return element;
	}
	function implementPrototype(element, definition) {
	if (Object.__proto__) {
	element.__proto__ = definition.prototype;
	} else {
	customMixin(element, definition.prototype, definition.native);
	element.__proto__ = definition.prototype;
	}
	}
	function customMixin(inTarget, inSrc, inNative) {
	var used = {};
	var p = inSrc;
	while (p !== inNative && p !== HTMLElement.prototype) {
	var keys = Object.getOwnPropertyNames(p);
	for (var i = 0, k; k = keys[i]; i++) {
	if (!used[k]) {
	Object.defineProperty(inTarget, k, Object.getOwnPropertyDescriptor(p, k));
	used[k] = 1;
	}
	}
	p = Object.getPrototypeOf(p);
	}
	}
	function created(element) {
	if (element.createdCallback) {
	element.createdCallback();
	}
	}
	scope.upgrade = upgrade;
	scope.upgradeWithDefinition = upgradeWithDefinition;
	scope.implementPrototype = implementPrototype;
	});

	CustomElements.addModule(function(scope) {
	var upgradeDocumentTree = scope.upgradeDocumentTree;
	var upgrade = scope.upgrade;
	var upgradeWithDefinition = scope.upgradeWithDefinition;
	var implementPrototype = scope.implementPrototype;
	var useNative = scope.useNative;
	function register(name, options) {
	var definition = options \|\| {};
	if (!name) {
	throw new Error("document.registerElement: first argument `name` must not be empty");
	}
	if (name.indexOf("-") < 0) {
	throw new Error("document.registerElement: first argument ('name') must contain a dash ('-'). Argument provided was '" + String(name) + "'.");
	}
	if (isReservedTag(name)) {
	throw new Error("Failed to execute 'registerElement' on 'Document': Registration failed for type '" + String(name) + "'. The type name is invalid.");
	}
	if (getRegisteredDefinition(name)) {
	throw new Error("DuplicateDefinitionError: a type with name '" + String(name) + "' is already registered");
	}
	if (!definition.prototype) {
	definition.prototype = Object.create(HTMLElement.prototype);
	}
	definition.__name = name.toLowerCase();
	definition.lifecycle = definition.lifecycle \|\| {};
	definition.ancestry = ancestry(definition.extends);
	resolveTagName(definition);
	resolvePrototypeChain(definition);
	overrideAttributeApi(definition.prototype);
	registerDefinition(definition.__name, definition);
	definition.ctor = generateConstructor(definition);
	definition.ctor.prototype = definition.prototype;
	definition.prototype.constructor = definition.ctor;
	if (scope.ready) {
	upgradeDocumentTree(document);
	}
	return definition.ctor;
	}
	function overrideAttributeApi(prototype) {
	if (prototype.setAttribute._polyfilled) {
	return;
	}
	var setAttribute = prototype.setAttribute;
	prototype.setAttribute = function(name, value) {
	changeAttribute.call(this, name, value, setAttribute);
	};
	var removeAttribute = prototype.removeAttribute;
	prototype.removeAttribute = function(name) {
	changeAttribute.call(this, name, null, removeAttribute);
	};
	prototype.setAttribute._polyfilled = true;
	}
	function changeAttribute(name, value, operation) {
	name = name.toLowerCase();
	var oldValue = this.getAttribute(name);
	operation.apply(this, arguments);
	var newValue = this.getAttribute(name);
	if (this.attributeChangedCallback && newValue !== oldValue) {
	this.attributeChangedCallback(name, oldValue, newValue);
	}
	}
	function isReservedTag(name) {
	for (var i = 0; i < reservedTagList.length; i++) {
	if (name === reservedTagList[i]) {
	return true;
	}
	}
	}
	var reservedTagList = [ "annotation-xml", "color-profile", "font-face", "font-face-src", "font-face-uri", "font-face-format", "font-face-name", "missing-glyph" ];
	function ancestry(extnds) {
	var extendee = getRegisteredDefinition(extnds);
	if (extendee) {
	return ancestry(extendee.extends).concat([ extendee ]);
	}
	return [];
	}
	function resolveTagName(definition) {
	var baseTag = definition.extends;
	for (var i = 0, a; a = definition.ancestry[i]; i++) {
	baseTag = a.is && a.tag;
	}
	definition.tag = baseTag \|\| definition.__name;
	if (baseTag) {
	definition.is = definition.__name;
	}
	}
	function resolvePrototypeChain(definition) {
	if (!Object.__proto__) {
	var nativePrototype = HTMLElement.prototype;
	if (definition.is) {
	var inst = document.createElement(definition.tag);
	var expectedPrototype = Object.getPrototypeOf(inst);
	if (expectedPrototype === definition.prototype) {
	nativePrototype = expectedPrototype;
	}
	}
	var proto = definition.prototype, ancestor;
	while (proto && proto !== nativePrototype) {
	ancestor = Object.getPrototypeOf(proto);
	proto.__proto__ = ancestor;
	proto = ancestor;
	}
	definition.native = nativePrototype;
	}
	}
	function instantiate(definition) {
	return upgradeWithDefinition(domCreateElement(definition.tag), definition);
	}
	var registry = {};
	function getRegisteredDefinition(name) {
	if (name) {
	return registry[name.toLowerCase()];
	}
	}
	function registerDefinition(name, definition) {
	registry[name] = definition;
	}
	function generateConstructor(definition) {
	return function() {
	return instantiate(definition);
	};
	}
	var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
	function createElementNS(namespace, tag, typeExtension) {
	if (namespace === HTML_NAMESPACE) {
	return createElement(tag, typeExtension);
	} else {
	return domCreateElementNS(namespace, tag);
	}
	}
	function createElement(tag, typeExtension) {
	var definition = getRegisteredDefinition(typeExtension \|\| tag);
	if (definition) {
	if (tag == definition.tag && typeExtension == definition.is) {
	return new definition.ctor();
	}
	if (!typeExtension && !definition.is) {
	return new definition.ctor();
	}
	}
	var element;
	if (typeExtension) {
	element = createElement(tag);
	element.setAttribute("is", typeExtension);
	return element;
	}
	element = domCreateElement(tag);
	if (tag.indexOf("-") >= 0) {
	implementPrototype(element, HTMLElement);
	}
	return element;
	}
	function cloneNode(deep) {
	var n = domCloneNode.call(this, deep);
	upgrade(n);
	return n;
	}
	var domCreateElement = document.createElement.bind(document);
	var domCreateElementNS = document.createElementNS.bind(document);
	var domCloneNode = Node.prototype.cloneNode;
	var isInstance;
	if (!Object.__proto__ && !useNative) {
	isInstance = function(obj, ctor) {
	var p = obj;
	while (p) {
	if (p === ctor.prototype) {
	return true;
	}
	p = p.__proto__;
	}
	return false;
	};
	} else {
	isInstance = function(obj, base) {
	return obj instanceof base;
	};
	}
	document.registerElement = register;
	document.createElement = createElement;
	document.createElementNS = createElementNS;
	Node.prototype.cloneNode = cloneNode;
	scope.registry = registry;
	scope.instanceof = isInstance;
	scope.reservedTagList = reservedTagList;
	scope.getRegisteredDefinition = getRegisteredDefinition;
	document.register = document.registerElement;
	});

	(function(scope) {
	var useNative = scope.useNative;
	var initializeModules = scope.initializeModules;
	var isIE11OrOlder = /Trident/.test(navigator.userAgent);
	if (useNative) {
	var nop = function() {};
	scope.watchShadow = nop;
	scope.upgrade = nop;
	scope.upgradeAll = nop;
	scope.upgradeDocumentTree = nop;
	scope.upgradeSubtree = nop;
	scope.takeRecords = nop;
	scope.instanceof = function(obj, base) {
	return obj instanceof base;
	};
	} else {
	initializeModules();
	}
	var upgradeDocumentTree = scope.upgradeDocumentTree;
	if (!window.wrap) {
	if (window.ShadowDOMPolyfill) {
	window.wrap = ShadowDOMPolyfill.wrapIfNeeded;
	window.unwrap = ShadowDOMPolyfill.unwrapIfNeeded;
	} else {
	window.wrap = window.unwrap = function(node) {
	return node;
	};
	}
	}
	function bootstrap() {
	upgradeDocumentTree(wrap(document));
	if (window.HTMLImports) {
	HTMLImports.__importsParsingHook = function(elt) {
	upgradeDocumentTree(wrap(elt.import));
	};
	}
	CustomElements.ready = true;
	setTimeout(function() {
	CustomElements.readyTime = Date.now();
	if (window.HTMLImports) {
	CustomElements.elapsed = CustomElements.readyTime - HTMLImports.readyTime;
	}
	document.dispatchEvent(new CustomEvent("WebComponentsReady", {
	bubbles: true
	}));
	});
	}
	if (isIE11OrOlder && typeof window.CustomEvent !== "function") {
	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;
	}
	if (document.readyState === "complete" \|\| scope.flags.eager) {
	bootstrap();
	} else if (document.readyState === "interactive" && !window.attachEvent && (!window.HTMLImports \|\| window.HTMLImports.ready)) {
	bootstrap();
	} else {
	var loadEvent = window.HTMLImports && !HTMLImports.ready ? "HTMLImportsLoaded" : "DOMContentLoaded";
	window.addEventListener(loadEvent, bootstrap);
	}
	})(window.CustomElements);