@stencil/core 4.22.3-dev.1732597307.7bdf128 → 4.22.3-dev.1732770122.a15bc5d

package/internal/hydrate/index.js

@@ -1,5 +1,5 @@
 /*
- Stencil Hydrate Platform v4.22.3-dev.1732597307.7bdf128 | MIT Licensed | https://stenciljs.com
+ Stencil Hydrate Platform v4.22.3-dev.1732770122.a15bc5d | MIT Licensed | https://stenciljs.com
  */
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -953,8 +953,12 @@ var relocateToHostRoot = (parentElm) => {
   plt.$flags$ |= 1 /* isTmpDisconnected */;
   const host = parentElm.closest(hostTagName.toLowerCase());
   if (host != null) {
-    const contentRefNode = Array.from(host.childNodes).find((ref) => ref["s-cr"]);
-    const childNodeArray = Array.from(parentElm.childNodes);
+    const contentRefNode = Array.from(host.__childNodes || host.childNodes).find(
+      (ref) => ref["s-cr"]
+    );
+    const childNodeArray = Array.from(
+      parentElm.__childNodes || parentElm.childNodes
+    );
     for (const childNode of contentRefNode ? childNodeArray.reverse() : childNodeArray) {
       if (childNode["s-sh"] != null) {
         insertBefore(host, childNode, contentRefNode != null ? contentRefNode : null);
@@ -967,7 +971,7 @@ var relocateToHostRoot = (parentElm) => {
 };
 var putBackInOriginalLocation = (parentElm, recursive) => {
   plt.$flags$ |= 1 /* isTmpDisconnected */;
-  const oldSlotChildNodes = Array.from(parentElm.childNodes);
+  const oldSlotChildNodes = Array.from(parentElm.__childNodes || parentElm.childNodes);
   if (parentElm["s-sr"] && BUILD10.experimentalSlotFixes) {
     let node = parentElm;
     while (node = node.nextSibling) {
@@ -1188,7 +1192,7 @@ var patch = (oldVNode, newVNode2, isInitialRender = false) => {
   }
 };
 var updateFallbackSlotVisibility = (elm) => {
-  const childNodes = elm.childNodes;
+  const childNodes = elm.__childNodes || elm.childNodes;
   for (const childNode of childNodes) {
     if (childNode.nodeType === 1 /* ElementNode */) {
       if (childNode["s-sr"]) {
@@ -1219,9 +1223,10 @@ var markSlotContentForRelocation = (elm) => {
   let node;
   let hostContentNodes;
   let j;
-  for (const childNode of elm.childNodes) {
+  const children = elm.__childNodes || elm.childNodes;
+  for (const childNode of children) {
     if (childNode["s-sr"] && (node = childNode["s-cr"]) && node.parentNode) {
-      hostContentNodes = node.parentNode.childNodes;
+      hostContentNodes = node.parentNode.__childNodes || node.parentNode.childNodes;
       const slotName = childNode["s-sn"];
       for (j = hostContentNodes.length - 1; j >= 0; j--) {
         node = hostContentNodes[j];
@@ -1310,7 +1315,7 @@ var updateElementScopeIds = (element, parent, iterateChildNodes = false) => {
     if (scopeIds.size) {
       (_a = element.classList) == null ? void 0 : _a.add(...element["s-scs"] = Array.from(scopeIds));
       if (element["s-ol"] || iterateChildNodes) {
-        for (const childNode of Array.from(element.childNodes)) {
+        for (const childNode of Array.from(element.__childNodes || element.childNodes)) {
           updateElementScopeIds(childNode, element, true);
         }
       }
@@ -1428,7 +1433,8 @@ render() {
     relocateNodes.length = 0;
   }
   if (BUILD10.experimentalScopedSlotChanges && cmpMeta.$flags$ & 2 /* scopedCssEncapsulation */) {
-    for (const childNode of rootVnode.$elm$.childNodes) {
+    const children = rootVnode.$elm$.__childNodes || rootVnode.$elm$.childNodes;
+    for (const childNode of children) {
       if (childNode["s-hn"] !== hostTagName && !childNode["s-sh"]) {
         if (isInitialLoad && childNode["s-ih"] == null) {
           childNode["s-ih"] = (_e = childNode.hidden) != null ? _e : false;
@@ -1820,31 +1826,77 @@ var proxyComponent = (Cstr, cmpMeta, flags) => {
     const members = Object.entries((_a = cmpMeta.$members$) != null ? _a : {});
     members.map(([memberName, [memberFlags]]) => {
       if ((BUILD13.prop || BUILD13.state) && (memberFlags & 31 /* Prop */ || (!BUILD13.lazyLoad || flags & 2 /* proxyState */) && memberFlags & 32 /* State */)) {
-        Object.defineProperty(prototype, memberName, {
-          get() {
-            return getValue(this, memberName);
-          },
-          set(newValue) {
-            if (BUILD13.isDev) {
-              const ref = getHostRef(this);
-              if (
-                // we are proxying the instance (not element)
-                (flags & 1 /* isElementConstructor */) === 0 && // the element is not constructing
-                (ref && ref.$flags$ & 8 /* isConstructingInstance */) === 0 && // the member is a prop
-                (memberFlags & 31 /* Prop */) !== 0 && // the member is not mutable
-                (memberFlags & 1024 /* Mutable */) === 0
-              ) {
-                consoleDevWarn(
-                  `@Prop() "${memberName}" on <${cmpMeta.$tagName$}> is immutable but was modified from within the component.
+        if ((memberFlags & 2048 /* Getter */) === 0) {
+          Object.defineProperty(prototype, memberName, {
+            get() {
+              return getValue(this, memberName);
+            },
+            set(newValue) {
+              if (BUILD13.isDev) {
+                const ref = getHostRef(this);
+                if (
+                  // we are proxying the instance (not element)
+                  (flags & 1 /* isElementConstructor */) === 0 && // the element is not constructing
+                  (ref && ref.$flags$ & 8 /* isConstructingInstance */) === 0 && // the member is a prop
+                  (memberFlags & 31 /* Prop */) !== 0 && // the member is not mutable
+                  (memberFlags & 1024 /* Mutable */) === 0
+                ) {
+                  consoleDevWarn(
+                    `@Prop() "${memberName}" on <${cmpMeta.$tagName$}> is immutable but was modified from within the component.
 More information: https://stenciljs.com/docs/properties#prop-mutability`
-                );
+                  );
+                }
               }
-            }
-            setValue(this, memberName, newValue, cmpMeta);
-          },
-          configurable: true,
-          enumerable: true
-        });
+              setValue(this, memberName, newValue, cmpMeta);
+            },
+            configurable: true,
+            enumerable: true
+          });
+        } else if (flags & 1 /* isElementConstructor */ && memberFlags & 2048 /* Getter */) {
+          if (BUILD13.lazyLoad) {
+            Object.defineProperty(prototype, memberName, {
+              get() {
+                const ref = getHostRef(this);
+                const instance = BUILD13.lazyLoad && ref ? ref.$lazyInstance$ : prototype;
+                if (!instance) return;
+                return instance[memberName];
+              },
+              configurable: true,
+              enumerable: true
+            });
+          }
+          if (memberFlags & 4096 /* Setter */) {
+            const origSetter = Object.getOwnPropertyDescriptor(prototype, memberName).set;
+            Object.defineProperty(prototype, memberName, {
+              set(newValue) {
+                const ref = getHostRef(this);
+                if (origSetter) {
+                  const currentValue = ref.$hostElement$[memberName];
+                  if (!ref.$instanceValues$.get(memberName) && currentValue) {
+                    ref.$instanceValues$.set(memberName, currentValue);
+                  }
+                  origSetter.apply(this, [parsePropertyValue(newValue, cmpMeta.$members$[memberName][0])]);
+                  setValue(this, memberName, ref.$hostElement$[memberName], cmpMeta);
+                  return;
+                }
+                if (!ref) return;
+                const setterSetVal = () => {
+                  const currentValue = ref.$lazyInstance$[memberName];
+                  if (!ref.$instanceValues$.get(memberName) && currentValue) {
+                    ref.$instanceValues$.set(memberName, currentValue);
+                  }
+                  ref.$lazyInstance$[memberName] = parsePropertyValue(newValue, cmpMeta.$members$[memberName][0]);
+                  setValue(this, memberName, ref.$lazyInstance$[memberName], cmpMeta);
+                };
+                if (ref.$lazyInstance$) {
+                  setterSetVal();
+                } else {
+                  ref.$onReadyPromise$.then(() => setterSetVal());
+                }
+              }
+            });
+          }
+        }
       } else if (BUILD13.lazyLoad && BUILD13.method && flags & 1 /* isElementConstructor */ && memberFlags & 64 /* Method */) {
         Object.defineProperty(prototype, memberName, {
           value(...args) {
@@ -1885,7 +1937,10 @@ More information: https://stenciljs.com/docs/properties#prop-mutability`
             }
             return;
           }
-          this[propName] = newValue === null && typeof this[propName] === "boolean" ? false : newValue;
+          const propDesc = Object.getOwnPropertyDescriptor(prototype, propName);
+          if (!propDesc.get || !!propDesc.set) {
+            this[propName] = newValue === null && typeof this[propName] === "boolean" ? false : newValue;
+          }
         });
       };
       Cstr.observedAttributes = Array.from(
@@ -2097,7 +2152,7 @@ var disconnectedCallback = async (elm) => {
 
 // src/runtime/dom-extras.ts
 import { BUILD as BUILD17 } from "@stencil/core/internal/app-data";
-var patchPseudoShadowDom = (hostElementPrototype, descriptorPrototype) => {
+var patchPseudoShadowDom = (hostElementPrototype) => {
   patchCloneNode(hostElementPrototype);
   patchSlotAppendChild(hostElementPrototype);
   patchSlotAppend(hostElementPrototype);
@@ -2106,7 +2161,7 @@ var patchPseudoShadowDom = (hostElementPrototype, descriptorPrototype) => {
   patchSlotInsertAdjacentHTML(hostElementPrototype);
   patchSlotInsertAdjacentText(hostElementPrototype);
   patchTextContent(hostElementPrototype);
-  patchChildSlotNodes(hostElementPrototype, descriptorPrototype);
+  patchChildSlotNodes(hostElementPrototype);
   patchSlotRemoveChild(hostElementPrototype);
 };
 var patchCloneNode = (HostElementPrototype) => {
@@ -2135,9 +2190,10 @@ var patchCloneNode = (HostElementPrototype) => {
         "s-rf",
         "s-scs"
       ];
-      for (; i2 < srcNode.childNodes.length; i2++) {
-        slotted = srcNode.childNodes[i2]["s-nr"];
-        nonStencilNode = stencilPrivates.every((privateField) => !srcNode.childNodes[i2][privateField]);
+      const childNodes = this.__childNodes || this.childNodes;
+      for (; i2 < childNodes.length; i2++) {
+        slotted = childNodes[i2]["s-nr"];
+        nonStencilNode = stencilPrivates.every((privateField) => !childNodes[i2][privateField]);
         if (slotted) {
           if (BUILD17.appendChildSlotFix && clonedNode.__appendChild) {
             clonedNode.__appendChild(slotted.cloneNode(true));
@@ -2146,7 +2202,7 @@ var patchCloneNode = (HostElementPrototype) => {
           }
         }
         if (nonStencilNode) {
-          clonedNode.appendChild(srcNode.childNodes[i2].cloneNode(true));
+          clonedNode.appendChild(childNodes[i2].cloneNode(true));
         }
       }
     }
@@ -2157,13 +2213,9 @@ var patchSlotAppendChild = (HostElementPrototype) => {
   HostElementPrototype.__appendChild = HostElementPrototype.appendChild;
   HostElementPrototype.appendChild = function(newChild) {
     const slotName = newChild["s-sn"] = getSlotName(newChild);
-    const slotNode = getHostSlotNode(this.childNodes, slotName, this.tagName);
+    const slotNode = getHostSlotNode(this.__childNodes || this.childNodes, slotName, this.tagName);
     if (slotNode) {
-      const slotPlaceholder = document.createTextNode("");
-      slotPlaceholder["s-nr"] = newChild;
-      slotNode["s-cr"].parentNode.__appendChild(slotPlaceholder);
-      newChild["s-ol"] = slotPlaceholder;
-      newChild["s-sh"] = slotNode["s-hn"];
+      addSlotRelocateNode(newChild, slotNode);
       const slotChildNodes = getHostSlotChildNodes(slotNode, slotName);
       const appendAfter = slotChildNodes[slotChildNodes.length - 1];
       const insertedNode = insertBefore(appendAfter.parentNode, newChild, appendAfter.nextSibling);
@@ -2177,35 +2229,29 @@ var patchSlotRemoveChild = (ElementPrototype) => {
   ElementPrototype.__removeChild = ElementPrototype.removeChild;
   ElementPrototype.removeChild = function(toRemove) {
     if (toRemove && typeof toRemove["s-sn"] !== "undefined") {
-      const slotNode = getHostSlotNode(this.childNodes, toRemove["s-sn"], this.tagName);
-      if (slotNode) {
-        const slotChildNodes = getHostSlotChildNodes(slotNode, toRemove["s-sn"]);
-        const existingNode = slotChildNodes.find((n) => n === toRemove);
-        if (existingNode) {
-          existingNode.remove();
-          updateFallbackSlotVisibility(this);
-          return;
-        }
+      const childNodes = this.__childNodes || this.childNodes;
+      const slotNode = getHostSlotNode(childNodes, toRemove["s-sn"], this.tagName);
+      if (slotNode && toRemove.isConnected) {
+        toRemove.remove();
+        updateFallbackSlotVisibility(this);
+        return;
       }
     }
     return this.__removeChild(toRemove);
   };
 };
 var patchSlotPrepend = (HostElementPrototype) => {
-  const originalPrepend = HostElementPrototype.prepend;
+  HostElementPrototype.__prepend = HostElementPrototype.prepend;
   HostElementPrototype.prepend = function(...newChildren) {
     newChildren.forEach((newChild) => {
       if (typeof newChild === "string") {
         newChild = this.ownerDocument.createTextNode(newChild);
       }
       const slotName = newChild["s-sn"] = getSlotName(newChild);
-      const slotNode = getHostSlotNode(this.childNodes, slotName, this.tagName);
+      const childNodes = this.__childNodes || this.childNodes;
+      const slotNode = getHostSlotNode(childNodes, slotName, this.tagName);
       if (slotNode) {
-        const slotPlaceholder = document.createTextNode("");
-        slotPlaceholder["s-nr"] = newChild;
-        slotNode["s-cr"].parentNode.__appendChild(slotPlaceholder);
-        newChild["s-ol"] = slotPlaceholder;
-        newChild["s-sh"] = slotNode["s-hn"];
+        addSlotRelocateNode(newChild, slotNode, true);
         const slotChildNodes = getHostSlotChildNodes(slotNode, slotName);
         const appendAfter = slotChildNodes[0];
         return insertBefore(appendAfter.parentNode, newChild, appendAfter.nextSibling);
@@ -2213,11 +2259,12 @@ var patchSlotPrepend = (HostElementPrototype) => {
       if (newChild.nodeType === 1 && !!newChild.getAttribute("slot")) {
         newChild.hidden = true;
       }
-      return originalPrepend.call(this, newChild);
+      return HostElementPrototype.__prepend(newChild);
     });
   };
 };
 var patchSlotAppend = (HostElementPrototype) => {
+  HostElementPrototype.__append = HostElementPrototype.append;
   HostElementPrototype.append = function(...newChildren) {
     newChildren.forEach((newChild) => {
       if (typeof newChild === "string") {
@@ -2269,126 +2316,86 @@ var patchSlotInsertAdjacentElement = (HostElementPrototype) => {
   };
 };
 var patchTextContent = (hostElementPrototype) => {
-  const descriptor = Object.getOwnPropertyDescriptor(Node.prototype, "textContent");
-  Object.defineProperty(hostElementPrototype, "__textContent", descriptor);
-  if (BUILD17.experimentalScopedSlotChanges) {
-    Object.defineProperty(hostElementPrototype, "textContent", {
-      // To mimic shadow root behavior, we need to return the text content of all
-      // nodes in a slot reference node
-      get() {
-        const slotRefNodes = getAllChildSlotNodes(this.childNodes);
-        const textContent = slotRefNodes.map((node) => {
-          var _a, _b;
-          const text = [];
-          let slotContent = node.nextSibling;
-          while (slotContent && slotContent["s-sn"] === node["s-sn"]) {
-            if (slotContent.nodeType === 3 /* TEXT_NODE */ || slotContent.nodeType === 1 /* ELEMENT_NODE */) {
-              text.push((_b = (_a = slotContent.textContent) == null ? void 0 : _a.trim()) != null ? _b : "");
-            }
-            slotContent = slotContent.nextSibling;
-          }
-          return text.filter((ref) => ref !== "").join(" ");
-        }).filter((text) => text !== "").join(" ");
-        return " " + textContent + " ";
-      },
-      // To mimic shadow root behavior, we need to overwrite all nodes in a slot
-      // reference node. If a default slot reference node exists, the text content will be
-      // placed there. Otherwise, the new text node will be hidden
-      set(value) {
-        const slotRefNodes = getAllChildSlotNodes(this.childNodes);
-        slotRefNodes.forEach((node) => {
-          let slotContent = node.nextSibling;
-          while (slotContent && slotContent["s-sn"] === node["s-sn"]) {
-            const tmp = slotContent;
-            slotContent = slotContent.nextSibling;
-            tmp.remove();
-          }
-          if (node["s-sn"] === "") {
-            const textNode = this.ownerDocument.createTextNode(value);
-            textNode["s-sn"] = "";
-            insertBefore(node.parentElement, textNode, node.nextSibling);
-          } else {
-            node.remove();
-          }
-        });
-      }
-    });
-  } else {
-    Object.defineProperty(hostElementPrototype, "textContent", {
-      get() {
-        var _a;
-        const slotNode = getHostSlotNode(this.childNodes, "", this.tagName);
-        if (((_a = slotNode == null ? void 0 : slotNode.nextSibling) == null ? void 0 : _a.nodeType) === 3 /* TEXT_NODE */) {
-          return slotNode.nextSibling.textContent;
-        } else if (slotNode) {
-          return slotNode.textContent;
-        } else {
-          return this.__textContent;
-        }
-      },
-      set(value) {
-        var _a;
-        const slotNode = getHostSlotNode(this.childNodes, "", this.tagName);
-        if (((_a = slotNode == null ? void 0 : slotNode.nextSibling) == null ? void 0 : _a.nodeType) === 3 /* TEXT_NODE */) {
-          slotNode.nextSibling.textContent = value;
-        } else if (slotNode) {
-          slotNode.textContent = value;
-        } else {
-          this.__textContent = value;
-          const contentRefElm = this["s-cr"];
-          if (contentRefElm) {
-            insertBefore(this, contentRefElm, this.firstChild);
-          }
-        }
-      }
-    });
-  }
+  let descriptor = Object.getOwnPropertyDescriptor(Node.prototype, "textContent");
+  if (!descriptor) {
+    descriptor = Object.getOwnPropertyDescriptor(hostElementPrototype, "textContent");
+  }
+  if (descriptor) Object.defineProperty(hostElementPrototype, "__textContent", descriptor);
+  Object.defineProperty(hostElementPrototype, "textContent", {
+    get: function() {
+      let text = "";
+      const childNodes = this.__childNodes ? this.childNodes : getSlottedChildNodes(this.childNodes);
+      childNodes.forEach((node) => text += node.textContent || "");
+      return text;
+    },
+    set: function(value) {
+      const childNodes = this.__childNodes ? this.childNodes : getSlottedChildNodes(this.childNodes);
+      childNodes.forEach((node) => {
+        if (node["s-ol"]) node["s-ol"].remove();
+        node.remove();
+      });
+      this.insertAdjacentHTML("beforeend", value);
+    }
+  });
 };
-var patchChildSlotNodes = (elm, cmpMeta) => {
+var patchChildSlotNodes = (elm) => {
   class FakeNodeList extends Array {
     item(n) {
       return this[n];
     }
   }
-  if (cmpMeta.$flags$ & 8 /* needsShadowDomShim */) {
-    const childNodesFn = elm.__lookupGetter__("childNodes");
-    Object.defineProperty(elm, "children", {
-      get() {
-        return this.childNodes.map((n) => n.nodeType === 1);
-      }
-    });
-    Object.defineProperty(elm, "childElementCount", {
-      get() {
-        return elm.children.length;
-      }
-    });
-    Object.defineProperty(elm, "childNodes", {
-      get() {
-        const childNodes = childNodesFn.call(this);
-        if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0 && getHostRef(this).$flags$ & 2 /* hasRendered */) {
-          const result = new FakeNodeList();
-          for (let i2 = 0; i2 < childNodes.length; i2++) {
-            const slot = childNodes[i2]["s-nr"];
-            if (slot) {
-              result.push(slot);
-            }
-          }
-          return result;
-        }
-        return FakeNodeList.from(childNodes);
+  let childNodesFn = Object.getOwnPropertyDescriptor(Node.prototype, "childNodes");
+  if (!childNodesFn) {
+    childNodesFn = Object.getOwnPropertyDescriptor(elm, "childNodes");
+  }
+  if (childNodesFn) Object.defineProperty(elm, "__childNodes", childNodesFn);
+  Object.defineProperty(elm, "children", {
+    get() {
+      return this.childNodes.filter((n) => n.nodeType === 1);
+    }
+  });
+  Object.defineProperty(elm, "childElementCount", {
+    get() {
+      return this.children.length;
+    }
+  });
+  if (!childNodesFn) return;
+  Object.defineProperty(elm, "childNodes", {
+    get() {
+      var _a, _b;
+      if (!plt.$flags$ || !((_a = getHostRef(this)) == null ? void 0 : _a.$flags$) || (plt.$flags$ & 1 /* isTmpDisconnected */) === 0 && ((_b = getHostRef(this)) == null ? void 0 : _b.$flags$) & 2 /* hasRendered */) {
+        const result = new FakeNodeList();
+        const nodes = getSlottedChildNodes(this.__childNodes);
+        result.push(...nodes);
+        return result;
       }
-    });
+      return FakeNodeList.from(this.__childNodes);
+    }
+  });
+};
+var addSlotRelocateNode = (newChild, slotNode, prepend) => {
+  let slottedNodeLocation;
+  if (newChild["s-ol"] && newChild["s-ol"].isConnected) {
+    slottedNodeLocation = newChild["s-ol"];
+  } else {
+    slottedNodeLocation = document.createTextNode("");
+    slottedNodeLocation["s-nr"] = newChild;
   }
+  const parent = slotNode["s-cr"].parentNode;
+  const appendMethod = prepend ? parent.__prepend : parent.__appendChild;
+  newChild["s-ol"] = slottedNodeLocation;
+  newChild["s-sh"] = slotNode["s-hn"];
+  appendMethod.call(parent, slottedNodeLocation);
 };
-var getAllChildSlotNodes = (childNodes) => {
-  const slotRefNodes = [];
-  for (const childNode of Array.from(childNodes)) {
-    if (childNode["s-sr"]) {
-      slotRefNodes.push(childNode);
+var getSlottedChildNodes = (childNodes) => {
+  const result = [];
+  for (let i2 = 0; i2 < childNodes.length; i2++) {
+    const slottedNode = childNodes[i2]["s-nr"];
+    if (slottedNode && slottedNode.isConnected) {
+      result.push(slottedNode);
     }
-    slotRefNodes.push(...getAllChildSlotNodes(childNode.childNodes));
   }
-  return slotRefNodes;
+  return result;
 };
 var getSlotName = (node) => node["s-sn"] || node.nodeType === 1 && node.getAttribute("slot") || "";
 var getHostSlotNode = (childNodes, slotName, hostName) => {
@@ -2440,11 +2447,11 @@ var proxyCustomElement = (Cstr, compactMeta) => {
   }
   if (BUILD18.experimentalSlotFixes) {
     if (BUILD18.scoped && cmpMeta.$flags$ & 2 /* scopedCssEncapsulation */) {
-      patchPseudoShadowDom(Cstr.prototype, cmpMeta);
+      patchPseudoShadowDom(Cstr.prototype);
     }
   } else {
     if (BUILD18.slotChildNodesFix) {
-      patchChildSlotNodes(Cstr.prototype, cmpMeta);
+      patchChildSlotNodes(Cstr.prototype);
     }
     if (BUILD18.cloneNodeFix) {
       patchCloneNode(Cstr.prototype);
@@ -2650,11 +2657,11 @@ var bootstrapLazy = (lazyBundles, options = {}) => {
       };
       if (BUILD19.experimentalSlotFixes) {
         if (BUILD19.scoped && cmpMeta.$flags$ & 2 /* scopedCssEncapsulation */) {
-          patchPseudoShadowDom(HostElement.prototype, cmpMeta);
+          patchPseudoShadowDom(HostElement.prototype);
         }
       } else {
         if (BUILD19.slotChildNodesFix) {
-          patchChildSlotNodes(HostElement.prototype, cmpMeta);
+          patchChildSlotNodes(HostElement.prototype);
         }
         if (BUILD19.cloneNodeFix) {
           patchCloneNode(HostElement.prototype);

package/internal/hydrate/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stencil/core/internal/hydrate",
-  "version": "4.22.3-dev.1732597307.7bdf128",
+  "version": "4.22.3-dev.1732770122.a15bc5d",
   "description": "Stencil internal hydrate platform to be imported by the Stencil Compiler. Breaking changes can and will happen at any time.",
   "main": "./index.js",
   "private": true

package/internal/hydrate/runner.js

@@ -1,5 +1,5 @@
 /*
- Stencil Hydrate Runner v4.22.3-dev.1732597307.7bdf128 | MIT Licensed | https://stenciljs.com
+ Stencil Hydrate Runner v4.22.3-dev.1732770122.a15bc5d | MIT Licensed | https://stenciljs.com
  */
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {

package/internal/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stencil/core/internal",
-  "version": "4.22.3-dev.1732597307.7bdf128",
+  "version": "4.22.3-dev.1732770122.a15bc5d",
   "description": "Stencil internals only to be imported by the Stencil Compiler. Breaking changes can and will happen at any time.",
   "main": "./index.js",
   "types": "./index.d.ts",

package/internal/stencil-private.d.ts

@@ -581,6 +581,8 @@ export interface ComponentCompilerStaticProperty {
     reflect?: boolean;
     docs: CompilerJsDoc;
     defaultValue?: string;
+    getter: boolean;
+    setter: boolean;
 }
 /**
  * Intermediate Representation (IR) of a property on a Stencil component
@@ -1256,6 +1258,12 @@ export interface RenderNode extends HostElement {
      * empty "" for shadow, "c" from scoped
      */
     ['s-en']?: '' | /*shadow*/ 'c';
+    /**
+     * On a `scoped: true` component
+     * with `experimentalSlotFixes` flag enabled,
+     * returns the internal `childNodes` of the scoped element
+     */
+    readonly __childNodes?: NodeListOf<ChildNode>;
 }
 export type LazyBundlesRuntimeData = LazyBundleRuntimeData[];
 export type LazyBundleRuntimeData = [

package/internal/stencil-public-docs.d.ts

@@ -311,6 +311,14 @@ export interface JsonDocsProp {
 	 * ```
 	 */
 	required: boolean;
+	/**
+	 * `true` if the prop has a `get()`. `false` otherwise
+	 */
+	getter: boolean;
+	/**
+	 * `true` if the prop has a `set()`. `false` otherwise
+	 */
+	setter: boolean;
 }
 export interface JsonDocsMethod {
 	name: string;