tracing/third_party/components/webcomponentsjs/HTMLImports.js - external/trace-viewer - 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.HTMLImports = window.HTMLImports || {
   flags: {}
 };

 (function(scope) {
   var IMPORT_LINK_TYPE = "import";
   var useNative = Boolean(IMPORT_LINK_TYPE in document.createElement("link"));
   var hasShadowDOMPolyfill = Boolean(window.ShadowDOMPolyfill);
   var wrap = function(node) {
     return hasShadowDOMPolyfill ? ShadowDOMPolyfill.wrapIfNeeded(node) : node;
   };
   var rootDocument = wrap(document);
   var currentScriptDescriptor = {
     get: function() {
       var script = HTMLImports.currentScript || document.currentScript || (document.readyState !== "complete" ? document.scripts[document.scripts.length - 1] : null);
       return wrap(script);
     },
     configurable: true
   };
   Object.defineProperty(document, "_currentScript", currentScriptDescriptor);
   Object.defineProperty(rootDocument, "_currentScript", currentScriptDescriptor);
   var isIE = /Trident|Edge/.test(navigator.userAgent);
   function whenReady(callback, doc) {
     doc = doc || rootDocument;
     whenDocumentReady(function() {
       watchImportsLoad(callback, doc);
     }, doc);
   }
   var requiredReadyState = isIE ? "complete" : "interactive";
   var READY_EVENT = "readystatechange";
   function isDocumentReady(doc) {
     return doc.readyState === "complete" || doc.readyState === requiredReadyState;
   }
   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();
     }
   }
   function markTargetLoaded(event) {
     event.target.__loaded = true;
   }
   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) {
       markTargetLoaded(e);
       loaded++;
       checkDone();
     }
     if (l) {
       for (var i = 0, imp; i < l && (imp = imports[i]); i++) {
         if (isImportLoaded(imp)) {
           loadedImport.call(imp, {
             target: imp
           });
         } else {
           imp.addEventListener("load", loadedImport);
           imp.addEventListener("error", loadedImport);
         }
       }
     } else {
       checkDone();
     }
   }
   function isImportLoaded(link) {
     return useNative ? link.__loaded || link.import && link.import.readyState !== "loading" : link.__importParsed;
   }
   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() {
       if (document.readyState === "loading") {
         var imports = document.querySelectorAll("link[rel=import]");
         for (var i = 0, l = imports.length, imp; i < l && (imp = imports[i]); i++) {
           handleImport(imp);
         }
       }
     })();
   }
   whenReady(function() {
     HTMLImports.ready = true;
     HTMLImports.readyTime = new Date().getTime();
     var evt = rootDocument.createEvent("CustomEvent");
     evt.initCustomEvent("HTMLImportsLoaded", true, true, {});
     rootDocument.dispatchEvent(evt);
   });
   scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;
   scope.useNative = useNative;
   scope.rootDocument = rootDocument;
   scope.whenReady = whenReady;
   scope.isIE = isIE;
 })(HTMLImports);

 (function(scope) {
   var modules = [];
   var addModule = function(module) {
     modules.push(module);
   };
   var initializeModules = function() {
     modules.forEach(function(module) {
       module(scope);
     });
   };
   scope.addModule = addModule;
   scope.initializeModules = initializeModules;
 })(HTMLImports);

 HTMLImports.addModule(function(scope) {
   var CSS_URL_REGEXP = /(url\()([^)]*)(\))/g;
   var CSS_IMPORT_REGEXP = /(@import[\s]+(?!url\())([^;]*)(;)/g;
   var path = {
     resolveUrlsInStyle: function(style) {
       var doc = style.ownerDocument;
       var resolver = doc.createElement("a");
       style.textContent = this.resolveUrlsInCssText(style.textContent, resolver);
       return style;
     },
     resolveUrlsInCssText: function(cssText, urlObj) {
       var r = this.replaceUrls(cssText, urlObj, CSS_URL_REGEXP);
       r = this.replaceUrls(r, urlObj, CSS_IMPORT_REGEXP);
       return r;
     },
     replaceUrls: function(text, urlObj, regexp) {
       return text.replace(regexp, function(m, pre, url, post) {
         var urlPath = url.replace(/["']/g, "");
         urlObj.href = urlPath;
         urlPath = urlObj.href;
         return pre + "'" + urlPath + "'" + post;
       });
     }
   };
   scope.path = path;
 });

 HTMLImports.addModule(function(scope) {
   var xhr = {
     async: true,
     ok: function(request) {
       return request.status >= 200 && request.status < 300 || request.status === 304 || request.status === 0;
     },
     load: function(url, next, nextContext) {
       var request = new XMLHttpRequest();
       if (scope.flags.debug || scope.flags.bust) {
         url += "?" + Math.random();
       }
       request.open("GET", url, xhr.async);
       request.addEventListener("readystatechange", function(e) {
         if (request.readyState === 4) {
           var locationHeader = request.getResponseHeader("Location");
           var redirectedUrl = null;
           if (locationHeader) {
             var redirectedUrl = locationHeader.substr(0, 1) === "/" ? location.origin + locationHeader : locationHeader;
           }
           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";
     }
   };
   scope.xhr = xhr;
 });

 HTMLImports.addModule(function(scope) {
   var xhr = scope.xhr;
   var flags = scope.flags;
   var Loader = function(onLoad, onComplete) {
     this.cache = {};
     this.onload = onLoad;
     this.oncomplete = onComplete;
     this.inflight = 0;
     this.pending = {};
   };
   Loader.prototype = {
     addNodes: function(nodes) {
       this.inflight += nodes.length;
       for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) {
         this.require(n);
       }
       this.checkDone();
     },
     addNode: function(node) {
       this.inflight++;
       this.require(node);
       this.checkDone();
     },
     require: function(elt) {
       var url = elt.src || elt.href;
       elt.__nodeUrl = url;
       if (!this.dedupe(url, elt)) {
         this.fetch(url, elt);
       }
     },
     dedupe: function(url, elt) {
       if (this.pending[url]) {
         this.pending[url].push(elt);
         return true;
       }
       var resource;
       if (this.cache[url]) {
         this.onload(url, elt, this.cache[url]);
         this.tail();
         return true;
       }
       this.pending[url] = [ elt ];
       return false;
     },
     fetch: function(url, elt) {
       flags.load && console.log("fetch", url, elt);
       if (!url) {
         setTimeout(function() {
           this.receive(url, elt, {
             error: "href must be specified"
           }, null);
         }.bind(this), 0);
       } else if (url.match(/^data:/)) {
         var pieces = url.split(",");
         var header = pieces[0];
         var body = pieces[1];
         if (header.indexOf(";base64") > -1) {
           body = atob(body);
         } else {
           body = decodeURIComponent(body);
         }
         setTimeout(function() {
           this.receive(url, elt, null, body);
         }.bind(this), 0);
       } else {
         var receiveXhr = function(err, resource, redirectedUrl) {
           this.receive(url, elt, err, resource, redirectedUrl);
         }.bind(this);
         xhr.load(url, receiveXhr);
       }
     },
     receive: function(url, elt, err, resource, redirectedUrl) {
       this.cache[url] = resource;
       var $p = this.pending[url];
       for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) {
         this.onload(url, p, resource, err, redirectedUrl);
         this.tail();
       }
       this.pending[url] = null;
     },
     tail: function() {
       --this.inflight;
       this.checkDone();
     },
     checkDone: function() {
       if (!this.inflight) {
         this.oncomplete();
       }
     }
   };
   scope.Loader = Loader;
 });

 HTMLImports.addModule(function(scope) {
   var Observer = function(addCallback) {
     this.addCallback = addCallback;
     this.mo = new MutationObserver(this.handler.bind(this));
   };
   Observer.prototype = {
     handler: function(mutations) {
       for (var i = 0, l = mutations.length, m; i < l && (m = mutations[i]); i++) {
         if (m.type === "childList" && m.addedNodes.length) {
           this.addedNodes(m.addedNodes);
         }
       }
     },
     addedNodes: function(nodes) {
       if (this.addCallback) {
         this.addCallback(nodes);
       }
       for (var i = 0, l = nodes.length, n, loading; i < l && (n = nodes[i]); i++) {
         if (n.children && n.children.length) {
           this.addedNodes(n.children);
         }
       }
     },
     observe: function(root) {
       this.mo.observe(root, {
         childList: true,
         subtree: true
       });
     }
   };
   scope.Observer = Observer;
 });

 HTMLImports.addModule(function(scope) {
   var path = scope.path;
   var rootDocument = scope.rootDocument;
   var flags = scope.flags;
   var isIE = scope.isIE;
   var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;
   var IMPORT_SELECTOR = "link[rel=" + IMPORT_LINK_TYPE + "]";
   var importParser = {
     documentSelectors: IMPORT_SELECTOR,
     importsSelectors: [ IMPORT_SELECTOR, "link[rel=stylesheet]", "style", "script:not([type])", 'script[type="text/javascript"]' ].join(","),
     map: {
       link: "parseLink",
       script: "parseScript",
       style: "parseStyle"
     },
     dynamicElements: [],
     parseNext: function() {
       var next = this.nextToParse();
       if (next) {
         this.parse(next);
       }
     },
     parse: function(elt) {
       if (this.isParsed(elt)) {
         flags.parse && console.log("[%s] is already parsed", elt.localName);
         return;
       }
       var fn = this[this.map[elt.localName]];
       if (fn) {
         this.markParsing(elt);
         fn.call(this, elt);
       }
     },
     parseDynamic: function(elt, quiet) {
       this.dynamicElements.push(elt);
       if (!quiet) {
         this.parseNext();
       }
     },
     markParsing: function(elt) {
       flags.parse && console.log("parsing", elt);
       this.parsingElement = elt;
     },
     markParsingComplete: function(elt) {
       elt.__importParsed = true;
       this.markDynamicParsingComplete(elt);
       if (elt.__importElement) {
         elt.__importElement.__importParsed = true;
         this.markDynamicParsingComplete(elt.__importElement);
       }
       this.parsingElement = null;
       flags.parse && console.log("completed", elt);
     },
     markDynamicParsingComplete: function(elt) {
       var i = this.dynamicElements.indexOf(elt);
       if (i >= 0) {
         this.dynamicElements.splice(i, 1);
       }
     },
     parseImport: function(elt) {
       if (HTMLImports.__importsParsingHook) {
         HTMLImports.__importsParsingHook(elt);
       }
       if (elt.import) {
         elt.import.__importParsed = true;
       }
       this.markParsingComplete(elt);
       if (elt.__resource && !elt.__error) {
         elt.dispatchEvent(new CustomEvent("load", {
           bubbles: false
         }));
       } else {
         elt.dispatchEvent(new CustomEvent("error", {
           bubbles: false
         }));
       }
       if (elt.__pending) {
         var fn;
         while (elt.__pending.length) {
           fn = elt.__pending.shift();
           if (fn) {
             fn({
               target: elt
             });
           }
         }
       }
       this.parseNext();
     },
     parseLink: function(linkElt) {
       if (nodeIsImport(linkElt)) {
         this.parseImport(linkElt);
       } else {
         linkElt.href = linkElt.href;
         this.parseGeneric(linkElt);
       }
     },
     parseStyle: function(elt) {
       var src = elt;
       elt = cloneStyle(elt);
       elt.__importElement = src;
       this.parseGeneric(elt);
     },
     parseGeneric: function(elt) {
       this.trackElement(elt);
       this.addElementToDocument(elt);
     },
     rootImportForElement: function(elt) {
       var n = elt;
       while (n.ownerDocument.__importLink) {
         n = n.ownerDocument.__importLink;
       }
       return n;
     },
     addElementToDocument: function(elt) {
       var port = this.rootImportForElement(elt.__importElement || elt);
       port.parentNode.insertBefore(elt, port);
     },
     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);
       if (isIE && elt.localName === "style") {
         var fakeLoad = false;
         if (elt.textContent.indexOf("@import") == -1) {
           fakeLoad = true;
         } else if (elt.sheet) {
           fakeLoad = true;
           var csr = elt.sheet.cssRules;
           var len = csr ? csr.length : 0;
           for (var i = 0, r; i < len && (r = csr[i]); i++) {
             if (r.type === CSSRule.IMPORT_RULE) {
               fakeLoad = fakeLoad && Boolean(r.styleSheet);
             }
           }
         }
         if (fakeLoad) {
           elt.dispatchEvent(new CustomEvent("load", {
             bubbles: false
           }));
         }
       }
     },
     parseScript: function(scriptElt) {
       var script = document.createElement("script");
       script.__importElement = scriptElt;
       script.src = scriptElt.src ? scriptElt.src : generateScriptDataUrl(scriptElt);
       scope.currentScript = scriptElt;
       this.trackElement(script, function(e) {
         script.parentNode.removeChild(script);
         scope.currentScript = null;
       });
       this.addElementToDocument(script);
     },
     nextToParse: function() {
       this._mayParse = [];
       return !this.parsingElement && (this.nextToParseInDoc(rootDocument) || this.nextToParseDynamic());
     },
     nextToParseInDoc: function(doc, link) {
       if (doc && this._mayParse.indexOf(doc) < 0) {
         this._mayParse.push(doc);
         var nodes = doc.querySelectorAll(this.parseSelectorsForNode(doc));
         for (var i = 0, l = nodes.length, p = 0, n; i < l && (n = nodes[i]); i++) {
           if (!this.isParsed(n)) {
             if (this.hasResource(n)) {
               return nodeIsImport(n) ? this.nextToParseInDoc(n.import, n) : n;
             } else {
               return;
             }
           }
         }
       }
       return link;
     },
     nextToParseDynamic: function() {
       return this.dynamicElements[0];
     },
     parseSelectorsForNode: function(node) {
       var doc = node.ownerDocument || node;
       return doc === rootDocument ? this.documentSelectors : this.importsSelectors;
     },
     isParsed: function(node) {
       return node.__importParsed;
     },
     needsDynamicParsing: function(elt) {
       return this.dynamicElements.indexOf(elt) >= 0;
     },
     hasResource: function(node) {
       if (nodeIsImport(node) && node.import === undefined) {
         return false;
       }
       return true;
     }
   };
   function nodeIsImport(elt) {
     return elt.localName === "link" && elt.rel === IMPORT_LINK_TYPE;
   }
   function generateScriptDataUrl(script) {
     var scriptContent = generateScriptContent(script);
     return "data:text/javascript;charset=utf-8," + encodeURIComponent(scriptContent);
   }
   function generateScriptContent(script) {
     return script.textContent + generateSourceMapHint(script);
   }
   function generateSourceMapHint(script) {
     var owner = script.ownerDocument;
     owner.__importedScripts = owner.__importedScripts || 0;
     var moniker = script.ownerDocument.baseURI;
     var num = owner.__importedScripts ? "-" + owner.__importedScripts : "";
     owner.__importedScripts++;
     return "\n//# sourceURL=" + moniker + num + ".js\n";
   }
   function cloneStyle(style) {
     var clone = style.ownerDocument.createElement("style");
     clone.textContent = style.textContent;
     path.resolveUrlsInStyle(clone);
     return clone;
   }
   scope.parser = importParser;
   scope.IMPORT_SELECTOR = IMPORT_SELECTOR;
 });

 HTMLImports.addModule(function(scope) {
   var flags = scope.flags;
   var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;
   var IMPORT_SELECTOR = scope.IMPORT_SELECTOR;
   var rootDocument = scope.rootDocument;
   var Loader = scope.Loader;
   var Observer = scope.Observer;
   var parser = scope.parser;
   var importer = {
     documents: {},
     documentPreloadSelectors: IMPORT_SELECTOR,
     importsPreloadSelectors: [ IMPORT_SELECTOR ].join(","),
     loadNode: function(node) {
       importLoader.addNode(node);
     },
     loadSubtree: function(parent) {
       var nodes = this.marshalNodes(parent);
       importLoader.addNodes(nodes);
     },
     marshalNodes: function(parent) {
       return parent.querySelectorAll(this.loadSelectorsForNode(parent));
     },
     loadSelectorsForNode: function(node) {
       var doc = node.ownerDocument || node;
       return doc === rootDocument ? this.documentPreloadSelectors : this.importsPreloadSelectors;
     },
     loaded: function(url, elt, resource, err, redirectedUrl) {
       flags.load && console.log("loaded", url, elt);
       elt.__resource = resource;
       elt.__error = err;
       if (isImportLink(elt)) {
         var doc = this.documents[url];
         if (doc === undefined) {
           doc = err ? null : makeDocument(resource, redirectedUrl || url);
           if (doc) {
             doc.__importLink = elt;
             this.bootDocument(doc);
           }
           this.documents[url] = doc;
         }
         elt.import = doc;
       }
       parser.parseNext();
     },
     bootDocument: function(doc) {
       this.loadSubtree(doc);
       this.observer.observe(doc);
       parser.parseNext();
     },
     loadedAll: function() {
       parser.parseNext();
     }
   };
   var importLoader = new Loader(importer.loaded.bind(importer), importer.loadedAll.bind(importer));
   importer.observer = new Observer();
   function isImportLink(elt) {
     return isLinkRel(elt, IMPORT_LINK_TYPE);
   }
   function isLinkRel(elt, rel) {
     return elt.localName === "link" && elt.getAttribute("rel") === rel;
   }
   function hasBaseURIAccessor(doc) {
     return !!Object.getOwnPropertyDescriptor(doc, "baseURI");
   }
   function makeDocument(resource, url) {
     var doc = document.implementation.createHTMLDocument(IMPORT_LINK_TYPE);
     doc._URL = url;
     var base = doc.createElement("base");
     base.setAttribute("href", url);
     if (!doc.baseURI && !hasBaseURIAccessor(doc)) {
       Object.defineProperty(doc, "baseURI", {
         value: url
       });
     }
     var meta = doc.createElement("meta");
     meta.setAttribute("charset", "utf-8");
     doc.head.appendChild(meta);
     doc.head.appendChild(base);
     doc.body.innerHTML = resource;
     if (window.HTMLTemplateElement && HTMLTemplateElement.bootstrap) {
       HTMLTemplateElement.bootstrap(doc);
     }
     return doc;
   }
   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(rootDocument, "baseURI", baseURIDescriptor);
   }
   scope.importer = importer;
   scope.importLoader = importLoader;
 });

 HTMLImports.addModule(function(scope) {
   var parser = scope.parser;
   var importer = scope.importer;
   var dynamic = {
     added: function(nodes) {
       var owner, parsed, loading;
       for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) {
         if (!owner) {
           owner = n.ownerDocument;
           parsed = parser.isParsed(owner);
         }
         loading = this.shouldLoadNode(n);
         if (loading) {
           importer.loadNode(n);
         }
         if (this.shouldParseNode(n) && parsed) {
           parser.parseDynamic(n, loading);
         }
       }
     },
     shouldLoadNode: function(node) {
       return node.nodeType === 1 && matches.call(node, importer.loadSelectorsForNode(node));
     },
     shouldParseNode: function(node) {
       return node.nodeType === 1 && matches.call(node, parser.parseSelectorsForNode(node));
     }
   };
   importer.observer.addCallback = dynamic.added.bind(dynamic);
   var matches = HTMLElement.prototype.matches || HTMLElement.prototype.matchesSelector || HTMLElement.prototype.webkitMatchesSelector || HTMLElement.prototype.mozMatchesSelector || HTMLElement.prototype.msMatchesSelector;
 });

 (function(scope) {
   var initializeModules = scope.initializeModules;
   var isIE = scope.isIE;
   if (scope.useNative) {
     return;
   }
   if (isIE && 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;
   }
   initializeModules();
   var rootDocument = scope.rootDocument;
   function bootstrap() {
     HTMLImports.importer.bootDocument(rootDocument);
   }
   if (document.readyState === "complete" || document.readyState === "interactive" && !window.attachEvent) {
     bootstrap();
   } else {
     document.addEventListener("DOMContentLoaded", bootstrap);
   }
 })(HTMLImports);
	/**
	* @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.HTMLImports = window.HTMLImports \|\| {
	flags: {}
	};

	(function(scope) {
	var IMPORT_LINK_TYPE = "import";
	var useNative = Boolean(IMPORT_LINK_TYPE in document.createElement("link"));
	var hasShadowDOMPolyfill = Boolean(window.ShadowDOMPolyfill);
	var wrap = function(node) {
	return hasShadowDOMPolyfill ? ShadowDOMPolyfill.wrapIfNeeded(node) : node;
	};
	var rootDocument = wrap(document);
	var currentScriptDescriptor = {
	get: function() {
	var script = HTMLImports.currentScript \|\| document.currentScript \|\| (document.readyState !== "complete" ? document.scripts[document.scripts.length - 1] : null);
	return wrap(script);
	},
	configurable: true
	};
	Object.defineProperty(document, "_currentScript", currentScriptDescriptor);
	Object.defineProperty(rootDocument, "_currentScript", currentScriptDescriptor);
	var isIE = /Trident\|Edge/.test(navigator.userAgent);
	function whenReady(callback, doc) {
	doc = doc \|\| rootDocument;
	whenDocumentReady(function() {
	watchImportsLoad(callback, doc);
	}, doc);
	}
	var requiredReadyState = isIE ? "complete" : "interactive";
	var READY_EVENT = "readystatechange";
	function isDocumentReady(doc) {
	return doc.readyState === "complete" \|\| doc.readyState === requiredReadyState;
	}
	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();
	}
	}
	function markTargetLoaded(event) {
	event.target.__loaded = true;
	}
	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) {
	markTargetLoaded(e);
	loaded++;
	checkDone();
	}
	if (l) {
	for (var i = 0, imp; i < l && (imp = imports[i]); i++) {
	if (isImportLoaded(imp)) {
	loadedImport.call(imp, {
	target: imp
	});
	} else {
	imp.addEventListener("load", loadedImport);
	imp.addEventListener("error", loadedImport);
	}
	}
	} else {
	checkDone();
	}
	}
	function isImportLoaded(link) {
	return useNative ? link.__loaded \|\| link.import && link.import.readyState !== "loading" : link.__importParsed;
	}
	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() {
	if (document.readyState === "loading") {
	var imports = document.querySelectorAll("link[rel=import]");
	for (var i = 0, l = imports.length, imp; i < l && (imp = imports[i]); i++) {
	handleImport(imp);
	}
	}
	})();
	}
	whenReady(function() {
	HTMLImports.ready = true;
	HTMLImports.readyTime = new Date().getTime();
	var evt = rootDocument.createEvent("CustomEvent");
	evt.initCustomEvent("HTMLImportsLoaded", true, true, {});
	rootDocument.dispatchEvent(evt);
	});
	scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;
	scope.useNative = useNative;
	scope.rootDocument = rootDocument;
	scope.whenReady = whenReady;
	scope.isIE = isIE;
	})(HTMLImports);

	(function(scope) {
	var modules = [];
	var addModule = function(module) {
	modules.push(module);
	};
	var initializeModules = function() {
	modules.forEach(function(module) {
	module(scope);
	});
	};
	scope.addModule = addModule;
	scope.initializeModules = initializeModules;
	})(HTMLImports);

	HTMLImports.addModule(function(scope) {
	var CSS_URL_REGEXP = /(url\()([^)]*)(\))/g;
	var CSS_IMPORT_REGEXP = /(@import[\s]+(?!url\())([^;]*)(;)/g;
	var path = {
	resolveUrlsInStyle: function(style) {
	var doc = style.ownerDocument;
	var resolver = doc.createElement("a");
	style.textContent = this.resolveUrlsInCssText(style.textContent, resolver);
	return style;
	},
	resolveUrlsInCssText: function(cssText, urlObj) {
	var r = this.replaceUrls(cssText, urlObj, CSS_URL_REGEXP);
	r = this.replaceUrls(r, urlObj, CSS_IMPORT_REGEXP);
	return r;
	},
	replaceUrls: function(text, urlObj, regexp) {
	return text.replace(regexp, function(m, pre, url, post) {
	var urlPath = url.replace(/["']/g, "");
	urlObj.href = urlPath;
	urlPath = urlObj.href;
	return pre + "'" + urlPath + "'" + post;
	});
	}
	};
	scope.path = path;
	});

	HTMLImports.addModule(function(scope) {
	var xhr = {
	async: true,
	ok: function(request) {
	return request.status >= 200 && request.status < 300 \|\| request.status === 304 \|\| request.status === 0;
	},
	load: function(url, next, nextContext) {
	var request = new XMLHttpRequest();
	if (scope.flags.debug \|\| scope.flags.bust) {
	url += "?" + Math.random();
	}
	request.open("GET", url, xhr.async);
	request.addEventListener("readystatechange", function(e) {
	if (request.readyState === 4) {
	var locationHeader = request.getResponseHeader("Location");
	var redirectedUrl = null;
	if (locationHeader) {
	var redirectedUrl = locationHeader.substr(0, 1) === "/" ? location.origin + locationHeader : locationHeader;
	}
	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";
	}
	};
	scope.xhr = xhr;
	});

	HTMLImports.addModule(function(scope) {
	var xhr = scope.xhr;
	var flags = scope.flags;
	var Loader = function(onLoad, onComplete) {
	this.cache = {};
	this.onload = onLoad;
	this.oncomplete = onComplete;
	this.inflight = 0;
	this.pending = {};
	};
	Loader.prototype = {
	addNodes: function(nodes) {
	this.inflight += nodes.length;
	for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) {
	this.require(n);
	}
	this.checkDone();
	},
	addNode: function(node) {
	this.inflight++;
	this.require(node);
	this.checkDone();
	},
	require: function(elt) {
	var url = elt.src \|\| elt.href;
	elt.__nodeUrl = url;
	if (!this.dedupe(url, elt)) {
	this.fetch(url, elt);
	}
	},
	dedupe: function(url, elt) {
	if (this.pending[url]) {
	this.pending[url].push(elt);
	return true;
	}
	var resource;
	if (this.cache[url]) {
	this.onload(url, elt, this.cache[url]);
	this.tail();
	return true;
	}
	this.pending[url] = [ elt ];
	return false;
	},
	fetch: function(url, elt) {
	flags.load && console.log("fetch", url, elt);
	if (!url) {
	setTimeout(function() {
	this.receive(url, elt, {
	error: "href must be specified"
	}, null);
	}.bind(this), 0);
	} else if (url.match(/^data:/)) {
	var pieces = url.split(",");
	var header = pieces[0];
	var body = pieces[1];
	if (header.indexOf(";base64") > -1) {
	body = atob(body);
	} else {
	body = decodeURIComponent(body);
	}
	setTimeout(function() {
	this.receive(url, elt, null, body);
	}.bind(this), 0);
	} else {
	var receiveXhr = function(err, resource, redirectedUrl) {
	this.receive(url, elt, err, resource, redirectedUrl);
	}.bind(this);
	xhr.load(url, receiveXhr);
	}
	},
	receive: function(url, elt, err, resource, redirectedUrl) {
	this.cache[url] = resource;
	var $p = this.pending[url];
	for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) {
	this.onload(url, p, resource, err, redirectedUrl);
	this.tail();
	}
	this.pending[url] = null;
	},
	tail: function() {
	--this.inflight;
	this.checkDone();
	},
	checkDone: function() {
	if (!this.inflight) {
	this.oncomplete();
	}
	}
	};
	scope.Loader = Loader;
	});

	HTMLImports.addModule(function(scope) {
	var Observer = function(addCallback) {
	this.addCallback = addCallback;
	this.mo = new MutationObserver(this.handler.bind(this));
	};
	Observer.prototype = {
	handler: function(mutations) {
	for (var i = 0, l = mutations.length, m; i < l && (m = mutations[i]); i++) {
	if (m.type === "childList" && m.addedNodes.length) {
	this.addedNodes(m.addedNodes);
	}
	}
	},
	addedNodes: function(nodes) {
	if (this.addCallback) {
	this.addCallback(nodes);
	}
	for (var i = 0, l = nodes.length, n, loading; i < l && (n = nodes[i]); i++) {
	if (n.children && n.children.length) {
	this.addedNodes(n.children);
	}
	}
	},
	observe: function(root) {
	this.mo.observe(root, {
	childList: true,
	subtree: true
	});
	}
	};
	scope.Observer = Observer;
	});

	HTMLImports.addModule(function(scope) {
	var path = scope.path;
	var rootDocument = scope.rootDocument;
	var flags = scope.flags;
	var isIE = scope.isIE;
	var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;
	var IMPORT_SELECTOR = "link[rel=" + IMPORT_LINK_TYPE + "]";
	var importParser = {
	documentSelectors: IMPORT_SELECTOR,
	importsSelectors: [ IMPORT_SELECTOR, "link[rel=stylesheet]", "style", "script:not([type])", 'script[type="text/javascript"]' ].join(","),
	map: {
	link: "parseLink",
	script: "parseScript",
	style: "parseStyle"
	},
	dynamicElements: [],
	parseNext: function() {
	var next = this.nextToParse();
	if (next) {
	this.parse(next);
	}
	},
	parse: function(elt) {
	if (this.isParsed(elt)) {
	flags.parse && console.log("[%s] is already parsed", elt.localName);
	return;
	}
	var fn = this[this.map[elt.localName]];
	if (fn) {
	this.markParsing(elt);
	fn.call(this, elt);
	}
	},
	parseDynamic: function(elt, quiet) {
	this.dynamicElements.push(elt);
	if (!quiet) {
	this.parseNext();
	}
	},
	markParsing: function(elt) {
	flags.parse && console.log("parsing", elt);
	this.parsingElement = elt;
	},
	markParsingComplete: function(elt) {
	elt.__importParsed = true;
	this.markDynamicParsingComplete(elt);
	if (elt.__importElement) {
	elt.__importElement.__importParsed = true;
	this.markDynamicParsingComplete(elt.__importElement);
	}
	this.parsingElement = null;
	flags.parse && console.log("completed", elt);
	},
	markDynamicParsingComplete: function(elt) {
	var i = this.dynamicElements.indexOf(elt);
	if (i >= 0) {
	this.dynamicElements.splice(i, 1);
	}
	},
	parseImport: function(elt) {
	if (HTMLImports.__importsParsingHook) {
	HTMLImports.__importsParsingHook(elt);
	}
	if (elt.import) {
	elt.import.__importParsed = true;
	}
	this.markParsingComplete(elt);
	if (elt.__resource && !elt.__error) {
	elt.dispatchEvent(new CustomEvent("load", {
	bubbles: false
	}));
	} else {
	elt.dispatchEvent(new CustomEvent("error", {
	bubbles: false
	}));
	}
	if (elt.__pending) {
	var fn;
	while (elt.__pending.length) {
	fn = elt.__pending.shift();
	if (fn) {
	fn({
	target: elt
	});
	}
	}
	}
	this.parseNext();
	},
	parseLink: function(linkElt) {
	if (nodeIsImport(linkElt)) {
	this.parseImport(linkElt);
	} else {
	linkElt.href = linkElt.href;
	this.parseGeneric(linkElt);
	}
	},
	parseStyle: function(elt) {
	var src = elt;
	elt = cloneStyle(elt);
	elt.__importElement = src;
	this.parseGeneric(elt);
	},
	parseGeneric: function(elt) {
	this.trackElement(elt);
	this.addElementToDocument(elt);
	},
	rootImportForElement: function(elt) {
	var n = elt;
	while (n.ownerDocument.__importLink) {
	n = n.ownerDocument.__importLink;
	}
	return n;
	},
	addElementToDocument: function(elt) {
	var port = this.rootImportForElement(elt.__importElement \|\| elt);
	port.parentNode.insertBefore(elt, port);
	},
	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);
	if (isIE && elt.localName === "style") {
	var fakeLoad = false;
	if (elt.textContent.indexOf("@import") == -1) {
	fakeLoad = true;
	} else if (elt.sheet) {
	fakeLoad = true;
	var csr = elt.sheet.cssRules;
	var len = csr ? csr.length : 0;
	for (var i = 0, r; i < len && (r = csr[i]); i++) {
	if (r.type === CSSRule.IMPORT_RULE) {
	fakeLoad = fakeLoad && Boolean(r.styleSheet);
	}
	}
	}
	if (fakeLoad) {
	elt.dispatchEvent(new CustomEvent("load", {
	bubbles: false
	}));
	}
	}
	},
	parseScript: function(scriptElt) {
	var script = document.createElement("script");
	script.__importElement = scriptElt;
	script.src = scriptElt.src ? scriptElt.src : generateScriptDataUrl(scriptElt);
	scope.currentScript = scriptElt;
	this.trackElement(script, function(e) {
	script.parentNode.removeChild(script);
	scope.currentScript = null;
	});
	this.addElementToDocument(script);
	},
	nextToParse: function() {
	this._mayParse = [];
	return !this.parsingElement && (this.nextToParseInDoc(rootDocument) \|\| this.nextToParseDynamic());
	},
	nextToParseInDoc: function(doc, link) {
	if (doc && this._mayParse.indexOf(doc) < 0) {
	this._mayParse.push(doc);
	var nodes = doc.querySelectorAll(this.parseSelectorsForNode(doc));
	for (var i = 0, l = nodes.length, p = 0, n; i < l && (n = nodes[i]); i++) {
	if (!this.isParsed(n)) {
	if (this.hasResource(n)) {
	return nodeIsImport(n) ? this.nextToParseInDoc(n.import, n) : n;
	} else {
	return;
	}
	}
	}
	}
	return link;
	},
	nextToParseDynamic: function() {
	return this.dynamicElements[0];
	},
	parseSelectorsForNode: function(node) {
	var doc = node.ownerDocument \|\| node;
	return doc === rootDocument ? this.documentSelectors : this.importsSelectors;
	},
	isParsed: function(node) {
	return node.__importParsed;
	},
	needsDynamicParsing: function(elt) {
	return this.dynamicElements.indexOf(elt) >= 0;
	},
	hasResource: function(node) {
	if (nodeIsImport(node) && node.import === undefined) {
	return false;
	}
	return true;
	}
	};
	function nodeIsImport(elt) {
	return elt.localName === "link" && elt.rel === IMPORT_LINK_TYPE;
	}
	function generateScriptDataUrl(script) {
	var scriptContent = generateScriptContent(script);
	return "data:text/javascript;charset=utf-8," + encodeURIComponent(scriptContent);
	}
	function generateScriptContent(script) {
	return script.textContent + generateSourceMapHint(script);
	}
	function generateSourceMapHint(script) {
	var owner = script.ownerDocument;
	owner.__importedScripts = owner.__importedScripts \|\| 0;
	var moniker = script.ownerDocument.baseURI;
	var num = owner.__importedScripts ? "-" + owner.__importedScripts : "";
	owner.__importedScripts++;
	return "\n//# sourceURL=" + moniker + num + ".js\n";
	}
	function cloneStyle(style) {
	var clone = style.ownerDocument.createElement("style");
	clone.textContent = style.textContent;
	path.resolveUrlsInStyle(clone);
	return clone;
	}
	scope.parser = importParser;
	scope.IMPORT_SELECTOR = IMPORT_SELECTOR;
	});

	HTMLImports.addModule(function(scope) {
	var flags = scope.flags;
	var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;
	var IMPORT_SELECTOR = scope.IMPORT_SELECTOR;
	var rootDocument = scope.rootDocument;
	var Loader = scope.Loader;
	var Observer = scope.Observer;
	var parser = scope.parser;
	var importer = {
	documents: {},
	documentPreloadSelectors: IMPORT_SELECTOR,
	importsPreloadSelectors: [ IMPORT_SELECTOR ].join(","),
	loadNode: function(node) {
	importLoader.addNode(node);
	},
	loadSubtree: function(parent) {
	var nodes = this.marshalNodes(parent);
	importLoader.addNodes(nodes);
	},
	marshalNodes: function(parent) {
	return parent.querySelectorAll(this.loadSelectorsForNode(parent));
	},
	loadSelectorsForNode: function(node) {
	var doc = node.ownerDocument \|\| node;
	return doc === rootDocument ? this.documentPreloadSelectors : this.importsPreloadSelectors;
	},
	loaded: function(url, elt, resource, err, redirectedUrl) {
	flags.load && console.log("loaded", url, elt);
	elt.__resource = resource;
	elt.__error = err;
	if (isImportLink(elt)) {
	var doc = this.documents[url];
	if (doc === undefined) {
	doc = err ? null : makeDocument(resource, redirectedUrl \|\| url);
	if (doc) {
	doc.__importLink = elt;
	this.bootDocument(doc);
	}
	this.documents[url] = doc;
	}
	elt.import = doc;
	}
	parser.parseNext();
	},
	bootDocument: function(doc) {
	this.loadSubtree(doc);
	this.observer.observe(doc);
	parser.parseNext();
	},
	loadedAll: function() {
	parser.parseNext();
	}
	};
	var importLoader = new Loader(importer.loaded.bind(importer), importer.loadedAll.bind(importer));
	importer.observer = new Observer();
	function isImportLink(elt) {
	return isLinkRel(elt, IMPORT_LINK_TYPE);
	}
	function isLinkRel(elt, rel) {
	return elt.localName === "link" && elt.getAttribute("rel") === rel;
	}
	function hasBaseURIAccessor(doc) {
	return !!Object.getOwnPropertyDescriptor(doc, "baseURI");
	}
	function makeDocument(resource, url) {
	var doc = document.implementation.createHTMLDocument(IMPORT_LINK_TYPE);
	doc._URL = url;
	var base = doc.createElement("base");
	base.setAttribute("href", url);
	if (!doc.baseURI && !hasBaseURIAccessor(doc)) {
	Object.defineProperty(doc, "baseURI", {
	value: url
	});
	}
	var meta = doc.createElement("meta");
	meta.setAttribute("charset", "utf-8");
	doc.head.appendChild(meta);
	doc.head.appendChild(base);
	doc.body.innerHTML = resource;
	if (window.HTMLTemplateElement && HTMLTemplateElement.bootstrap) {
	HTMLTemplateElement.bootstrap(doc);
	}
	return doc;
	}
	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(rootDocument, "baseURI", baseURIDescriptor);
	}
	scope.importer = importer;
	scope.importLoader = importLoader;
	});

	HTMLImports.addModule(function(scope) {
	var parser = scope.parser;
	var importer = scope.importer;
	var dynamic = {
	added: function(nodes) {
	var owner, parsed, loading;
	for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) {
	if (!owner) {
	owner = n.ownerDocument;
	parsed = parser.isParsed(owner);
	}
	loading = this.shouldLoadNode(n);
	if (loading) {
	importer.loadNode(n);
	}
	if (this.shouldParseNode(n) && parsed) {
	parser.parseDynamic(n, loading);
	}
	}
	},
	shouldLoadNode: function(node) {
	return node.nodeType === 1 && matches.call(node, importer.loadSelectorsForNode(node));
	},
	shouldParseNode: function(node) {
	return node.nodeType === 1 && matches.call(node, parser.parseSelectorsForNode(node));
	}
	};
	importer.observer.addCallback = dynamic.added.bind(dynamic);
	var matches = HTMLElement.prototype.matches \|\| HTMLElement.prototype.matchesSelector \|\| HTMLElement.prototype.webkitMatchesSelector \|\| HTMLElement.prototype.mozMatchesSelector \|\| HTMLElement.prototype.msMatchesSelector;
	});

	(function(scope) {
	var initializeModules = scope.initializeModules;
	var isIE = scope.isIE;
	if (scope.useNative) {
	return;
	}
	if (isIE && 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;
	}
	initializeModules();
	var rootDocument = scope.rootDocument;
	function bootstrap() {
	HTMLImports.importer.bootDocument(rootDocument);
	}
	if (document.readyState === "complete" \|\| document.readyState === "interactive" && !window.attachEvent) {
	bootstrap();
	} else {
	document.addEventListener("DOMContentLoaded", bootstrap);
	}
	})(HTMLImports);