var __extends = this && this.__extends || function() {
  var extendStatics = function(e, t) {
    return (extendStatics = Object.setPrototypeOf || {
      __proto__: []
    } instanceof Array && function(e, t) {
      e.__proto__ = t;
    } || function(e, t) {
      for (var n in t) Object.prototype.hasOwnProperty.call(t, n) && (e[n] = t[n]);
    })(e, t);
  };
  return function(e, t) {
    if ("function" != typeof t && null !== t) throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
    function __() {
      this.constructor = e;
    }
    extendStatics(e, t), e.prototype = null === t ? Object.create(t) : (__.prototype = t.prototype, 
    new __);
  };
}(), __awaiter = this && this.__awaiter || function(e, t, n, o) {
  return new (n || (n = Promise))((function(r, a) {
    function fulfilled(e) {
      try {
        step(o.next(e));
      } catch (t) {
        a(t);
      }
    }
    function rejected(e) {
      try {
        step(o.throw(e));
      } catch (t) {
        a(t);
      }
    }
    function step(e) {
      var t;
      e.done ? r(e.value) : (t = e.value, t instanceof n ? t : new n((function(e) {
        e(t);
      }))).then(fulfilled, rejected);
    }
    step((o = o.apply(e, t || [])).next());
  }));
}, __generator = this && this.__generator || function(e, t) {
  var n, o, r, a, s = {
    label: 0,
    sent: function() {
      if (1 & r[0]) throw r[1];
      return r[1];
    },
    trys: [],
    ops: []
  };
  return a = {
    next: verb(0),
    throw: verb(1),
    return: verb(2)
  }, "function" == typeof Symbol && (a[Symbol.iterator] = function() {
    return this;
  }), a;
  function verb(a) {
    return function(l) {
      return function(a) {
        if (n) throw new TypeError("Generator is already executing.");
        for (;s; ) try {
          if (n = 1, o && (r = 2 & a[0] ? o.return : a[0] ? o.throw || ((r = o.return) && r.call(o), 
          0) : o.next) && !(r = r.call(o, a[1])).done) return r;
          switch (o = 0, r && (a = [ 2 & a[0], r.value ]), a[0]) {
           case 0:
           case 1:
            r = a;
            break;

           case 4:
            return s.label++, {
              value: a[1],
              done: !1
            };

           case 5:
            s.label++, o = a[1], a = [ 0 ];
            continue;

           case 7:
            a = s.ops.pop(), s.trys.pop();
            continue;

           default:
            if (!(r = s.trys, (r = r.length > 0 && r[r.length - 1]) || 6 !== a[0] && 2 !== a[0])) {
              s = 0;
              continue;
            }
            if (3 === a[0] && (!r || a[1] > r[0] && a[1] < r[3])) {
              s.label = a[1];
              break;
            }
            if (6 === a[0] && s.label < r[1]) {
              s.label = r[1], r = a;
              break;
            }
            if (r && s.label < r[2]) {
              s.label = r[2], s.ops.push(a);
              break;
            }
            r[2] && s.ops.pop(), s.trys.pop();
            continue;
          }
          a = t.call(e, s);
        } catch (l) {
          a = [ 6, l ], o = 0;
        } finally {
          n = r = 0;
        }
        if (5 & a[0]) throw a[1];
        return {
          value: a[0] ? a[1] : void 0,
          done: !0
        };
      }([ a, l ]);
    };
  }
}, __spreadArray = this && this.__spreadArray || function(e, t) {
  for (var n = 0, o = t.length, r = e.length; n < o; n++, r++) e[r] = t[n];
  return e;
};

