@wsxjs/wsx-core 0.0.27 → 0.0.30

package/dist/index.mjs

@@ -3,8 +3,10 @@ import {
   RenderContext,
   createLogger,
   h,
+  parseHTMLToNodes,
+  reconcileElement,
   shouldPreserveElement
-} from "./chunk-DYG2LIOG.mjs";
+} from "./chunk-2ER76KOQ.mjs";
 
 // src/styles/style-manager.ts
 var StyleManager = class {
@@ -527,7 +529,7 @@ var BaseComponent = class extends HTMLElement {
       }
     }
     if (activeElement) {
-      const isInputElement = activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement || activeElement instanceof HTMLSelectElement || activeElement.hasAttribute("contenteditable");
+      const isInputElement = activeElement instanceof HTMLInputElement && activeElement.type !== "radio" && activeElement.type !== "checkbox" || activeElement instanceof HTMLTextAreaElement || activeElement instanceof HTMLSelectElement || activeElement.hasAttribute("contenteditable");
       const forceRender = activeElement.hasAttribute("data-wsx-force-render");
       if (isInputElement && !forceRender) {
         this._pendingRerender = true;
@@ -543,14 +545,8 @@ var BaseComponent = class extends HTMLElement {
     }
     this._hasScheduledRender = true;
     requestAnimationFrame(() => {
-      console.warn("[scheduleRerender] RAF callback:", {
-        component: this.constructor.name,
-        connected: this.connected,
-        isRendering: this._isRendering
-      });
       this._hasScheduledRender = false;
       if (this.connected && !this._isRendering) {
-        console.warn("[scheduleRerender] calling _rerender()");
         this._isRendering = true;
         this._rerender();
       } else if (!this.connected) {
@@ -579,7 +575,8 @@ var BaseComponent = class extends HTMLElement {
       clearTimeout(this._rerenderDebounceTimer);
       this._rerenderDebounceTimer = null;
     }
-    document.removeEventListener("blur", this.handleGlobalBlur, true);
+    const root = this.getActiveRoot();
+    root.removeEventListener("blur", this.handleGlobalBlur, true);
     this._pendingRerender = false;
   }
   /**
@@ -587,7 +584,8 @@ var BaseComponent = class extends HTMLElement {
    * @internal
    */
   initializeEventListeners() {
-    document.addEventListener("blur", this.handleGlobalBlur, true);
+    const root = this.getActiveRoot();
+    root.addEventListener("blur", this.handleGlobalBlur, true);
   }
   /**
    * 获取配置值
@@ -897,7 +895,7 @@ var WebComponent = class extends BaseComponent {
       if (!isContentAlreadyInShadowRoot) {
         this.shadowRoot.appendChild(content);
       }
-      const oldChildren = Array.from(this.shadowRoot.children).filter((child) => {
+      const oldNodes = Array.from(this.shadowRoot.childNodes).filter((child) => {
         if (child === content) {
           return false;
         }
@@ -909,7 +907,7 @@ var WebComponent = class extends BaseComponent {
         }
         return true;
       });
-      oldChildren.forEach((child) => child.remove());
+      oldNodes.forEach((node) => node.remove());
       const hasStylesAfterDOM = this.shadowRoot.adoptedStyleSheets && this.shadowRoot.adoptedStyleSheets.length > 0;
       const hasStyleElementAfterDOM = Array.from(this.shadowRoot.children).some(
         (child) => child instanceof HTMLStyleElement
@@ -1044,6 +1042,10 @@ var LightComponent = class extends BaseComponent {
   querySelectorAll(selector) {
     return HTMLElement.prototype.querySelectorAll.call(this, selector);
   }
+  /**
+   * 递归协调子元素
+   * 更新现有子元素的属性和内容，而不是替换整个子树
+   */
   /**
    * 内部重渲染实现
    * 包含从 rerender() 方法迁移的实际渲染逻辑
@@ -1060,9 +1062,9 @@ var LightComponent = class extends BaseComponent {
     this._pendingFocusState = focusState;
     const jsxChildren = this.getJSXChildren();
     try {
-      const content = RenderContext.runInContext(this, () => this.render());
+      const newContent = RenderContext.runInContext(this, () => this.render());
       if (focusState && focusState.key && focusState.value !== void 0) {
-        const target = content.querySelector(
+        const target = newContent.querySelector(
           `[data-wsx-key="${focusState.key}"]`
         );
         if (target) {
@@ -1087,36 +1089,50 @@ var LightComponent = class extends BaseComponent {
         }
       }
       requestAnimationFrame(() => {
-        this.appendChild(content);
         const oldChildren = Array.from(this.children).filter((child) => {
-          if (child === content) {
-            return false;
-          }
           if (stylesToApply && child instanceof HTMLStyleElement && child.getAttribute("data-wsx-light-component") === styleName) {
             return false;
           }
           if (child instanceof HTMLElement && jsxChildren.includes(child)) {
             return false;
           }
-          if (shouldPreserveElement(child)) {
-            return false;
-          }
           return true;
         });
-        oldChildren.forEach((child) => child.remove());
+        if (oldChildren.length === 1 && newContent instanceof HTMLElement) {
+          const oldElement = oldChildren[0];
+          if (oldElement instanceof HTMLElement && oldElement.tagName === newContent.tagName) {
+            Array.from(oldElement.attributes).forEach((attr) => {
+              if (!newContent.hasAttribute(attr.name)) {
+                oldElement.removeAttribute(attr.name);
+              }
+            });
+            Array.from(newContent.attributes).forEach((attr) => {
+              if (oldElement.getAttribute(attr.name) !== attr.value) {
+                oldElement.setAttribute(attr.name, attr.value);
+              }
+            });
+            reconcileElement(oldElement, newContent);
+          } else {
+            oldElement.remove();
+            this.appendChild(newContent);
+          }
+        } else {
+          oldChildren.forEach((child) => child.remove());
+          this.appendChild(newContent);
+        }
         if (stylesToApply) {
-          let styleElement = this.querySelector(
+          let styleEl = this.querySelector(
             `style[data-wsx-light-component="${styleName}"]`
           );
-          if (!styleElement) {
-            styleElement = document.createElement("style");
-            styleElement.setAttribute("data-wsx-light-component", styleName);
-            styleElement.textContent = stylesToApply;
-            this.insertBefore(styleElement, this.firstChild);
-          } else if (styleElement.textContent !== stylesToApply) {
-            styleElement.textContent = stylesToApply;
-          } else if (styleElement !== this.firstChild) {
-            this.insertBefore(styleElement, this.firstChild);
+          if (!styleEl) {
+            styleEl = document.createElement("style");
+            styleEl.setAttribute("data-wsx-light-component", styleName);
+            styleEl.textContent = stylesToApply;
+            this.insertBefore(styleEl, this.firstChild);
+          } else if (styleEl.textContent !== stylesToApply) {
+            styleEl.textContent = stylesToApply;
+          } else if (styleEl !== this.firstChild) {
+            this.insertBefore(styleEl, this.firstChild);
           }
         }
         requestAnimationFrame(() => {
@@ -1319,6 +1335,7 @@ export {
   h as jsx,
   h as jsxs,
   logger5 as logger,
+  parseHTMLToNodes,
   registerComponent,
   state
 };

package/dist/jsx-runtime.js

@@ -33,6 +33,7 @@ function parseHTMLToNodes(html) {
   temp.innerHTML = html;
   return Array.from(temp.childNodes).map((node) => {
     if (node instanceof HTMLElement || node instanceof SVGElement) {
+      node.__wsxManaged = true;
       return node;
     } else {
       return node.textContent || "";
@@ -45,7 +46,13 @@ function isHTMLString(str) {
   const htmlTagPattern = /<[a-z][a-z0-9]*(\s[^>]*)?(\/>|>)/i;
   const looksLikeMath = /^[^<]*<[^>]*>[^>]*$/.test(trimmed) && !htmlTagPattern.test(trimmed);
   if (looksLikeMath) return false;
-  return htmlTagPattern.test(trimmed);
+  const result = htmlTagPattern.test(trimmed);
+  if (result) {
+    console.log(`[WSX Debug] isHTMLString("${trimmed.substring(0, 50)}..."): ${result}`, {
+      looksLikeMath
+    });
+  }
+  return result;
 }
 function flattenChildren(children, skipHTMLDetection = false, depth = 0) {
   if (depth > 10) {
@@ -86,6 +93,17 @@ function flattenChildren(children, skipHTMLDetection = false, depth = 0) {
       } else {
         result.push(child);
       }
+    } else if (child instanceof DocumentFragment) {
+      const fragmentChildren = Array.from(child.childNodes);
+      for (const fragChild of fragmentChildren) {
+        if (fragChild instanceof HTMLElement || fragChild instanceof SVGElement) {
+          result.push(fragChild);
+        } else if (fragChild.nodeType === Node.TEXT_NODE) {
+          result.push(fragChild.textContent || "");
+        } else if (fragChild instanceof DocumentFragment) {
+          result.push(...flattenChildren([fragChild], skipHTMLDetection, depth + 1));
+        }
+      }
     } else {
       result.push(child);
     }
@@ -186,12 +204,12 @@ function isCreatedByH(element) {
 }
 function shouldPreserveElement(element) {
   if (!(element instanceof HTMLElement || element instanceof SVGElement)) {
-    return true;
+    return false;
   }
-  if (!isCreatedByH(element)) {
+  if (!isCreatedByH(element) && element.__wsxManaged !== true) {
     return true;
   }
-  if (element.hasAttribute("data-wsx-preserve")) {
+  if (element instanceof HTMLElement && element.hasAttribute("data-wsx-preserve")) {
     return true;
   }
   return false;
@@ -637,7 +655,9 @@ function appendChildrenToElement(element, children) {
       return;
     }
     if (typeof child === "string" || typeof child === "number") {
-      element.appendChild(document.createTextNode(String(child)));
+      const textNode = document.createTextNode(String(child));
+      textNode.__wsxManaged = true;
+      element.appendChild(textNode);
     } else if (child instanceof HTMLElement || child instanceof SVGElement) {
       element.appendChild(child);
     } else if (child instanceof DocumentFragment) {
@@ -657,6 +677,9 @@ function collectPreservedElements(element) {
   const preserved = [];
   for (let i = 0; i < element.childNodes.length; i++) {
     const child = element.childNodes[i];
+    if (child.nodeType === Node.TEXT_NODE) {
+      continue;
+    }
     if (shouldPreserveElement(child)) {
       preserved.push(child);
     }
@@ -690,38 +713,40 @@ function findElementNode(oldChild, parent) {
   }
   return null;
 }
-function findTextNode(parent, domIndex) {
-  while (domIndex.value < parent.childNodes.length) {
-    const node = parent.childNodes[domIndex.value];
-    if (node.nodeType === Node.TEXT_NODE && node.parentNode === parent) {
-      const textNode = node;
-      domIndex.value++;
-      return textNode;
+function findTextNode(parent, domIndex, processedNodes) {
+  for (let i = domIndex.value; i < parent.childNodes.length; i++) {
+    const node = parent.childNodes[i];
+    if (node.nodeType === Node.TEXT_NODE && node.__wsxManaged === true && !processedNodes.has(node)) {
+      domIndex.value = i + 1;
+      return node;
     }
-    domIndex.value++;
   }
   return null;
 }
-function updateOrCreateTextNode(parent, oldNode, newText) {
+function updateOrCreateTextNode(parent, oldNode, newText, insertBeforeNode) {
+  if (shouldPreserveElement(parent)) {
+    if (oldNode && oldNode.nodeType === Node.TEXT_NODE) {
+      return oldNode;
+    }
+    return document.createTextNode(newText);
+  }
   if (oldNode && oldNode.nodeType === Node.TEXT_NODE) {
     if (oldNode.textContent !== newText) {
       oldNode.textContent = newText;
     }
-    return oldNode;
-  } else {
-    if (!oldNode) {
-      for (let i = 0; i < parent.childNodes.length; i++) {
-        const node = parent.childNodes[i];
-        if (node.nodeType === Node.TEXT_NODE && node.parentNode === parent && node.textContent === newText) {
-          return node;
-        }
+    if (insertBeforeNode !== void 0) {
+      if (oldNode !== insertBeforeNode && oldNode.nextSibling !== insertBeforeNode) {
+        parent.insertBefore(oldNode, insertBeforeNode);
       }
     }
+    return oldNode;
+  } else {
     const newTextNode = document.createTextNode(newText);
+    newTextNode.__wsxManaged = true;
     if (oldNode && !shouldPreserveElement(oldNode)) {
       parent.replaceChild(newTextNode, oldNode);
     } else {
-      parent.insertBefore(newTextNode, oldNode || null);
+      parent.insertBefore(newTextNode, insertBeforeNode ?? null);
     }
     return newTextNode;
   }
@@ -731,25 +756,36 @@ function removeNodeIfNotPreserved(parent, node) {
     parent.removeChild(node);
   }
 }
-function replaceOrInsertElement(parent, newChild, oldNode) {
-  const targetNextSibling = oldNode && shouldPreserveElement(oldNode) ? oldNode : oldNode?.nextSibling || null;
-  replaceOrInsertElementAtPosition(parent, newChild, oldNode, targetNextSibling);
-}
-function replaceOrInsertElementAtPosition(parent, newChild, oldNode, targetNextSibling) {
+function replaceOrInsertElementAtPosition(parent, newChild, oldNode, targetNextSibling, processedNodes) {
   if (newChild.parentNode && newChild.parentNode !== parent) {
     newChild.parentNode.removeChild(newChild);
   }
-  const isInCorrectPosition = newChild.parentNode === parent && newChild.nextSibling === targetNextSibling;
+  const isInCorrectPosition = newChild.parentNode === parent && (newChild.nextSibling === targetNextSibling || targetNextSibling === newChild);
   if (isInCorrectPosition) {
+    if (processedNodes) processedNodes.add(newChild);
     return;
   }
   if (newChild.parentNode === parent) {
     parent.insertBefore(newChild, targetNextSibling);
+    if (processedNodes) processedNodes.add(newChild);
     return;
   }
   if (oldNode && oldNode.parentNode === parent && !shouldPreserveElement(oldNode)) {
     if (oldNode !== newChild) {
+      const oldCacheKey = getElementCacheKey(oldNode);
+      const newCacheKey = getElementCacheKey(newChild);
+      if (!oldCacheKey && !newCacheKey && oldNode.__wsxManaged === true) {
+        const oldTag = oldNode.tagName.toLowerCase();
+        const newTag = newChild.tagName.toLowerCase();
+        if (oldTag === newTag && oldNode.textContent === newChild.textContent) {
+          if (processedNodes) processedNodes.add(oldNode);
+          return;
+        }
+      }
       parent.replaceChild(newChild, oldNode);
+      if (processedNodes) processedNodes.add(newChild);
+    } else {
+      if (processedNodes) processedNodes.add(newChild);
     }
   } else {
     if (newChild.parentNode === parent) {
@@ -764,6 +800,12 @@ function replaceOrInsertElementAtPosition(parent, newChild, oldNode, targetNextS
         if (existingNode instanceof HTMLElement || existingNode instanceof SVGElement) {
           const existingCacheKey = getElementCacheKey(existingNode);
           if (!existingCacheKey && existingNode.tagName.toLowerCase() === newChildTag && existingNode.textContent === newChildContent && existingNode !== newChild) {
+            console.log(
+              "[WSX Debug] Found duplicate content, keeping existing:",
+              existingNode.tagName,
+              existingNode.textContent
+            );
+            if (processedNodes) processedNodes.add(existingNode);
             return;
           }
         }
@@ -778,6 +820,7 @@ function appendNewChild(parent, child, processedNodes) {
   }
   if (typeof child === "string" || typeof child === "number") {
     const newTextNode = document.createTextNode(String(child));
+    newTextNode.__wsxManaged = true;
     parent.appendChild(newTextNode);
     if (processedNodes) {
       processedNodes.add(newTextNode);
@@ -794,6 +837,11 @@ function appendNewChild(parent, child, processedNodes) {
       processedNodes.add(child);
     }
   } else if (child instanceof DocumentFragment) {
+    if (processedNodes) {
+      for (let i = 0; i < child.childNodes.length; i++) {
+        processedNodes.add(child.childNodes[i]);
+      }
+    }
     parent.appendChild(child);
   }
 }
@@ -814,20 +862,31 @@ function buildNewChildrenMaps(flatNew) {
   return { elementSet, cacheKeyMap };
 }
 function shouldRemoveNode(node, elementSet, cacheKeyMap, processedNodes) {
-  if (shouldPreserveElement(node)) {
-    return false;
-  }
-  if (node.nodeType === Node.TEXT_NODE && processedNodes && processedNodes.has(node)) {
-    return false;
-  }
-  if (node.nodeType === Node.TEXT_NODE && processedNodes) {
-    let parent = node.parentNode;
-    while (parent) {
-      if (processedNodes.has(parent) && parent.parentNode) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    if (node.__wsxManaged === true) {
+      if (processedNodes && processedNodes.has(node)) {
         return false;
       }
-      parent = parent.parentNode;
+      return true;
     }
+    const parent = node.parentNode;
+    if (parent && (parent instanceof HTMLElement || parent instanceof SVGElement)) {
+      if (shouldPreserveElement(parent)) {
+        return false;
+      }
+    }
+    return true;
+  } else {
+    if (shouldPreserveElement(node)) {
+      return false;
+    }
+  }
+  const isProcessed = processedNodes && processedNodes.has(node);
+  if (isProcessed) {
+    return false;
+  }
+  if (shouldPreserveElement(node)) {
+    return false;
   }
   if (node instanceof HTMLElement || node instanceof SVGElement || node instanceof DocumentFragment) {
     if (elementSet.has(node)) {
@@ -870,7 +929,8 @@ function collectNodesToRemove(parent, elementSet, cacheKeyMap, processedNodes) {
   const nodesToRemove = [];
   for (let i = 0; i < parent.childNodes.length; i++) {
     const node = parent.childNodes[i];
-    if (shouldRemoveNode(node, elementSet, cacheKeyMap, processedNodes)) {
+    const removed = shouldRemoveNode(node, elementSet, cacheKeyMap, processedNodes);
+    if (removed) {
       nodesToRemove.push(node);
     }
   }
@@ -1072,6 +1132,7 @@ function updateChildren(element, oldChildren, newChildren, _cacheManager) {
   const preservedElements = collectPreservedElements(element);
   const minLength = Math.min(flatOld.length, flatNew.length);
   const domIndex = { value: 0 };
+  const insertionIndex = { value: 0 };
   const processedNodes = /* @__PURE__ */ new Set();
   for (let i = 0; i < minLength; i++) {
     const oldChild = flatOld[i];
@@ -1086,48 +1147,54 @@ function updateChildren(element, oldChildren, newChildren, _cacheManager) {
         }
       }
     } else if (typeof oldChild === "string" || typeof oldChild === "number") {
-      oldNode = findTextNode(element, domIndex);
-      if (!oldNode && element.childNodes.length > 0) {
-        const oldText = String(oldChild);
-        for (let j = domIndex.value; j < element.childNodes.length; j++) {
-          const node = element.childNodes[j];
-          if (node.nodeType === Node.TEXT_NODE && node.parentNode === element && node.textContent === oldText) {
-            oldNode = node;
-            domIndex.value = j + 1;
-            break;
+      if (shouldPreserveElement(element)) {
+        oldNode = null;
+      } else {
+        oldNode = findTextNode(element, domIndex, processedNodes);
+        if (oldNode) {
+          const nodeIndex = Array.from(element.childNodes).indexOf(oldNode);
+          if (nodeIndex !== -1 && nodeIndex >= domIndex.value) {
+            domIndex.value = nodeIndex + 1;
           }
         }
       }
     }
     if (typeof oldChild === "string" || typeof oldChild === "number") {
       if (typeof newChild === "string" || typeof newChild === "number") {
-        const oldText = String(oldChild);
         const newText = String(newChild);
-        const needsUpdate = oldText !== newText || oldNode && oldNode.nodeType === Node.TEXT_NODE && oldNode.textContent !== newText;
-        if (needsUpdate) {
-          const updatedNode = updateOrCreateTextNode(element, oldNode, newText);
-          if (updatedNode && !processedNodes.has(updatedNode)) {
-            processedNodes.add(updatedNode);
-          }
-        } else {
-          if (oldNode && oldNode.parentNode === element) {
-            processedNodes.add(oldNode);
-          } else if (!oldNode && oldText === newText) {
-            for (let j = domIndex.value; j < element.childNodes.length; j++) {
-              const node = element.childNodes[j];
-              if (node.nodeType === Node.TEXT_NODE && node.parentNode === element && node.textContent === newText && !processedNodes.has(node)) {
-                processedNodes.add(node);
-                break;
-              }
-            }
-          }
+        if (shouldPreserveElement(element)) {
+          continue;
+        }
+        const insertBeforeNode = insertionIndex.value < element.childNodes.length ? element.childNodes[insertionIndex.value] : null;
+        const updatedNode = updateOrCreateTextNode(
+          element,
+          oldNode,
+          newText,
+          insertBeforeNode
+        );
+        if (updatedNode) {
+          processedNodes.add(updatedNode);
+          insertionIndex.value++;
         }
       } else {
-        removeNodeIfNotPreserved(element, oldNode);
+        const targetNode = insertionIndex.value < element.childNodes.length ? element.childNodes[insertionIndex.value] : null;
         if (newChild instanceof HTMLElement || newChild instanceof SVGElement) {
-          replaceOrInsertElement(element, newChild, oldNode);
+          if (oldNode && oldNode === targetNode && oldNode.parentNode === element) {
+            element.replaceChild(newChild, oldNode);
+          } else {
+            element.insertBefore(newChild, targetNode);
+            removeNodeIfNotPreserved(element, oldNode);
+          }
+          processedNodes.add(newChild);
+          insertionIndex.value++;
         } else if (newChild instanceof DocumentFragment) {
-          element.insertBefore(newChild, oldNode || null);
+          if (processedNodes) {
+            for (let i2 = 0; i2 < newChild.childNodes.length; i2++) {
+              processedNodes.add(newChild.childNodes[i2]);
+            }
+          }
+          element.insertBefore(newChild, targetNode);
+          removeNodeIfNotPreserved(element, oldNode);
         }
       }
     } else if (oldChild instanceof HTMLElement || oldChild instanceof SVGElement) {
@@ -1135,49 +1202,36 @@ function updateChildren(element, oldChildren, newChildren, _cacheManager) {
         continue;
       }
       if (newChild instanceof HTMLElement || newChild instanceof SVGElement) {
-        let targetNextSibling = null;
-        let foundPreviousElement = false;
-        for (let j = i - 1; j >= 0; j--) {
-          const prevChild = flatNew[j];
-          if (prevChild instanceof HTMLElement || prevChild instanceof SVGElement) {
-            if (prevChild.parentNode === element) {
-              targetNextSibling = prevChild.nextSibling;
-              foundPreviousElement = true;
-              break;
-            }
-          }
-        }
-        if (!foundPreviousElement) {
-          const firstChild = Array.from(element.childNodes).find(
-            (node) => !shouldPreserveElement(node) && !processedNodes.has(node)
-          );
-          targetNextSibling = firstChild || null;
-        }
-        const isInCorrectPosition = newChild.parentNode === element && newChild.nextSibling === targetNextSibling;
-        if (newChild === oldChild && isInCorrectPosition) {
-          if (oldNode) processedNodes.add(oldNode);
-          processedNodes.add(newChild);
-          continue;
-        }
-        const referenceNode = oldNode && oldNode.parentNode === element ? oldNode : null;
+        const insertBeforeNode = insertionIndex.value < element.childNodes.length ? element.childNodes[insertionIndex.value] : null;
         replaceOrInsertElementAtPosition(
           element,
           newChild,
-          referenceNode,
-          targetNextSibling
+          oldNode,
+          insertBeforeNode,
+          processedNodes
         );
-        if (oldNode && oldNode !== newChild) {
-          processedNodes.delete(oldNode);
-        }
-        processedNodes.add(newChild);
+        insertionIndex.value++;
       } else {
-        removeNodeIfNotPreserved(element, oldNode);
+        const targetNode = insertionIndex.value < element.childNodes.length ? element.childNodes[insertionIndex.value] : null;
         if (typeof newChild === "string" || typeof newChild === "number") {
           const newTextNode = document.createTextNode(String(newChild));
-          element.insertBefore(newTextNode, oldNode?.nextSibling || null);
+          newTextNode.__wsxManaged = true;
+          if (oldNode && oldNode === targetNode && oldNode.parentNode === element) {
+            element.replaceChild(newTextNode, oldNode);
+          } else {
+            element.insertBefore(newTextNode, targetNode);
+            removeNodeIfNotPreserved(element, oldNode);
+          }
           processedNodes.add(newTextNode);
+          insertionIndex.value++;
         } else if (newChild instanceof DocumentFragment) {
-          element.insertBefore(newChild, oldNode?.nextSibling || null);
+          if (processedNodes) {
+            for (let i2 = 0; i2 < newChild.childNodes.length; i2++) {
+              processedNodes.add(newChild.childNodes[i2]);
+            }
+          }
+          element.insertBefore(newChild, targetNode);
+          removeNodeIfNotPreserved(element, oldNode);
         }
       }
     }
@@ -1299,7 +1353,9 @@ function Fragment(_props, children) {
       return;
     }
     if (typeof child === "string" || typeof child === "number") {
-      fragment.appendChild(document.createTextNode(String(child)));
+      const textNode = document.createTextNode(String(child));
+      textNode.__wsxManaged = true;
+      fragment.appendChild(textNode);
     } else if (child instanceof HTMLElement || child instanceof SVGElement) {
       fragment.appendChild(child);
     } else if (child instanceof DocumentFragment) {

package/dist/jsx-runtime.mjs

@@ -2,7 +2,7 @@ import {
   Fragment,
   jsx,
   jsxs
-} from "./chunk-DYG2LIOG.mjs";
+} from "./chunk-2ER76KOQ.mjs";
 export {
   Fragment,
   jsx,