@xplortech/apollo-core 2.11.0 → 2.12.0

package/dist/esm/{index-CXkZUm1c.js → index-ukZKsqqq.js}

@@ -9,6 +9,30 @@ const BUILD = /* apollo-core */ { hotModuleReplacement: false, hydratedSelectorN
 // src/utils/constants.ts
 var SVG_NS = "http://www.w3.org/2000/svg";
 var HTML_NS = "http://www.w3.org/1999/xhtml";
+var PrimitiveType = /* @__PURE__ */ ((PrimitiveType2) => {
+  PrimitiveType2["Undefined"] = "undefined";
+  PrimitiveType2["Null"] = "null";
+  PrimitiveType2["String"] = "string";
+  PrimitiveType2["Number"] = "number";
+  PrimitiveType2["SpecialNumber"] = "number";
+  PrimitiveType2["Boolean"] = "boolean";
+  PrimitiveType2["BigInt"] = "bigint";
+  return PrimitiveType2;
+})(PrimitiveType || {});
+var NonPrimitiveType = /* @__PURE__ */ ((NonPrimitiveType2) => {
+  NonPrimitiveType2["Array"] = "array";
+  NonPrimitiveType2["Date"] = "date";
+  NonPrimitiveType2["Map"] = "map";
+  NonPrimitiveType2["Object"] = "object";
+  NonPrimitiveType2["RegularExpression"] = "regexp";
+  NonPrimitiveType2["Set"] = "set";
+  NonPrimitiveType2["Channel"] = "channel";
+  NonPrimitiveType2["Symbol"] = "symbol";
+  return NonPrimitiveType2;
+})(NonPrimitiveType || {});
+var TYPE_CONSTANT = "type";
+var VALUE_CONSTANT = "value";
+var SERIALIZED_PREFIX = "serialized:";
 
 // src/utils/get-prop-descriptor.ts
 function getPropertyDescriptor(obj, memberName, getOnly) {
@@ -120,6 +144,18 @@ var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
                     return import(
                       /* webpackMode: "lazy" */
                       './xpl-application-shell.entry.js').then(processMod, consoleError);
+                case 'xpl-banner':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-banner.entry.js').then(processMod, consoleError);
+                case 'xpl-breadcrumb-item':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-breadcrumb-item.entry.js').then(processMod, consoleError);
+                case 'xpl-breadcrumbs':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-breadcrumbs.entry.js').then(processMod, consoleError);
                 case 'xpl-button-row':
                     return import(
                       /* webpackMode: "lazy" */
@@ -128,6 +164,22 @@ var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
                     return import(
                       /* webpackMode: "lazy" */
                       './xpl-calendar.entry.js').then(processMod, consoleError);
+                case 'xpl-choicelist':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-choicelist.entry.js').then(processMod, consoleError);
+                case 'xpl-content-area':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-content-area.entry.js').then(processMod, consoleError);
+                case 'xpl-dashboard':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-dashboard.entry.js').then(processMod, consoleError);
+                case 'xpl-data-card':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-data-card.entry.js').then(processMod, consoleError);
                 case 'xpl-dynamic-table':
                     return import(
                       /* webpackMode: "lazy" */
@@ -148,14 +200,90 @@ var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
                     return import(
                       /* webpackMode: "lazy" */
                       './xpl-grid-item.entry.js').then(processMod, consoleError);
+                case 'xpl-header-accordion':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-header-accordion.entry.js').then(processMod, consoleError);
                 case 'xpl-large-card':
                     return import(
                       /* webpackMode: "lazy" */
                       './xpl-large-card.entry.js').then(processMod, consoleError);
+                case 'xpl-list':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-list.entry.js').then(processMod, consoleError);
                 case 'xpl-main-nav':
                     return import(
                       /* webpackMode: "lazy" */
                       './xpl-main-nav.entry.js').then(processMod, consoleError);
+                case 'xpl-modal':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-modal.entry.js').then(processMod, consoleError);
+                case 'xpl-nav-header-menu':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-nav-header-menu.entry.js').then(processMod, consoleError);
+                case 'xpl-nav-item':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-nav-item.entry.js').then(processMod, consoleError);
+                case 'xpl-pagination':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-pagination.entry.js').then(processMod, consoleError);
+                case 'xpl-panel':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-panel.entry.js').then(processMod, consoleError);
+                case 'xpl-progress-bar':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-progress-bar.entry.js').then(processMod, consoleError);
+                case 'xpl-progress-indicator':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-progress-indicator.entry.js').then(processMod, consoleError);
+                case 'xpl-secondary-nav':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-secondary-nav.entry.js').then(processMod, consoleError);
+                case 'xpl-side-nav-header-item':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-side-nav-header-item.entry.js').then(processMod, consoleError);
+                case 'xpl-side-nav-item':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-side-nav-item.entry.js').then(processMod, consoleError);
+                case 'xpl-side-nav-section':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-side-nav-section.entry.js').then(processMod, consoleError);
+                case 'xpl-skeleton':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-skeleton.entry.js').then(processMod, consoleError);
+                case 'xpl-slideout':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-slideout.entry.js').then(processMod, consoleError);
+                case 'xpl-spotlight':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-spotlight.entry.js').then(processMod, consoleError);
+                case 'xpl-tab':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-tab.entry.js').then(processMod, consoleError);
+                case 'xpl-tab-panel':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-tab-panel.entry.js').then(processMod, consoleError);
+                case 'xpl-table':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-table.entry.js').then(processMod, consoleError);
                 case 'xpl-table-header':
                     return import(
                       /* webpackMode: "lazy" */
@@ -164,6 +292,14 @@ var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
                     return import(
                       /* webpackMode: "lazy" */
                       './xpl-table-header-cell.entry.js').then(processMod, consoleError);
+                case 'xpl-tabs':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-tabs.entry.js').then(processMod, consoleError);
+                case 'xpl-toast':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-toast.entry.js').then(processMod, consoleError);
                 case 'xpl-toggle':
                     return import(
                       /* webpackMode: "lazy" */
@@ -172,14 +308,86 @@ var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
                     return import(
                       /* webpackMode: "lazy" */
                       './xpl-toolbar.entry.js').then(processMod, consoleError);
+                case 'xpl-top-nav':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-top-nav.entry.js').then(processMod, consoleError);
                 case 'xpl-top-nav-menu':
                     return import(
                       /* webpackMode: "lazy" */
                       './xpl-top-nav-menu.entry.js').then(processMod, consoleError);
-                case 'xpl-avatar_54':
+                case 'xpl-utility-bar':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-utility-bar.entry.js').then(processMod, consoleError);
+                case 'xpl-list-item':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-list-item.entry.js').then(processMod, consoleError);
+                case 'xpl-popover':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-popover.entry.js').then(processMod, consoleError);
+                case 'xpl-backdrop':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-backdrop.entry.js').then(processMod, consoleError);
+                case 'xpl-badge':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-badge.entry.js').then(processMod, consoleError);
+                case 'xpl-checkbox':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-checkbox.entry.js').then(processMod, consoleError);
+                case 'xpl-button':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-button.entry.js').then(processMod, consoleError);
+                case 'xpl-side-nav':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-side-nav.entry.js').then(processMod, consoleError);
+                case 'xpl-tooltip':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-tooltip.entry.js').then(processMod, consoleError);
+                case 'xpl-select_2':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-select_2.entry.js').then(processMod, consoleError);
+                case 'xpl-top-nav-item':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-top-nav-item.entry.js').then(processMod, consoleError);
+                case 'xpl-input-color':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-input-color.entry.js').then(processMod, consoleError);
+                case 'xpl-input-time':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-input-time.entry.js').then(processMod, consoleError);
+                case 'xpl-avatar_3':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-avatar_3.entry.js').then(processMod, consoleError);
+                case 'xpl-input-phone':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-input-phone.entry.js').then(processMod, consoleError);
+                case 'xpl-input_4':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-input_4.entry.js').then(processMod, consoleError);
+                case 'xpl-dropdown_4':
+                    return import(
+                      /* webpackMode: "lazy" */
+                      './xpl-dropdown_4.entry.js').then(processMod, consoleError);
+                case 'xpl-icon':
                     return import(
                       /* webpackMode: "lazy" */
-                      './xpl-avatar_54.entry.js').then(processMod, consoleError);
+                      './xpl-icon.entry.js').then(processMod, consoleError);
           }
       }
   return import(
@@ -203,6 +411,16 @@ var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
 
 // src/client/client-style.ts
 var styles = /* @__PURE__ */ new Map();
+
+// src/runtime/runtime-constants.ts
+var CONTENT_REF_ID = "r";
+var ORG_LOCATION_ID = "o";
+var SLOT_NODE_ID = "s";
+var TEXT_NODE_ID = "t";
+var COMMENT_NODE_ID = "c";
+var HYDRATE_ID = "s-id";
+var HYDRATED_STYLE_ID = "sty-id";
+var HYDRATE_CHILD_ID = "c-id";
 var HYDRATED_CSS = "{visibility:hidden}.hydrated{visibility:inherit}";
 var SLOT_FB_CSS = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
 var XLINK_NS = "http://www.w3.org/1999/xlink";
@@ -351,6 +569,34 @@ var isNodeLocatedInSlot = (nodeToRelocate, slotName) => {
   }
   return slotName === "";
 };
+var addSlotRelocateNode = (newChild, slotNode, prepend, position) => {
+  if (newChild["s-ol"] && newChild["s-ol"].isConnected) {
+    return;
+  }
+  const slottedNodeLocation = document.createTextNode("");
+  slottedNodeLocation["s-nr"] = newChild;
+  if (!slotNode["s-cr"] || !slotNode["s-cr"].parentNode) return;
+  const parent = slotNode["s-cr"].parentNode;
+  const appendMethod = internalCall(parent, "appendChild");
+  if (typeof position !== "undefined") {
+    slottedNodeLocation["s-oo"] = position;
+    const childNodes = internalCall(parent, "childNodes");
+    const slotRelocateNodes = [slottedNodeLocation];
+    childNodes.forEach((n) => {
+      if (n["s-nr"]) slotRelocateNodes.push(n);
+    });
+    slotRelocateNodes.sort((a, b) => {
+      if (!a["s-oo"] || a["s-oo"] < (b["s-oo"] || 0)) return -1;
+      else if (!b["s-oo"] || b["s-oo"] < a["s-oo"]) return 1;
+      return 0;
+    });
+    slotRelocateNodes.forEach((n) => appendMethod.call(parent, n));
+  } else {
+    appendMethod.call(parent, slottedNodeLocation);
+  }
+  newChild["s-ol"] = slottedNodeLocation;
+  newChild["s-sh"] = slotNode["s-hn"];
+};
 var getSlotName = (node) => typeof node["s-sn"] === "string" ? node["s-sn"] : node.nodeType === 1 && node.getAttribute("slot") || void 0;
 function patchSlotNode(node) {
   if (node.assignedElements || node.assignedNodes || !node["s-sr"]) return;
@@ -454,7 +700,10 @@ var addStyle = (styleContainerNode, cmpMeta, mode) => {
       if (!appliedStyles) {
         rootAppliedStyles.set(styleContainerNode, appliedStyles = /* @__PURE__ */ new Set());
       }
-      if (!appliedStyles.has(scopeId2)) {
+      const existingStyleElm = styleContainerNode.querySelector(`[${HYDRATED_STYLE_ID}="${scopeId2}"]`);
+      if (existingStyleElm) {
+        existingStyleElm.textContent = style;
+      } else if (!appliedStyles.has(scopeId2)) {
         styleElm = win.document.createElement("style");
         styleElm.textContent = style;
         const nonce = (_a = plt.$nonce$) != null ? _a : queryNonceMetaTagContent(win.document);
@@ -523,6 +772,12 @@ var addStyle = (styleContainerNode, cmpMeta, mode) => {
           styleContainerNode.adoptedStyleSheets = [...styleContainerNode.adoptedStyleSheets, stylesheet];
         }
         appliedStyles.add(scopeId2);
+        if ("host" in styleContainerNode) {
+          const ssrStyleElm = styleContainerNode.querySelector(`[${HYDRATED_STYLE_ID}="${scopeId2}"]`);
+          if (ssrStyleElm) {
+            writeTask(() => ssrStyleElm.remove());
+          }
+        }
       }
     }
   }
@@ -660,6 +915,353 @@ var convertToPrivate = (node) => {
   return vnode;
 };
 
+// src/runtime/client-hydrate.ts
+var initializeClientHydrate = (hostElm, tagName, hostId, hostRef) => {
+  var _a, _b, _c, _d;
+  const endHydrate = createTime("hydrateClient", tagName);
+  const shadowRoot = hostElm.shadowRoot;
+  const childRenderNodes = [];
+  const slotNodes = [];
+  const slottedNodes = [];
+  const shadowRootNodes = null;
+  const vnode = newVNode(tagName, null);
+  vnode.$elm$ = hostElm;
+  if (win.document && (!plt.$orgLocNodes$ || !plt.$orgLocNodes$.size)) {
+    initializeDocumentHydrate(win.document.body, plt.$orgLocNodes$ = /* @__PURE__ */ new Map());
+  }
+  hostElm[HYDRATE_ID] = hostId;
+  hostElm.removeAttribute(HYDRATE_ID);
+  hostRef.$vnode$ = clientHydrate(
+    vnode,
+    childRenderNodes,
+    slotNodes,
+    shadowRootNodes,
+    hostElm,
+    hostElm,
+    hostId,
+    slottedNodes
+  );
+  let crIndex = 0;
+  const crLength = childRenderNodes.length;
+  let childRenderNode;
+  for (crIndex; crIndex < crLength; crIndex++) {
+    childRenderNode = childRenderNodes[crIndex];
+    const orgLocationId = childRenderNode.$hostId$ + "." + childRenderNode.$nodeId$;
+    const orgLocationNode = plt.$orgLocNodes$.get(orgLocationId);
+    const node = childRenderNode.$elm$;
+    if (!shadowRoot) {
+      node["s-hn"] = transformTag(tagName).toUpperCase();
+      if (childRenderNode.$tag$ === "slot") {
+        node["s-cr"] = hostElm["s-cr"];
+      }
+    } else if (((_a = childRenderNode.$tag$) == null ? void 0 : _a.toString().includes("-")) && childRenderNode.$tag$ !== "slot-fb" && !childRenderNode.$elm$.shadowRoot) {
+      const cmpMeta = getHostRef(childRenderNode.$elm$);
+      if (cmpMeta) {
+        const scopeId3 = getScopeId(
+          cmpMeta.$cmpMeta$);
+        const styleSheet = win.document.querySelector(`style[sty-id="${scopeId3}"]`);
+        if (styleSheet) {
+          shadowRootNodes.unshift(styleSheet.cloneNode(true));
+        }
+      }
+    }
+    if (childRenderNode.$tag$ === "slot") {
+      childRenderNode.$name$ = childRenderNode.$elm$["s-sn"] || childRenderNode.$elm$["name"] || null;
+      if (childRenderNode.$children$) {
+        childRenderNode.$flags$ |= 2 /* isSlotFallback */;
+        if (!childRenderNode.$elm$.childNodes.length) {
+          childRenderNode.$children$.forEach((c) => {
+            childRenderNode.$elm$.appendChild(c.$elm$);
+          });
+        }
+      } else {
+        childRenderNode.$flags$ |= 1 /* isSlotReference */;
+      }
+    }
+    if (orgLocationNode && orgLocationNode.isConnected) {
+      if (orgLocationNode.parentElement.shadowRoot && orgLocationNode["s-en"] === "") {
+        orgLocationNode.parentNode.insertBefore(node, orgLocationNode.nextSibling);
+      }
+      orgLocationNode.parentNode.removeChild(orgLocationNode);
+      if (!shadowRoot) {
+        node["s-oo"] = parseInt(childRenderNode.$nodeId$);
+      }
+    }
+    if (orgLocationNode && !orgLocationNode["s-id"]) {
+      plt.$orgLocNodes$.delete(orgLocationId);
+    }
+  }
+  const hosts = [];
+  const snLen = slottedNodes.length;
+  let snIndex = 0;
+  let slotGroup;
+  let snGroupIdx;
+  let snGroupLen;
+  let slottedItem;
+  let currentPos = 0;
+  for (snIndex; snIndex < snLen; snIndex++) {
+    slotGroup = slottedNodes[snIndex];
+    if (!slotGroup || !slotGroup.length) continue;
+    snGroupLen = slotGroup.length;
+    snGroupIdx = 0;
+    for (snGroupIdx; snGroupIdx < snGroupLen; snGroupIdx++) {
+      slottedItem = slotGroup[snGroupIdx];
+      if (!hosts[slottedItem.hostId]) {
+        hosts[slottedItem.hostId] = plt.$orgLocNodes$.get(slottedItem.hostId);
+      }
+      if (!hosts[slottedItem.hostId]) continue;
+      const hostEle = hosts[slottedItem.hostId];
+      if (hostEle.shadowRoot && slottedItem.node.parentElement !== hostEle) {
+        hostEle.insertBefore(slottedItem.node, (_c = (_b = slotGroup[snGroupIdx - 1]) == null ? void 0 : _b.node) == null ? void 0 : _c.nextSibling);
+      }
+      if (!hostEle.shadowRoot || !shadowRoot) {
+        if (!slottedItem.slot["s-cr"]) {
+          slottedItem.slot["s-cr"] = hostEle["s-cr"];
+          if (!slottedItem.slot["s-cr"] && hostEle.shadowRoot) {
+            slottedItem.slot["s-cr"] = hostEle;
+          } else {
+            slottedItem.slot["s-cr"] = (hostEle.__childNodes || hostEle.childNodes)[0];
+          }
+        }
+        addSlotRelocateNode(slottedItem.node, slottedItem.slot, false, slottedItem.node["s-oo"] || currentPos);
+        if (((_d = slottedItem.node.parentElement) == null ? void 0 : _d.shadowRoot) && slottedItem.node["getAttribute"] && slottedItem.node.getAttribute("slot")) {
+          slottedItem.node.removeAttribute("slot");
+        }
+      }
+      currentPos = (slottedItem.node["s-oo"] || currentPos) + 1;
+    }
+  }
+  hostRef.$hostElement$ = hostElm;
+  endHydrate();
+};
+var clientHydrate = (parentVNode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, node, hostId, slottedNodes = []) => {
+  let childNodeType;
+  let childIdSplt;
+  let childVNode;
+  let i2;
+  if (node.nodeType === 1 /* ElementNode */) {
+    childNodeType = node.getAttribute(HYDRATE_CHILD_ID);
+    if (childNodeType) {
+      childIdSplt = childNodeType.split(".");
+      if (childIdSplt[0] === hostId || childIdSplt[0] === "0") {
+        childVNode = createSimpleVNode({
+          $flags$: 0,
+          $hostId$: childIdSplt[0],
+          $nodeId$: childIdSplt[1],
+          $depth$: childIdSplt[2],
+          $index$: childIdSplt[3],
+          $tag$: node.tagName.toLowerCase(),
+          $elm$: node,
+          // If we don't add the initial classes to the VNode, the first `vdom-render.ts` patch
+          // won't try to reconcile them. Classes set on the node will be blown away.
+          $attrs$: { class: node.className || "" }
+        });
+        childRenderNodes.push(childVNode);
+        node.removeAttribute(HYDRATE_CHILD_ID);
+        if (!parentVNode.$children$) {
+          parentVNode.$children$ = [];
+        }
+        const slotName = childVNode.$elm$.getAttribute("s-sn");
+        if (typeof slotName === "string") {
+          if (childVNode.$tag$ === "slot-fb") {
+            addSlot(
+              slotName,
+              childIdSplt[2],
+              childVNode,
+              node,
+              parentVNode,
+              childRenderNodes,
+              slotNodes,
+              shadowRootNodes,
+              slottedNodes
+            );
+          }
+          childVNode.$elm$["s-sn"] = slotName;
+          childVNode.$elm$.removeAttribute("s-sn");
+        }
+        if (childVNode.$index$ !== void 0) {
+          parentVNode.$children$[childVNode.$index$] = childVNode;
+        }
+        parentVNode = childVNode;
+      }
+    }
+    if (node.shadowRoot) {
+      for (i2 = node.shadowRoot.childNodes.length - 1; i2 >= 0; i2--) {
+        clientHydrate(
+          parentVNode,
+          childRenderNodes,
+          slotNodes,
+          shadowRootNodes,
+          hostElm,
+          node.shadowRoot.childNodes[i2],
+          hostId,
+          slottedNodes
+        );
+      }
+    }
+    const nonShadowNodes = node.__childNodes || node.childNodes;
+    for (i2 = nonShadowNodes.length - 1; i2 >= 0; i2--) {
+      clientHydrate(
+        parentVNode,
+        childRenderNodes,
+        slotNodes,
+        shadowRootNodes,
+        hostElm,
+        nonShadowNodes[i2],
+        hostId,
+        slottedNodes
+      );
+    }
+  } else if (node.nodeType === 8 /* CommentNode */) {
+    childIdSplt = node.nodeValue.split(".");
+    if (childIdSplt[1] === hostId || childIdSplt[1] === "0") {
+      childNodeType = childIdSplt[0];
+      childVNode = createSimpleVNode({
+        $hostId$: childIdSplt[1],
+        $nodeId$: childIdSplt[2],
+        $depth$: childIdSplt[3],
+        $index$: childIdSplt[4] || "0",
+        $elm$: node,
+        $attrs$: null,
+        $children$: null,
+        $key$: null,
+        $name$: null,
+        $tag$: null,
+        $text$: null
+      });
+      if (childNodeType === TEXT_NODE_ID) {
+        childVNode.$elm$ = findCorrespondingNode(node, 3 /* TextNode */);
+        if (childVNode.$elm$ && childVNode.$elm$.nodeType === 3 /* TextNode */) {
+          childVNode.$text$ = childVNode.$elm$.textContent;
+          childRenderNodes.push(childVNode);
+          node.remove();
+          if (hostId === childVNode.$hostId$) {
+            if (!parentVNode.$children$) {
+              parentVNode.$children$ = [];
+            }
+            parentVNode.$children$[childVNode.$index$] = childVNode;
+          }
+        }
+      } else if (childNodeType === COMMENT_NODE_ID) {
+        childVNode.$elm$ = findCorrespondingNode(node, 8 /* CommentNode */);
+        if (childVNode.$elm$ && childVNode.$elm$.nodeType === 8 /* CommentNode */) {
+          childRenderNodes.push(childVNode);
+          node.remove();
+        }
+      } else if (childVNode.$hostId$ === hostId) {
+        if (childNodeType === SLOT_NODE_ID) {
+          const slotName = node["s-sn"] = childIdSplt[5] || "";
+          addSlot(
+            slotName,
+            childIdSplt[2],
+            childVNode,
+            node,
+            parentVNode,
+            childRenderNodes,
+            slotNodes,
+            shadowRootNodes,
+            slottedNodes
+          );
+        } else if (childNodeType === CONTENT_REF_ID) {
+          {
+            hostElm["s-cr"] = node;
+            node["s-cn"] = true;
+          }
+        }
+      }
+    }
+  } else if (parentVNode && parentVNode.$tag$ === "style") {
+    const vnode = newVNode(null, node.textContent);
+    vnode.$elm$ = node;
+    vnode.$index$ = "0";
+    parentVNode.$children$ = [vnode];
+  }
+  return parentVNode;
+};
+var initializeDocumentHydrate = (node, orgLocNodes) => {
+  if (node.nodeType === 1 /* ElementNode */) {
+    const componentId = node[HYDRATE_ID] || node.getAttribute(HYDRATE_ID);
+    if (componentId) {
+      orgLocNodes.set(componentId, node);
+    }
+    let i2 = 0;
+    if (node.shadowRoot) {
+      for (; i2 < node.shadowRoot.childNodes.length; i2++) {
+        initializeDocumentHydrate(node.shadowRoot.childNodes[i2], orgLocNodes);
+      }
+    }
+    const nonShadowNodes = node.__childNodes || node.childNodes;
+    for (i2 = 0; i2 < nonShadowNodes.length; i2++) {
+      initializeDocumentHydrate(nonShadowNodes[i2], orgLocNodes);
+    }
+  } else if (node.nodeType === 8 /* CommentNode */) {
+    const childIdSplt = node.nodeValue.split(".");
+    if (childIdSplt[0] === ORG_LOCATION_ID) {
+      orgLocNodes.set(childIdSplt[1] + "." + childIdSplt[2], node);
+      node.nodeValue = "";
+      node["s-en"] = childIdSplt[3];
+    }
+  }
+};
+var createSimpleVNode = (vnode) => {
+  const defaultVNode = {
+    $flags$: 0,
+    $hostId$: null,
+    $nodeId$: null,
+    $depth$: null,
+    $index$: "0",
+    $elm$: null,
+    $attrs$: null,
+    $children$: null,
+    $key$: null,
+    $name$: null,
+    $tag$: null,
+    $text$: null
+  };
+  return { ...defaultVNode, ...vnode };
+};
+function addSlot(slotName, slotId, childVNode, node, parentVNode, childRenderNodes, slotNodes, shadowRootNodes, slottedNodes) {
+  node["s-sr"] = true;
+  childVNode.$name$ = slotName || null;
+  childVNode.$tag$ = "slot";
+  const parentNodeId = (parentVNode == null ? void 0 : parentVNode.$elm$) ? parentVNode.$elm$["s-id"] || parentVNode.$elm$.getAttribute("s-id") : "";
+  {
+    const slot = childVNode.$elm$;
+    const shouldMove = parentNodeId && parentNodeId !== childVNode.$hostId$ && parentVNode.$elm$.shadowRoot;
+    addSlottedNodes(slottedNodes, slotId, slotName, node, shouldMove ? parentNodeId : childVNode.$hostId$);
+    patchSlotNode(node);
+    if (shouldMove) {
+      parentVNode.$elm$.insertBefore(slot, parentVNode.$elm$.children[0]);
+    }
+  }
+  childRenderNodes.push(childVNode);
+  slotNodes.push(childVNode);
+  if (!parentVNode.$children$) {
+    parentVNode.$children$ = [];
+  }
+  parentVNode.$children$[childVNode.$index$] = childVNode;
+}
+var addSlottedNodes = (slottedNodes, slotNodeId, slotName, slotNode, hostId) => {
+  var _a, _b;
+  let slottedNode = slotNode.nextSibling;
+  slottedNodes[slotNodeId] = slottedNodes[slotNodeId] || [];
+  if (!slottedNode || ((_a = slottedNode.nodeValue) == null ? void 0 : _a.startsWith(SLOT_NODE_ID + "."))) return;
+  do {
+    if (slottedNode && ((slottedNode["getAttribute"] && slottedNode.getAttribute("slot") || slottedNode["s-sn"]) === slotName || slotName === "" && !slottedNode["s-sn"] && (!slottedNode["getAttribute"] || !slottedNode.getAttribute("slot")) && (slottedNode.nodeType === 8 /* CommentNode */ || slottedNode.nodeType === 3 /* TextNode */))) {
+      slottedNode["s-sn"] = slotName;
+      slottedNodes[slotNodeId].push({ slot: slotNode, node: slottedNode, hostId });
+    }
+    slottedNode = slottedNode == null ? void 0 : slottedNode.nextSibling;
+  } while (slottedNode && !((_b = slottedNode.nodeValue) == null ? void 0 : _b.startsWith(SLOT_NODE_ID + ".")));
+};
+var findCorrespondingNode = (node, type) => {
+  let sibling = node;
+  do {
+    sibling = sibling.nextSibling;
+  } while (sibling && (sibling.nodeType !== type || !sibling.nodeValue));
+  return sibling;
+};
+
 // src/runtime/normalize-watchers.ts
 var normalizeWatchers = (raw) => {
   if (!raw) return void 0;
@@ -685,8 +1287,123 @@ var normalizeWatchers = (raw) => {
   return out;
 };
 
+// src/utils/remote-value.ts
+var RemoteValue = class _RemoteValue {
+  /**
+   * Deserializes a LocalValue serialized object back to its original JavaScript representation
+   *
+   * @param serialized The serialized LocalValue object
+   * @returns The original JavaScript value/object
+   */
+  static fromLocalValue(serialized) {
+    const type = serialized[TYPE_CONSTANT];
+    const value = VALUE_CONSTANT in serialized ? serialized[VALUE_CONSTANT] : void 0;
+    switch (type) {
+      case "string" /* String */:
+        return value;
+      case "boolean" /* Boolean */:
+        return value;
+      case "bigint" /* BigInt */:
+        return BigInt(value);
+      case "undefined" /* Undefined */:
+        return void 0;
+      case "null" /* Null */:
+        return null;
+      case "number" /* Number */:
+        if (value === "NaN") return NaN;
+        if (value === "-0") return -0;
+        if (value === "Infinity") return Infinity;
+        if (value === "-Infinity") return -Infinity;
+        return value;
+      case "array" /* Array */:
+        return value.map((item) => _RemoteValue.fromLocalValue(item));
+      case "date" /* Date */:
+        return new Date(value);
+      case "map" /* Map */:
+        const map = /* @__PURE__ */ new Map();
+        for (const [key, val] of value) {
+          const deserializedKey = typeof key === "object" && key !== null ? _RemoteValue.fromLocalValue(key) : key;
+          const deserializedValue = _RemoteValue.fromLocalValue(val);
+          map.set(deserializedKey, deserializedValue);
+        }
+        return map;
+      case "object" /* Object */:
+        const obj = {};
+        for (const [key, val] of value) {
+          obj[key] = _RemoteValue.fromLocalValue(val);
+        }
+        return obj;
+      case "regexp" /* RegularExpression */:
+        const { pattern, flags } = value;
+        return new RegExp(pattern, flags);
+      case "set" /* Set */:
+        const set = /* @__PURE__ */ new Set();
+        for (const item of value) {
+          set.add(_RemoteValue.fromLocalValue(item));
+        }
+        return set;
+      case "symbol" /* Symbol */:
+        return Symbol(value);
+      default:
+        throw new Error(`Unsupported type: ${type}`);
+    }
+  }
+  /**
+   * Utility method to deserialize multiple LocalValues at once
+   *
+   * @param serializedValues Array of serialized LocalValue objects
+   * @returns Array of deserialized JavaScript values
+   */
+  static fromLocalValueArray(serializedValues) {
+    return serializedValues.map((value) => _RemoteValue.fromLocalValue(value));
+  }
+  /**
+   * Verifies if the given object matches the structure of a serialized LocalValue
+   *
+   * @param obj Object to verify
+   * @returns boolean indicating if the object has LocalValue structure
+   */
+  static isLocalValueObject(obj) {
+    if (typeof obj !== "object" || obj === null) {
+      return false;
+    }
+    if (!obj.hasOwnProperty(TYPE_CONSTANT)) {
+      return false;
+    }
+    const type = obj[TYPE_CONSTANT];
+    const hasTypeProperty = Object.values({ ...PrimitiveType, ...NonPrimitiveType }).includes(type);
+    if (!hasTypeProperty) {
+      return false;
+    }
+    if (type !== "null" /* Null */ && type !== "undefined" /* Undefined */) {
+      return obj.hasOwnProperty(VALUE_CONSTANT);
+    }
+    return true;
+  }
+};
+
+// src/utils/serialize.ts
+function decodeBase64Unicode(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i2 = 0; i2 < binary.length; i2++) {
+    bytes[i2] = binary.charCodeAt(i2);
+  }
+  return new TextDecoder().decode(bytes);
+}
+function deserializeProperty(value) {
+  if (typeof value !== "string" || !value.startsWith(SERIALIZED_PREFIX)) {
+    return value;
+  }
+  return RemoteValue.fromLocalValue(JSON.parse(decodeBase64Unicode(value.slice(SERIALIZED_PREFIX.length))));
+}
+
 // src/runtime/parse-property-value.ts
 var parsePropertyValue = (propValue, propType, isFormAssociated) => {
+  if (typeof propValue === "string" && propValue.startsWith(SERIALIZED_PREFIX)) {
+    propValue = deserializeProperty(propValue);
+    return propValue;
+  }
   if (propValue != null && !isComplexType(propValue)) {
     if (propType & 4 /* Boolean */) {
       {
@@ -737,7 +1454,15 @@ var setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags, initialRen
     const classList = elm.classList;
     const oldClasses = parseClassList(oldValue);
     let newClasses = parseClassList(newValue);
-    {
+    if ((elm["s-si"] || elm["s-sc"]) && initialRender) {
+      const scopeId2 = elm["s-sc"] || elm["s-si"];
+      newClasses.push(scopeId2);
+      oldClasses.forEach((c) => {
+        if (c.startsWith(scopeId2)) newClasses.push(c);
+      });
+      newClasses = [...new Set(newClasses)].filter((c) => c);
+      classList.add(...newClasses);
+    } else {
       classList.remove(...oldClasses.filter((c) => c && !newClasses.includes(c)));
       classList.add(...newClasses.filter((c) => c && !oldClasses.includes(c)));
     }
@@ -887,7 +1612,9 @@ var updateElement = (oldVnode, newVnode, isSvgMode2, isInitialRender) => {
           oldVnodeAttrs[memberName],
           void 0,
           isSvgMode2,
-          newVnode.$flags$);
+          newVnode.$flags$,
+          isInitialRender
+        );
       }
     }
   }
@@ -898,7 +1625,9 @@ var updateElement = (oldVnode, newVnode, isSvgMode2, isInitialRender) => {
       oldVnodeAttrs[memberName],
       newVnodeAttrs[memberName],
       isSvgMode2,
-      newVnode.$flags$);
+      newVnode.$flags$,
+      isInitialRender
+    );
   }
 };
 function sortedAttrNames(attrNames) {
@@ -1208,7 +1937,7 @@ var patch = (oldVNode, newVNode2, isInitialRender = false) => {
           relocateToHostRoot(newVNode2.$elm$.parentElement);
         }
       }
-      updateElement(oldVNode, newVNode2, isSvgMode);
+      updateElement(oldVNode, newVNode2, isSvgMode, isInitialRender);
     }
     if (oldChildren !== null && newChildren !== null) {
       updateChildren(elm, oldChildren, newVNode2, newChildren, isInitialRender);
@@ -1222,7 +1951,9 @@ var patch = (oldVNode, newVNode2, isInitialRender = false) => {
       !isInitialRender && BUILD.updatable && oldChildren !== null
     ) {
       removeVnodes(oldChildren, 0, oldChildren.length - 1);
-    } else ;
+    } else if (isInitialRender && BUILD.updatable && oldChildren !== null && newChildren === null) {
+      newVNode2.$children$ = oldChildren;
+    }
     if (isSvgMode && tag === "svg") {
       isSvgMode = false;
     }
@@ -1621,7 +2352,13 @@ var forceUpdate = (ref) => {
   }
 };
 var appDidLoad = (who) => {
+  var _a;
   nextTick(() => emitEvent(win, "appload", { detail: { namespace: NAMESPACE } }));
+  {
+    if ((_a = plt.$orgLocNodes$) == null ? void 0 : _a.size) {
+      plt.$orgLocNodes$.clear();
+    }
+  }
 };
 var safeCall = (instance, method, arg, elm) => {
   if (instance && instance[method]) {
@@ -1962,7 +2699,14 @@ var connectedCallback = (elm) => {
     const endConnected = createTime("connectedCallback", cmpMeta.$tagName$);
     if (!(hostRef.$flags$ & 1 /* hasConnected */)) {
       hostRef.$flags$ |= 1 /* hasConnected */;
+      let hostId;
       {
+        hostId = elm.getAttribute(HYDRATE_ID);
+        if (hostId) {
+          initializeClientHydrate(elm, cmpMeta.$tagName$, hostId, hostRef);
+        }
+      }
+      if (!hostId) {
         if (// TODO(STENCIL-854): Remove code related to legacy shadowDomShim field
         cmpMeta.$flags$ & (4 /* hasSlotRelocation */ | 8 /* needsShadowDomShim */)) {
           setContentReference(elm);
@@ -1971,7 +2715,7 @@ var connectedCallback = (elm) => {
       {
         let ancestorComponent = elm;
         while (ancestorComponent = ancestorComponent.parentNode || ancestorComponent.host) {
-          if (ancestorComponent["s-p"]) {
+          if (ancestorComponent.nodeType === 1 /* ElementNode */ && ancestorComponent.hasAttribute("s-id") && ancestorComponent["s-p"] || ancestorComponent["s-p"]) {
             attachToAncestor(hostRef, hostRef.$ancestorComponent$ = ancestorComponent);
             break;
           }
@@ -2057,6 +2801,9 @@ var bootstrapLazy = (lazyBundles, options = {}) => {
   let isBootstrapping = true;
   Object.assign(plt, options);
   plt.$resourcesUrl$ = new URL(options.resourcesUrl || "./", win.document.baseURI).href;
+  {
+    plt.$flags$ |= 2 /* appLoaded */;
+  }
   let hasSlotRelocation = false;
   lazyBundles.map((lazyBundle) => {
     lazyBundle[1].map((compactMeta) => {