1/**
2 * @license
3 * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
4 * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
5 * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
6 * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
7 * Code distributed by Google as part of the polymer project is also
8 * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
9 */
10// @version 0.6.1
11window.WebComponents = window.WebComponents || {};
12
13(function(scope) {
14  var flags = scope.flags || {};
15  var file = "webcomponents.js";
16  var script = document.querySelector('script[src*="' + file + '"]');
17  if (!flags.noOpts) {
18    location.search.slice(1).split("&").forEach(function(o) {
19      o = o.split("=");
20      o[0] && (flags[o[0]] = o[1] || true);
21    });
22    if (script) {
23      for (var i = 0, a; a = script.attributes[i]; i++) {
24        if (a.name !== "src") {
25          flags[a.name] = a.value || true;
26        }
27      }
28    }
29    if (flags.log && flags.log.split) {
30      var parts = flags.log.split(",");
31      flags.log = {};
32      parts.forEach(function(f) {
33        flags.log[f] = true;
34      });
35    } else {
36      flags.log = {};
37    }
38  }
39  flags.shadow = flags.shadow || flags.shadowdom || flags.polyfill;
40  if (flags.shadow === "native") {
41    flags.shadow = false;
42  } else {
43    flags.shadow = flags.shadow || !HTMLElement.prototype.createShadowRoot;
44  }
45  if (flags.register) {
46    window.CustomElements = window.CustomElements || {
47      flags: {}
48    };
49    window.CustomElements.flags.register = flags.register;
50  }
51  scope.flags = flags;
52})(WebComponents);
53
54(function(scope) {
55  "use strict";
56  var hasWorkingUrl = false;
57  if (!scope.forceJURL) {
58    try {
59      var u = new URL("b", "http://a");
60      u.pathname = "c%20d";
61      hasWorkingUrl = u.href === "http://a/c%20d";
62    } catch (e) {}
63  }
64  if (hasWorkingUrl) return;
65  var relative = Object.create(null);
66  relative["ftp"] = 21;
67  relative["file"] = 0;
68  relative["gopher"] = 70;
69  relative["http"] = 80;
70  relative["https"] = 443;
71  relative["ws"] = 80;
72  relative["wss"] = 443;
73  var relativePathDotMapping = Object.create(null);
74  relativePathDotMapping["%2e"] = ".";
75  relativePathDotMapping[".%2e"] = "..";
76  relativePathDotMapping["%2e."] = "..";
77  relativePathDotMapping["%2e%2e"] = "..";
78  function isRelativeScheme(scheme) {
79    return relative[scheme] !== undefined;
80  }
81  function invalid() {
82    clear.call(this);
83    this._isInvalid = true;
84  }
85  function IDNAToASCII(h) {
86    if ("" == h) {
87      invalid.call(this);
88    }
89    return h.toLowerCase();
90  }
91  function percentEscape(c) {
92    var unicode = c.charCodeAt(0);
93    if (unicode > 32 && unicode < 127 && [ 34, 35, 60, 62, 63, 96 ].indexOf(unicode) == -1) {
94      return c;
95    }
96    return encodeURIComponent(c);
97  }
98  function percentEscapeQuery(c) {
99    var unicode = c.charCodeAt(0);
100    if (unicode > 32 && unicode < 127 && [ 34, 35, 60, 62, 96 ].indexOf(unicode) == -1) {
101      return c;
102    }
103    return encodeURIComponent(c);
104  }
105  var EOF = undefined, ALPHA = /[a-zA-Z]/, ALPHANUMERIC = /[a-zA-Z0-9\+\-\.]/;
106  function parse(input, stateOverride, base) {
107    function err(message) {
108      errors.push(message);
109    }
110    var state = stateOverride || "scheme start", cursor = 0, buffer = "", seenAt = false, seenBracket = false, errors = [];
111    loop: while ((input[cursor - 1] != EOF || cursor == 0) && !this._isInvalid) {
112      var c = input[cursor];
113      switch (state) {
114       case "scheme start":
115        if (c && ALPHA.test(c)) {
116          buffer += c.toLowerCase();
117          state = "scheme";
118        } else if (!stateOverride) {
119          buffer = "";
120          state = "no scheme";
121          continue;
122        } else {
123          err("Invalid scheme.");
124          break loop;
125        }
126        break;
127
128       case "scheme":
129        if (c && ALPHANUMERIC.test(c)) {
130          buffer += c.toLowerCase();
131        } else if (":" == c) {
132          this._scheme = buffer;
133          buffer = "";
134          if (stateOverride) {
135            break loop;
136          }
137          if (isRelativeScheme(this._scheme)) {
138            this._isRelative = true;
139          }
140          if ("file" == this._scheme) {
141            state = "relative";
142          } else if (this._isRelative && base && base._scheme == this._scheme) {
143            state = "relative or authority";
144          } else if (this._isRelative) {
145            state = "authority first slash";
146          } else {
147            state = "scheme data";
148          }
149        } else if (!stateOverride) {
150          buffer = "";
151          cursor = 0;
152          state = "no scheme";
153          continue;
154        } else if (EOF == c) {
155          break loop;
156        } else {
157          err("Code point not allowed in scheme: " + c);
158          break loop;
159        }
160        break;
161
162       case "scheme data":
163        if ("?" == c) {
164          query = "?";
165          state = "query";
166        } else if ("#" == c) {
167          this._fragment = "#";
168          state = "fragment";
169        } else {
170          if (EOF != c && "	" != c && "\n" != c && "\r" != c) {
171            this._schemeData += percentEscape(c);
172          }
173        }
174        break;
175
176       case "no scheme":
177        if (!base || !isRelativeScheme(base._scheme)) {
178          err("Missing scheme.");
179          invalid.call(this);
180        } else {
181          state = "relative";
182          continue;
183        }
184        break;
185
186       case "relative or authority":
187        if ("/" == c && "/" == input[cursor + 1]) {
188          state = "authority ignore slashes";
189        } else {
190          err("Expected /, got: " + c);
191          state = "relative";
192          continue;
193        }
194        break;
195
196       case "relative":
197        this._isRelative = true;
198        if ("file" != this._scheme) this._scheme = base._scheme;
199        if (EOF == c) {
200          this._host = base._host;
201          this._port = base._port;
202          this._path = base._path.slice();
203          this._query = base._query;
204          break loop;
205        } else if ("/" == c || "\\" == c) {
206          if ("\\" == c) err("\\ is an invalid code point.");
207          state = "relative slash";
208        } else if ("?" == c) {
209          this._host = base._host;
210          this._port = base._port;
211          this._path = base._path.slice();
212          this._query = "?";
213          state = "query";
214        } else if ("#" == c) {
215          this._host = base._host;
216          this._port = base._port;
217          this._path = base._path.slice();
218          this._query = base._query;
219          this._fragment = "#";
220          state = "fragment";
221        } else {
222          var nextC = input[cursor + 1];
223          var nextNextC = input[cursor + 2];
224          if ("file" != this._scheme || !ALPHA.test(c) || nextC != ":" && nextC != "|" || EOF != nextNextC && "/" != nextNextC && "\\" != nextNextC && "?" != nextNextC && "#" != nextNextC) {
225            this._host = base._host;
226            this._port = base._port;
227            this._path = base._path.slice();
228            this._path.pop();
229          }
230          state = "relative path";
231          continue;
232        }
233        break;
234
235       case "relative slash":
236        if ("/" == c || "\\" == c) {
237          if ("\\" == c) {
238            err("\\ is an invalid code point.");
239          }
240          if ("file" == this._scheme) {
241            state = "file host";
242          } else {
243            state = "authority ignore slashes";
244          }
245        } else {
246          if ("file" != this._scheme) {
247            this._host = base._host;
248            this._port = base._port;
249          }
250          state = "relative path";
251          continue;
252        }
253        break;
254
255       case "authority first slash":
256        if ("/" == c) {
257          state = "authority second slash";
258        } else {
259          err("Expected '/', got: " + c);
260          state = "authority ignore slashes";
261          continue;
262        }
263        break;
264
265       case "authority second slash":
266        state = "authority ignore slashes";
267        if ("/" != c) {
268          err("Expected '/', got: " + c);
269          continue;
270        }
271        break;
272
273       case "authority ignore slashes":
274        if ("/" != c && "\\" != c) {
275          state = "authority";
276          continue;
277        } else {
278          err("Expected authority, got: " + c);
279        }
280        break;
281
282       case "authority":
283        if ("@" == c) {
284          if (seenAt) {
285            err("@ already seen.");
286            buffer += "%40";
287          }
288          seenAt = true;
289          for (var i = 0; i < buffer.length; i++) {
290            var cp = buffer[i];
291            if ("	" == cp || "\n" == cp || "\r" == cp) {
292              err("Invalid whitespace in authority.");
293              continue;
294            }
295            if (":" == cp && null === this._password) {
296              this._password = "";
297              continue;
298            }
299            var tempC = percentEscape(cp);
300            null !== this._password ? this._password += tempC : this._username += tempC;
301          }
302          buffer = "";
303        } else if (EOF == c || "/" == c || "\\" == c || "?" == c || "#" == c) {
304          cursor -= buffer.length;
305          buffer = "";
306          state = "host";
307          continue;
308        } else {
309          buffer += c;
310        }
311        break;
312
313       case "file host":
314        if (EOF == c || "/" == c || "\\" == c || "?" == c || "#" == c) {
315          if (buffer.length == 2 && ALPHA.test(buffer[0]) && (buffer[1] == ":" || buffer[1] == "|")) {
316            state = "relative path";
317          } else if (buffer.length == 0) {
318            state = "relative path start";
319          } else {
320            this._host = IDNAToASCII.call(this, buffer);
321            buffer = "";
322            state = "relative path start";
323          }
324          continue;
325        } else if ("	" == c || "\n" == c || "\r" == c) {
326          err("Invalid whitespace in file host.");
327        } else {
328          buffer += c;
329        }
330        break;
331
332       case "host":
333       case "hostname":
334        if (":" == c && !seenBracket) {
335          this._host = IDNAToASCII.call(this, buffer);
336          buffer = "";
337          state = "port";
338          if ("hostname" == stateOverride) {
339            break loop;
340          }
341        } else if (EOF == c || "/" == c || "\\" == c || "?" == c || "#" == c) {
342          this._host = IDNAToASCII.call(this, buffer);
343          buffer = "";
344          state = "relative path start";
345          if (stateOverride) {
346            break loop;
347          }
348          continue;
349        } else if ("	" != c && "\n" != c && "\r" != c) {
350          if ("[" == c) {
351            seenBracket = true;
352          } else if ("]" == c) {
353            seenBracket = false;
354          }
355          buffer += c;
356        } else {
357          err("Invalid code point in host/hostname: " + c);
358        }
359        break;
360
361       case "port":
362        if (/[0-9]/.test(c)) {
363          buffer += c;
364        } else if (EOF == c || "/" == c || "\\" == c || "?" == c || "#" == c || stateOverride) {
365          if ("" != buffer) {
366            var temp = parseInt(buffer, 10);
367            if (temp != relative[this._scheme]) {
368              this._port = temp + "";
369            }
370            buffer = "";
371          }
372          if (stateOverride) {
373            break loop;
374          }
375          state = "relative path start";
376          continue;
377        } else if ("	" == c || "\n" == c || "\r" == c) {
378          err("Invalid code point in port: " + c);
379        } else {
380          invalid.call(this);
381        }
382        break;
383
384       case "relative path start":
385        if ("\\" == c) err("'\\' not allowed in path.");
386        state = "relative path";
387        if ("/" != c && "\\" != c) {
388          continue;
389        }
390        break;
391
392       case "relative path":
393        if (EOF == c || "/" == c || "\\" == c || !stateOverride && ("?" == c || "#" == c)) {
394          if ("\\" == c) {
395            err("\\ not allowed in relative path.");
396          }
397          var tmp;
398          if (tmp = relativePathDotMapping[buffer.toLowerCase()]) {
399            buffer = tmp;
400          }
401          if (".." == buffer) {
402            this._path.pop();
403            if ("/" != c && "\\" != c) {
404              this._path.push("");
405            }
406          } else if ("." == buffer && "/" != c && "\\" != c) {
407            this._path.push("");
408          } else if ("." != buffer) {
409            if ("file" == this._scheme && this._path.length == 0 && buffer.length == 2 && ALPHA.test(buffer[0]) && buffer[1] == "|") {
410              buffer = buffer[0] + ":";
411            }
412            this._path.push(buffer);
413          }
414          buffer = "";
415          if ("?" == c) {
416            this._query = "?";
417            state = "query";
418          } else if ("#" == c) {
419            this._fragment = "#";
420            state = "fragment";
421          }
422        } else if ("	" != c && "\n" != c && "\r" != c) {
423          buffer += percentEscape(c);
424        }
425        break;
426
427       case "query":
428        if (!stateOverride && "#" == c) {
429          this._fragment = "#";
430          state = "fragment";
431        } else if (EOF != c && "	" != c && "\n" != c && "\r" != c) {
432          this._query += percentEscapeQuery(c);
433        }
434        break;
435
436       case "fragment":
437        if (EOF != c && "	" != c && "\n" != c && "\r" != c) {
438          this._fragment += c;
439        }
440        break;
441      }
442      cursor++;
443    }
444  }
445  function clear() {
446    this._scheme = "";
447    this._schemeData = "";
448    this._username = "";
449    this._password = null;
450    this._host = "";
451    this._port = "";
452    this._path = [];
453    this._query = "";
454    this._fragment = "";
455    this._isInvalid = false;
456    this._isRelative = false;
457  }
458  function jURL(url, base) {
459    if (base !== undefined && !(base instanceof jURL)) base = new jURL(String(base));
460    this._url = url;
461    clear.call(this);
462    var input = url.replace(/^[ \t\r\n\f]+|[ \t\r\n\f]+$/g, "");
463    parse.call(this, input, null, base);
464  }
465  jURL.prototype = {
466    toString: function() {
467      return this.href;
468    },
469    get href() {
470      if (this._isInvalid) return this._url;
471      var authority = "";
472      if ("" != this._username || null != this._password) {
473        authority = this._username + (null != this._password ? ":" + this._password : "") + "@";
474      }
475      return this.protocol + (this._isRelative ? "//" + authority + this.host : "") + this.pathname + this._query + this._fragment;
476    },
477    set href(href) {
478      clear.call(this);
479      parse.call(this, href);
480    },
481    get protocol() {
482      return this._scheme + ":";
483    },
484    set protocol(protocol) {
485      if (this._isInvalid) return;
486      parse.call(this, protocol + ":", "scheme start");
487    },
488    get host() {
489      return this._isInvalid ? "" : this._port ? this._host + ":" + this._port : this._host;
490    },
491    set host(host) {
492      if (this._isInvalid || !this._isRelative) return;
493      parse.call(this, host, "host");
494    },
495    get hostname() {
496      return this._host;
497    },
498    set hostname(hostname) {
499      if (this._isInvalid || !this._isRelative) return;
500      parse.call(this, hostname, "hostname");
501    },
502    get port() {
503      return this._port;
504    },
505    set port(port) {
506      if (this._isInvalid || !this._isRelative) return;
507      parse.call(this, port, "port");
508    },
509    get pathname() {
510      return this._isInvalid ? "" : this._isRelative ? "/" + this._path.join("/") : this._schemeData;
511    },
512    set pathname(pathname) {
513      if (this._isInvalid || !this._isRelative) return;
514      this._path = [];
515      parse.call(this, pathname, "relative path start");
516    },
517    get search() {
518      return this._isInvalid || !this._query || "?" == this._query ? "" : this._query;
519    },
520    set search(search) {
521      if (this._isInvalid || !this._isRelative) return;
522      this._query = "?";
523      if ("?" == search[0]) search = search.slice(1);
524      parse.call(this, search, "query");
525    },
526    get hash() {
527      return this._isInvalid || !this._fragment || "#" == this._fragment ? "" : this._fragment;
528    },
529    set hash(hash) {
530      if (this._isInvalid) return;
531      this._fragment = "#";
532      if ("#" == hash[0]) hash = hash.slice(1);
533      parse.call(this, hash, "fragment");
534    },
535    get origin() {
536      var host;
537      if (this._isInvalid || !this._scheme) {
538        return "";
539      }
540      switch (this._scheme) {
541       case "data":
542       case "file":
543       case "javascript":
544       case "mailto":
545        return "null";
546      }
547      host = this.host;
548      if (!host) {
549        return "";
550      }
551      return this._scheme + "://" + host;
552    }
553  };
554  var OriginalURL = scope.URL;
555  if (OriginalURL) {
556    jURL.createObjectURL = function(blob) {
557      return OriginalURL.createObjectURL.apply(OriginalURL, arguments);
558    };
559    jURL.revokeObjectURL = function(url) {
560      OriginalURL.revokeObjectURL(url);
561    };
562  }
563  scope.URL = jURL;
564})(this);
565
566if (typeof WeakMap === "undefined") {
567  (function() {
568    var defineProperty = Object.defineProperty;
569    var counter = Date.now() % 1e9;
570    var WeakMap = function() {
571      this.name = "__st" + (Math.random() * 1e9 >>> 0) + (counter++ + "__");
572    };
573    WeakMap.prototype = {
574      set: function(key, value) {
575        var entry = key[this.name];
576        if (entry && entry[0] === key) entry[1] = value; else defineProperty(key, this.name, {
577          value: [ key, value ],
578          writable: true
579        });
580        return this;
581      },
582      get: function(key) {
583        var entry;
584        return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined;
585      },
586      "delete": function(key) {
587        var entry = key[this.name];
588        if (!entry || entry[0] !== key) return false;
589        entry[0] = entry[1] = undefined;
590        return true;
591      },
592      has: function(key) {
593        var entry = key[this.name];
594        if (!entry) return false;
595        return entry[0] === key;
596      }
597    };
598    window.WeakMap = WeakMap;
599  })();
600}
601
602(function(global) {
603  var registrationsTable = new WeakMap();
604  var setImmediate;
605  if (/Trident|Edge/.test(navigator.userAgent)) {
606    setImmediate = setTimeout;
607  } else if (window.setImmediate) {
608    setImmediate = window.setImmediate;
609  } else {
610    var setImmediateQueue = [];
611    var sentinel = String(Math.random());
612    window.addEventListener("message", function(e) {
613      if (e.data === sentinel) {
614        var queue = setImmediateQueue;
615        setImmediateQueue = [];
616        queue.forEach(function(func) {
617          func();
618        });
619      }
620    });
621    setImmediate = function(func) {
622      setImmediateQueue.push(func);
623      window.postMessage(sentinel, "*");
624    };
625  }
626  var isScheduled = false;
627  var scheduledObservers = [];
628  function scheduleCallback(observer) {
629    scheduledObservers.push(observer);
630    if (!isScheduled) {
631      isScheduled = true;
632      setImmediate(dispatchCallbacks);
633    }
634  }
635  function wrapIfNeeded(node) {
636    return window.ShadowDOMPolyfill && window.ShadowDOMPolyfill.wrapIfNeeded(node) || node;
637  }
638  function dispatchCallbacks() {
639    isScheduled = false;
640    var observers = scheduledObservers;
641    scheduledObservers = [];
642    observers.sort(function(o1, o2) {
643      return o1.uid_ - o2.uid_;
644    });
645    var anyNonEmpty = false;
646    observers.forEach(function(observer) {
647      var queue = observer.takeRecords();
648      removeTransientObserversFor(observer);
649      if (queue.length) {
650        observer.callback_(queue, observer);
651        anyNonEmpty = true;
652      }
653    });
654    if (anyNonEmpty) dispatchCallbacks();
655  }
656  function removeTransientObserversFor(observer) {
657    observer.nodes_.forEach(function(node) {
658      var registrations = registrationsTable.get(node);
659      if (!registrations) return;
660      registrations.forEach(function(registration) {
661        if (registration.observer === observer) registration.removeTransientObservers();
662      });
663    });
664  }
665  function forEachAncestorAndObserverEnqueueRecord(target, callback) {
666    for (var node = target; node; node = node.parentNode) {
667      var registrations = registrationsTable.get(node);
668      if (registrations) {
669        for (var j = 0; j < registrations.length; j++) {
670          var registration = registrations[j];
671          var options = registration.options;
672          if (node !== target && !options.subtree) continue;
673          var record = callback(options);
674          if (record) registration.enqueue(record);
675        }
676      }
677    }
678  }
679  var uidCounter = 0;
680  function JsMutationObserver(callback) {
681    this.callback_ = callback;
682    this.nodes_ = [];
683    this.records_ = [];
684    this.uid_ = ++uidCounter;
685  }
686  JsMutationObserver.prototype = {
687    observe: function(target, options) {
688      target = wrapIfNeeded(target);
689      if (!options.childList && !options.attributes && !options.characterData || options.attributeOldValue && !options.attributes || options.attributeFilter && options.attributeFilter.length && !options.attributes || options.characterDataOldValue && !options.characterData) {
690        throw new SyntaxError();
691      }
692      var registrations = registrationsTable.get(target);
693      if (!registrations) registrationsTable.set(target, registrations = []);
694      var registration;
695      for (var i = 0; i < registrations.length; i++) {
696        if (registrations[i].observer === this) {
697          registration = registrations[i];
698          registration.removeListeners();
699          registration.options = options;
700          break;
701        }
702      }
703      if (!registration) {
704        registration = new Registration(this, target, options);
705        registrations.push(registration);
706        this.nodes_.push(target);
707      }
708      registration.addListeners();
709    },
710    disconnect: function() {
711      this.nodes_.forEach(function(node) {
712        var registrations = registrationsTable.get(node);
713        for (var i = 0; i < registrations.length; i++) {
714          var registration = registrations[i];
715          if (registration.observer === this) {
716            registration.removeListeners();
717            registrations.splice(i, 1);
718            break;
719          }
720        }
721      }, this);
722      this.records_ = [];
723    },
724    takeRecords: function() {
725      var copyOfRecords = this.records_;
726      this.records_ = [];
727      return copyOfRecords;
728    }
729  };
730  function MutationRecord(type, target) {
731    this.type = type;
732    this.target = target;
733    this.addedNodes = [];
734    this.removedNodes = [];
735    this.previousSibling = null;
736    this.nextSibling = null;
737    this.attributeName = null;
738    this.attributeNamespace = null;
739    this.oldValue = null;
740  }
741  function copyMutationRecord(original) {
742    var record = new MutationRecord(original.type, original.target);
743    record.addedNodes = original.addedNodes.slice();
744    record.removedNodes = original.removedNodes.slice();
745    record.previousSibling = original.previousSibling;
746    record.nextSibling = original.nextSibling;
747    record.attributeName = original.attributeName;
748    record.attributeNamespace = original.attributeNamespace;
749    record.oldValue = original.oldValue;
750    return record;
751  }
752  var currentRecord, recordWithOldValue;
753  function getRecord(type, target) {
754    return currentRecord = new MutationRecord(type, target);
755  }
756  function getRecordWithOldValue(oldValue) {
757    if (recordWithOldValue) return recordWithOldValue;
758    recordWithOldValue = copyMutationRecord(currentRecord);
759    recordWithOldValue.oldValue = oldValue;
760    return recordWithOldValue;
761  }
762  function clearRecords() {
763    currentRecord = recordWithOldValue = undefined;
764  }
765  function recordRepresentsCurrentMutation(record) {
766    return record === recordWithOldValue || record === currentRecord;
767  }
768  function selectRecord(lastRecord, newRecord) {
769    if (lastRecord === newRecord) return lastRecord;
770    if (recordWithOldValue && recordRepresentsCurrentMutation(lastRecord)) return recordWithOldValue;
771    return null;
772  }
773  function Registration(observer, target, options) {
774    this.observer = observer;
775    this.target = target;
776    this.options = options;
777    this.transientObservedNodes = [];
778  }
779  Registration.prototype = {
780    enqueue: function(record) {
781      var records = this.observer.records_;
782      var length = records.length;
783      if (records.length > 0) {
784        var lastRecord = records[length - 1];
785        var recordToReplaceLast = selectRecord(lastRecord, record);
786        if (recordToReplaceLast) {
787          records[length - 1] = recordToReplaceLast;
788          return;
789        }
790      } else {
791        scheduleCallback(this.observer);
792      }
793      records[length] = record;
794    },
795    addListeners: function() {
796      this.addListeners_(this.target);
797    },
798    addListeners_: function(node) {
799      var options = this.options;
800      if (options.attributes) node.addEventListener("DOMAttrModified", this, true);
801      if (options.characterData) node.addEventListener("DOMCharacterDataModified", this, true);
802      if (options.childList) node.addEventListener("DOMNodeInserted", this, true);
803      if (options.childList || options.subtree) node.addEventListener("DOMNodeRemoved", this, true);
804    },
805    removeListeners: function() {
806      this.removeListeners_(this.target);
807    },
808    removeListeners_: function(node) {
809      var options = this.options;
810      if (options.attributes) node.removeEventListener("DOMAttrModified", this, true);
811      if (options.characterData) node.removeEventListener("DOMCharacterDataModified", this, true);
812      if (options.childList) node.removeEventListener("DOMNodeInserted", this, true);
813      if (options.childList || options.subtree) node.removeEventListener("DOMNodeRemoved", this, true);
814    },
815    addTransientObserver: function(node) {
816      if (node === this.target) return;
817      this.addListeners_(node);
818      this.transientObservedNodes.push(node);
819      var registrations = registrationsTable.get(node);
820      if (!registrations) registrationsTable.set(node, registrations = []);
821      registrations.push(this);
822    },
823    removeTransientObservers: function() {
824      var transientObservedNodes = this.transientObservedNodes;
825      this.transientObservedNodes = [];
826      transientObservedNodes.forEach(function(node) {
827        this.removeListeners_(node);
828        var registrations = registrationsTable.get(node);
829        for (var i = 0; i < registrations.length; i++) {
830          if (registrations[i] === this) {
831            registrations.splice(i, 1);
832            break;
833          }
834        }
835      }, this);
836    },
837    handleEvent: function(e) {
838      e.stopImmediatePropagation();
839      switch (e.type) {
840       case "DOMAttrModified":
841        var name = e.attrName;
842        var namespace = e.relatedNode.namespaceURI;
843        var target = e.target;
844        var record = new getRecord("attributes", target);
845        record.attributeName = name;
846        record.attributeNamespace = namespace;
847        var oldValue = e.attrChange === MutationEvent.ADDITION ? null : e.prevValue;
848        forEachAncestorAndObserverEnqueueRecord(target, function(options) {
849          if (!options.attributes) return;
850          if (options.attributeFilter && options.attributeFilter.length && options.attributeFilter.indexOf(name) === -1 && options.attributeFilter.indexOf(namespace) === -1) {
851            return;
852          }
853          if (options.attributeOldValue) return getRecordWithOldValue(oldValue);
854          return record;
855        });
856        break;
857
858       case "DOMCharacterDataModified":
859        var target = e.target;
860        var record = getRecord("characterData", target);
861        var oldValue = e.prevValue;
862        forEachAncestorAndObserverEnqueueRecord(target, function(options) {
863          if (!options.characterData) return;
864          if (options.characterDataOldValue) return getRecordWithOldValue(oldValue);
865          return record;
866        });
867        break;
868
869       case "DOMNodeRemoved":
870        this.addTransientObserver(e.target);
871
872       case "DOMNodeInserted":
873        var changedNode = e.target;
874        var addedNodes, removedNodes;
875        if (e.type === "DOMNodeInserted") {
876          addedNodes = [ changedNode ];
877          removedNodes = [];
878        } else {
879          addedNodes = [];
880          removedNodes = [ changedNode ];
881        }
882        var previousSibling = changedNode.previousSibling;
883        var nextSibling = changedNode.nextSibling;
884        var record = getRecord("childList", e.target.parentNode);
885        record.addedNodes = addedNodes;
886        record.removedNodes = removedNodes;
887        record.previousSibling = previousSibling;
888        record.nextSibling = nextSibling;
889        forEachAncestorAndObserverEnqueueRecord(e.relatedNode, function(options) {
890          if (!options.childList) return;
891          return record;
892        });
893      }
894      clearRecords();
895    }
896  };
897  global.JsMutationObserver = JsMutationObserver;
898  if (!global.MutationObserver) global.MutationObserver = JsMutationObserver;
899})(this);
900
901window.HTMLImports = window.HTMLImports || {
902  flags: {}
903};
904
905(function(scope) {
906  var IMPORT_LINK_TYPE = "import";
907  var useNative = Boolean(IMPORT_LINK_TYPE in document.createElement("link"));
908  var hasShadowDOMPolyfill = Boolean(window.ShadowDOMPolyfill);
909  var wrap = function(node) {
910    return hasShadowDOMPolyfill ? ShadowDOMPolyfill.wrapIfNeeded(node) : node;
911  };
912  var rootDocument = wrap(document);
913  var currentScriptDescriptor = {
914    get: function() {
915      var script = HTMLImports.currentScript || document.currentScript || (document.readyState !== "complete" ? document.scripts[document.scripts.length - 1] : null);
916      return wrap(script);
917    },
918    configurable: true
919  };
920  Object.defineProperty(document, "_currentScript", currentScriptDescriptor);
921  Object.defineProperty(rootDocument, "_currentScript", currentScriptDescriptor);
922  var isIE = /Trident|Edge/.test(navigator.userAgent);
923  function whenReady(callback, doc) {
924    doc = doc || rootDocument;
925    whenDocumentReady(function() {
926      watchImportsLoad(callback, doc);
927    }, doc);
928  }
929  var requiredReadyState = isIE ? "complete" : "interactive";
930  var READY_EVENT = "readystatechange";
931  function isDocumentReady(doc) {
932    return doc.readyState === "complete" || doc.readyState === requiredReadyState;
933  }
934  function whenDocumentReady(callback, doc) {
935    if (!isDocumentReady(doc)) {
936      var checkReady = function() {
937        if (doc.readyState === "complete" || doc.readyState === requiredReadyState) {
938          doc.removeEventListener(READY_EVENT, checkReady);
939          whenDocumentReady(callback, doc);
940        }
941      };
942      doc.addEventListener(READY_EVENT, checkReady);
943    } else if (callback) {
944      callback();
945    }
946  }
947  function markTargetLoaded(event) {
948    event.target.__loaded = true;
949  }
950  function watchImportsLoad(callback, doc) {
951    var imports = doc.querySelectorAll("link[rel=import]");
952    var parsedCount = 0, importCount = imports.length, newImports = [], errorImports = [];
953    function checkDone() {
954      if (parsedCount == importCount && callback) {
955        callback({
956          allImports: imports,
957          loadedImports: newImports,
958          errorImports: errorImports
959        });
960      }
961    }
962    function loadedImport(e) {
963      markTargetLoaded(e);
964      newImports.push(this);
965      parsedCount++;
966      checkDone();
967    }
968    function errorLoadingImport(e) {
969      errorImports.push(this);
970      parsedCount++;
971      checkDone();
972    }
973    if (importCount) {
974      for (var i = 0, imp; i < importCount && (imp = imports[i]); i++) {
975        if (isImportLoaded(imp)) {
976          parsedCount++;
977          checkDone();
978        } else {
979          imp.addEventListener("load", loadedImport);
980          imp.addEventListener("error", errorLoadingImport);
981        }
982      }
983    } else {
984      checkDone();
985    }
986  }
987  function isImportLoaded(link) {
988    return useNative ? link.__loaded || link.import && link.import.readyState !== "loading" : link.__importParsed;
989  }
990  if (useNative) {
991    new MutationObserver(function(mxns) {
992      for (var i = 0, l = mxns.length, m; i < l && (m = mxns[i]); i++) {
993        if (m.addedNodes) {
994          handleImports(m.addedNodes);
995        }
996      }
997    }).observe(document.head, {
998      childList: true
999    });
1000    function handleImports(nodes) {
1001      for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) {
1002        if (isImport(n)) {
1003          handleImport(n);
1004        }
1005      }
1006    }
1007    function isImport(element) {
1008      return element.localName === "link" && element.rel === "import";
1009    }
1010    function handleImport(element) {
1011      var loaded = element.import;
1012      if (loaded) {
1013        markTargetLoaded({
1014          target: element
1015        });
1016      } else {
1017        element.addEventListener("load", markTargetLoaded);
1018        element.addEventListener("error", markTargetLoaded);
1019      }
1020    }
1021    (function() {
1022      if (document.readyState === "loading") {
1023        var imports = document.querySelectorAll("link[rel=import]");
1024        for (var i = 0, l = imports.length, imp; i < l && (imp = imports[i]); i++) {
1025          handleImport(imp);
1026        }
1027      }
1028    })();
1029  }
1030  whenReady(function(detail) {
1031    HTMLImports.ready = true;
1032    HTMLImports.readyTime = new Date().getTime();
1033    var evt = rootDocument.createEvent("CustomEvent");
1034    evt.initCustomEvent("HTMLImportsLoaded", true, true, detail);
1035    rootDocument.dispatchEvent(evt);
1036  });
1037  scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;
1038  scope.useNative = useNative;
1039  scope.rootDocument = rootDocument;
1040  scope.whenReady = whenReady;
1041  scope.isIE = isIE;
1042})(HTMLImports);
1043
1044(function(scope) {
1045  var modules = [];
1046  var addModule = function(module) {
1047    modules.push(module);
1048  };
1049  var initializeModules = function() {
1050    modules.forEach(function(module) {
1051      module(scope);
1052    });
1053  };
1054  scope.addModule = addModule;
1055  scope.initializeModules = initializeModules;
1056})(HTMLImports);
1057
1058HTMLImports.addModule(function(scope) {
1059  var CSS_URL_REGEXP = /(url\()([^)]*)(\))/g;
1060  var CSS_IMPORT_REGEXP = /(@import[\s]+(?!url\())([^;]*)(;)/g;
1061  var path = {
1062    resolveUrlsInStyle: function(style, linkUrl) {
1063      var doc = style.ownerDocument;
1064      var resolver = doc.createElement("a");
1065      style.textContent = this.resolveUrlsInCssText(style.textContent, linkUrl, resolver);
1066      return style;
1067    },
1068    resolveUrlsInCssText: function(cssText, linkUrl, urlObj) {
1069      var r = this.replaceUrls(cssText, urlObj, linkUrl, CSS_URL_REGEXP);
1070      r = this.replaceUrls(r, urlObj, linkUrl, CSS_IMPORT_REGEXP);
1071      return r;
1072    },
1073    replaceUrls: function(text, urlObj, linkUrl, regexp) {
1074      return text.replace(regexp, function(m, pre, url, post) {
1075        var urlPath = url.replace(/["']/g, "");
1076        if (linkUrl) {
1077          urlPath = new URL(urlPath, linkUrl).href;
1078        }
1079        urlObj.href = urlPath;
1080        urlPath = urlObj.href;
1081        return pre + "'" + urlPath + "'" + post;
1082      });
1083    }
1084  };
1085  scope.path = path;
1086});
1087
1088HTMLImports.addModule(function(scope) {
1089  var xhr = {
1090    async: true,
1091    ok: function(request) {
1092      return request.status >= 200 && request.status < 300 || request.status === 304 || request.status === 0;
1093    },
1094    load: function(url, next, nextContext) {
1095      var request = new XMLHttpRequest();
1096      if (scope.flags.debug || scope.flags.bust) {
1097        url += "?" + Math.random();
1098      }
1099      request.open("GET", url, xhr.async);
1100      request.addEventListener("readystatechange", function(e) {
1101        if (request.readyState === 4) {
1102          var locationHeader = request.getResponseHeader("Location");
1103          var redirectedUrl = null;
1104          if (locationHeader) {
1105            var redirectedUrl = locationHeader.substr(0, 1) === "/" ? location.origin + locationHeader : locationHeader;
1106          }
1107          next.call(nextContext, !xhr.ok(request) && request, request.response || request.responseText, redirectedUrl);
1108        }
1109      });
1110      request.send();
1111      return request;
1112    },
1113    loadDocument: function(url, next, nextContext) {
1114      this.load(url, next, nextContext).responseType = "document";
1115    }
1116  };
1117  scope.xhr = xhr;
1118});
1119
1120HTMLImports.addModule(function(scope) {
1121  var xhr = scope.xhr;
1122  var flags = scope.flags;
1123  var Loader = function(onLoad, onComplete) {
1124    this.cache = {};
1125    this.onload = onLoad;
1126    this.oncomplete = onComplete;
1127    this.inflight = 0;
1128    this.pending = {};
1129  };
1130  Loader.prototype = {
1131    addNodes: function(nodes) {
1132      this.inflight += nodes.length;
1133      for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) {
1134        this.require(n);
1135      }
1136      this.checkDone();
1137    },
1138    addNode: function(node) {
1139      this.inflight++;
1140      this.require(node);
1141      this.checkDone();
1142    },
1143    require: function(elt) {
1144      var url = elt.src || elt.href;
1145      elt.__nodeUrl = url;
1146      if (!this.dedupe(url, elt)) {
1147        this.fetch(url, elt);
1148      }
1149    },
1150    dedupe: function(url, elt) {
1151      if (this.pending[url]) {
1152        this.pending[url].push(elt);
1153        return true;
1154      }
1155      var resource;
1156      if (this.cache[url]) {
1157        this.onload(url, elt, this.cache[url]);
1158        this.tail();
1159        return true;
1160      }
1161      this.pending[url] = [ elt ];
1162      return false;
1163    },
1164    fetch: function(url, elt) {
1165      flags.load && console.log("fetch", url, elt);
1166      if (!url) {
1167        setTimeout(function() {
1168          this.receive(url, elt, {
1169            error: "href must be specified"
1170          }, null);
1171        }.bind(this), 0);
1172      } else if (url.match(/^data:/)) {
1173        var pieces = url.split(",");
1174        var header = pieces[0];
1175        var body = pieces[1];
1176        if (header.indexOf(";base64") > -1) {
1177          body = atob(body);
1178        } else {
1179          body = decodeURIComponent(body);
1180        }
1181        setTimeout(function() {
1182          this.receive(url, elt, null, body);
1183        }.bind(this), 0);
1184      } else {
1185        var receiveXhr = function(err, resource, redirectedUrl) {
1186          this.receive(url, elt, err, resource, redirectedUrl);
1187        }.bind(this);
1188        xhr.load(url, receiveXhr);
1189      }
1190    },
1191    receive: function(url, elt, err, resource, redirectedUrl) {
1192      this.cache[url] = resource;
1193      var $p = this.pending[url];
1194      for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) {
1195        this.onload(url, p, resource, err, redirectedUrl);
1196        this.tail();
1197      }
1198      this.pending[url] = null;
1199    },
1200    tail: function() {
1201      --this.inflight;
1202      this.checkDone();
1203    },
1204    checkDone: function() {
1205      if (!this.inflight) {
1206        this.oncomplete();
1207      }
1208    }
1209  };
1210  scope.Loader = Loader;
1211});
1212
1213HTMLImports.addModule(function(scope) {
1214  var Observer = function(addCallback) {
1215    this.addCallback = addCallback;
1216    this.mo = new MutationObserver(this.handler.bind(this));
1217  };
1218  Observer.prototype = {
1219    handler: function(mutations) {
1220      for (var i = 0, l = mutations.length, m; i < l && (m = mutations[i]); i++) {
1221        if (m.type === "childList" && m.addedNodes.length) {
1222          this.addedNodes(m.addedNodes);
1223        }
1224      }
1225    },
1226    addedNodes: function(nodes) {
1227      if (this.addCallback) {
1228        this.addCallback(nodes);
1229      }
1230      for (var i = 0, l = nodes.length, n, loading; i < l && (n = nodes[i]); i++) {
1231        if (n.children && n.children.length) {
1232          this.addedNodes(n.children);
1233        }
1234      }
1235    },
1236    observe: function(root) {
1237      this.mo.observe(root, {
1238        childList: true,
1239        subtree: true
1240      });
1241    }
1242  };
1243  scope.Observer = Observer;
1244});
1245
1246HTMLImports.addModule(function(scope) {
1247  var path = scope.path;
1248  var rootDocument = scope.rootDocument;
1249  var flags = scope.flags;
1250  var isIE = scope.isIE;
1251  var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;
1252  var IMPORT_SELECTOR = "link[rel=" + IMPORT_LINK_TYPE + "]";
1253  var importParser = {
1254    documentSelectors: IMPORT_SELECTOR,
1255    importsSelectors: [ IMPORT_SELECTOR, "link[rel=stylesheet]", "style", "script:not([type])", 'script[type="text/javascript"]' ].join(","),
1256    map: {
1257      link: "parseLink",
1258      script: "parseScript",
1259      style: "parseStyle"
1260    },
1261    dynamicElements: [],
1262    parseNext: function() {
1263      var next = this.nextToParse();
1264      if (next) {
1265        this.parse(next);
1266      }
1267    },
1268    parse: function(elt) {
1269      if (this.isParsed(elt)) {
1270        flags.parse && console.log("[%s] is already parsed", elt.localName);
1271        return;
1272      }
1273      var fn = this[this.map[elt.localName]];
1274      if (fn) {
1275        this.markParsing(elt);
1276        fn.call(this, elt);
1277      }
1278    },
1279    parseDynamic: function(elt, quiet) {
1280      this.dynamicElements.push(elt);
1281      if (!quiet) {
1282        this.parseNext();
1283      }
1284    },
1285    markParsing: function(elt) {
1286      flags.parse && console.log("parsing", elt);
1287      this.parsingElement = elt;
1288    },
1289    markParsingComplete: function(elt) {
1290      elt.__importParsed = true;
1291      this.markDynamicParsingComplete(elt);
1292      if (elt.__importElement) {
1293        elt.__importElement.__importParsed = true;
1294        this.markDynamicParsingComplete(elt.__importElement);
1295      }
1296      this.parsingElement = null;
1297      flags.parse && console.log("completed", elt);
1298    },
1299    markDynamicParsingComplete: function(elt) {
1300      var i = this.dynamicElements.indexOf(elt);
1301      if (i >= 0) {
1302        this.dynamicElements.splice(i, 1);
1303      }
1304    },
1305    parseImport: function(elt) {
1306      if (HTMLImports.__importsParsingHook) {
1307        HTMLImports.__importsParsingHook(elt);
1308      }
1309      if (elt.import) {
1310        elt.import.__importParsed = true;
1311      }
1312      this.markParsingComplete(elt);
1313      if (elt.__resource && !elt.__error) {
1314        elt.dispatchEvent(new CustomEvent("load", {
1315          bubbles: false
1316        }));
1317      } else {
1318        elt.dispatchEvent(new CustomEvent("error", {
1319          bubbles: false
1320        }));
1321      }
1322      if (elt.__pending) {
1323        var fn;
1324        while (elt.__pending.length) {
1325          fn = elt.__pending.shift();
1326          if (fn) {
1327            fn({
1328              target: elt
1329            });
1330          }
1331        }
1332      }
1333      this.parseNext();
1334    },
1335    parseLink: function(linkElt) {
1336      if (nodeIsImport(linkElt)) {
1337        this.parseImport(linkElt);
1338      } else {
1339        linkElt.href = linkElt.href;
1340        this.parseGeneric(linkElt);
1341      }
1342    },
1343    parseStyle: function(elt) {
1344      var src = elt;
1345      elt = cloneStyle(elt);
1346      src.__appliedElement = elt;
1347      elt.__importElement = src;
1348      this.parseGeneric(elt);
1349    },
1350    parseGeneric: function(elt) {
1351      this.trackElement(elt);
1352      this.addElementToDocument(elt);
1353    },
1354    rootImportForElement: function(elt) {
1355      var n = elt;
1356      while (n.ownerDocument.__importLink) {
1357        n = n.ownerDocument.__importLink;
1358      }
1359      return n;
1360    },
1361    addElementToDocument: function(elt) {
1362      var port = this.rootImportForElement(elt.__importElement || elt);
1363      port.parentNode.insertBefore(elt, port);
1364    },
1365    trackElement: function(elt, callback) {
1366      var self = this;
1367      var done = function(e) {
1368        if (callback) {
1369          callback(e);
1370        }
1371        self.markParsingComplete(elt);
1372        self.parseNext();
1373      };
1374      elt.addEventListener("load", done);
1375      elt.addEventListener("error", done);
1376      if (isIE && elt.localName === "style") {
1377        var fakeLoad = false;
1378        if (elt.textContent.indexOf("@import") == -1) {
1379          fakeLoad = true;
1380        } else if (elt.sheet) {
1381          fakeLoad = true;
1382          var csr = elt.sheet.cssRules;
1383          var len = csr ? csr.length : 0;
1384          for (var i = 0, r; i < len && (r = csr[i]); i++) {
1385            if (r.type === CSSRule.IMPORT_RULE) {
1386              fakeLoad = fakeLoad && Boolean(r.styleSheet);
1387            }
1388          }
1389        }
1390        if (fakeLoad) {
1391          elt.dispatchEvent(new CustomEvent("load", {
1392            bubbles: false
1393          }));
1394        }
1395      }
1396    },
1397    parseScript: function(scriptElt) {
1398      var script = document.createElement("script");
1399      script.__importElement = scriptElt;
1400      script.src = scriptElt.src ? scriptElt.src : generateScriptDataUrl(scriptElt);
1401      scope.currentScript = scriptElt;
1402      this.trackElement(script, function(e) {
1403        script.parentNode.removeChild(script);
1404        scope.currentScript = null;
1405      });
1406      this.addElementToDocument(script);
1407    },
1408    nextToParse: function() {
1409      this._mayParse = [];
1410      return !this.parsingElement && (this.nextToParseInDoc(rootDocument) || this.nextToParseDynamic());
1411    },
1412    nextToParseInDoc: function(doc, link) {
1413      if (doc && this._mayParse.indexOf(doc) < 0) {
1414        this._mayParse.push(doc);
1415        var nodes = doc.querySelectorAll(this.parseSelectorsForNode(doc));
1416        for (var i = 0, l = nodes.length, p = 0, n; i < l && (n = nodes[i]); i++) {
1417          if (!this.isParsed(n)) {
1418            if (this.hasResource(n)) {
1419              return nodeIsImport(n) ? this.nextToParseInDoc(n.import, n) : n;
1420            } else {
1421              return;
1422            }
1423          }
1424        }
1425      }
1426      return link;
1427    },
1428    nextToParseDynamic: function() {
1429      return this.dynamicElements[0];
1430    },
1431    parseSelectorsForNode: function(node) {
1432      var doc = node.ownerDocument || node;
1433      return doc === rootDocument ? this.documentSelectors : this.importsSelectors;
1434    },
1435    isParsed: function(node) {
1436      return node.__importParsed;
1437    },
1438    needsDynamicParsing: function(elt) {
1439      return this.dynamicElements.indexOf(elt) >= 0;
1440    },
1441    hasResource: function(node) {
1442      if (nodeIsImport(node) && node.import === undefined) {
1443        return false;
1444      }
1445      return true;
1446    }
1447  };
1448  function nodeIsImport(elt) {
1449    return elt.localName === "link" && elt.rel === IMPORT_LINK_TYPE;
1450  }
1451  function generateScriptDataUrl(script) {
1452    var scriptContent = generateScriptContent(script);
1453    return "data:text/javascript;charset=utf-8," + encodeURIComponent(scriptContent);
1454  }
1455  function generateScriptContent(script) {
1456    return script.textContent + generateSourceMapHint(script);
1457  }
1458  function generateSourceMapHint(script) {
1459    var owner = script.ownerDocument;
1460    owner.__importedScripts = owner.__importedScripts || 0;
1461    var moniker = script.ownerDocument.baseURI;
1462    var num = owner.__importedScripts ? "-" + owner.__importedScripts : "";
1463    owner.__importedScripts++;
1464    return "\n//# sourceURL=" + moniker + num + ".js\n";
1465  }
1466  function cloneStyle(style) {
1467    var clone = style.ownerDocument.createElement("style");
1468    clone.textContent = style.textContent;
1469    path.resolveUrlsInStyle(clone);
1470    return clone;
1471  }
1472  scope.parser = importParser;
1473  scope.IMPORT_SELECTOR = IMPORT_SELECTOR;
1474});
1475
1476HTMLImports.addModule(function(scope) {
1477  var flags = scope.flags;
1478  var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;
1479  var IMPORT_SELECTOR = scope.IMPORT_SELECTOR;
1480  var rootDocument = scope.rootDocument;
1481  var Loader = scope.Loader;
1482  var Observer = scope.Observer;
1483  var parser = scope.parser;
1484  var importer = {
1485    documents: {},
1486    documentPreloadSelectors: IMPORT_SELECTOR,
1487    importsPreloadSelectors: [ IMPORT_SELECTOR ].join(","),
1488    loadNode: function(node) {
1489      importLoader.addNode(node);
1490    },
1491    loadSubtree: function(parent) {
1492      var nodes = this.marshalNodes(parent);
1493      importLoader.addNodes(nodes);
1494    },
1495    marshalNodes: function(parent) {
1496      return parent.querySelectorAll(this.loadSelectorsForNode(parent));
1497    },
1498    loadSelectorsForNode: function(node) {
1499      var doc = node.ownerDocument || node;
1500      return doc === rootDocument ? this.documentPreloadSelectors : this.importsPreloadSelectors;
1501    },
1502    loaded: function(url, elt, resource, err, redirectedUrl) {
1503      flags.load && console.log("loaded", url, elt);
1504      elt.__resource = resource;
1505      elt.__error = err;
1506      if (isImportLink(elt)) {
1507        var doc = this.documents[url];
1508        if (doc === undefined) {
1509          doc = err ? null : makeDocument(resource, redirectedUrl || url);
1510          if (doc) {
1511            doc.__importLink = elt;
1512            this.bootDocument(doc);
1513          }
1514          this.documents[url] = doc;
1515        }
1516        elt.import = doc;
1517      }
1518      parser.parseNext();
1519    },
1520    bootDocument: function(doc) {
1521      this.loadSubtree(doc);
1522      this.observer.observe(doc);
1523      parser.parseNext();
1524    },
1525    loadedAll: function() {
1526      parser.parseNext();
1527    }
1528  };
1529  var importLoader = new Loader(importer.loaded.bind(importer), importer.loadedAll.bind(importer));
1530  importer.observer = new Observer();
1531  function isImportLink(elt) {
1532    return isLinkRel(elt, IMPORT_LINK_TYPE);
1533  }
1534  function isLinkRel(elt, rel) {
1535    return elt.localName === "link" && elt.getAttribute("rel") === rel;
1536  }
1537  function hasBaseURIAccessor(doc) {
1538    return !!Object.getOwnPropertyDescriptor(doc, "baseURI");
1539  }
1540  function makeDocument(resource, url) {
1541    var doc = document.implementation.createHTMLDocument(IMPORT_LINK_TYPE);
1542    doc._URL = url;
1543    var base = doc.createElement("base");
1544    base.setAttribute("href", url);
1545    if (!doc.baseURI && !hasBaseURIAccessor(doc)) {
1546      Object.defineProperty(doc, "baseURI", {
1547        value: url
1548      });
1549    }
1550    var meta = doc.createElement("meta");
1551    meta.setAttribute("charset", "utf-8");
1552    doc.head.appendChild(meta);
1553    doc.head.appendChild(base);
1554    doc.body.innerHTML = resource;
1555    if (window.HTMLTemplateElement && HTMLTemplateElement.bootstrap) {
1556      HTMLTemplateElement.bootstrap(doc);
1557    }
1558    return doc;
1559  }
1560  if (!document.baseURI) {
1561    var baseURIDescriptor = {
1562      get: function() {
1563        var base = document.querySelector("base");
1564        return base ? base.href : window.location.href;
1565      },
1566      configurable: true
1567    };
1568    Object.defineProperty(document, "baseURI", baseURIDescriptor);
1569    Object.defineProperty(rootDocument, "baseURI", baseURIDescriptor);
1570  }
1571  scope.importer = importer;
1572  scope.importLoader = importLoader;
1573});
1574
1575HTMLImports.addModule(function(scope) {
1576  var parser = scope.parser;
1577  var importer = scope.importer;
1578  var dynamic = {
1579    added: function(nodes) {
1580      var owner, parsed, loading;
1581      for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) {
1582        if (!owner) {
1583          owner = n.ownerDocument;
1584          parsed = parser.isParsed(owner);
1585        }
1586        loading = this.shouldLoadNode(n);
1587        if (loading) {
1588          importer.loadNode(n);
1589        }
1590        if (this.shouldParseNode(n) && parsed) {
1591          parser.parseDynamic(n, loading);
1592        }
1593      }
1594    },
1595    shouldLoadNode: function(node) {
1596      return node.nodeType === 1 && matches.call(node, importer.loadSelectorsForNode(node));
1597    },
1598    shouldParseNode: function(node) {
1599      return node.nodeType === 1 && matches.call(node, parser.parseSelectorsForNode(node));
1600    }
1601  };
1602  importer.observer.addCallback = dynamic.added.bind(dynamic);
1603  var matches = HTMLElement.prototype.matches || HTMLElement.prototype.matchesSelector || HTMLElement.prototype.webkitMatchesSelector || HTMLElement.prototype.mozMatchesSelector || HTMLElement.prototype.msMatchesSelector;
1604});
1605
1606(function(scope) {
1607  var initializeModules = scope.initializeModules;
1608  var isIE = scope.isIE;
1609  if (scope.useNative) {
1610    return;
1611  }
1612  if (isIE && typeof window.CustomEvent !== "function") {
1613    window.CustomEvent = function(inType, params) {
1614      params = params || {};
1615      var e = document.createEvent("CustomEvent");
1616      e.initCustomEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable), params.detail);
1617      return e;
1618    };
1619    window.CustomEvent.prototype = window.Event.prototype;
1620  }
1621  initializeModules();
1622  var rootDocument = scope.rootDocument;
1623  function bootstrap() {
1624    HTMLImports.importer.bootDocument(rootDocument);
1625  }
1626  if (document.readyState === "complete" || document.readyState === "interactive" && !window.attachEvent) {
1627    bootstrap();
1628  } else {
1629    document.addEventListener("DOMContentLoaded", bootstrap);
1630  }
1631})(HTMLImports);
1632
1633window.CustomElements = window.CustomElements || {
1634  flags: {}
1635};
1636
1637(function(scope) {
1638  var flags = scope.flags;
1639  var modules = [];
1640  var addModule = function(module) {
1641    modules.push(module);
1642  };
1643  var initializeModules = function() {
1644    modules.forEach(function(module) {
1645      module(scope);
1646    });
1647  };
1648  scope.addModule = addModule;
1649  scope.initializeModules = initializeModules;
1650  scope.hasNative = Boolean(document.registerElement);
1651  scope.useNative = !flags.register && scope.hasNative && !window.ShadowDOMPolyfill && (!window.HTMLImports || HTMLImports.useNative);
1652})(CustomElements);
1653
1654CustomElements.addModule(function(scope) {
1655  var IMPORT_LINK_TYPE = window.HTMLImports ? HTMLImports.IMPORT_LINK_TYPE : "none";
1656  function forSubtree(node, cb) {
1657    findAllElements(node, function(e) {
1658      if (cb(e)) {
1659        return true;
1660      }
1661      forRoots(e, cb);
1662    });
1663    forRoots(node, cb);
1664  }
1665  function findAllElements(node, find, data) {
1666    var e = node.firstElementChild;
1667    if (!e) {
1668      e = node.firstChild;
1669      while (e && e.nodeType !== Node.ELEMENT_NODE) {
1670        e = e.nextSibling;
1671      }
1672    }
1673    while (e) {
1674      if (find(e, data) !== true) {
1675        findAllElements(e, find, data);
1676      }
1677      e = e.nextElementSibling;
1678    }
1679    return null;
1680  }
1681  function forRoots(node, cb) {
1682    var root = node.shadowRoot;
1683    while (root) {
1684      forSubtree(root, cb);
1685      root = root.olderShadowRoot;
1686    }
1687  }
1688  function forDocumentTree(doc, cb) {
1689    _forDocumentTree(doc, cb, []);
1690  }
1691  function _forDocumentTree(doc, cb, processingDocuments) {
1692    doc = wrap(doc);
1693    if (processingDocuments.indexOf(doc) >= 0) {
1694      return;
1695    }
1696    processingDocuments.push(doc);
1697    var imports = doc.querySelectorAll("link[rel=" + IMPORT_LINK_TYPE + "]");
1698    for (var i = 0, l = imports.length, n; i < l && (n = imports[i]); i++) {
1699      if (n.import) {
1700        _forDocumentTree(n.import, cb, processingDocuments);
1701      }
1702    }
1703    cb(doc);
1704  }
1705  scope.forDocumentTree = forDocumentTree;
1706  scope.forSubtree = forSubtree;
1707});
1708
1709CustomElements.addModule(function(scope) {
1710  var flags = scope.flags;
1711  var forSubtree = scope.forSubtree;
1712  var forDocumentTree = scope.forDocumentTree;
1713  function addedNode(node) {
1714    return added(node) || addedSubtree(node);
1715  }
1716  function added(node) {
1717    if (scope.upgrade(node)) {
1718      return true;
1719    }
1720    attached(node);
1721  }
1722  function addedSubtree(node) {
1723    forSubtree(node, function(e) {
1724      if (added(e)) {
1725        return true;
1726      }
1727    });
1728  }
1729  function attachedNode(node) {
1730    attached(node);
1731    if (inDocument(node)) {
1732      forSubtree(node, function(e) {
1733        attached(e);
1734      });
1735    }
1736  }
1737  var hasPolyfillMutations = !window.MutationObserver || window.MutationObserver === window.JsMutationObserver;
1738  scope.hasPolyfillMutations = hasPolyfillMutations;
1739  var isPendingMutations = false;
1740  var pendingMutations = [];
1741  function deferMutation(fn) {
1742    pendingMutations.push(fn);
1743    if (!isPendingMutations) {
1744      isPendingMutations = true;
1745      setTimeout(takeMutations);
1746    }
1747  }
1748  function takeMutations() {
1749    isPendingMutations = false;
1750    var $p = pendingMutations;
1751    for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) {
1752      p();
1753    }
1754    pendingMutations = [];
1755  }
1756  function attached(element) {
1757    if (hasPolyfillMutations) {
1758      deferMutation(function() {
1759        _attached(element);
1760      });
1761    } else {
1762      _attached(element);
1763    }
1764  }
1765  function _attached(element) {
1766    if (element.__upgraded__ && (element.attachedCallback || element.detachedCallback)) {
1767      if (!element.__attached && inDocument(element)) {
1768        element.__attached = true;
1769        if (element.attachedCallback) {
1770          element.attachedCallback();
1771        }
1772      }
1773    }
1774  }
1775  function detachedNode(node) {
1776    detached(node);
1777    forSubtree(node, function(e) {
1778      detached(e);
1779    });
1780  }
1781  function detached(element) {
1782    if (hasPolyfillMutations) {
1783      deferMutation(function() {
1784        _detached(element);
1785      });
1786    } else {
1787      _detached(element);
1788    }
1789  }
1790  function _detached(element) {
1791    if (element.__upgraded__ && (element.attachedCallback || element.detachedCallback)) {
1792      if (element.__attached && !inDocument(element)) {
1793        element.__attached = false;
1794        if (element.detachedCallback) {
1795          element.detachedCallback();
1796        }
1797      }
1798    }
1799  }
1800  function inDocument(element) {
1801    var p = element;
1802    var doc = wrap(document);
1803    while (p) {
1804      if (p == doc) {
1805        return true;
1806      }
1807      p = p.parentNode || p.nodeType === Node.DOCUMENT_FRAGMENT_NODE && p.host;
1808    }
1809  }
1810  function watchShadow(node) {
1811    if (node.shadowRoot && !node.shadowRoot.__watched) {
1812      flags.dom && console.log("watching shadow-root for: ", node.localName);
1813      var root = node.shadowRoot;
1814      while (root) {
1815        observe(root);
1816        root = root.olderShadowRoot;
1817      }
1818    }
1819  }
1820  function handler(mutations) {
1821    if (flags.dom) {
1822      var mx = mutations[0];
1823      if (mx && mx.type === "childList" && mx.addedNodes) {
1824        if (mx.addedNodes) {
1825          var d = mx.addedNodes[0];
1826          while (d && d !== document && !d.host) {
1827            d = d.parentNode;
1828          }
1829          var u = d && (d.URL || d._URL || d.host && d.host.localName) || "";
1830          u = u.split("/?").shift().split("/").pop();
1831        }
1832      }
1833      console.group("mutations (%d) [%s]", mutations.length, u || "");
1834    }
1835    mutations.forEach(function(mx) {
1836      if (mx.type === "childList") {
1837        forEach(mx.addedNodes, function(n) {
1838          if (!n.localName) {
1839            return;
1840          }
1841          addedNode(n);
1842        });
1843        forEach(mx.removedNodes, function(n) {
1844          if (!n.localName) {
1845            return;
1846          }
1847          detachedNode(n);
1848        });
1849      }
1850    });
1851    flags.dom && console.groupEnd();
1852  }
1853  function takeRecords(node) {
1854    node = wrap(node);
1855    if (!node) {
1856      node = wrap(document);
1857    }
1858    while (node.parentNode) {
1859      node = node.parentNode;
1860    }
1861    var observer = node.__observer;
1862    if (observer) {
1863      handler(observer.takeRecords());
1864      takeMutations();
1865    }
1866  }
1867  var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
1868  function observe(inRoot) {
1869    if (inRoot.__observer) {
1870      return;
1871    }
1872    var observer = new MutationObserver(handler);
1873    observer.observe(inRoot, {
1874      childList: true,
1875      subtree: true
1876    });
1877    inRoot.__observer = observer;
1878  }
1879  function upgradeDocument(doc) {
1880    doc = wrap(doc);
1881    flags.dom && console.group("upgradeDocument: ", doc.baseURI.split("/").pop());
1882    addedNode(doc);
1883    observe(doc);
1884    flags.dom && console.groupEnd();
1885  }
1886  function upgradeDocumentTree(doc) {
1887    forDocumentTree(doc, upgradeDocument);
1888  }
1889  var originalCreateShadowRoot = Element.prototype.createShadowRoot;
1890  if (originalCreateShadowRoot) {
1891    Element.prototype.createShadowRoot = function() {
1892      var root = originalCreateShadowRoot.call(this);
1893      CustomElements.watchShadow(this);
1894      return root;
1895    };
1896  }
1897  scope.watchShadow = watchShadow;
1898  scope.upgradeDocumentTree = upgradeDocumentTree;
1899  scope.upgradeSubtree = addedSubtree;
1900  scope.upgradeAll = addedNode;
1901  scope.attachedNode = attachedNode;
1902  scope.takeRecords = takeRecords;
1903});
1904
1905CustomElements.addModule(function(scope) {
1906  var flags = scope.flags;
1907  function upgrade(node) {
1908    if (!node.__upgraded__ && node.nodeType === Node.ELEMENT_NODE) {
1909      var is = node.getAttribute("is");
1910      var definition = scope.getRegisteredDefinition(is || node.localName);
1911      if (definition) {
1912        if (is && definition.tag == node.localName) {
1913          return upgradeWithDefinition(node, definition);
1914        } else if (!is && !definition.extends) {
1915          return upgradeWithDefinition(node, definition);
1916        }
1917      }
1918    }
1919  }
1920  function upgradeWithDefinition(element, definition) {
1921    flags.upgrade && console.group("upgrade:", element.localName);
1922    if (definition.is) {
1923      element.setAttribute("is", definition.is);
1924    }
1925    implementPrototype(element, definition);
1926    element.__upgraded__ = true;
1927    created(element);
1928    scope.attachedNode(element);
1929    scope.upgradeSubtree(element);
1930    flags.upgrade && console.groupEnd();
1931    return element;
1932  }
1933  function implementPrototype(element, definition) {
1934    if (Object.__proto__) {
1935      element.__proto__ = definition.prototype;
1936    } else {
1937      customMixin(element, definition.prototype, definition.native);
1938      element.__proto__ = definition.prototype;
1939    }
1940  }
1941  function customMixin(inTarget, inSrc, inNative) {
1942    var used = {};
1943    var p = inSrc;
1944    while (p !== inNative && p !== HTMLElement.prototype) {
1945      var keys = Object.getOwnPropertyNames(p);
1946      for (var i = 0, k; k = keys[i]; i++) {
1947        if (!used[k]) {
1948          Object.defineProperty(inTarget, k, Object.getOwnPropertyDescriptor(p, k));
1949          used[k] = 1;
1950        }
1951      }
1952      p = Object.getPrototypeOf(p);
1953    }
1954  }
1955  function created(element) {
1956    if (element.createdCallback) {
1957      element.createdCallback();
1958    }
1959  }
1960  scope.upgrade = upgrade;
1961  scope.upgradeWithDefinition = upgradeWithDefinition;
1962  scope.implementPrototype = implementPrototype;
1963});
1964
1965CustomElements.addModule(function(scope) {
1966  var isIE11OrOlder = scope.isIE11OrOlder;
1967  var upgradeDocumentTree = scope.upgradeDocumentTree;
1968  var upgradeAll = scope.upgradeAll;
1969  var upgradeWithDefinition = scope.upgradeWithDefinition;
1970  var implementPrototype = scope.implementPrototype;
1971  var useNative = scope.useNative;
1972  function register(name, options) {
1973    var definition = options || {};
1974    if (!name) {
1975      throw new Error("document.registerElement: first argument `name` must not be empty");
1976    }
1977    if (name.indexOf("-") < 0) {
1978      throw new Error("document.registerElement: first argument ('name') must contain a dash ('-'). Argument provided was '" + String(name) + "'.");
1979    }
1980    if (isReservedTag(name)) {
1981      throw new Error("Failed to execute 'registerElement' on 'Document': Registration failed for type '" + String(name) + "'. The type name is invalid.");
1982    }
1983    if (getRegisteredDefinition(name)) {
1984      throw new Error("DuplicateDefinitionError: a type with name '" + String(name) + "' is already registered");
1985    }
1986    if (!definition.prototype) {
1987      definition.prototype = Object.create(HTMLElement.prototype);
1988    }
1989    definition.__name = name.toLowerCase();
1990    definition.lifecycle = definition.lifecycle || {};
1991    definition.ancestry = ancestry(definition.extends);
1992    resolveTagName(definition);
1993    resolvePrototypeChain(definition);
1994    overrideAttributeApi(definition.prototype);
1995    registerDefinition(definition.__name, definition);
1996    definition.ctor = generateConstructor(definition);
1997    definition.ctor.prototype = definition.prototype;
1998    definition.prototype.constructor = definition.ctor;
1999    if (scope.ready) {
2000      upgradeDocumentTree(document);
2001    }
2002    return definition.ctor;
2003  }
2004  function overrideAttributeApi(prototype) {
2005    if (prototype.setAttribute._polyfilled) {
2006      return;
2007    }
2008    var setAttribute = prototype.setAttribute;
2009    prototype.setAttribute = function(name, value) {
2010      changeAttribute.call(this, name, value, setAttribute);
2011    };
2012    var removeAttribute = prototype.removeAttribute;
2013    prototype.removeAttribute = function(name) {
2014      changeAttribute.call(this, name, null, removeAttribute);
2015    };
2016    prototype.setAttribute._polyfilled = true;
2017  }
2018  function changeAttribute(name, value, operation) {
2019    name = name.toLowerCase();
2020    var oldValue = this.getAttribute(name);
2021    operation.apply(this, arguments);
2022    var newValue = this.getAttribute(name);
2023    if (this.attributeChangedCallback && newValue !== oldValue) {
2024      this.attributeChangedCallback(name, oldValue, newValue);
2025    }
2026  }
2027  function isReservedTag(name) {
2028    for (var i = 0; i < reservedTagList.length; i++) {
2029      if (name === reservedTagList[i]) {
2030        return true;
2031      }
2032    }
2033  }
2034  var reservedTagList = [ "annotation-xml", "color-profile", "font-face", "font-face-src", "font-face-uri", "font-face-format", "font-face-name", "missing-glyph" ];
2035  function ancestry(extnds) {
2036    var extendee = getRegisteredDefinition(extnds);
2037    if (extendee) {
2038      return ancestry(extendee.extends).concat([ extendee ]);
2039    }
2040    return [];
2041  }
2042  function resolveTagName(definition) {
2043    var baseTag = definition.extends;
2044    for (var i = 0, a; a = definition.ancestry[i]; i++) {
2045      baseTag = a.is && a.tag;
2046    }
2047    definition.tag = baseTag || definition.__name;
2048    if (baseTag) {
2049      definition.is = definition.__name;
2050    }
2051  }
2052  function resolvePrototypeChain(definition) {
2053    if (!Object.__proto__) {
2054      var nativePrototype = HTMLElement.prototype;
2055      if (definition.is) {
2056        var inst = document.createElement(definition.tag);
2057        var expectedPrototype = Object.getPrototypeOf(inst);
2058        if (expectedPrototype === definition.prototype) {
2059          nativePrototype = expectedPrototype;
2060        }
2061      }
2062      var proto = definition.prototype, ancestor;
2063      while (proto && proto !== nativePrototype) {
2064        ancestor = Object.getPrototypeOf(proto);
2065        proto.__proto__ = ancestor;
2066        proto = ancestor;
2067      }
2068      definition.native = nativePrototype;
2069    }
2070  }
2071  function instantiate(definition) {
2072    return upgradeWithDefinition(domCreateElement(definition.tag), definition);
2073  }
2074  var registry = {};
2075  function getRegisteredDefinition(name) {
2076    if (name) {
2077      return registry[name.toLowerCase()];
2078    }
2079  }
2080  function registerDefinition(name, definition) {
2081    registry[name] = definition;
2082  }
2083  function generateConstructor(definition) {
2084    return function() {
2085      return instantiate(definition);
2086    };
2087  }
2088  var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
2089  function createElementNS(namespace, tag, typeExtension) {
2090    if (namespace === HTML_NAMESPACE) {
2091      return createElement(tag, typeExtension);
2092    } else {
2093      return domCreateElementNS(namespace, tag);
2094    }
2095  }
2096  function createElement(tag, typeExtension) {
2097    var definition = getRegisteredDefinition(typeExtension || tag);
2098    if (definition) {
2099      if (tag == definition.tag && typeExtension == definition.is) {
2100        return new definition.ctor();
2101      }
2102      if (!typeExtension && !definition.is) {
2103        return new definition.ctor();
2104      }
2105    }
2106    var element;
2107    if (typeExtension) {
2108      element = createElement(tag);
2109      element.setAttribute("is", typeExtension);
2110      return element;
2111    }
2112    element = domCreateElement(tag);
2113    if (tag.indexOf("-") >= 0) {
2114      implementPrototype(element, HTMLElement);
2115    }
2116    return element;
2117  }
2118  var domCreateElement = document.createElement.bind(document);
2119  var domCreateElementNS = document.createElementNS.bind(document);
2120  var isInstance;
2121  if (!Object.__proto__ && !useNative) {
2122    isInstance = function(obj, ctor) {
2123      var p = obj;
2124      while (p) {
2125        if (p === ctor.prototype) {
2126          return true;
2127        }
2128        p = p.__proto__;
2129      }
2130      return false;
2131    };
2132  } else {
2133    isInstance = function(obj, base) {
2134      return obj instanceof base;
2135    };
2136  }
2137  function wrapDomMethodToForceUpgrade(obj, methodName) {
2138    var orig = obj[methodName];
2139    obj[methodName] = function() {
2140      var n = orig.apply(this, arguments);
2141      upgradeAll(n);
2142      return n;
2143    };
2144  }
2145  wrapDomMethodToForceUpgrade(Node.prototype, "cloneNode");
2146  wrapDomMethodToForceUpgrade(document, "importNode");
2147  if (isIE11OrOlder) {
2148    (function() {
2149      var importNode = document.importNode;
2150      document.importNode = function() {
2151        var n = importNode.apply(document, arguments);
2152        if (n.nodeType == n.DOCUMENT_FRAGMENT_NODE) {
2153          var f = document.createDocumentFragment();
2154          f.appendChild(n);
2155          return f;
2156        } else {
2157          return n;
2158        }
2159      };
2160    })();
2161  }
2162  document.registerElement = register;
2163  document.createElement = createElement;
2164  document.createElementNS = createElementNS;
2165  scope.registry = registry;
2166  scope.instanceof = isInstance;
2167  scope.reservedTagList = reservedTagList;
2168  scope.getRegisteredDefinition = getRegisteredDefinition;
2169  document.register = document.registerElement;
2170});
2171
2172(function(scope) {
2173  var useNative = scope.useNative;
2174  var initializeModules = scope.initializeModules;
2175  var isIE11OrOlder = /Trident/.test(navigator.userAgent);
2176  if (useNative) {
2177    var nop = function() {};
2178    scope.watchShadow = nop;
2179    scope.upgrade = nop;
2180    scope.upgradeAll = nop;
2181    scope.upgradeDocumentTree = nop;
2182    scope.upgradeSubtree = nop;
2183    scope.takeRecords = nop;
2184    scope.instanceof = function(obj, base) {
2185      return obj instanceof base;
2186    };
2187  } else {
2188    initializeModules();
2189  }
2190  var upgradeDocumentTree = scope.upgradeDocumentTree;
2191  if (!window.wrap) {
2192    if (window.ShadowDOMPolyfill) {
2193      window.wrap = ShadowDOMPolyfill.wrapIfNeeded;
2194      window.unwrap = ShadowDOMPolyfill.unwrapIfNeeded;
2195    } else {
2196      window.wrap = window.unwrap = function(node) {
2197        return node;
2198      };
2199    }
2200  }
2201  function bootstrap() {
2202    upgradeDocumentTree(wrap(document));
2203    if (window.HTMLImports) {
2204      HTMLImports.__importsParsingHook = function(elt) {
2205        upgradeDocumentTree(wrap(elt.import));
2206      };
2207    }
2208    CustomElements.ready = true;
2209    setTimeout(function() {
2210      CustomElements.readyTime = Date.now();
2211      if (window.HTMLImports) {
2212        CustomElements.elapsed = CustomElements.readyTime - HTMLImports.readyTime;
2213      }
2214      document.dispatchEvent(new CustomEvent("WebComponentsReady", {
2215        bubbles: true
2216      }));
2217    });
2218  }
2219  if (isIE11OrOlder && typeof window.CustomEvent !== "function") {
2220    window.CustomEvent = function(inType, params) {
2221      params = params || {};
2222      var e = document.createEvent("CustomEvent");
2223      e.initCustomEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable), params.detail);
2224      return e;
2225    };
2226    window.CustomEvent.prototype = window.Event.prototype;
2227  }
2228  if (document.readyState === "complete" || scope.flags.eager) {
2229    bootstrap();
2230  } else if (document.readyState === "interactive" && !window.attachEvent && (!window.HTMLImports || window.HTMLImports.ready)) {
2231    bootstrap();
2232  } else {
2233    var loadEvent = window.HTMLImports && !HTMLImports.ready ? "HTMLImportsLoaded" : "DOMContentLoaded";
2234    window.addEventListener(loadEvent, bootstrap);
2235  }
2236  scope.isIE11OrOlder = isIE11OrOlder;
2237})(window.CustomElements);
2238
2239if (typeof HTMLTemplateElement === "undefined") {
2240  (function() {
2241    var TEMPLATE_TAG = "template";
2242    HTMLTemplateElement = function() {};
2243    HTMLTemplateElement.prototype = Object.create(HTMLElement.prototype);
2244    HTMLTemplateElement.decorate = function(template) {
2245      if (!template.content) {
2246        template.content = template.ownerDocument.createDocumentFragment();
2247        var child;
2248        while (child = template.firstChild) {
2249          template.content.appendChild(child);
2250        }
2251      }
2252    };
2253    HTMLTemplateElement.bootstrap = function(doc) {
2254      var templates = doc.querySelectorAll(TEMPLATE_TAG);
2255      for (var i = 0, l = templates.length, t; i < l && (t = templates[i]); i++) {
2256        HTMLTemplateElement.decorate(t);
2257      }
2258    };
2259    addEventListener("DOMContentLoaded", function() {
2260      HTMLTemplateElement.bootstrap(document);
2261    });
2262  })();
2263}
2264
2265(function(scope) {
2266  var style = document.createElement("style");
2267  style.textContent = "" + "body {" + "transition: opacity ease-in 0.2s;" + " } \n" + "body[unresolved] {" + "opacity: 0; display: block; overflow: hidden; position: relative;" + " } \n";
2268  var head = document.querySelector("head");
2269  head.insertBefore(style, head.firstChild);
2270})(window.WebComponents);