@genexus/genexus-ide-ui 1.0.56 → 1.0.58

package/dist/genexus-ide-ui/{p-49712340.js → p-2cf37639.js}

@@ -65,7 +65,7 @@ const t = /* genexus-ide-ui */ {
   slotRelocation: true,
   state: true,
   style: true,
-  svg: false,
+  svg: true,
   taskQueue: true,
   transformTagName: false,
   updatable: true,
@@ -107,8 +107,8 @@ let f = false;
 let r = false;
 
 const getAssetPath = e => {
-  const t = new URL(e, T._$$resourcesUrl$$_);
-  return t.origin !== C.location.origin ? t.href : t.pathname;
+  const t = new URL(e, R._$$resourcesUrl$$_);
+  return t.origin !== T.location.origin ? t.href : t.pathname;
 };
 
 const createTime = (e, t = "") => {
@@ -140,6 +140,12 @@ const a = "{visibility:hidden}.hydrated{visibility:inherit}";
  * Don't add values to these!!
  */ const d = {};
 
+/**
+ * Namespaces
+ */ const p = "http://www.w3.org/2000/svg";
+
+const v = "http://www.w3.org/1999/xhtml";
+
 const isDef = e => e != null
 /**
  * Check whether a value is a 'complex type', defined here as an object or a
@@ -261,14 +267,14 @@ const h = (e, t, ...n) => {
   return n;
 };
 
-const p = {};
+const m = {};
 
 /**
  * Check whether a given node is a Host node or not
  *
  * @param node the virtual DOM node to check
  * @returns whether it's a Host node or not
- */ const isHost = e => e && e._$$tag$$_ === p
+ */ const isHost = e => e && e._$$tag$$_ === m
 /**
  * Parse a new property value for a given property type.
  *
@@ -339,16 +345,16 @@ const createEvent = (e, t, n) => {
  * @param opts options for configuring a custom Event
  * @returns the custom Event
  */ const emitEvent = (e, t, n) => {
-  const s = T.ce(t, n);
+  const s = R.ce(t, n);
   e.dispatchEvent(s);
   return s;
 };
 
-const m =  new WeakMap;
+const y =  new WeakMap;
 
 const registerStyle = (e, t, n) => {
-  let s = S.get(e);
-  if (L && n) {
+  let s = k.get(e);
+  if (D && n) {
     s = s || new CSSStyleSheet;
     if (typeof s === "string") {
       s = t;
@@ -358,30 +364,30 @@ const registerStyle = (e, t, n) => {
   } else {
     s = t;
   }
-  S.set(e, s);
+  k.set(e, s);
 };
 
 const addStyle = (e, t, n) => {
   var s;
   const o = getScopeId(t);
-  const l = S.get(o);
+  const l = k.get(o);
   // 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
-    e = e.nodeType === 11 /* NODE_TYPE.DocumentFragment */ ? e : k;
+    e = e.nodeType === 11 /* NODE_TYPE.DocumentFragment */ ? e : L;
   if (l) {
     if (typeof l === "string") {
       e = e.head || e;
-      let n = m.get(e);
+      let n = y.get(e);
       let i;
       if (!n) {
-        m.set(e, n = new Set);
+        y.set(e, n = new Set);
       }
       if (!n.has(o)) {
         {
-          i = k.createElement("style");
+          i = L.createElement("style");
           i.innerHTML = l;
           // Apply CSP nonce to the style tag if it exists
-                    const t = (s = T._$$nonce$$_) !== null && s !== void 0 ? s : queryNonceMetaTagContent(k);
+                    const t = (s = R._$$nonce$$_) !== null && s !== void 0 ? s : queryNonceMetaTagContent(L);
           if (t != null) {
             i.setAttribute("nonce", t);
           }
@@ -498,7 +504,7 @@ const setAccessor = (e, t, n, s, o, l) => {
         // <my-cmp on-ionChange> // listens for "ionChange"
         // <my-cmp on-EVENTS> // listens for "EVENTS"
         t = t.slice(3);
-      } else if (isMemberInElement(C, c)) {
+      } else if (isMemberInElement(T, c)) {
         // standard event
         // the JSX attribute could have been "onMouseOver" and the
         // member name "onmouseover" is on the window's prototype
@@ -516,14 +522,14 @@ const setAccessor = (e, t, n, s, o, l) => {
         // Need to account for "capture" events.
         // If the event name ends with "Capture", we'll update the name to remove
         // the "Capture" suffix and make sure the event listener is setup to handle the capture event.
-        const o = t.endsWith(y);
+        const o = t.endsWith($);
         // Make sure we only replace the last instance of "Capture"
-                t = t.replace(b, "");
+                t = t.replace(g, "");
         if (n) {
-          T.rel(e, t, n, o);
+          R.rel(e, t, n, o);
         }
         if (s) {
-          T.ael(e, t, s, o);
+          R.ael(e, t, s, o);
         }
       }
     } else {
@@ -563,17 +569,17 @@ const setAccessor = (e, t, n, s, o, l) => {
   }
 };
 
-const v = /\s/;
+const b = /\s/;
 
 /**
  * Parsed a string of classnames into an array
  * @param value className string, e.g. "foo bar baz"
  * @returns list of classes, e.g. ["foo", "bar", "baz"]
- */ const parseClassList = e => !e ? [] : e.split(v);
+ */ const parseClassList = e => !e ? [] : e.split(b);
 
-const y = "Capture";
+const $ = "Capture";
 
-const b = new RegExp(y + "$");
+const g = new RegExp($ + "$");
 
 const updateElement = (e, t, n, s) => {
   // if the element passed in is a shadow root, which is a document fragment
@@ -610,9 +616,9 @@ const updateElement = (e, t, n, s) => {
   // tslint:disable-next-line: prefer-const
     const u = t._$$children$$_[i];
   let d = 0;
-  let p;
   let m;
-  let v;
+  let y;
+  let b;
   if (!l) {
     // remember for later we need to check to relocate nodes
     c = true;
@@ -628,50 +634,65 @@ const updateElement = (e, t, n, s) => {
   }
   if (u._$$text$$_ !== null) {
     // create text node
-    p = u._$$elm$$_ = k.createTextNode(u._$$text$$_);
+    m = u._$$elm$$_ = L.createTextNode(u._$$text$$_);
   } else if (u._$$flags$$_ & 1 /* VNODE_FLAGS.isSlotReference */) {
     // create a slot reference node
-    p = u._$$elm$$_ = slotReferenceDebugNode(u);
+    m = u._$$elm$$_ = slotReferenceDebugNode(u);
   } else {
+    if (!f) {
+      f = u._$$tag$$_ === "svg";
+    }
     // create element
-    p = u._$$elm$$_ = k.createElement(u._$$flags$$_ & 2 /* VNODE_FLAGS.isSlotFallback */ ? "slot-fb" : u._$$tag$$_);
+        m = u._$$elm$$_ = L.createElementNS(f ? p : v, u._$$flags$$_ & 2 /* VNODE_FLAGS.isSlotFallback */ ? "slot-fb" : u._$$tag$$_);
+    if (f && u._$$tag$$_ === "foreignObject") {
+      f = false;
+    }
     // add css classes, attrs, props, listeners, etc.
         {
       updateElement(null, u, f);
     }
-    if (isDef(n) && p["s-si"] !== n) {
+    if (isDef(n) && m["s-si"] !== n) {
       // if there is a scopeId and this is the initial render
       // then let's add the scopeId as a css class
-      p.classList.add(p["s-si"] = n);
+      m.classList.add(m["s-si"] = n);
     }
     if (u._$$children$$_) {
       for (d = 0; d < u._$$children$$_.length; ++d) {
         // create the node
-        m = createElm(e, u, d, p);
+        y = createElm(e, u, d, m);
         // return node could have been null
-                if (m) {
+                if (y) {
           // append our new node
-          p.appendChild(m);
+          m.appendChild(y);
         }
       }
     }
+    {
+      if (u._$$tag$$_ === "svg") {
+        // Only reset the SVG context when we're exiting <svg> element
+        f = false;
+      } else if (m.tagName === "foreignObject") {
+        // Reenter SVG context when we're exiting <foreignObject> element
+        f = true;
+      }
+    }
   }
   // This needs to always happen so we can hide nodes that are projected
   // to another component but don't end up in a slot
-    p["s-hn"] = o;
+    m["s-hn"] = o;
   {
     if (u._$$flags$$_ & (2 /* VNODE_FLAGS.isSlotFallback */ | 1 /* VNODE_FLAGS.isSlotReference */)) {
       // remember the content reference comment
-      p["s-sr"] = true;
+      m["s-sr"] = true;
       // Persist the name of the slot that this slot was going to be projected into.
-            p["s-fs"] = (a = u._$$attrs$$_) === null || a === void 0 ? void 0 : a.slot;
+            m["s-fs"] = (a = u._$$attrs$$_) === null || a === void 0 ? void 0 : a.slot;
       // remember the content reference comment
-            p["s-cr"] = s;
+            m["s-cr"] = s;
       // remember the slot name, or empty string for default slot
-            p["s-sn"] = u._$$name$$_ || "";
+            m["s-sn"] = u._$$name$$_ || "";
       // check if we've got an old vnode for this slot
-            v = e && e._$$children$$_ && e._$$children$$_[i];
-      if (v && v._$$tag$$_ === u._$$tag$$_ && e._$$elm$$_) {
+            b = e && e._$$children$$_ && e._$$children$$_[i];
+      if (b && b._$$tag$$_ === u._$$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 its original location
@@ -680,12 +701,12 @@ const updateElement = (e, t, n, s) => {
       }
     }
   }
-  return p;
+  return m;
 };
 
 const putBackInOriginalLocation = (e, t) => {
   var n;
-  T._$$flags$$_ |= 1 /* PLATFORM_FLAGS.isTmpDisconnected */;
+  R._$$flags$$_ |= 1 /* PLATFORM_FLAGS.isTmpDisconnected */;
   const s = e.childNodes;
   for (let e = s.length - 1; e >= 0; e--) {
     const l = s[e];
@@ -711,7 +732,7 @@ const putBackInOriginalLocation = (e, t) => {
       putBackInOriginalLocation(l, t);
     }
   }
-  T._$$flags$$_ &= ~1 /* PLATFORM_FLAGS.isTmpDisconnected */;
+  R._$$flags$$_ &= ~1 /* PLATFORM_FLAGS.isTmpDisconnected */;
 };
 
 /**
@@ -860,8 +881,8 @@ const putBackInOriginalLocation = (e, t) => {
   let u = t[r];
   let d = s.length - 1;
   let p = s[0];
-  let m = s[d];
-  let v;
+  let v = s[d];
+  let m;
   let y;
   while (l <= r && i <= d) {
     if (a == null) {
@@ -871,8 +892,8 @@ const putBackInOriginalLocation = (e, t) => {
       u = t[--r];
     } else if (p == null) {
       p = s[++i];
-    } else if (m == null) {
-      m = s[--d];
+    } else if (v == null) {
+      v = s[--d];
     } else if (isSameVnode(a, p, o)) {
       // if the start nodes are the same then we should patch the new VNode
       // onto the old one, and increment our `newStartIdx` and `oldStartIdx`
@@ -881,14 +902,14 @@ const putBackInOriginalLocation = (e, t) => {
       patch(a, p, o);
       a = t[++l];
       p = s[++i];
-    } else if (isSameVnode(u, m, o)) {
+    } else if (isSameVnode(u, v, o)) {
       // likewise, if the end nodes are the same we patch new onto old and
       // decrement our end indices, and also likewise in this case we don't
       // need to move any DOM Nodes.
-      patch(u, m, o);
+      patch(u, v, o);
       u = t[--r];
-      m = s[--d];
-    } else if (isSameVnode(a, m, o)) {
+      v = s[--d];
+    } else if (isSameVnode(a, v, o)) {
       // case: "Vnode moved right"
       // We've found that the last node in our window on the new children is
       // the same VNode as the _first_ node in our window on the old children
@@ -900,10 +921,10 @@ const putBackInOriginalLocation = (e, t) => {
       //              ^^^^^^^^^^^^^
       // In this situation we need to patch `newEndVnode` onto `oldStartVnode`
       // and move the DOM element for `oldStartVnode`.
-      if (a._$$tag$$_ === "slot" || m._$$tag$$_ === "slot") {
+      if (a._$$tag$$_ === "slot" || v._$$tag$$_ === "slot") {
         putBackInOriginalLocation(a._$$elm$$_.parentNode, false);
       }
-      patch(a, m, o);
+      patch(a, v, o);
       // We need to move the element for `oldStartVnode` into a position which
       // will be appropriate for `newEndVnode`. For this we can use
       // `.insertBefore` and `oldEndVnode.$elm$.nextSibling`. If there is a
@@ -923,7 +944,7 @@ const putBackInOriginalLocation = (e, t) => {
       // append it to the children of the parent element.
             e.insertBefore(a._$$elm$$_, u._$$elm$$_.nextSibling);
       a = t[++l];
-      m = s[--d];
+      v = s[--d];
     } else if (isSameVnode(u, p, o)) {
       // case: "Vnode moved left"
       // We've found that the first node in our window on the new children is
@@ -937,7 +958,7 @@ const putBackInOriginalLocation = (e, t) => {
       // (which will handle updating any changed attributes, reconciling their
       // children etc) but we also need to move the DOM node to which
       // `oldEndVnode` corresponds.
-      if (a._$$tag$$_ === "slot" || m._$$tag$$_ === "slot") {
+      if (a._$$tag$$_ === "slot" || v._$$tag$$_ === "slot") {
         putBackInOriginalLocation(u._$$elm$$_.parentNode, false);
       }
       patch(u, p, o);
@@ -972,13 +993,13 @@ const putBackInOriginalLocation = (e, t) => {
         y = t[c];
         if (y._$$tag$$_ !== p._$$tag$$_) {
           // the tag doesn't match so we'll need a new DOM element
-          v = createElm(t && t[i], n, c, e);
+          m = createElm(t && t[i], n, c, e);
         } else {
           patch(y, p, o);
           // invalidate the matching old node so that we won't try to update it
           // again later on
                     t[c] = undefined;
-          v = y._$$elm$$_;
+          m = y._$$elm$$_;
         }
         p = s[++i];
       } else {
@@ -986,13 +1007,13 @@ const putBackInOriginalLocation = (e, t) => {
         // the key of the first new child OR the build is not using `key`
         // attributes at all. In either case we need to create a new element
         // for the new node.
-        v = createElm(t && t[i], n, i, e);
+        m = createElm(t && t[i], n, i, e);
         p = s[++i];
       }
-      if (v) {
+      if (m) {
         // if we created a new node then handle inserting it to the DOM
         {
-          parentReferenceNode(a._$$elm$$_).insertBefore(v, referenceNode(a._$$elm$$_));
+          parentReferenceNode(a._$$elm$$_).insertBefore(m, referenceNode(a._$$elm$$_));
         }
       }
     }
@@ -1067,6 +1088,11 @@ const patch = (e, t, n = false) => {
   const c = t._$$text$$_;
   let r;
   if (c === null) {
+    {
+      // 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 = i === "svg" ? true : i === "foreignObject" ? false : f;
+    }
     {
       if (i === "slot") ; else {
         // either this is the first render of an element OR it's an update
@@ -1091,6 +1117,9 @@ const patch = (e, t, n = false) => {
       // no new child vnodes, but there are old child vnodes to remove
       removeVnodes(o, 0, o.length - 1);
     }
+    if (f && i === "svg") {
+      f = false;
+    }
   } else if (r = s["s-cr"]) {
     // this element has slotted content
     r.parentNode.textContent = c;
@@ -1157,7 +1186,7 @@ const patch = (e, t, n = false) => {
 /**
  * Component-global information about nodes which are either currently being
  * relocated or will be shortly.
- */ const $ = [];
+ */ const w = [];
 
 /**
  * Mark the contents of a slot for relocation via adding references to them to
@@ -1195,7 +1224,7 @@ const patch = (e, t, n = false) => {
           // (under the host element parent) to the right slot location
           if (isNodeLocatedInSlot(n, e)) {
             // it's possible we've already decided to relocate this node
-            let t = $.find((e => e._$$nodeToRelocate$$_ === n));
+            let t = w.find((e => e._$$nodeToRelocate$$_ === n));
             // made some changes to slots
             // let's make sure we also double check
             // fallbacks are correctly hidden or shown
@@ -1211,27 +1240,27 @@ const patch = (e, t, n = false) => {
             } else {
               n["s-sh"] = l["s-hn"];
               // add to our list of nodes to relocate
-                            $.push({
+                            w.push({
                 _$$slotRefNode$$_: l,
                 _$$nodeToRelocate$$_: n
               });
             }
             if (n["s-sr"]) {
-              $.map((e => {
+              w.map((e => {
                 if (isNodeLocatedInSlot(e._$$nodeToRelocate$$_, n["s-sn"])) {
-                  t = $.find((e => e._$$nodeToRelocate$$_ === n));
+                  t = w.find((e => e._$$nodeToRelocate$$_ === n));
                   if (t && !e._$$slotRefNode$$_) {
                     e._$$slotRefNode$$_ = t._$$slotRefNode$$_;
                   }
                 }
               }));
             }
-          } else if (!$.some((e => e._$$nodeToRelocate$$_ === n))) {
+          } else if (!w.some((e => e._$$nodeToRelocate$$_ === n))) {
             // the node is not found within the slot (`childNode`) that we're
             // currently looking at, so we stick it into `relocateNodes` to
             // handle later. If we never find a home for this element then
             // we'll need to hide it
-            $.push({
+            w.push({
               _$$nodeToRelocate$$_: n
             });
           }
@@ -1298,8 +1327,8 @@ const patch = (e, t, n = false) => {
  */ const renderVdom = (e, t, f = false) => {
   var r, a, u, d;
   const p = e.$hostElement$;
-  const m = e._$$cmpMeta$$_;
-  const v = e._$$vnode$$_ || newVNode(null, null);
+  const v = e._$$cmpMeta$$_;
+  const m = e._$$vnode$$_ || newVNode(null, null);
   // if `renderFnResults` is a Host node then we can use it directly. If not,
   // we need to call `h` again to wrap the children of our component in a
   // 'dummy' Host node (well, an empty vnode) since `renderVdom` assumes
@@ -1307,9 +1336,9 @@ const patch = (e, t, n = false) => {
   // contains attrs that need to be set on the host element.
     const y = isHost(t) ? t : h(null, null, t);
   o = p.tagName;
-  if (m._$$attrsToReflect$$_) {
+  if (v._$$attrsToReflect$$_) {
     y._$$attrs$$_ = y._$$attrs$$_ || {};
-    m._$$attrsToReflect$$_.map((([e, t]) => y._$$attrs$$_[t] = p[e]));
+    v._$$attrsToReflect$$_.map((([e, t]) => y._$$attrs$$_[t] = p[e]));
   }
   // On the first render and *only* on the first render we want to check for
   // any attributes set on the host element which are also set on the vdom
@@ -1334,25 +1363,25 @@ const patch = (e, t, n = false) => {
   y._$$tag$$_ = null;
   y._$$flags$$_ |= 4 /* VNODE_FLAGS.isHost */;
   e._$$vnode$$_ = y;
-  y._$$elm$$_ = v._$$elm$$_ = p.shadowRoot || p;
+  y._$$elm$$_ = m._$$elm$$_ = p.shadowRoot || p;
   {
     n = p["s-sc"];
   }
   {
     s = p["s-cr"];
-    l = (m._$$flags$$_ & 1 /* CMP_FLAGS.shadowDomEncapsulation */) !== 0;
+    l = (v._$$flags$$_ & 1 /* CMP_FLAGS.shadowDomEncapsulation */) !== 0;
     // always reset
         i = false;
   }
   // synchronous patch
-    patch(v, y, f);
+    patch(m, y, f);
   {
     // while we're moving nodes around existing nodes, temporarily disable
     // the disconnectCallback from working
-    T._$$flags$$_ |= 1 /* PLATFORM_FLAGS.isTmpDisconnected */;
+    R._$$flags$$_ |= 1 /* PLATFORM_FLAGS.isTmpDisconnected */;
     if (c) {
       markSlotContentForRelocation(y._$$elm$$_);
-      for (const e of $) {
+      for (const e of w) {
         const t = e._$$nodeToRelocate$$_;
         if (!t["s-ol"]) {
           // add a reference node marking this node's original location
@@ -1362,7 +1391,7 @@ const patch = (e, t, n = false) => {
           t.parentNode.insertBefore(t["s-ol"] = e, t);
         }
       }
-      for (const e of $) {
+      for (const e of w) {
         const t = e._$$nodeToRelocate$$_;
         const n = e._$$slotRefNode$$_;
         if (n) {
@@ -1436,17 +1465,17 @@ const patch = (e, t, n = false) => {
     }
     // done moving nodes around
     // allow the disconnect callback to work again
-        T._$$flags$$_ &= ~1 /* PLATFORM_FLAGS.isTmpDisconnected */;
+        R._$$flags$$_ &= ~1 /* PLATFORM_FLAGS.isTmpDisconnected */;
     // always reset
-        $.length = 0;
+        w.length = 0;
   }
 };
 
 // slot comment debug nodes only created with the `--debug` flag
 // otherwise these nodes are text nodes w/out content
-const slotReferenceDebugNode = e => k.createComment(`<slot${e._$$name$$_ ? ' name="' + e._$$name$$_ + '"' : ""}> (host=${o.toLowerCase()})`);
+const slotReferenceDebugNode = e => L.createComment(`<slot${e._$$name$$_ ? ' name="' + e._$$name$$_ + '"' : ""}> (host=${o.toLowerCase()})`);
 
-const originalLocationDebugNode = e => k.createComment(`org-location for ` + (e.localName ? `<${e.localName}> (host=${e["s-hn"]})` : `[${e.textContent}]`));
+const originalLocationDebugNode = e => L.createComment(`org-location for ` + (e.localName ? `<${e.localName}> (host=${e["s-hn"]})` : `[${e.textContent}]`));
 
 const attachToAncestor = (e, t) => {
   if (t && !e._$$onRenderResolve$$_ && t["s-p"]) {
@@ -1467,7 +1496,7 @@ const scheduleUpdate = (e, t) => {
   // has already fired off its lifecycle update then
   // fire off the initial update
     const dispatch = () => dispatchHooks(e, t);
-  return x(dispatch);
+  return O(dispatch);
 };
 
 /**
@@ -1690,9 +1719,9 @@ const appDidLoad = t => {
   // on appload
   // we have finish the first big initial render
   {
-    addHydratedFlag(k.documentElement);
+    addHydratedFlag(L.documentElement);
   }
-  nextTick((() => emitEvent(C, "appload", {
+  nextTick((() => emitEvent(T, "appload", {
     detail: {
       namespace: e
     }
@@ -1832,7 +1861,7 @@ const setValue = (e, t, n, s) => {
     if (n & 1 /* PROXY_FLAGS.isElementConstructor */) {
       const n = new Map;
       o.attributeChangedCallback = function(e, s, l) {
-        T.jmp((() => {
+        R.jmp((() => {
           var i;
           const c = n.get(e);
           //  In a web component lifecycle the attributeChangedCallback runs prior to connectedCallback
@@ -1986,7 +2015,7 @@ const setValue = (e, t, n, s) => {
       // this component has styles but we haven't registered them yet
       let e = o.style;
       const t = getScopeId(n);
-      if (!S.has(t)) {
+      if (!k.has(t)) {
         const s = createTime("registerStyles", n._$$tagName$$_);
         registerStyle(t, e, !!(n._$$flags$$_ & 1 /* CMP_FLAGS.shadowDomEncapsulation */));
         s();
@@ -2016,7 +2045,7 @@ const fireConnectedCallback = e => {
 };
 
 const connectedCallback = e => {
-  if ((T._$$flags$$_ & 1 /* PLATFORM_FLAGS.isTmpDisconnected */) === 0) {
+  if ((R._$$flags$$_ & 1 /* PLATFORM_FLAGS.isTmpDisconnected */) === 0) {
     const t = getHostRef(e);
     const n = t._$$cmpMeta$$_;
     const s = createTime("connectedCallback", n._$$tagName$$_);
@@ -2085,7 +2114,7 @@ const setContentReference = e => {
   // 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
-  const t = e["s-cr"] = k.createComment(`content-ref (host=${e.localName})`);
+  const t = e["s-cr"] = L.createComment(`content-ref (host=${e.localName})`);
   t["s-cn"] = true;
   e.insertBefore(t, e.firstChild);
 };
@@ -2093,7 +2122,7 @@ const setContentReference = e => {
 const disconnectInstance = e => {};
 
 const disconnectedCallback = async e => {
-  if ((T._$$flags$$_ & 1 /* PLATFORM_FLAGS.isTmpDisconnected */) === 0) {
+  if ((R._$$flags$$_ & 1 /* PLATFORM_FLAGS.isTmpDisconnected */) === 0) {
     const t = getHostRef(e);
     {
       if (t._$$rmListeners$$_) {
@@ -2112,16 +2141,16 @@ const bootstrapLazy = (e, t = {}) => {
   const s = createTime();
   const o = [];
   const l = t.exclude || [];
-  const i = C.customElements;
-  const c = k.head;
+  const i = T.customElements;
+  const c = L.head;
   const f =  c.querySelector("meta[charset]");
-  const r =  k.createElement("style");
+  const r =  L.createElement("style");
   const d = [];
   let p;
-  let m = true;
-  Object.assign(T, t);
-  T._$$resourcesUrl$$_ = new URL(t.resourcesUrl || "./", k.baseURI).href;
-  let v = false;
+  let v = true;
+  Object.assign(R, t);
+  R._$$resourcesUrl$$_ = new URL(t.resourcesUrl || "./", L.baseURI).href;
+  let m = false;
   e.map((e => {
     e[1].map((t => {
       var n;
@@ -2134,7 +2163,7 @@ const bootstrapLazy = (e, t = {}) => {
       // Check if we are using slots outside the shadow DOM in this component.
       // We'll use this information later to add styles for `slot-fb` elements
             if (s._$$flags$$_ & 4 /* CMP_FLAGS.hasSlotRelocation */) {
-        v = true;
+        m = true;
       }
       {
         s._$$members$$_ = t[2];
@@ -2176,15 +2205,15 @@ const bootstrapLazy = (e, t = {}) => {
             clearTimeout(p);
             p = null;
           }
-          if (m) {
+          if (v) {
             // connectedCallback will be processed once all components have been registered
             d.push(this);
           } else {
-            T.jmp((() => connectedCallback(this)));
+            R.jmp((() => connectedCallback(this)));
           }
         }
         disconnectedCallback() {
-          T.jmp((() => disconnectedCallback(this)));
+          R.jmp((() => disconnectedCallback(this)));
         }
         componentOnReady() {
           return getHostRef(this)._$$onReadyPromise$$_;
@@ -2198,7 +2227,7 @@ const bootstrapLazy = (e, t = {}) => {
     }));
   }));
   // Add styles for `slot-fb` elements if any of our components are using slots outside the Shadow DOM
-    if (v) {
+    if (m) {
     r.innerHTML += u;
   }
   // Add hydration styles
@@ -2209,7 +2238,7 @@ const bootstrapLazy = (e, t = {}) => {
     if (r.innerHTML.length) {
     r.setAttribute("data-styles", "");
     // Apply CSP nonce to the style tag if it exists
-        const e = (n = T._$$nonce$$_) !== null && n !== void 0 ? n : queryNonceMetaTagContent(k);
+        const e = (n = R._$$nonce$$_) !== null && n !== void 0 ? n : queryNonceMetaTagContent(L);
     if (e != null) {
       r.setAttribute("nonce", e);
     }
@@ -2218,12 +2247,12 @@ const bootstrapLazy = (e, t = {}) => {
         c.insertBefore(r, f ? f.nextSibling : c.firstChild);
   }
   // Process deferred connectedCallbacks now all components have been registered
-    m = false;
+    v = false;
   if (d.length) {
     d.map((e => e.connectedCallback()));
   } else {
     {
-      T.jmp((() => p = setTimeout(appDidLoad, 30)));
+      R.jmp((() => p = setTimeout(appDidLoad, 30)));
     }
   }
   // Fallback appLoad event
@@ -2236,8 +2265,8 @@ const addHostEventListeners = (e, t, n, s) => {
       const l = e;
       const i = hostListenerProxy(t, o);
       const c = hostListenerOpts(n);
-      T.ael(l, s, i, c);
-      (t._$$rmListeners$$_ = t._$$rmListeners$$_ || []).push((() => T.rel(l, s, i, c)));
+      R.ael(l, s, i, c);
+      (t._$$rmListeners$$_ = t._$$rmListeners$$_ || []).push((() => R.rel(l, s, i, c)));
     }));
   }
 };
@@ -2267,20 +2296,20 @@ const hostListenerOpts = e => (e & 2 /* LISTENER_FLAGS.Capture */) !== 0
  * @returns void
  */;
 
-const setNonce = e => T._$$nonce$$_ = e
+const setNonce = e => R._$$nonce$$_ = e
 /**
  * A WeakMap mapping runtime component references to their corresponding host reference
  * instances.
  */;
 
-const g =  new WeakMap;
+const S =  new WeakMap;
 
 /**
  * Given a {@link d.RuntimeRef} retrieve the corresponding {@link d.HostRef}
  *
  * @param ref the runtime ref of interest
  * @returns the Host reference (if found) or undefined
- */ const getHostRef = e => g.get(e)
+ */ const getHostRef = e => S.get(e)
 /**
  * Register a lazy instance with the {@link hostRefs} object so it's
  * corresponding {@link d.HostRef} can be retrieved later.
@@ -2290,7 +2319,7 @@ const g =  new WeakMap;
  * @returns a reference to the host ref WeakMap
  */;
 
-const registerInstance = (e, t) => g.set(t._$$lazyInstance$$_ = e, t)
+const registerInstance = (e, t) => S.set(t._$$lazyInstance$$_ = e, t)
 /**
  * Register a host element for a Stencil component, setting up various metadata
  * and callbacks based on {@link BUILD} flags as well as the component's runtime
@@ -2317,20 +2346,20 @@ const registerHost = (e, t) => {
     e["s-rc"] = [];
   }
   addHostEventListeners(e, n, t._$$listeners$$_);
-  return g.set(e, n);
+  return S.set(e, n);
 };
 
 const isMemberInElement = (e, t) => t in e;
 
 const consoleError = (e, t) => (0, console.error)(e, t);
 
-const w =  new Map;
+const C =  new Map;
 
 const loadModule = (e, t, n) => {
   // loadModuleImport
   const s = e._$$tagName$$_.replace(/-/g, "_");
   const o = e._$$lazyBundleId$$_;
-  const l = w.get(o);
+  const l = C.get(o);
   if (l) {
     return l[s];
   }
@@ -2341,21 +2370,21 @@ const loadModule = (e, t, n) => {
   /* webpackMode: "lazy" */
   `./${o}.entry.js${""}`).then((e => {
     {
-      w.set(o, e);
+      C.set(o, e);
     }
     return e[s];
   }), consoleError);
 };
 
-const S =  new Map;
+const k =  new Map;
 
-const C = typeof window !== "undefined" ? window : {};
+const T = typeof window !== "undefined" ? window : {};
 
-const k = C.document || {
+const L = T.document || {
   head: {}
 };
 
-const T = {
+const R = {
   _$$flags$$_: 0,
   _$$resourcesUrl$$_: "",
   jmp: e => e(),
@@ -2367,7 +2396,7 @@ const T = {
 
 const promiseResolve = e => Promise.resolve(e);
 
-const L =  (() => {
+const D =  (() => {
   try {
     new CSSStyleSheet;
     return typeof (new CSSStyleSheet).replaceSync === "function";
@@ -2375,18 +2404,18 @@ const L =  (() => {
   return false;
 })();
 
-const R = [];
+const j = [];
 
-const D = [];
+const x = [];
 
 const queueTask = (e, t) => n => {
   e.push(n);
   if (!r) {
     r = true;
-    if (t && T._$$flags$$_ & 4 /* PLATFORM_FLAGS.queueSync */) {
+    if (t && R._$$flags$$_ & 4 /* PLATFORM_FLAGS.queueSync */) {
       nextTick(flush);
     } else {
-      T.raf(flush);
+      R.raf(flush);
     }
   }
 };
@@ -2406,21 +2435,21 @@ const flush = () => {
   // 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(R);
+  consume(j);
   // DOM WRITES!!!
     {
-    consume(D);
-    if (r = R.length > 0) {
+    consume(x);
+    if (r = j.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
-      T.raf(flush);
+      R.raf(flush);
     }
   }
 };
 
 const nextTick = e => promiseResolve().then(e);
 
-const x =  queueTask(D, true);
+const O =  queueTask(x, true);
 
-export { p as H, getAssetPath as a, bootstrapLazy as b, createEvent as c, getElement as g, h, promiseResolve as p, registerInstance as r, setNonce as s };
-//# sourceMappingURL=p-49712340.js.map
+export { m as H, getAssetPath as a, bootstrapLazy as b, createEvent as c, getElement as g, h, promiseResolve as p, registerInstance as r, setNonce as s };
+//# sourceMappingURL=p-2cf37639.js.map