System.register([], (function(e, t) {
  "use strict";
  return {
    execute: function() {
      var n, o, r, a, s = this, l = e("N", "tecnologia-webcomponents"), i = e("B", /* tecnologia-webcomponents */ {
        allRenderFn: !0,
        appendChildSlotFix: !1,
        asyncLoading: !0,
        asyncQueue: !1,
        attachStyles: !0,
        cloneNodeFix: !1,
        cmpDidLoad: !0,
        cmpDidRender: !1,
        cmpDidUnload: !1,
        cmpDidUpdate: !1,
        cmpShouldUpdate: !1,
        cmpWillLoad: !0,
        cmpWillRender: !1,
        cmpWillUpdate: !1,
        connectedCallback: !1,
        constructableCSS: !0,
        cssAnnotations: !0,
        cssVarShim: !0,
        devTools: !1,
        disconnectedCallback: !1,
        dynamicImportShim: !0,
        element: !1,
        event: !0,
        hasRenderFn: !0,
        hostListener: !1,
        hostListenerTarget: !1,
        hostListenerTargetBody: !1,
        hostListenerTargetDocument: !1,
        hostListenerTargetParent: !1,
        hostListenerTargetWindow: !1,
        hotModuleReplacement: !1,
        hydrateClientSide: !1,
        hydrateServerSide: !1,
        hydratedAttribute: !1,
        hydratedClass: !0,
        initializeNextTick: !1,
        isDebug: !0,
        isDev: !0,
        isTesting: !0,
        lazyLoad: !0,
        lifecycle: !0,
        lifecycleDOMEvents: !0,
        member: !0,
        method: !0,
        mode: !1,
        observeAttribute: !0,
        profile: !1,
        prop: !0,
        propBoolean: !0,
        propMutable: !0,
        propNumber: !0,
        propString: !0,
        reflect: !0,
        safari10: !0,
        scoped: !1,
        scriptDataOpts: !0,
        shadowDelegatesFocus: !1,
        shadowDom: !0,
        shadowDomShim: !0,
        slot: !0,
        slotChildNodesFix: !0,
        slotRelocation: !0,
        state: !0,
        style: !0,
        svg: !1,
        taskQueue: !0,
        transformTagName: !1,
        updatable: !0,
        vdomAttribute: !0,
        vdomClass: !0,
        vdomFunctional: !0,
        vdomKey: !1,
        vdomListener: !0,
        vdomPropOrAttr: !0,
        vdomRef: !1,
        vdomRender: !0,
        vdomStyle: !0,
        vdomText: !0,
        vdomXlink: !1,
        watchCallback: !0
      }), $ = 0, c = !1, d = !1, u = !1, f = !1, m = 0, h = !1, p = e("w", "undefined" != typeof window ? window : {}), g = (e("C", i.cssVarShim ? p.CSS : null), 
      e("d", p.document || {
        head: {}
      })), v = (e("H", p.HTMLElement || function() {}), e("p", {
        $flags$: 0,
        $resourcesUrl$: "",
        jmp: function(e) {
          return e();
        },
        raf: function(e) {
          return requestAnimationFrame(e);
        },
        ael: function(e, t, n, o) {
          return e.addEventListener(t, n, o);
        },
        rel: function(e, t, n, o) {
          return e.removeEventListener(t, n, o);
        },
        ce: function(e, t) {
          return new CustomEvent(e, t);
        }
      })), y = !i.shadowDomShim || !i.shadowDom ||  function() {
        return (g.head.attachShadow + "").indexOf("[native") > -1;
      }(), b =  function() {
        var e = !1;
        try {
          g.addEventListener("e", null, Object.defineProperty({}, "passive", {
            get: function() {
              e = !0;
            }
          }));
        } catch (t) {}
        return e;
      }(), w = e("a", (function(e) {
        return Promise.resolve(e);
      })), S = !!i.constructableCSS &&  function() {
        try {
          return new CSSStyleSheet, "function" == typeof (new CSSStyleSheet).replace;
        } catch (e) {}
        return !1;
      }(), addHostEventListeners = function(e, t, n, o) {
        i.hostListener && n && (
        // this is called immediately within the element's constructor
        // initialize our event listeners on the host element
        // we do this now so that we can listen to events that may
        // have fired even before the instance is ready
        i.hostListenerTargetParent && (
        // this component may have event listeners that should be attached to the parent
        // this is being ran from within the connectedCallback
        // which is important so that we know the host element actually has a parent element
        // filter out the listeners to only have the ones that ARE being attached to the parent
        n = o ? n.filter((function(e) {
          return 32 & e[0];
        } /* TargetParent */)) : n.filter((function(e) {
          return !(32 /* TargetParent */ & e[0]);
        }))), n.map((function(n) {
          var o = n[0], r = n[1], a = n[2], s = i.hostListenerTarget ? getHostListenerTarget(e, o) : e, l = hostListenerProxy(t, a), $ = hostListenerOpts(o);
          v.ael(s, r, l, $), (t.$rmListeners$ = t.$rmListeners$ || []).push((function() {
            return v.rel(s, r, l, $);
          }));
        })));
      }, hostListenerProxy = function(e, t) {
        return function(n) {
          try {
            i.lazyLoad ? 256 /* isListenReady */ & e.$flags$ ? 
            // instance is ready, let's call it's member method for this event
            e.$lazyInstance$[t](n) : (e.$queuedListeners$ = e.$queuedListeners$ || []).push([ t, n ]) : e.$hostElement$[t](n);
          } catch (o) {
            consoleError(o);
          }
        };
      }, getHostListenerTarget = function(e, t) {
        return i.hostListenerTargetDocument && 4 /* TargetDocument */ & t ? g : i.hostListenerTargetWindow && 8 /* TargetWindow */ & t ? p : i.hostListenerTargetBody && 16 /* TargetBody */ & t ? g.body : i.hostListenerTargetParent && 32 /* TargetParent */ & t ? e.parentElement : e;
      }, hostListenerOpts = function(e) {
        return b ? {
          passive: 0 != (1 /* Passive */ & e),
          capture: 0 != (2 /* Capture */ & e)
        } : 0 != (2 /* Capture */ & e);
      }, N = "s-id", R = "sty-id", L = "c-id", C = "http://www.w3.org/1999/xlink", createTime = function(e, t) {
        if (void 0 === t && (t = ""), i.profile && performance.mark) {
          var n = "st:" + e + ":" + t + ":" + $++;
          // Start
                    // End
          return performance.mark(n), function() {
            return performance.measure("[Stencil] " + e + "() <" + t + ">", n);
          };
        }
        return function() {};
      }, installDevTools = function() {
        if (i.devTools) {
          var e = p.stencil = p.stencil || {}, t = e.inspect;
          e.inspect = function(e) {
            var n = function(e) {
              var t, n = getHostRef(e);
              if (n) {
                var o = n.$flags$, r = n.$hostElement$;
                return (t = {
                  renderCount: n.$renderCount$,
                  flags: {
                    hasRendered: !!(2 /* hasRendered */ & o),
                    hasConnected: !!(1 /* hasConnected */ & o),
                    isWaitingForChildren: !!(4 /* isWaitingForChildren */ & o),
                    isConstructingInstance: !!(8 /* isConstructingInstance */ & o),
                    isQueuedForUpdate: !!(16 /* isQueuedForUpdate */ & o),
                    hasInitializedComponent: !!(32 /* hasInitializedComponent */ & o),
                    hasLoadedComponent: !!(64 /* hasLoadedComponent */ & o),
                    isWatchReady: !!(128 /* isWatchReady */ & o),
                    isListenReady: !!(256 /* isListenReady */ & o),
                    needsRerender: !!(512 /* needsRerender */ & o)
                  },
                  instanceValues: n.$instanceValues$,
                  ancestorComponent: n.$ancestorComponent$,
                  hostElement: r,
                  lazyInstance: n.$lazyInstance$,
                  vnode: n.$vnode$,
                  modeName: n.$modeName$,
                  onReadyPromise: n.$onReadyPromise$,
                  onReadyResolve: n.$onReadyResolve$,
                  onInstancePromise: n.$onInstancePromise$,
                  onInstanceResolve: n.$onInstanceResolve$,
                  onRenderResolve: n.$onRenderResolve$,
                  queuedListeners: n.$queuedListeners$,
                  rmListeners: n.$rmListeners$
                })["s-id"] = r["s-id"], t["s-cr"] = r["s-cr"], t["s-lr"] = r["s-lr"], t["s-p"] = r["s-p"], 
                t["s-rc"] = r["s-rc"], t["s-sc"] = r["s-sc"], t;
              }
            }(e);
            return n || "function" != typeof t || (n = t(e)), n;
          };
        }
      }, x = new WeakMap, registerStyle = function(e, t, n) {
        var o = F.get(e);
        S && n ? (o = o || new CSSStyleSheet).replace(t) : o = t, F.set(e, o);
      }, addStyle = function(e, t, n, o) {
        var r = getScopeId(t, n), a = F.get(r);
        if (!i.attachStyles) return r;
        // if an element is NOT connected then getRootNode() will return the wrong root node
        // so the fallback is to always use the document for the root node in those cases
                if (e = 11 /* DocumentFragment */ === e.nodeType ? e : g, a) if ("string" == typeof a) {
          e = e.head || e;
          var s = x.get(e), l = void 0;
          if (s || x.set(e, s = new Set), !s.has(r)) {
            if (i.hydrateClientSide && e.host && (l = e.querySelector('[sty-id="' + r + '"]'))) 
            // This is only happening on native shadow-dom, do not needs CSS var shim
            l.innerHTML = a; else {
              if (i.cssVarShim && v.$cssShim$) {
                var $ = (l = v.$cssShim$.createHostStyle(o, r, a, !!(10 /* needsScopedEncapsulation */ & t.$flags$)))["s-sc"];
                $ && (r = $, 
                // we don't want to add this styleID to the appliedStyles Set
                // since the cssVarShim might need to apply several different
                // stylesheets for the same component
                s = null);
              } else (l = g.createElement("style")).innerHTML = a;
              (i.hydrateServerSide || i.hotModuleReplacement) && l.setAttribute(R, r), e.insertBefore(l, e.querySelector("link"));
            }
            s && s.add(r);
          }
        } else i.constructableCSS && !e.adoptedStyleSheets.includes(a) && (e.adoptedStyleSheets = __spreadArray(__spreadArray([], e.adoptedStyleSheets), [ a ]));
        return r;
      }, attachStyles = function(e) {
        var t = e.$cmpMeta$, n = e.$hostElement$, o = t.$flags$, r = createTime("attachStyles", t.$tagName$), a = addStyle(i.shadowDom && y && n.shadowRoot ? n.shadowRoot : n.getRootNode(), t, e.$modeName$, n);
        (i.shadowDom || i.scoped) && i.cssAnnotations && 10 /* needsScopedEncapsulation */ & o && (
        // only required when we're NOT using native shadow dom (slot)
        // or this browser doesn't support native shadow dom
        // and this host element was NOT created with SSR
        // let's pick out the inner content for slot projection
        // create a node to represent where the original
        // content was first placed, which is useful later on
        // DOM WRITE!!
        n["s-sc"] = a, n.classList.add(a + "-h"), i.scoped && 2 /* scopedCssEncapsulation */ & o && n.classList.add(a + "-s")), 
        r();
      }, getScopeId = function(e, t) {
        return "sc-" + (i.mode && t && 32 /* hasMode */ & e.$flags$ ? e.$tagName$ + "-" + t : e.$tagName$);
      }, computeMode = function(e) {
        return H.map((function(t) {
          return t(e);
        })).find((function(e) {
          return !!e;
        }));
      }, k = {}, isComplexType = function(e) {
        return "object" === (
        // https://jsperf.com/typeof-fn-object/5
        e = typeof e) || "function" === e;
      }, T = e("h", (function(e, t) {
        for (var n = [], o = 2; o < arguments.length; o++) n[o - 2] = arguments[o];
        var r = null, a = null, s = null, l = !1, $ = !1, c = [], walk = function(t) {
          for (var n = 0; n < t.length; n++) r = t[n], Array.isArray(r) ? walk(r) : null != r && "boolean" != typeof r && ((l = "function" != typeof e && !isComplexType(r)) ? r = String(r) : i.isDev && "function" != typeof e && void 0 === r.$flags$ && consoleDevError("vNode passed as children has unexpected type.\nMake sure it's using the correct h() function.\nEmpty objects can also be the cause, look for JSX comments that became objects."), 
          l && $ ? 
          // If the previous child was simple (string), we merge both
          c[c.length - 1].$text$ += r : 
          // Append a new vNode, if it's text, we create a text vNode
          c.push(l ? newVNode(null, r) : r), $ = l);
        };
        if (walk(n), t && (i.isDev && "input" === e && validateInputProperties(t), 
        // normalize class / classname attributes
        i.vdomKey && t.key && (a = t.key), i.slotRelocation && t.name && (s = t.name), i.vdomClass)) {
          var d = t.className || t.class;
          d && (t.class = "object" != typeof d ? d : Object.keys(d).filter((function(e) {
            return d[e];
          })).join(" "));
        }
        if (i.isDev && c.some(isHost) && consoleDevError("The <Host> must be the single root component. Make sure:\n- You are NOT using hostData() and <Host> in the same component.\n- <Host> is used once, and it's the single root component of the render() function."), 
        i.vdomFunctional && "function" == typeof e) 
        // nodeName is a functional component
        return e(null === t ? {} : t, c, D);
        var u = newVNode(e, null);
        return u.$attrs$ = t, c.length > 0 && (u.$children$ = c), i.vdomKey && (u.$key$ = a), 
        i.slotRelocation && (u.$name$ = s), u;
      })), newVNode = function(e, t) {
        var n = {
          $flags$: 0,
          $tag$: e,
          $text$: t,
          $elm$: null,
          $children$: null
        };
        return i.vdomAttribute && (n.$attrs$ = null), i.vdomKey && (n.$key$ = null), i.slotRelocation && (n.$name$ = null), 
        n;
      }, _ = e("e", {}), isHost = function(e) {
        return e && e.$tag$ === _;
      }, D = {
        forEach: function(e, t) {
          return e.map(convertToPublic).forEach(t);
        },
        map: function(e, t) {
          return e.map(convertToPublic).map(t).map(convertToPrivate);
        }
      }, convertToPublic = function(e) {
        return {
          vattrs: e.$attrs$,
          vchildren: e.$children$,
          vkey: e.$key$,
          vname: e.$name$,
          vtag: e.$tag$,
          vtext: e.$text$
        };
      }, convertToPrivate = function(e) {
        if ("function" == typeof e.vtag) {
          var t = Object.assign({}, e.vattrs);
          return e.vkey && (t.key = e.vkey), e.vname && (t.name = e.vname), T.apply(void 0, __spreadArray([ e.vtag, t ], e.vchildren || []));
        }
        var n = newVNode(e.vtag, e.vtext);
        return n.$attrs$ = e.vattrs, n.$children$ = e.vchildren, n.$key$ = e.vkey, n.$name$ = e.vname, 
        n;
      }, validateInputProperties = function(e) {
        var t = Object.keys(e), n = t.indexOf("type"), o = t.indexOf("min"), r = t.indexOf("max"), a = t.indexOf("min"), s = t.indexOf("value");
        -1 !== s && (s < n || s < o || s < r || s < a) && consoleDevWarn('The "value" prop of <input> should be set after "min", "max", "type" and "step"');
      }, setAccessor = function(e, t, n, o, r, a) {
        if (n !== o) {
          var s = isMemberInElement(e, t), l = t.toLowerCase();
          if (i.vdomClass && "class" === t) {
            var $ = e.classList, c = parseClassList(n), d = parseClassList(o);
            $.remove.apply($, c.filter((function(e) {
              return e && !d.includes(e);
            }))), $.add.apply($, d.filter((function(e) {
              return e && !c.includes(e);
            })));
          } else if (i.vdomStyle && "style" === t) {
            // update style attribute, css properties and values
            if (i.updatable) for (var u in n) o && null != o[u] || (!i.hydrateServerSide && u.includes("-") ? e.style.removeProperty(u) : e.style[u] = "");
            for (var u in o) n && o[u] === n[u] || (!i.hydrateServerSide && u.includes("-") ? e.style.setProperty(u, o[u]) : e.style[u] = o[u]);
          } else if (i.vdomKey && "key" === t) ; else if (i.vdomRef && "ref" === t) 
          // minifier will clean this up
          o && o(e); else if (!i.vdomListener || (i.lazyLoad ? s : e.__lookupSetter__(t)) || "o" !== t[0] || "n" !== t[1]) {
            if (i.vdomPropOrAttr) {
              // Set property if it exists and it's not a SVG
              var f = isComplexType(o);
              if ((s || f && null !== o) && !r) try {
                if (e.tagName.includes("-")) e[t] = o; else {
                  var m = null == o ? "" : o;
                  // Workaround for Safari, moving the <input> caret when re-assigning the same valued
                                    "list" === t ? s = !1 : null != n && e[t] == m || (e[t] = m);
                }
              } catch (g) {}
              /**
             * Need to manually update attribute if:
             * - memberName is not an attribute
             * - if we are rendering the host element in order to reflect attribute
             * - if it's a SVG, since properties might not work in <svg>
             * - if the newValue is null/undefined or 'false'.
             */              var h = !1;
              i.vdomXlink && l !== (l = l.replace(/^xlink\:?/, "")) && (t = l, h = !0), null == o || !1 === o ? !1 === o && "" !== e.getAttribute(t) || (i.vdomXlink && h ? e.removeAttributeNS(C, t) : e.removeAttribute(t)) : (!s || 4 /* isHost */ & a || r) && !f && (o = !0 === o ? "" : o, 
              i.vdomXlink && h ? e.setAttributeNS(C, t, o) : e.setAttribute(t, o));
            }
          } else 
          // Event Handlers
          // so if the member name starts with "on" and the 3rd characters is
          // a capital letter, and it's not already a member on the element,
          // then we're assuming it's an event listener
          // on- prefixed events
          // allows to be explicit about the dom event to listen without any magic
          // under the hood:
          // <my-cmp on-click> // listens for "click"
          // <my-cmp on-Click> // listens for "Click"
          // <my-cmp on-ionChange> // listens for "ionChange"
          // <my-cmp on-EVENTS> // listens for "EVENTS"
          t = "-" === t[2] ? t.slice(3) : isMemberInElement(p, l) ? l.slice(2) : l[2] + t.slice(3), 
          n && v.rel(e, t, n, !1), o && v.ael(e, t, o, !1);
        }
      }, A = /\s/, parseClassList = function(e) {
        return e ? e.split(A) : [];
      }, updateElement = function(e, t, n, o) {
        // if the element passed in is a shadow root, which is a document fragment
        // then we want to be adding attrs/props to the shadow root's "host" element
        // if it's not a shadow root, then we add attrs/props to the same element
        var r = 11 /* DocumentFragment */ === t.$elm$.nodeType && t.$elm$.host ? t.$elm$.host : t.$elm$, a = e && e.$attrs$ || k, s = t.$attrs$ || k;
        if (i.updatable) 
        // remove attributes no longer present on the vnode by setting them to undefined
        for (o in a) o in s || setAccessor(r, o, a[o], void 0, n, t.$flags$);
        // add new & update changed attributes
                for (o in s) setAccessor(r, o, a[o], s[o], n, t.$flags$);
      }, createElm = function(e, t, a, s) {
        // tslint:disable-next-line: prefer-const
        var l, $, d, m = t.$children$[a], h = 0;
        if (i.slotRelocation && !c && (
        // remember for later we need to check to relocate nodes
        u = !0, "slot" === m.$tag$ && (n && 
        // scoped css needs to add its scoped id to the parent element
        s.classList.add(n + "-s"), m.$flags$ |= m.$children$ ? // slot element has fallback content
        2 /* isSlotFallback */ : // slot element does not have fallback content
        1 /* isSlotReference */)), i.isDev && m.$elm$ && consoleDevError("The JSX " + (null !== m.$text$ ? '"' + m.$text$ + '" text' : '"' + m.$tag$ + '" element') + " node should not be shared within the same renderer. The renderer caches element lookups in order to improve performance. However, a side effect from this is that the exact same JSX node should not be reused. For more information please see https://stenciljs.com/docs/templating-jsx#avoid-shared-jsx-nodes"), 
        i.vdomText && null !== m.$text$) 
        // create text node
        l = m.$elm$ = g.createTextNode(m.$text$); else if (i.slotRelocation && 1 /* isSlotReference */ & m.$flags$) 
        // create a slot reference node
        l = m.$elm$ = i.isDebug || i.hydrateServerSide ? slotReferenceDebugNode(m) : g.createTextNode(""); else {
          if (i.svg && !f && (f = "svg" === m.$tag$), 
          // create element
          l = m.$elm$ = i.svg ? g.createElementNS(f ? "http://www.w3.org/2000/svg" : "http://www.w3.org/1999/xhtml", i.slotRelocation && 2 /* isSlotFallback */ & m.$flags$ ? "slot-fb" : m.$tag$) : g.createElement(i.slotRelocation && 2 /* isSlotFallback */ & m.$flags$ ? "slot-fb" : m.$tag$), 
          i.svg && f && "foreignObject" === m.$tag$ && (f = !1), 
          // add css classes, attrs, props, listeners, etc.
          i.vdomAttribute && updateElement(null, m, f), (i.shadowDom || i.scoped) && null != n && l["s-si"] !== n && 
          // if there is a scopeId and this is the initial render
          // then let's add the scopeId as a css class
          l.classList.add(l["s-si"] = n), m.$children$) for (h = 0; h < m.$children$.length; ++h) 
          // create the node
          // return node could have been null
          ($ = createElm(e, m, h, l)) && 
          // append our new node
          l.appendChild($);
          i.svg && ("svg" === m.$tag$ ? 
          // Only reset the SVG context when we're exiting <svg> element
          f = !1 : "foreignObject" === l.tagName && (
          // Reenter SVG context when we're exiting <foreignObject> element
          f = !0));
        }
        return i.slotRelocation && (l["s-hn"] = r, 3 /* isSlotReference */ & m.$flags$ && (
        // remember the content reference comment
        l["s-sr"] = !0, 
        // remember the content reference comment
        l["s-cr"] = o, 
        // remember the slot name, or empty string for default slot
        l["s-sn"] = m.$name$ || "", (
        // check if we've got an old vnode for this slot
        d = e && e.$children$ && e.$children$[a]) && d.$tag$ === m.$tag$ && e.$elm$ && 
        // we've got an old slot vnode and the wrapper is being replaced
        // so let's move the old slot content back to it's original location
        putBackInOriginalLocation(e.$elm$, !1))), l;
      }, putBackInOriginalLocation = function(e, t) {
        v.$flags$ |= 1 /* isTmpDisconnected */;
        for (var n = e.childNodes, o = n.length - 1; o >= 0; o--) {
          var a = n[o];
          a["s-hn"] !== r && a["s-ol"] && (
          // // this child node in the old element is from another component
          // // remove this node from the old slot's parent
          // childNode.remove();
          // and relocate it back to it's original location
          parentReferenceNode(a).insertBefore(a, referenceNode(a)), 
          // remove the old original location comment entirely
          // later on the patch function will know what to do
          // and move this to the correct spot in need be
          a["s-ol"].remove(), a["s-ol"] = void 0, u = !0), t && putBackInOriginalLocation(a, t);
        }
        v.$flags$ &= -2 /* isTmpDisconnected */;
      }, addVnodes = function(e, t, n, o, a, s) {
        var l, $ = i.slotRelocation && e["s-cr"] && e["s-cr"].parentNode || e;
        for (i.shadowDom && $.shadowRoot && $.tagName === r && ($ = $.shadowRoot); a <= s; ++a) o[a] && (l = createElm(null, n, a, e)) && (o[a].$elm$ = l, 
        $.insertBefore(l, i.slotRelocation ? referenceNode(t) : t));
      }, removeVnodes = function(e, t, n, o, r) {
        for (;t <= n; ++t) (o = e[t]) && (r = o.$elm$, callNodeRefs(o), i.slotRelocation && (
        // we're removing this element
        // so it's possible we need to show slot fallback content now
        d = !0, r["s-ol"] ? 
        // remove the original location comment
        r["s-ol"].remove() : 
        // it's possible that child nodes of the node
        // that's being removed are slot nodes
        putBackInOriginalLocation(r, !0)), 
        // remove the vnode's element from the dom
        r.remove());
      }, isSameVnode = function(e, t) {
        // compare if two vnode to see if they're "technically" the same
        // need to have the same element tag, and same key to be the same
        return e.$tag$ === t.$tag$ && (i.slotRelocation && "slot" === e.$tag$ ? e.$name$ === t.$name$ : !i.vdomKey || e.$key$ === t.$key$);
      }, referenceNode = function(e) {
        // this node was relocated to a new location in the dom
        // because of some other component's slot
        // but we still have an html comment in place of where
        // it's original location was according to it's original vdom
        return e && e["s-ol"] || e;
      }, parentReferenceNode = function(e) {
        return (e["s-ol"] ? e["s-ol"] : e).parentNode;
      }, patch = function(e, t) {
        var n, o = t.$elm$ = e.$elm$, r = e.$children$, a = t.$children$, s = t.$tag$, l = t.$text$;
        i.vdomText && null !== l ? i.vdomText && i.slotRelocation && (n = o["s-cr"]) ? 
        // this element has slotted content
        n.parentNode.textContent = l : i.vdomText && e.$text$ !== l && (
        // update the text content for the text only vnode
        // and also only if the text is different than before
        o.data = l) : (i.svg && (
        // test if we're rendering an svg element, or still rendering nodes inside of one
        // only add this to the when the compiler sees we're using an svg somewhere
        f = "svg" === s || "foreignObject" !== s && f), 
        // element node
        (i.vdomAttribute || i.reflect) && (i.slot && "slot" === s || 
        // either this is the first render of an element OR it's an update
        // AND we already know it's possible it could have changed
        // this updates the element's css classes, attrs, props, listeners, etc.
        updateElement(e, t, f)), i.updatable && null !== r && null !== a ? 
        // looks like there's child vnodes for both the old and new vnodes
        function(e, t, n, o) {
          for (var r, a, s = 0, l = 0, $ = 0, c = 0, d = t.length - 1, u = t[0], f = t[d], m = o.length - 1, h = o[0], p = o[m]; s <= d && l <= m; ) if (null == u) 
          // Vnode might have been moved left
          u = t[++s]; else if (null == f) f = t[--d]; else if (null == h) h = o[++l]; else if (null == p) p = o[--m]; else if (isSameVnode(u, h)) patch(u, h), 
          u = t[++s], h = o[++l]; else if (isSameVnode(f, p)) patch(f, p), f = t[--d], p = o[--m]; else if (isSameVnode(u, p)) 
          // Vnode moved right
          !i.slotRelocation || "slot" !== u.$tag$ && "slot" !== p.$tag$ || putBackInOriginalLocation(u.$elm$.parentNode, !1), 
          patch(u, p), e.insertBefore(u.$elm$, f.$elm$.nextSibling), u = t[++s], p = o[--m]; else if (isSameVnode(f, h)) 
          // Vnode moved left
          !i.slotRelocation || "slot" !== u.$tag$ && "slot" !== p.$tag$ || putBackInOriginalLocation(f.$elm$.parentNode, !1), 
          patch(f, h), e.insertBefore(f.$elm$, u.$elm$), f = t[--d], h = o[++l]; else {
            if (
            // createKeyToOldIdx
            $ = -1, i.vdomKey) for (c = s; c <= d; ++c) if (t[c] && null !== t[c].$key$ && t[c].$key$ === h.$key$) {
              $ = c;
              break;
            }
            i.vdomKey && $ >= 0 ? ((a = t[$]).$tag$ !== h.$tag$ ? r = createElm(t && t[l], n, $, e) : (patch(a, h), 
            t[$] = void 0, r = a.$elm$), h = o[++l]) : (
            // new element
            r = createElm(t && t[l], n, l, e), h = o[++l]), r && (i.slotRelocation ? parentReferenceNode(u.$elm$).insertBefore(r, referenceNode(u.$elm$)) : u.$elm$.parentNode.insertBefore(r, u.$elm$));
          }
          s > d ? addVnodes(e, null == o[m + 1] ? null : o[m + 1].$elm$, n, o, l, m) : i.updatable && l > m && removeVnodes(t, s, d);
        }(o, r, t, a) : null !== a ? (
        // no old child vnodes, but there are new child vnodes to add
        i.updatable && i.vdomText && null !== e.$text$ && (
        // the old vnode was text, so be sure to clear it out
        o.textContent = ""), 
        // add the new vnode children
        addVnodes(o, null, t, a, 0, a.length - 1)) : i.updatable && null !== r && 
        // no new child vnodes, but there are old child vnodes to remove
        removeVnodes(r, 0, r.length - 1), i.svg && f && "svg" === s && (f = !1));
      }, updateFallbackSlotVisibility = function(e) {
        // tslint:disable-next-line: prefer-const
        var t, n, o, r, a, s, l = e.childNodes;
        for (n = 0, o = l.length; n < o; n++) if (1 /* ElementNode */ === (t = l[n]).nodeType) {
          if (t["s-sr"]) for (
          // this is a slot fallback node
          // get the slot name for this slot reference node
          a = t["s-sn"], 
          // by default always show a fallback slot node
          // then hide it if there are other slots in the light dom
          t.hidden = !1, r = 0; r < o; r++) if (s = l[r].nodeType, l[r]["s-hn"] !== t["s-hn"] || "" !== a) {
            // this sibling node is from a different component OR is a named fallback slot node
            if (1 /* ElementNode */ === s && a === l[r].getAttribute("slot")) {
              t.hidden = !0;
              break;
            }
          } else 
          // this is a default fallback slot node
          // any element or text node (with content)
          // should hide the default fallback slot node
          if (1 /* ElementNode */ === s || 3 /* TextNode */ === s && "" !== l[r].textContent.trim()) {
            t.hidden = !0;
            break;
          }
          // keep drilling down
                    updateFallbackSlotVisibility(t);
        }
      }, E = [], relocateSlotContent = function(e) {
        for (
        // tslint:disable-next-line: prefer-const
        var t, n, o, r, a, s, l = 0, i = e.childNodes, $ = i.length; l < $; l++) {
          if ((t = i[l])["s-sr"] && (n = t["s-cr"]) && n.parentNode) for (
          // first got the content reference comment node
          // then we got it's parent, which is where all the host content is in now
          o = n.parentNode.childNodes, r = t["s-sn"], s = o.length - 1; s >= 0; s--) (n = o[s])["s-cn"] || n["s-nr"] || n["s-hn"] === t["s-hn"] || (
          // let's do some relocating to its new home
          // but never relocate a content reference node
          // that is suppose to always represent the original content location
          isNodeLocatedInSlot(n, r) ? (
          // it's possible we've already decided to relocate this node
          a = E.find((function(e) {
            return e.$nodeToRelocate$ === n;
          })), 
          // made some changes to slots
          // let's make sure we also double check
          // fallbacks are correctly hidden or shown
          d = !0, n["s-sn"] = n["s-sn"] || r, a ? 
          // previously we never found a slot home for this node
          // but turns out we did, so let's remember it now
          a.$slotRefNode$ = t : 
          // add to our list of nodes to relocate
          E.push({
            $slotRefNode$: t,
            $nodeToRelocate$: n
          }), n["s-sr"] && E.map((function(e) {
            isNodeLocatedInSlot(e.$nodeToRelocate$, n["s-sn"]) && (a = E.find((function(e) {
              return e.$nodeToRelocate$ === n;
            }))) && !e.$slotRefNode$ && (e.$slotRefNode$ = a.$slotRefNode$);
          }))) : E.some((function(e) {
            return e.$nodeToRelocate$ === n;
          })) || 
          // so far this element does not have a slot home, not setting slotRefNode on purpose
          // if we never find a home for this element then we'll need to hide it
          E.push({
            $nodeToRelocate$: n
          }));
          1 /* ElementNode */ === t.nodeType && relocateSlotContent(t);
        }
      }, isNodeLocatedInSlot = function(e, t) {
        return 1 /* ElementNode */ === e.nodeType ? null === e.getAttribute("slot") && "" === t || e.getAttribute("slot") === t : e["s-sn"] === t || "" === t;
      }, callNodeRefs = function(e) {
        i.vdomRef && (e.$attrs$ && e.$attrs$.ref && e.$attrs$.ref(null), e.$children$ && e.$children$.map(callNodeRefs));
      }, renderVdom = function(e, t) {
        var a = e.$hostElement$, s = e.$cmpMeta$, l = e.$vnode$ || newVNode(null, null), $ = isHost(t) ? t : T(null, null, t);
        // <Host> runtime check
        if (r = a.tagName, i.isDev && Array.isArray(t) && t.some(isHost)) throw new Error('The <Host> must be the single root component.\nLooks like the render() function of "' + r.toLowerCase() + '" is returning an array that contains the <Host>.\n\nThe render() function should look like this instead:\n\nrender() {\n  // Do not return an array\n  return (\n    <Host>{content}</Host>\n  );\n}\n  ');
        if (i.reflect && s.$attrsToReflect$ && ($.$attrs$ = $.$attrs$ || {}, s.$attrsToReflect$.map((function(e) {
          var t = e[0], n = e[1];
          return $.$attrs$[n] = a[t];
        }))), $.$tag$ = null, $.$flags$ |= 4 /* isHost */ , e.$vnode$ = $, $.$elm$ = l.$elm$ = i.shadowDom && a.shadowRoot || a, 
        (i.scoped || i.shadowDom) && (n = a["s-sc"]), i.slotRelocation && (o = a["s-cr"], 
        c = y && 0 != (1 /* shadowDomEncapsulation */ & s.$flags$), 
        // always reset
        d = !1), 
        // synchronous patch
        patch(l, $), i.slotRelocation) {
          if (
          // while we're moving nodes around existing nodes, temporarily disable
          // the disconnectCallback from working
          v.$flags$ |= 1 /* isTmpDisconnected */ , u) {
            relocateSlotContent($.$elm$);
            for (var f = void 0, m = void 0, h = void 0, p = void 0, b = void 0, w = void 0, S = 0; S < E.length; S++) (m = (f = E[S]).$nodeToRelocate$)["s-ol"] || (
            // add a reference node marking this node's original location
            // keep a reference to this node for later lookups
            (h = i.isDebug || i.hydrateServerSide ? originalLocationDebugNode(m) : g.createTextNode(""))["s-nr"] = m, 
            m.parentNode.insertBefore(m["s-ol"] = h, m));
            for (S = 0; S < E.length; S++) if (m = (f = E[S]).$nodeToRelocate$, f.$slotRefNode$) {
              for (
              // by default we're just going to insert it directly
              // after the slot reference node
              p = f.$slotRefNode$.parentNode, b = f.$slotRefNode$.nextSibling, h = m["s-ol"]; h = h.previousSibling; ) if ((w = h["s-nr"]) && w["s-sn"] === m["s-sn"] && p === w.parentNode && (!(w = w.nextSibling) || !w["s-nr"])) {
                b = w;
                break;
              }
              (!b && p !== m.parentNode || m.nextSibling !== b) && m !== b && (!m["s-hn"] && m["s-ol"] && (
              // probably a component in the index.html that doesn't have it's hostname set
              m["s-hn"] = m["s-ol"].parentNode.nodeName), 
              // add it back to the dom but in its new home
              p.insertBefore(m, b));
            } else 
            // this node doesn't have a slot home to go to, so let's hide it
            1 /* ElementNode */ === m.nodeType && (m.hidden = !0);
          }
          d && updateFallbackSlotVisibility($.$elm$), 
          // done moving nodes around
          // allow the disconnect callback to work again
          v.$flags$ &= -2 /* isTmpDisconnected */ , 
          // always reset
          E.length = 0;
        }
      }, slotReferenceDebugNode = function(e) {
        return g.createComment("<slot" + (e.$name$ ? ' name="' + e.$name$ + '"' : "") + "> (host=" + r.toLowerCase() + ")");
      }, originalLocationDebugNode = function(e) {
        return g.createComment("org-location for " + (e.localName ? "<" + e.localName + "> (host=" + e["s-hn"] + ")" : "[" + e.textContent + "]"));
      }, z = e("g", (function(e) {
        return i.lazyLoad ? getHostRef(e).$hostElement$ : e;
      })), j = (e("f", (function(e, t, n) {
        var o = z(e);
        return {
          emit: function(e) {
            return i.isDev && !o.isConnected && consoleDevWarn('The "' + t + '" event was emitted, but the dispatcher node is no longer connected to the dom.'), 
            j(o, t, {
              bubbles: !!(4 /* Bubbles */ & n),
              composed: !!(2 /* Composed */ & n),
              cancelable: !!(1 /* Cancellable */ & n),
              detail: e
            });
          }
        };
      })), function(e, t, n) {
        var o = v.ce(t, n);
        return e.dispatchEvent(o), o;
      }), attachToAncestor = function(e, t) {
        i.asyncLoading && t && !e.$onRenderResolve$ && t["s-p"] && t["s-p"].push(new Promise((function(t) {
          return e.$onRenderResolve$ = t;
        })));
      }, scheduleUpdate = function(e, t) {
        if (i.taskQueue && i.updatable && (e.$flags$ |= 16 /* isQueuedForUpdate */), !(i.asyncLoading && 4 /* isWaitingForChildren */ & e.$flags$)) {
          attachToAncestor(e, e.$ancestorComponent$);
          // there is no ancestor component or the ancestor component
          // has already fired off its lifecycle update then
          // fire off the initial update
          var dispatch = function() {
            return dispatchHooks(e, t);
          };
          return i.taskQueue ? V(dispatch) : dispatch();
        }
        e.$flags$ |= 512 /* needsRerender */;
      }, dispatchHooks = function(e, t) {
        var n, o = e.$hostElement$, r = createTime("scheduleUpdate", e.$cmpMeta$.$tagName$), a = i.lazyLoad ? e.$lazyInstance$ : o;
        return t ? (i.lazyLoad && i.hostListener && (e.$flags$ |= 256 /* isListenReady */ , 
        e.$queuedListeners$ && (e.$queuedListeners$.map((function(e) {
          var t = e[0], n = e[1];
          return safeCall(a, t, n);
        })), e.$queuedListeners$ = null)), emitLifecycleEvent(o, "componentWillLoad"), i.cmpWillLoad && (n = safeCall(a, "componentWillLoad"))) : (emitLifecycleEvent(o, "componentWillUpdate"), 
        i.cmpWillUpdate && (n = safeCall(a, "componentWillUpdate"))), emitLifecycleEvent(o, "componentWillRender"), 
        i.cmpWillRender && (n = then(n, (function() {
          return safeCall(a, "componentWillRender");
        }))), r(), then(n, (function() {
          return updateComponent(e, a, t);
        }));
      }, updateComponent = function(e, t, n) {
        return __awaiter(s, void 0, void 0, (function() {
          var o, r, a, s, l, $;
          return __generator(this, (function(c) {
            switch (c.label) {
             case 0:
              return o = e.$hostElement$, r = createTime("update", e.$cmpMeta$.$tagName$), a = o["s-rc"], 
              i.style && n && 
              // DOM WRITE!
              attachStyles(e), s = createTime("render", e.$cmpMeta$.$tagName$), i.isDev && (e.$flags$ |= 1024 /* devOnRender */), 
              i.hydrateServerSide ? [ 4 /*yield*/ , callRender(e, t, o) ] : [ 3 /*break*/ , 2 ];

             case 1:
              return c.sent(), [ 3 /*break*/ , 3 ];

             case 2:
              callRender(e, t, o), c.label = 3;

             case 3:
              if (i.cssVarShim && v.$cssShim$ && v.$cssShim$.updateHost(o), i.isDev && (e.$renderCount$++, 
              e.$flags$ &= -1025 /* devOnRender */), i.hydrateServerSide) try {
                // manually connected child components during server-side hydrate
                serverSideConnected(o), n && (
                // using only during server-side hydrate
                1 /* shadowDomEncapsulation */ & e.$cmpMeta$.$flags$ ? o["s-en"] = "" : 2 /* scopedCssEncapsulation */ & e.$cmpMeta$.$flags$ && (o["s-en"] = "c"));
              } catch (d) {
                consoleError(d, o);
              }
              return i.asyncLoading && a && (
              // ok, so turns out there are some child host elements
              // waiting on this parent element to load
              // let's fire off all update callbacks waiting
              a.map((function(e) {
                return e();
              })), o["s-rc"] = void 0), s(), r(), i.asyncLoading ? (l = o["s-p"], $ = function() {
                return postUpdateComponent(e);
              }, 0 === l.length ? $() : (Promise.all(l).then($), e.$flags$ |= 4 /* isWaitingForChildren */ , 
              l.length = 0)) : postUpdateComponent(e), [ 2 /*return*/ ];
            }
          }));
        }));
      }, callRender = function(e, t, n) {
        // in order for bundlers to correctly treeshake the BUILD object
        // we need to ensure BUILD is not deoptimized within a try/catch
        // https://rollupjs.org/guide/en/#treeshake tryCatchDeoptimization
        var o = !!i.allRenderFn, r = !!i.lazyLoad, a = !!i.taskQueue, s = !!i.updatable;
        try {
          if (t, t = (o || t.render) && t.render(), s && a && (e.$flags$ &= -17 /* isQueuedForUpdate */), 
          (s || r) && (e.$flags$ |= 2 /* hasRendered */), i.hasRenderFn || i.reflect) if (i.vdomRender || i.reflect) {
            // looks like we've got child nodes to render into this host element
            // or we need to update the css class/attrs on the host element
            // DOM WRITE!
            if (i.hydrateServerSide) return Promise.resolve(t).then((function(t) {
              return renderVdom(e, t);
            }));
            renderVdom(e, t);
          } else n.textContent = t;
        } catch (l) {
          consoleError(l, e.$hostElement$);
        }
        return null, null;
      }, postUpdateComponent = function(e) {
        var t = e.$cmpMeta$.$tagName$, n = e.$hostElement$, o = createTime("postUpdate", t), r = i.lazyLoad ? e.$lazyInstance$ : n, a = e.$ancestorComponent$;
        i.cmpDidRender && (i.isDev && (e.$flags$ |= 1024 /* devOnRender */), safeCall(r, "componentDidRender"), 
        i.isDev && (e.$flags$ &= -1025 /* devOnRender */)), emitLifecycleEvent(n, "componentDidRender"), 
        64 /* hasLoadedComponent */ & e.$flags$ ? (i.cmpDidUpdate && (
        // we've already loaded this component
        // fire off the user's componentDidUpdate method (if one was provided)
        // componentDidUpdate runs AFTER render() has been called
        // and all child components have finished updating
        i.isDev && (e.$flags$ |= 1024 /* devOnRender */), safeCall(r, "componentDidUpdate"), 
        i.isDev && (e.$flags$ &= -1025 /* devOnRender */)), emitLifecycleEvent(n, "componentDidUpdate"), 
        o()) : (e.$flags$ |= 64 /* hasLoadedComponent */ , i.asyncLoading && i.cssAnnotations && 
        // DOM WRITE!
        addHydratedFlag(n), i.cmpDidLoad && (i.isDev && (e.$flags$ |= 2048 /* devOnDidLoad */), 
        safeCall(r, "componentDidLoad"), i.isDev && (e.$flags$ &= -2049 /* devOnDidLoad */)), 
        emitLifecycleEvent(n, "componentDidLoad"), o(), i.asyncLoading && (e.$onReadyResolve$(n), 
        a || appDidLoad(t))), i.hotModuleReplacement && n["s-hmr-load"] && n["s-hmr-load"](), 
        i.method && i.lazyLoad && e.$onInstanceResolve$(n), 
        // load events fire from bottom to top
        // the deepest elements load first then bubbles up
        i.asyncLoading && (e.$onRenderResolve$ && (e.$onRenderResolve$(), e.$onRenderResolve$ = void 0), 
        512 /* needsRerender */ & e.$flags$ && nextTick((function() {
          return scheduleUpdate(e, !1);
        })), e.$flags$ &= -517 /* needsRerender */);
      }, appDidLoad = function(e) {
        // on appload
        // we have finish the first big initial render
        i.cssAnnotations && addHydratedFlag(g.documentElement), i.asyncQueue && (v.$flags$ |= 2 /* appLoaded */), 
        nextTick((function() {
          return j(p, "appload", {
            detail: {
              namespace: l
            }
          });
        })), i.profile && performance.measure && performance.measure("[Stencil] " + l + " initial load (by " + e + ")", "st:app:start");
      }, safeCall = function(e, t, n) {
        if (e && e[t]) try {
          return e[t](n);
        } catch (o) {
          consoleError(o);
        }
      }, then = function(e, t) {
        return e && e.then ? e.then(t) : t();
      }, emitLifecycleEvent = function(e, t) {
        i.lifecycleDOMEvents && j(e, "stencil_" + t, {
          bubbles: !0,
          composed: !0,
          detail: {
            namespace: l
          }
        });
      }, addHydratedFlag = function(e) {
        return i.hydratedClass ? e.classList.add("hydrated") : i.hydratedAttribute ? e.setAttribute("hydrated", "") : void 0;
      }, serverSideConnected = function(e) {
        var t = e.children;
        if (null != t) for (var n = 0, o = t.length; n < o; n++) {
          var r = t[n];
          "function" == typeof r.connectedCallback && r.connectedCallback(), serverSideConnected(r);
        }
      }, clientHydrate = function(e, t, n, o, r, a, s) {
        var l, $, c, d;
        if (1 /* ElementNode */ === a.nodeType) {
          // recursively drill down, end to start so we can remove nodes
          for ((l = a.getAttribute(L)) && ((
          // got the node data from the element's attribute
          // `${hostId}.${nodeId}.${depth}.${index}`
          $ = l.split("."))[0] !== s && "0" !== $[0] || (c = {
            $flags$: 0,
            $hostId$: $[0],
            $nodeId$: $[1],
            $depth$: $[2],
            $index$: $[3],
            $tag$: a.tagName.toLowerCase(),
            $elm$: a,
            $attrs$: null,
            $children$: null,
            $key$: null,
            $name$: null,
            $text$: null
          }, t.push(c), a.removeAttribute(L), 
          // this is a new child vnode
          // so ensure its parent vnode has the vchildren array
          e.$children$ || (e.$children$ = []), 
          // add our child vnode to a specific index of the vnode's children
          e.$children$[c.$index$] = c, 
          // this is now the new parent vnode for all the next child checks
          e = c, o && "0" === c.$depth$ && (o[c.$index$] = c.$elm$))), d = a.childNodes.length - 1; d >= 0; d--) clientHydrate(e, t, n, o, r, a.childNodes[d], s);
          if (a.shadowRoot) 
          // keep drilling down through the shadow root nodes
          for (d = a.shadowRoot.childNodes.length - 1; d >= 0; d--) clientHydrate(e, t, n, o, r, a.shadowRoot.childNodes[d], s);
        } else if (8 /* CommentNode */ === a.nodeType) 
        // `${COMMENT_TYPE}.${hostId}.${nodeId}.${depth}.${index}`
        ($ = a.nodeValue.split("."))[1] !== s && "0" !== $[1] || (
        // comment node for either the host id or a 0 host id
        l = $[0], c = {
          $flags$: 0,
          $hostId$: $[1],
          $nodeId$: $[2],
          $depth$: $[3],
          $index$: $[4],
          $elm$: a,
          $attrs$: null,
          $children$: null,
          $key$: null,
          $name$: null,
          $tag$: null,
          $text$: null
        }, "t" === l ? (c.$elm$ = a.nextSibling, c.$elm$ && 3 /* TextNode */ === c.$elm$.nodeType && (c.$text$ = c.$elm$.textContent, 
        t.push(c), 
        // remove the text comment since it's no longer needed
        a.remove(), e.$children$ || (e.$children$ = []), e.$children$[c.$index$] = c, o && "0" === c.$depth$ && (o[c.$index$] = c.$elm$))) : c.$hostId$ === s && (
        // this comment node is specifcally for this host id
        "s" === l ? (
        // `${SLOT_NODE_ID}.${hostId}.${nodeId}.${depth}.${index}.${slotName}`;
        c.$tag$ = "slot", $[5] ? a["s-sn"] = c.$name$ = $[5] : a["s-sn"] = "", a["s-sr"] = !0, 
        i.shadowDom && o && (
        // browser support shadowRoot and this is a shadow dom component
        // create an actual slot element
        c.$elm$ = g.createElement(c.$tag$), c.$name$ && 
        // add the slot name attribute
        c.$elm$.setAttribute("name", c.$name$), 
        // insert the new slot element before the slot comment
        a.parentNode.insertBefore(c.$elm$, a), 
        // remove the slot comment since it's not needed for shadow
        a.remove(), "0" === c.$depth$ && (o[c.$index$] = c.$elm$)), n.push(c), e.$children$ || (e.$children$ = []), 
        e.$children$[c.$index$] = c) : "r" === l && (
        // `${CONTENT_REF_ID}.${hostId}`;
        i.shadowDom && o ? 
        // remove the content ref comment since it's not needed for shadow
        a.remove() : i.slotRelocation && (r["s-cr"] = a, a["s-cn"] = !0)))); else if (e && "style" === e.$tag$) {
          var u = newVNode(null, a.textContent);
          u.$elm$ = a, u.$index$ = "0", e.$children$ = [ u ];
        }
      }, initializeDocumentHydrate = function(e, t) {
        if (1 /* ElementNode */ === e.nodeType) {
          for (var n = 0; n < e.childNodes.length; n++) initializeDocumentHydrate(e.childNodes[n], t);
          if (e.shadowRoot) for (n = 0; n < e.shadowRoot.childNodes.length; n++) initializeDocumentHydrate(e.shadowRoot.childNodes[n], t);
        } else if (8 /* CommentNode */ === e.nodeType) {
          var o = e.nodeValue.split(".");
          "o" === o[0] && (t.set(o[1] + "." + o[2], e), e.nodeValue = "", 
          // useful to know if the original location is
          // the root light-dom of a shadow dom component
          e["s-en"] = o[3]);
        }
      }, setValue = function(e, t, n, o) {
        // check our new property value against our internal value
        var r, a, s = getHostRef(e), l = i.lazyLoad ? s.$hostElement$ : e, $ = s.$instanceValues$.get(t), c = s.$flags$, d = i.lazyLoad ? s.$lazyInstance$ : l;
        if (r = n, a = o.$members$[t][0], n = 
        // ensure this value is of the correct prop type
        null == r || isComplexType(r) ? r : i.propBoolean && 4 /* Boolean */ & a ? "false" !== r && ("" === r || !!r) : i.propNumber && 2 /* Number */ & a ? parseFloat(r) : i.propString && 1 /* String */ & a ? String(r) : r, 
        !(i.lazyLoad && 8 /* isConstructingInstance */ & c && void 0 !== $ || n === $) && (
        // gadzooks! the property's value has changed!!
        // set our new value!
        s.$instanceValues$.set(t, n), i.isDev && (1024 /* devOnRender */ & s.$flags$ ? consoleDevWarn('The state/prop "' + t + '" changed during rendering. This can potentially lead to infinite-loops and other bugs.', "\nElement", l, "\nNew value", n, "\nOld value", $) : 2048 /* devOnDidLoad */ & s.$flags$ && consoleDevWarn('The state/prop "' + t + '" changed during "componentDidLoad()", this triggers extra re-renders, try to setup on "componentWillLoad()"', "\nElement", l, "\nNew value", n, "\nOld value", $)), 
        !i.lazyLoad || d)) {
          // get an array of method names of watch functions to call
          if (i.watchCallback && o.$watchers$ && 128 /* isWatchReady */ & c) {
            var u = o.$watchers$[t];
            u && 
            // this instance is watching for when this property changed
            u.map((function(e) {
              try {
                // fire off each of the watch methods that are watching this property
                d[e](n, $, t);
              } catch (o) {
                consoleError(o, l);
              }
            }));
          }
          if (i.updatable && 2 /* hasRendered */ == (18 /* isQueuedForUpdate */ & c)) {
            if (i.cmpShouldUpdate && d.componentShouldUpdate && !1 === d.componentShouldUpdate(n, $, t)) return;
            // looks like this value actually changed, so we've got work to do!
            // but only if we've already rendered, otherwise just chill out
            // queue that we need to do an update, but don't worry about queuing
            // up millions cuz this function ensures it only runs once
                        scheduleUpdate(s, !1);
          }
        }
      }, proxyComponent = function(e, t, n) {
        if (i.member && t.$members$) {
          i.watchCallback && e.watchers && (t.$watchers$ = e.watchers);
          // It's better to have a const than two Object.entries()
                    var o = Object.entries(t.$members$), r = e.prototype;
          if (o.map((function(e) {
            var o = e[0], a = e[1][0];
            (i.prop || i.state) && (31 /* Prop */ & a || (!i.lazyLoad || 2 /* proxyState */ & n) && 32 /* State */ & a) ? 
            // proxyComponent - prop
            Object.defineProperty(r, o, {
              get: function() {
                // proxyComponent, get value
                return e = o, getHostRef(this).$instanceValues$.get(e);
                var e;
              },
              set: function(e) {
                // only during dev time
                if (i.isDev) {
                  var r = getHostRef(this);
                  // we are proxying the instance (not element)
                  0 == (1 /* isElementConstructor */ & n) && 
                  // the element is not constructing
                  0 == (8 /* isConstructingInstance */ & r.$flags$) && 
                  // the member is a prop
                  0 != (31 /* Prop */ & a) && 
                  // the member is not mutable
                  0 == (1024 /* Mutable */ & a) && consoleDevWarn('@Prop() "' + o + '" on <' + t.$tagName$ + "> is immutable but was modified from within the component.\nMore information: https://stenciljs.com/docs/properties#prop-mutability");
                }
                // proxyComponent, set value
                                setValue(this, o, e, t);
              },
              configurable: !0,
              enumerable: !0
            }) : i.lazyLoad && i.method && 1 /* isElementConstructor */ & n && 64 /* Method */ & a && 
            // proxyComponent - method
            Object.defineProperty(r, o, {
              value: function() {
                for (var e = [], t = 0; t < arguments.length; t++) e[t] = arguments[t];
                var n = getHostRef(this);
                return n.$onInstancePromise$.then((function() {
                  var t;
                  return (t = n.$lazyInstance$)[o].apply(t, e);
                }));
              }
            });
          })), i.observeAttribute && (!i.lazyLoad || 1 /* isElementConstructor */ & n)) {
            var a = new Map;
            r.attributeChangedCallback = function(e, t, n) {
              var o = this;
              v.jmp((function() {
                var t = a.get(e);
                o[t] = (null !== n || "boolean" != typeof o[t]) && n;
              }));
            }, 
            // create an array of attributes to observe
            // and also create a map of html attribute name to js property name
            e.observedAttributes = o.filter((function(e) {
              e[0];
              return 15 & e[1][0];
            } /* HasAttribute */)).map((function(e) {
              var n = e[0], o = e[1], r = o[1] || n;
              return a.set(r, n), i.reflect && 512 /* ReflectAttr */ & o[0] && t.$attrsToReflect$.push([ n, r ]), 
              r;
            }));
          }
        }
        return e;
      }, initializeComponent = function(e, n, o, r, a) {
        return __awaiter(s, void 0, void 0, (function() {
          var s, l, $, c, d, u, f;
          return __generator(this, (function(m) {
            switch (m.label) {
             case 0:
              return (i.lazyLoad || i.hydrateServerSide || i.style) && 0 == (32 /* hasInitializedComponent */ & n.$flags$) ? i.lazyLoad || i.hydrateClientSide ? (
              // we haven't initialized this element yet
              n.$flags$ |= 32 /* hasInitializedComponent */ , (
              // lazy loaded components
              // request the component's implementation to be
              // wired up with the host element
              a = loadModule(o, n, r)).then ? (h = "st:load:" + o.$tagName$ + ":" + n.$modeName$, 
              p = "[Stencil] Load module for <" + o.$tagName$ + ">", s = i.profile && performance.mark ? (0 === performance.getEntriesByName(h).length && performance.mark(h), 
              function() {
                0 === performance.getEntriesByName(p).length && performance.measure(p, h);
              }) : function() {}, [ 4 /*yield*/ , a ]) : [ 3 /*break*/ , 2 ]) : [ 3 /*break*/ , 3 ] : [ 3 /*break*/ , 7 ];

             case 1:
              a = m.sent(), s(), m.label = 2;

             case 2:
              if ((i.isDev || i.isDebug) && !a) throw new Error('Constructor for "' + o.$tagName$ + "#" + n.$modeName$ + '" was not found');
              i.member && !a.isProxied && (
              // we'eve never proxied this Constructor before
              // let's add the getters/setters to its prototype before
              // the first time we create an instance of the implementation
              i.watchCallback && (o.$watchers$ = a.watchers), proxyComponent(a, o, 2 /* proxyState */), 
              a.isProxied = !0), l = createTime("createInstance", o.$tagName$), 
              // ok, time to construct the instance
              // but let's keep track of when we start and stop
              // so that the getters/setters don't incorrectly step on data
              i.member && (n.$flags$ |= 8 /* isConstructingInstance */);
              // construct the lazy-loaded component implementation
              // passing the hostRef is very important during
              // construction in order to directly wire together the
              // host element and the lazy-loaded instance
              try {
                new a(n);
              } catch (g) {
                consoleError(g);
              }
              return i.member && (n.$flags$ &= -9 /* isConstructingInstance */), i.watchCallback && (n.$flags$ |= 128 /* isWatchReady */), 
              l(), fireConnectedCallback(n.$lazyInstance$), [ 3 /*break*/ , 4 ];

             case 3:
              // sync constructor component
              a = e.constructor, n.$flags$ |= 160 /* hasInitializedComponent */ , m.label = 4;

             case 4:
              return i.style && a.style ? ($ = a.style, i.mode && "string" != typeof $ && ($ = $[n.$modeName$ = computeMode(e)], 
              i.hydrateServerSide && n.$modeName$ && e.setAttribute("s-mode", n.$modeName$)), 
              c = getScopeId(o, n.$modeName$), F.has(c) ? [ 3 /*break*/ , 7 ] : (d = createTime("registerStyles", o.$tagName$), 
              !i.hydrateServerSide && i.shadowDom && i.shadowDomShim && 8 /* needsShadowDomShim */ & o.$flags$ ? [ 4 /*yield*/ , t.import("./shadow-css-2eae417e.system.js").then((function(e) {
                return e.scopeCss($, c, !1);
              })) ] : [ 3 /*break*/ , 6 ] /* needsShadowDomShim */)) : [ 3 /*break*/ , 7 ];

             case 5:
              $ = m.sent(), m.label = 6;

             case 6:
              registerStyle(c, $, !!(1 /* shadowDomEncapsulation */ & o.$flags$)), d(), m.label = 7;

             case 7:
              return u = n.$ancestorComponent$, f = function() {
                return scheduleUpdate(n, !0);
              }, i.asyncLoading && u && u["s-rc"] ? 
              // this is the intial load and this component it has an ancestor component
              // but the ancestor component has NOT fired its will update lifecycle yet
              // so let's just cool our jets and wait for the ancestor to continue first
              // this will get fired off when the ancestor component
              // finally gets around to rendering its lazy self
              // fire off the initial update
              u["s-rc"].push(f) : f(), [ 2 /*return*/ ];
            }
            var h, p;
          }));
        }));
      }, fireConnectedCallback = function(e) {
        i.lazyLoad && i.connectedCallback && safeCall(e, "connectedCallback");
      }, connectedCallback = function(e) {
        if (0 == (1 /* isTmpDisconnected */ & v.$flags$)) {
          var t = getHostRef(e), n = t.$cmpMeta$, o = createTime("connectedCallback", n.$tagName$);
          if (i.hostListenerTargetParent && 
          // only run if we have listeners being attached to a parent
          addHostEventListeners(e, t, n.$listeners$, !0), 1 /* hasConnected */ & t.$flags$) 
          // not the first time this has connected
          // reattach any event listeners to the host
          // since they would have been removed when disconnected
          addHostEventListeners(e, t, n.$listeners$, !1), 
          // fire off connectedCallback() on component instance
          fireConnectedCallback(t.$lazyInstance$); else {
            // first time this component has connected
            t.$flags$ |= 1 /* hasConnected */;
            var r = void 0;
            if (i.hydrateClientSide && (r = e.getAttribute(N))) {
              if (i.shadowDom && y && 1 /* shadowDomEncapsulation */ & n.$flags$) {
                var a = i.mode ? addStyle(e.shadowRoot, n, e.getAttribute("s-mode")) : addStyle(e.shadowRoot, n);
                e.classList.remove(a + "-h", a + "-s");
              }
              !function(e, t, n, o) {
                var r = createTime("hydrateClient", t), a = e.shadowRoot, s = [], l = i.shadowDom && a ? [] : null, $ = o.$vnode$ = newVNode(t, null);
                v.$orgLocNodes$ || initializeDocumentHydrate(g.body, v.$orgLocNodes$ = new Map), 
                e["s-id"] = n, e.removeAttribute(N), clientHydrate($, s, [], l, e, e, n), s.map((function(e) {
                  var n = e.$hostId$ + "." + e.$nodeId$, o = v.$orgLocNodes$.get(n), r = e.$elm$;
                  o && y && "" === o["s-en"] && o.parentNode.insertBefore(r, o.nextSibling), a || (r["s-hn"] = t, 
                  o && (r["s-ol"] = o, r["s-ol"]["s-nr"] = r)), v.$orgLocNodes$.delete(n);
                })), i.shadowDom && a && l.map((function(e) {
                  e && a.appendChild(e);
                })), r();
              }(e, n.$tagName$, r, t);
            }
            if (i.slotRelocation && !r && (i.hydrateServerSide || (i.slot || i.shadowDom) && 12 /* needsShadowDomShim */ & n.$flags$) && setContentReference(e), 
            i.asyncLoading) for (
            // find the first ancestor component (if there is one) and register
            // this component as one of the actively loading child components for its ancestor
            var s = e; s = s.parentNode || s.host; ) 
            // climb up the ancestors looking for the first
            // component that hasn't finished its lifecycle update yet
            if (i.hydrateClientSide && 1 /* ElementNode */ === s.nodeType && s.hasAttribute("s-id") && s["s-p"] || s["s-p"]) {
              // we found this components first ancestor component
              // keep a reference to this component's ancestor component
              attachToAncestor(t, t.$ancestorComponent$ = s);
              break;
            }
            // Lazy properties
            // https://developers.google.com/web/fundamentals/web-components/best-practices#lazy-properties
                        i.prop && i.lazyLoad && !i.hydrateServerSide && n.$members$ && Object.entries(n.$members$).map((function(t) {
              var n = t[0];
              if (31 /* Prop */ & t[1][0] && e.hasOwnProperty(n)) {
                var o = e[n];
                delete e[n], e[n] = o;
              }
            })), i.initializeNextTick ? 
            // connectedCallback, taskQueue, initialLoad
            // angular sets attribute AFTER connectCallback
            // https://github.com/angular/angular/issues/18909
            // https://github.com/angular/angular/issues/19940
            nextTick((function() {
              return initializeComponent(e, t, n);
            })) : initializeComponent(e, t, n);
          }
          o();
        }
      }, setContentReference = function(e) {
        // only required when we're NOT using native shadow dom (slot)
        // or this browser doesn't support native shadow dom
        // and this host element was NOT created with SSR
        // let's pick out the inner content for slot projection
        // create a node to represent where the original
        // content was first placed, which is useful later on
        var t = e["s-cr"] = g.createComment(i.isDebug ? "content-ref (host=" + e.localName + ")" : "");
        t["s-cn"] = !0, e.insertBefore(t, e.firstChild);
      }, disconnectedCallback = function(e) {
        if (0 == (1 /* isTmpDisconnected */ & v.$flags$)) {
          var t = getHostRef(e), n = i.lazyLoad ? t.$lazyInstance$ : e;
          i.hostListener && t.$rmListeners$ && (t.$rmListeners$.map((function(e) {
            return e();
          })), t.$rmListeners$ = void 0), 
          // clear CSS var-shim tracking
          i.cssVarShim && v.$cssShim$ && v.$cssShim$.removeHost(e), i.lazyLoad && i.disconnectedCallback && safeCall(n, "disconnectedCallback"), 
          i.cmpDidUnload && safeCall(n, "componentDidUnload");
        }
      }, getSlotName = function(e) {
        return e["s-sn"] || 1 === e.nodeType && e.getAttribute("slot") || "";
      }, getHostSlotNode = function(e, t) {
        for (var n, o = 0; o < e.length; o++) {
          if ((n = e[o])["s-sr"] && n["s-sn"] === t) return n;
          if (n = getHostSlotNode(n.childNodes, t)) return n;
        }
        return null;
      }, getHostSlotChildNodes = function(e, t) {
        for (var n = [ e ]; (e = e.nextSibling) && e["s-sn"] === t; ) n.push(e);
        return n;
      }, M = (e("b", (function(e, t) {
        void 0 === t && (t = {}), i.profile && performance.mark && performance.mark("st:app:start"), 
        installDevTools();
        var n, o = createTime("bootstrapLazy"), r = [], a = t.exclude || [], s = p.customElements, l = g.head, $ =  l.querySelector("meta[charset]"), c =  g.createElement("style"), d = [], u =  g.querySelectorAll("[sty-id]"), f = !0, m = 0;
        if (Object.assign(v, t), v.$resourcesUrl$ = new URL(t.resourcesUrl || "./", g.baseURI).href, 
        i.asyncQueue && t.syncQueue && (v.$flags$ |= 4 /* queueSync */), i.hydrateClientSide && (
        // If the app is already hydrated there is not point to disable the
        // async queue. This will improve the first input delay
        v.$flags$ |= 2 /* appLoaded */), i.hydrateClientSide && i.shadowDom) for (;m < u.length; m++) registerStyle(u[m].getAttribute(R), u[m].innerHTML.replace(/\/\*!@([^\/]+)\*\/[^\{]+\{/g, "$1{"), !0);
        e.map((function(e) {
          return e[1].map((function(o) {
            var l = {
              $flags$: o[0],
              $tagName$: o[1],
              $members$: o[2],
              $listeners$: o[3]
            };
            i.member && (l.$members$ = o[2]), i.hostListener && (l.$listeners$ = o[3]), i.reflect && (l.$attrsToReflect$ = []), 
            i.watchCallback && (l.$watchers$ = {}), i.shadowDom && !y && 1 /* shadowDomEncapsulation */ & l.$flags$ && (l.$flags$ |= 8 /* needsShadowDomShim */);
            var $, c, u = i.transformTagName && t.transformTagName ? t.transformTagName(l.$tagName$) : l.$tagName$, m = /** @class */ function(e) {
              // StencilLazyHost
              function HostElement(t) {
                var n = 
                // @ts-ignore
                e.call(this, t) || this;
                return O(t = n, l), i.shadowDom && 1 /* shadowDomEncapsulation */ & l.$flags$ && (
                // this component is using shadow dom
                // and this browser supports shadow dom
                // add the read-only property "shadowRoot" to the host element
                // adding the shadow root build conditionals to minimize runtime
                y ? i.shadowDelegatesFocus ? t.attachShadow({
                  mode: "open",
                  delegatesFocus: !!(16 /* shadowDelegatesFocus */ & l.$flags$)
                }) : t.attachShadow({
                  mode: "open"
                }) : i.hydrateServerSide || "shadowRoot" in t || (t.shadowRoot = t)), i.slotChildNodesFix && function(e, t) {
                  var n = /** @class */ function(e) {
                    function FakeNodeList() {
                      return null !== e && e.apply(this, arguments) || this;
                    }
                    return __extends(FakeNodeList, e), FakeNodeList.prototype.item = function(e) {
                      return this[e];
                    }, FakeNodeList;
                  }(Array);
                  if (8 /* needsShadowDomShim */ & t.$flags$) {
                    var o = e.__lookupGetter__("childNodes");
                    Object.defineProperty(e, "children", {
                      get: function() {
                        return this.childNodes.map((function(e) {
                          return 1 === e.nodeType;
                        }));
                      }
                    }), Object.defineProperty(e, "childElementCount", {
                      get: function() {
                        return e.children.length;
                      }
                    }), Object.defineProperty(e, "childNodes", {
                      get: function() {
                        var e = o.call(this);
                        if (0 == (1 /* isTmpDisconnected */ & v.$flags$) && 2 /* hasRendered */ & getHostRef(this).$flags$) {
                          for (var t = new n, r = 0; r < e.length; r++) {
                            var a = e[r]["s-nr"];
                            a && t.push(a);
                          }
                          return t;
                        }
                        return n.from(e);
                      }
                    });
                  }
                }(t, l), n;
              }
              return __extends(HostElement, e), HostElement.prototype.connectedCallback = function() {
                var e = this;
                n && (clearTimeout(n), n = null), f ? 
                // connectedCallback will be processed once all components have been registered
                d.push(this) : v.jmp((function() {
                  return connectedCallback(e);
                }));
              }, HostElement.prototype.disconnectedCallback = function() {
                var e = this;
                v.jmp((function() {
                  return disconnectedCallback(e);
                }));
              }, HostElement.prototype.componentOnReady = function() {
                return getHostRef(this).$onReadyPromise$;
              }, HostElement;
            }(HTMLElement);
            i.cloneNodeFix && ($ = m.prototype, c = $.cloneNode, $.cloneNode = function(e) {
              var t = this, n = !!i.shadowDom && t.shadowRoot && y, o = c.call(t, !!n && e);
              if (i.slot && !n && e) for (var r = 0, a = void 0, s = void 0, l = [ "s-id", "s-cr", "s-lr", "s-rc", "s-sc", "s-p", "s-cn", "s-sr", "s-sn", "s-hn", "s-ol", "s-nr", "s-si" ]; r < t.childNodes.length; r++) a = t.childNodes[r]["s-nr"], 
              s = l.every((function(e) {
                return !t.childNodes[r][e];
              })), a && (i.appendChildSlotFix && o.__appendChild ? o.__appendChild(a.cloneNode(!0)) : o.appendChild(a.cloneNode(!0))), 
              s && o.appendChild(t.childNodes[r].cloneNode(!0));
              return o;
            }), i.appendChildSlotFix && function(e) {
              e.__appendChild = e.appendChild, e.appendChild = function(e) {
                var t = e["s-sn"] = getSlotName(e), n = getHostSlotNode(this.childNodes, t);
                if (n) {
                  var o = getHostSlotChildNodes(n, t), r = o[o.length - 1];
                  return r.parentNode.insertBefore(e, r.nextSibling);
                }
                return this.__appendChild(e);
              };
            }(m.prototype), i.hotModuleReplacement && (m.prototype["s-hmr"] = function(e) {
              !function(e, t, n) {
                // ¯\_(ツ)_/¯
                var o = getHostRef(e);
                // reset state flags to only have been connected
                                o.$flags$ = 1 /* hasConnected */ , 
                // TODO
                // detatch any event listeners that may have been added
                // because we're not passing an exact event name it'll
                // remove all of this element's event, which is good
                // create a callback for when this component finishes hmr
                e["s-hmr-load"] = function() {
                  // finished hmr for this element
                  delete e["s-hmr-load"];
                }, 
                // re-initialize the component
                initializeComponent(e, o, t, n);
              }(this, l, e);
            }), l.$lazyBundleId$ = e[0], a.includes(u) || s.get(u) || (r.push(u), s.define(u, proxyComponent(m, l, 1 /* isElementConstructor */)));
          }));
        })), (i.hydratedClass || i.hydratedAttribute) && (c.innerHTML = r + "{visibility:hidden}.hydrated{visibility:inherit}", 
        c.setAttribute("data-styles", ""), l.insertBefore(c, $ ? $.nextSibling : l.firstChild)), 
        // Process deferred connectedCallbacks now all components have been registered
        f = !1, d.length ? d.map((function(e) {
          return e.connectedCallback();
        })) : i.profile ? v.jmp((function() {
          return n = setTimeout(appDidLoad, 30, "timeout");
        })) : v.jmp((function() {
          return n = setTimeout(appDidLoad, 30);
        })), 
        // Fallback appLoad event
        o();
      })), new WeakMap), getHostRef = function(e) {
        return M.get(e);
      }, O = (e("r", (function(e, t) {
        return M.set(t.$lazyInstance$ = e, t);
      })), function(e, t) {
        var n = {
          $flags$: 0,
          $hostElement$: e,
          $cmpMeta$: t,
          $instanceValues$: new Map
        };
        return i.isDev && (n.$renderCount$ = 0), i.method && i.lazyLoad && (n.$onInstancePromise$ = new Promise((function(e) {
          return n.$onInstanceResolve$ = e;
        }))), i.asyncLoading && (n.$onReadyPromise$ = new Promise((function(e) {
          return n.$onReadyResolve$ = e;
        })), e["s-p"] = [], e["s-rc"] = []), addHostEventListeners(e, n, t.$listeners$, !1), 
        M.set(e, n);
      }), isMemberInElement = function(e, t) {
        return t in e;
      }, consoleError = function(e, t) {
        return (a || console.error)(e, t);
      }, P = i.isTesting ? [ "STENCIL:" ] : [ "%cstencil", "color: white;background:#4c47ff;font-weight: bold; font-size:10px; padding:2px 6px; border-radius: 5px" ], consoleDevError = function() {
        for (var e = [], t = 0; t < arguments.length; t++) e[t] = arguments[t];
        return console.error.apply(console, __spreadArray(__spreadArray([], P), e));
      }, consoleDevWarn = function() {
        for (var e = [], t = 0; t < arguments.length; t++) e[t] = arguments[t];
        return console.warn.apply(console, __spreadArray(__spreadArray([], P), e));
      }, I = ( e("c", (function() {
        for (var e = [], t = 0; t < arguments.length; t++) e[t] = arguments[t];
        return console.info.apply(console, __spreadArray(__spreadArray([], P), e));
      })), new Map), loadModule = function(e, n, o) {
        // loadModuleImport
        var r = e.$tagName$.replace(/-/g, "_"), a = e.$lazyBundleId$;
        if (!i.isDev || "string" == typeof a) {
          var s = !i.hotModuleReplacement && I.get(a);
          return s ? s[r] : t.import(
          /* webpackInclude: /\.entry\.js$/ */
          /* webpackExclude: /\.system\.entry\.js$/ */
          /* webpackMode: "lazy" */
          "./" + a + ".entry.js" + (i.hotModuleReplacement && o ? "?s-hmr=" + o : "")).then((function(e) {
            return i.hotModuleReplacement || I.set(a, e), e[r];
          }), consoleError);
        }
        consoleDevError("Trying to lazily load component <" + e.$tagName$ + '> with style mode "' + n.$modeName$ + '", but it does not exist.');
      }, F = new Map, H = [], B = [], U = [], W = [], queueTask = function(e, t) {
        return function(n) {
          e.push(n), h || (h = !0, t && 4 /* queueSync */ & v.$flags$ ? nextTick(flush) : v.raf(flush));
        };
      }, consume = function(e) {
        for (var t = 0; t < e.length; t++) try {
          e[t](performance.now());
        } catch (n) {
          consoleError(n);
        }
        e.length = 0;
      }, consumeTimeout = function(e, t) {
        for (var n = 0, o = 0; n < e.length && (o = performance.now()) < t; ) try {
          e[n++](o);
        } catch (r) {
          consoleError(r);
        }
        n === e.length ? e.length = 0 : 0 !== n && e.splice(0, n);
      }, flush = function() {
        // DOM WRITES!!!
        if (i.asyncQueue && m++, 
        // always force a bunch of medium callbacks to run, but still have
        // a throttle on how many can run in a certain time
        // DOM READS!!!
        consume(B), i.asyncQueue) {
          var e = 2 /* appLoaded */ == (6 /* queueMask */ & v.$flags$) ? performance.now() + 14 * Math.ceil(.1 * m) : 1 / 0;
          consumeTimeout(U, e), consumeTimeout(W, e), U.length > 0 && (W.push.apply(W, U), 
          U.length = 0), (h = B.length + U.length + W.length > 0) ? 
          // still more to do yet, but we've run out of time
          // let's let this thing cool off and try again in the next tick
          v.raf(flush) : m = 0;
        } else consume(U), (h = B.length > 0) && 
        // still more to do yet, but we've run out of time
        // let's let this thing cool off and try again in the next tick
        v.raf(flush);
      }, nextTick =  function(e) {
        return w().then(e);
      }, V =  queueTask(U, !0);
      i.isDev, i.isTesting;
    }
  };
}));