@fictjs/runtime 0.8.0 → 0.9.0

package/dist/chunk-LBE6DC3V.cjs

@@ -0,0 +1,768 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+var _chunkOAM7HABAcjs = require('./chunk-OAM7HABA.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkUBFDB6OLcjs = require('./chunk-UBFDB6OL.cjs');
+
+// src/reconcile.ts
+function reconcileArrays(parentNode, a, b) {
+  const bLength = b.length;
+  let aEnd = a.length;
+  let bEnd = bLength;
+  let aStart = 0;
+  let bStart = 0;
+  const after = aEnd > 0 ? a[aEnd - 1].nextSibling : null;
+  let map = null;
+  while (aStart < aEnd || bStart < bEnd) {
+    if (a[aStart] === b[bStart]) {
+      aStart++;
+      bStart++;
+      continue;
+    }
+    while (a[aEnd - 1] === b[bEnd - 1]) {
+      aEnd--;
+      bEnd--;
+    }
+    if (aEnd === aStart) {
+      const node = bEnd < bLength ? bStart ? b[bStart - 1].nextSibling : _nullishCoalesce(b[bEnd - bStart], () => ( null)) : after;
+      const count = bEnd - bStart;
+      const doc = parentNode.ownerDocument;
+      if (count > 1 && doc) {
+        const frag = doc.createDocumentFragment();
+        for (let i = bStart; i < bEnd; i++) {
+          frag.appendChild(b[i]);
+        }
+        parentNode.insertBefore(frag, node);
+        bStart = bEnd;
+      } else {
+        while (bStart < bEnd) {
+          parentNode.insertBefore(b[bStart++], node);
+        }
+      }
+    } else if (bEnd === bStart) {
+      while (aStart < aEnd) {
+        const nodeToRemove = a[aStart];
+        if (!map || !map.has(nodeToRemove)) {
+          _optionalChain([nodeToRemove, 'access', _ => _.parentNode, 'optionalAccess', _2 => _2.removeChild, 'call', _3 => _3(nodeToRemove)]);
+        }
+        aStart++;
+      }
+    } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+      const node = a[--aEnd].nextSibling;
+      parentNode.insertBefore(b[bStart++], a[aStart++].nextSibling);
+      parentNode.insertBefore(b[--bEnd], node);
+      a[aEnd] = b[bEnd];
+    } else {
+      if (!map) {
+        map = /* @__PURE__ */ new Map();
+        let i = bStart;
+        while (i < bEnd) {
+          map.set(b[i], i++);
+        }
+      }
+      const index = map.get(a[aStart]);
+      if (index != null) {
+        if (bStart < index && index < bEnd) {
+          let i = aStart;
+          let sequence = 1;
+          let t;
+          while (++i < aEnd && i < bEnd) {
+            t = map.get(a[i]);
+            if (t == null || t !== index + sequence) break;
+            sequence++;
+          }
+          if (sequence > index - bStart) {
+            const node = a[aStart];
+            while (bStart < index) {
+              parentNode.insertBefore(b[bStart++], node);
+            }
+          } else {
+            parentNode.replaceChild(b[bStart++], a[aStart++]);
+          }
+        } else {
+          aStart++;
+        }
+      } else {
+        const nodeToRemove = a[aStart++];
+        _optionalChain([nodeToRemove, 'access', _4 => _4.parentNode, 'optionalAccess', _5 => _5.removeChild, 'call', _6 => _6(nodeToRemove)]);
+      }
+    }
+  }
+}
+
+// src/list-helpers.ts
+var isDev = typeof __DEV__ !== "undefined" ? __DEV__ : typeof process !== "undefined" && _optionalChain([process, 'access', _7 => _7.env, 'optionalAccess', _8 => _8.NODE_ENV]) !== "production";
+var isShadowRoot = (node) => typeof ShadowRoot !== "undefined" && node instanceof ShadowRoot;
+function moveNodesBefore(parent, nodes, anchor) {
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    const node = nodes[i];
+    if (!node || !(node instanceof Node)) {
+      const message = isDev ? "Invalid node in moveNodesBefore" : "FICT:E_NODE";
+      throw new Error(message);
+    }
+    if (node.nextSibling !== anchor) {
+      if (node.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
+        parent.ownerDocument.adoptNode(node);
+      }
+      try {
+        parent.insertBefore(node, anchor);
+      } catch (e) {
+        if (parent.ownerDocument) {
+          try {
+            const clone = parent.ownerDocument.importNode(node, true);
+            parent.insertBefore(clone, anchor);
+            nodes[i] = clone;
+            if (isDev) {
+              console.warn(
+                `[fict] Node cloning fallback triggered during list reordering. This may indicate cross-document node insertion. The node reference has been updated to the clone.`
+              );
+            }
+            anchor = clone;
+            continue;
+          } catch (e2) {
+          }
+        }
+        throw e;
+      }
+    }
+    anchor = node;
+  }
+}
+var MAX_SAFE_VERSION = 9007199254740991;
+function createVersionedSignalAccessor(initialValue) {
+  let current = initialValue;
+  let version = 0;
+  const track = _chunkUBFDB6OLcjs.signal.call(void 0, version);
+  function accessor(value) {
+    if (arguments.length === 0) {
+      track();
+      return current;
+    }
+    current = value;
+    version = version >= MAX_SAFE_VERSION ? 1 : version + 1;
+    track(version);
+  }
+  return accessor;
+}
+function createKeyedListContainer(startOverride, endOverride) {
+  const startMarker = _nullishCoalesce(startOverride, () => ( document.createComment("fict:list:start")));
+  const endMarker = _nullishCoalesce(endOverride, () => ( document.createComment("fict:list:end")));
+  const dispose = () => {
+    for (const block of container.blocks.values()) {
+      _chunkUBFDB6OLcjs.destroyRoot.call(void 0, block.root);
+    }
+    container.blocks.clear();
+    container.nextBlocks.clear();
+    if (!startMarker.parentNode || !endMarker.parentNode) {
+      container.currentNodes = [];
+      container.nextNodes = [];
+      container.orderedBlocks.length = 0;
+      container.nextOrderedBlocks.length = 0;
+      container.orderedIndexByKey.clear();
+      return;
+    }
+    const range = document.createRange();
+    range.setStartBefore(startMarker);
+    range.setEndAfter(endMarker);
+    range.deleteContents();
+    container.currentNodes = [];
+    container.nextNodes = [];
+    container.nextBlocks.clear();
+    container.orderedBlocks.length = 0;
+    container.nextOrderedBlocks.length = 0;
+    container.orderedIndexByKey.clear();
+  };
+  const container = {
+    startMarker,
+    endMarker,
+    blocks: /* @__PURE__ */ new Map(),
+    nextBlocks: /* @__PURE__ */ new Map(),
+    currentNodes: [startMarker, endMarker],
+    nextNodes: [],
+    orderedBlocks: [],
+    nextOrderedBlocks: [],
+    orderedIndexByKey: /* @__PURE__ */ new Map(),
+    dispose
+  };
+  return container;
+}
+function createKeyedBlock(key, item, index, render, needsIndex = true, hostRoot) {
+  const itemSig = createVersionedSignalAccessor(item);
+  const indexSig = needsIndex ? _chunkUBFDB6OLcjs.signal.call(void 0, index) : ((next) => {
+    if (arguments.length === 0) return index;
+    index = next;
+    return index;
+  });
+  const root = _chunkUBFDB6OLcjs.createRootContext.call(void 0, hostRoot);
+  const prevRoot = _chunkUBFDB6OLcjs.pushRoot.call(void 0, root);
+  let nodes = [];
+  let scopeDispose;
+  const prevSub = _chunkUBFDB6OLcjs.setActiveSub.call(void 0, void 0);
+  try {
+    scopeDispose = _chunkUBFDB6OLcjs.effectScope.call(void 0, () => {
+      const rendered = render(itemSig, indexSig, key);
+      if (rendered instanceof Node || Array.isArray(rendered) && rendered.every((n) => n instanceof Node)) {
+        nodes = _chunkOAM7HABAcjs.toNodeArray.call(void 0, rendered);
+      } else {
+        const element = _chunkOAM7HABAcjs.createElement.call(void 0, rendered);
+        nodes = _chunkOAM7HABAcjs.toNodeArray.call(void 0, element);
+      }
+    });
+    if (scopeDispose) {
+      root.cleanups.push(scopeDispose);
+    }
+  } finally {
+    _chunkUBFDB6OLcjs.setActiveSub.call(void 0, prevSub);
+    _chunkUBFDB6OLcjs.popRoot.call(void 0, prevRoot);
+  }
+  return {
+    key,
+    nodes,
+    root,
+    item: itemSig,
+    index: indexSig,
+    rawItem: item,
+    rawIndex: index
+  };
+}
+function isNodeBetweenMarkers(node, startMarker, endMarker) {
+  let current = startMarker.nextSibling;
+  while (current && current !== endMarker) {
+    if (current === node) return true;
+    current = current.nextSibling;
+  }
+  return false;
+}
+function reorderBySwap(parent, first, second) {
+  if (first === second) return false;
+  const firstNodes = first.nodes;
+  const secondNodes = second.nodes;
+  if (firstNodes.length === 0 || secondNodes.length === 0) return false;
+  const lastFirst = firstNodes[firstNodes.length - 1];
+  const lastSecond = secondNodes[secondNodes.length - 1];
+  const afterFirst = lastFirst.nextSibling;
+  const afterSecond = lastSecond.nextSibling;
+  moveNodesBefore(parent, firstNodes, afterSecond);
+  moveNodesBefore(parent, secondNodes, afterFirst);
+  return true;
+}
+function getLISIndices(sequence) {
+  const predecessors = new Array(sequence.length);
+  const result = [];
+  for (let i = 0; i < sequence.length; i++) {
+    const value = sequence[i];
+    if (value < 0) {
+      predecessors[i] = -1;
+      continue;
+    }
+    let low = 0;
+    let high = result.length;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (sequence[result[mid]] < value) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    predecessors[i] = low > 0 ? result[low - 1] : -1;
+    if (low === result.length) {
+      result.push(i);
+    } else {
+      result[low] = i;
+    }
+  }
+  const lis = new Array(result.length);
+  let k = result.length > 0 ? result[result.length - 1] : -1;
+  for (let i = result.length - 1; i >= 0; i--) {
+    lis[i] = k;
+    k = predecessors[k];
+  }
+  return lis;
+}
+function reorderByLIS(parent, endMarker, prev, next) {
+  const positions = /* @__PURE__ */ new Map();
+  for (let i = 0; i < prev.length; i++) {
+    positions.set(prev[i], i);
+  }
+  const sequence = new Array(next.length);
+  for (let i = 0; i < next.length; i++) {
+    const position = positions.get(next[i]);
+    if (position === void 0) return false;
+    sequence[i] = position;
+  }
+  const lisIndices = getLISIndices(sequence);
+  if (lisIndices.length === sequence.length) return true;
+  const inLIS = new Array(sequence.length).fill(false);
+  for (let i = 0; i < lisIndices.length; i++) {
+    inLIS[lisIndices[i]] = true;
+  }
+  let anchor = endMarker;
+  let moved = false;
+  for (let i = next.length - 1; i >= 0; i--) {
+    const block = next[i];
+    const nodes = block.nodes;
+    if (nodes.length === 0) continue;
+    if (inLIS[i]) {
+      anchor = nodes[0];
+      continue;
+    }
+    moveNodesBefore(parent, nodes, anchor);
+    anchor = nodes[0];
+    moved = true;
+  }
+  return moved;
+}
+function createKeyedList(getItems, keyFn, renderItem, needsIndex, startMarker, endMarker) {
+  const resolvedNeedsIndex = arguments.length >= 4 ? !!needsIndex : renderItem.length > 1;
+  return createFineGrainedKeyedList(
+    getItems,
+    keyFn,
+    renderItem,
+    resolvedNeedsIndex,
+    startMarker,
+    endMarker
+  );
+}
+function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex, startOverride, endOverride) {
+  const container = createKeyedListContainer(startOverride, endOverride);
+  const hostRoot = _chunkUBFDB6OLcjs.getCurrentRoot.call(void 0, );
+  const useProvided = !!(startOverride && endOverride);
+  const fragment = useProvided ? container.startMarker : document.createDocumentFragment();
+  if (!useProvided) {
+    ;
+    fragment.append(container.startMarker, container.endMarker);
+  }
+  let disposed = false;
+  let effectDispose;
+  let connectObserver = null;
+  let effectStarted = false;
+  let startScheduled = false;
+  let initialHydrating = _chunkUBFDB6OLcjs.__fictIsHydrating.call(void 0, );
+  const collectBetween = () => {
+    const nodes = [];
+    let cursor = container.startMarker.nextSibling;
+    while (cursor && cursor !== container.endMarker) {
+      nodes.push(cursor);
+      cursor = cursor.nextSibling;
+    }
+    return nodes;
+  };
+  const getConnectedParent = () => {
+    const endParent = container.endMarker.parentNode;
+    const startParent = container.startMarker.parentNode;
+    if (endParent && startParent && endParent === startParent && endParent.nodeType !== 11) {
+      const parentNode = endParent;
+      if ("isConnected" in parentNode && !parentNode.isConnected) return null;
+      return parentNode;
+    }
+    if (endParent && startParent && endParent === startParent && isShadowRoot(endParent)) {
+      const shadowRoot = endParent;
+      const host = shadowRoot.host;
+      if ("isConnected" in host && !host.isConnected) return null;
+      return shadowRoot;
+    }
+    return null;
+  };
+  const performDiff = () => {
+    if (disposed) return;
+    const isSSR = _chunkUBFDB6OLcjs.__fictIsSSR.call(void 0, );
+    const parent = isSSR ? container.startMarker.parentNode : getConnectedParent();
+    if (!parent) return;
+    _chunkOAM7HABAcjs.batch.call(void 0, () => {
+      const oldBlocks = container.blocks;
+      const newBlocks = container.nextBlocks;
+      const prevOrderedBlocks = container.orderedBlocks;
+      const nextOrderedBlocks = container.nextOrderedBlocks;
+      const orderedIndexByKey = container.orderedIndexByKey;
+      const newItems = getItems();
+      if (initialHydrating && _chunkOAM7HABAcjs.isHydratingActive.call(void 0, )) {
+        initialHydrating = false;
+        newBlocks.clear();
+        nextOrderedBlocks.length = 0;
+        orderedIndexByKey.clear();
+        if (newItems.length === 0) {
+          oldBlocks.clear();
+          prevOrderedBlocks.length = 0;
+          container.currentNodes = [container.startMarker, container.endMarker];
+          container.nextNodes.length = 0;
+          return;
+        }
+        const createdBlocks2 = [];
+        _chunkOAM7HABAcjs.withHydrationRange.call(void 0, 
+          container.startMarker.nextSibling,
+          container.endMarker,
+          _nullishCoalesce(parent.ownerDocument, () => ( document)),
+          () => {
+            for (let index = 0; index < newItems.length; index++) {
+              const item = newItems[index];
+              const key = keyFn(item, index);
+              if (newBlocks.has(key)) {
+                if (isDev) {
+                  console.warn(
+                    `[fict] Duplicate key "${String(key)}" detected in list hydration. Each item should have a unique key.`
+                  );
+                }
+                const existing = newBlocks.get(key);
+                if (existing) {
+                  _chunkUBFDB6OLcjs.destroyRoot.call(void 0, existing.root);
+                  _chunkOAM7HABAcjs.removeNodes.call(void 0, existing.nodes);
+                }
+              }
+              const block = createKeyedBlock(key, item, index, renderItem, needsIndex, hostRoot);
+              createdBlocks2.push(block);
+              newBlocks.set(key, block);
+              orderedIndexByKey.set(key, nextOrderedBlocks.length);
+              nextOrderedBlocks.push(block);
+            }
+          }
+        );
+        container.blocks = newBlocks;
+        container.nextBlocks = oldBlocks;
+        container.orderedBlocks = nextOrderedBlocks;
+        container.nextOrderedBlocks = prevOrderedBlocks;
+        oldBlocks.clear();
+        prevOrderedBlocks.length = 0;
+        container.currentNodes = [container.startMarker, ...collectBetween(), container.endMarker];
+        container.nextNodes.length = 0;
+        for (const block of createdBlocks2) {
+          if (newBlocks.get(block.key) === block) {
+            _chunkUBFDB6OLcjs.flushOnMount.call(void 0, block.root);
+          }
+        }
+        return;
+      }
+      if (newItems.length === 0) {
+        if (oldBlocks.size > 0) {
+          for (const block of oldBlocks.values()) {
+            _chunkUBFDB6OLcjs.destroyRoot.call(void 0, block.root);
+          }
+          const range = document.createRange();
+          range.setStartAfter(container.startMarker);
+          range.setEndBefore(container.endMarker);
+          range.deleteContents();
+        }
+        oldBlocks.clear();
+        newBlocks.clear();
+        prevOrderedBlocks.length = 0;
+        nextOrderedBlocks.length = 0;
+        orderedIndexByKey.clear();
+        container.currentNodes.length = 0;
+        container.currentNodes.push(container.startMarker, container.endMarker);
+        container.nextNodes.length = 0;
+        return;
+      }
+      const prevCount = prevOrderedBlocks.length;
+      if (prevCount > 0 && newItems.length === prevCount && orderedIndexByKey.size === prevCount) {
+        let stableOrder = true;
+        const seen = /* @__PURE__ */ new Set();
+        for (let i = 0; i < prevCount; i++) {
+          const item = newItems[i];
+          const key = keyFn(item, i);
+          if (seen.has(key) || prevOrderedBlocks[i].key !== key) {
+            stableOrder = false;
+            break;
+          }
+          seen.add(key);
+        }
+        if (stableOrder) {
+          for (let i = 0; i < prevCount; i++) {
+            const item = newItems[i];
+            const block = prevOrderedBlocks[i];
+            if (block.rawItem !== item) {
+              block.rawItem = item;
+              block.item(item);
+            }
+            if (needsIndex && block.rawIndex !== i) {
+              block.rawIndex = i;
+              block.index(i);
+            }
+          }
+          return;
+        }
+      }
+      newBlocks.clear();
+      nextOrderedBlocks.length = 0;
+      orderedIndexByKey.clear();
+      const createdBlocks = [];
+      let appendCandidate = prevCount > 0 && newItems.length >= prevCount;
+      const appendedBlocks = [];
+      let mismatchCount = 0;
+      let mismatchFirst = -1;
+      let mismatchSecond = -1;
+      let hasDuplicateKey = false;
+      newItems.forEach((item, index) => {
+        const key = keyFn(item, index);
+        let block = oldBlocks.get(key);
+        const existed = block !== void 0;
+        if (block) {
+          if (block.rawItem !== item) {
+            block.rawItem = item;
+            block.item(item);
+          }
+          if (needsIndex && block.rawIndex !== index) {
+            block.rawIndex = index;
+            block.index(index);
+          }
+        }
+        if (block) {
+          newBlocks.set(key, block);
+          oldBlocks.delete(key);
+        } else {
+          const existingBlock = newBlocks.get(key);
+          if (existingBlock) {
+            if (isDev) {
+              console.warn(
+                `[fict] Duplicate key "${String(key)}" detected in list rendering. Each item should have a unique key. The previous item with this key will be replaced.`
+              );
+            }
+            _chunkUBFDB6OLcjs.destroyRoot.call(void 0, existingBlock.root);
+            _chunkOAM7HABAcjs.removeNodes.call(void 0, existingBlock.nodes);
+          }
+          block = createKeyedBlock(key, item, index, renderItem, needsIndex, hostRoot);
+          createdBlocks.push(block);
+        }
+        const resolvedBlock = block;
+        newBlocks.set(key, resolvedBlock);
+        const position = orderedIndexByKey.get(key);
+        if (position !== void 0) {
+          appendCandidate = false;
+          hasDuplicateKey = true;
+          const prior = nextOrderedBlocks[position];
+          if (prior && prior !== resolvedBlock) {
+            _chunkUBFDB6OLcjs.destroyRoot.call(void 0, prior.root);
+            _chunkOAM7HABAcjs.removeNodes.call(void 0, prior.nodes);
+          }
+          nextOrderedBlocks[position] = resolvedBlock;
+        } else {
+          if (appendCandidate) {
+            if (index < prevCount) {
+              if (!prevOrderedBlocks[index] || prevOrderedBlocks[index].key !== key) {
+                appendCandidate = false;
+              }
+            } else if (existed) {
+              appendCandidate = false;
+            }
+          }
+          const nextIndex = nextOrderedBlocks.length;
+          orderedIndexByKey.set(key, nextIndex);
+          nextOrderedBlocks.push(resolvedBlock);
+          if (mismatchCount < 3 && (nextIndex >= prevCount || prevOrderedBlocks[nextIndex] !== resolvedBlock)) {
+            if (mismatchCount === 0) {
+              mismatchFirst = nextIndex;
+            } else if (mismatchCount === 1) {
+              mismatchSecond = nextIndex;
+            }
+            mismatchCount++;
+          }
+        }
+        if (appendCandidate && index >= prevCount) {
+          appendedBlocks.push(resolvedBlock);
+        }
+      });
+      const canAppend = appendCandidate && prevCount > 0 && newItems.length > prevCount && oldBlocks.size === 0 && appendedBlocks.length > 0;
+      if (canAppend) {
+        const appendedNodes = [];
+        for (const block of appendedBlocks) {
+          for (let i = 0; i < block.nodes.length; i++) {
+            appendedNodes.push(block.nodes[i]);
+          }
+        }
+        if (appendedNodes.length > 0) {
+          _chunkOAM7HABAcjs.insertNodesBefore.call(void 0, parent, appendedNodes, container.endMarker);
+          const currentNodes = container.currentNodes;
+          currentNodes.pop();
+          for (let i = 0; i < appendedNodes.length; i++) {
+            currentNodes.push(appendedNodes[i]);
+          }
+          currentNodes.push(container.endMarker);
+        }
+        container.blocks = newBlocks;
+        container.nextBlocks = oldBlocks;
+        container.orderedBlocks = nextOrderedBlocks;
+        container.nextOrderedBlocks = prevOrderedBlocks;
+        for (const block of createdBlocks) {
+          if (newBlocks.get(block.key) === block) {
+            _chunkUBFDB6OLcjs.flushOnMount.call(void 0, block.root);
+          }
+        }
+        return;
+      }
+      if (oldBlocks.size > 0) {
+        for (const block of oldBlocks.values()) {
+          _chunkUBFDB6OLcjs.destroyRoot.call(void 0, block.root);
+          _chunkOAM7HABAcjs.removeNodes.call(void 0, block.nodes);
+        }
+        oldBlocks.clear();
+      }
+      const canReorderInPlace = createdBlocks.length === 0 && oldBlocks.size === 0 && nextOrderedBlocks.length === prevOrderedBlocks.length;
+      let skipReconcile = false;
+      let updateNodeBuffer = true;
+      if (canReorderInPlace && nextOrderedBlocks.length > 0 && !hasDuplicateKey) {
+        if (mismatchCount === 0) {
+          skipReconcile = true;
+          updateNodeBuffer = false;
+        } else if (mismatchCount === 2 && prevOrderedBlocks[mismatchFirst] === nextOrderedBlocks[mismatchSecond] && prevOrderedBlocks[mismatchSecond] === nextOrderedBlocks[mismatchFirst]) {
+          if (reorderBySwap(
+            parent,
+            prevOrderedBlocks[mismatchFirst],
+            prevOrderedBlocks[mismatchSecond]
+          )) {
+            skipReconcile = true;
+          }
+        } else if (reorderByLIS(parent, container.endMarker, prevOrderedBlocks, nextOrderedBlocks)) {
+          skipReconcile = true;
+        }
+      }
+      if (!skipReconcile && (newBlocks.size > 0 || container.currentNodes.length > 0)) {
+        const prevNodes = container.currentNodes;
+        const nextNodes = container.nextNodes;
+        nextNodes.length = 0;
+        nextNodes.push(container.startMarker);
+        for (let i = 0; i < nextOrderedBlocks.length; i++) {
+          const nodes = nextOrderedBlocks[i].nodes;
+          for (let j = 0; j < nodes.length; j++) {
+            nextNodes.push(nodes[j]);
+          }
+        }
+        nextNodes.push(container.endMarker);
+        reconcileArrays(parent, prevNodes, nextNodes);
+        container.currentNodes = nextNodes;
+        container.nextNodes = prevNodes;
+      } else if (skipReconcile && updateNodeBuffer) {
+        const prevNodes = container.currentNodes;
+        const nextNodes = container.nextNodes;
+        nextNodes.length = 0;
+        nextNodes.push(container.startMarker);
+        for (let i = 0; i < nextOrderedBlocks.length; i++) {
+          const nodes = nextOrderedBlocks[i].nodes;
+          for (let j = 0; j < nodes.length; j++) {
+            nextNodes.push(nodes[j]);
+          }
+        }
+        nextNodes.push(container.endMarker);
+        container.currentNodes = nextNodes;
+        container.nextNodes = prevNodes;
+      }
+      container.blocks = newBlocks;
+      container.nextBlocks = oldBlocks;
+      container.orderedBlocks = nextOrderedBlocks;
+      container.nextOrderedBlocks = prevOrderedBlocks;
+      for (const block of createdBlocks) {
+        if (newBlocks.get(block.key) === block) {
+          _chunkUBFDB6OLcjs.flushOnMount.call(void 0, block.root);
+        }
+      }
+    });
+  };
+  const disconnectObserver = () => {
+    _optionalChain([connectObserver, 'optionalAccess', _9 => _9.disconnect, 'call', _10 => _10()]);
+    connectObserver = null;
+  };
+  const ensureEffectStarted = () => {
+    if (disposed || effectStarted) return effectStarted;
+    const isSSR = _chunkUBFDB6OLcjs.__fictIsSSR.call(void 0, );
+    const parent = isSSR ? container.startMarker.parentNode : getConnectedParent();
+    if (!parent) return false;
+    const start = () => {
+      effectDispose = _chunkUBFDB6OLcjs.createRenderEffect.call(void 0, performDiff);
+      effectStarted = true;
+    };
+    if (hostRoot) {
+      const prev = _chunkUBFDB6OLcjs.pushRoot.call(void 0, hostRoot);
+      try {
+        start();
+      } finally {
+        _chunkUBFDB6OLcjs.popRoot.call(void 0, prev);
+      }
+    } else {
+      start();
+    }
+    return true;
+  };
+  const waitForConnection = () => {
+    if (connectObserver || typeof MutationObserver === "undefined") return;
+    const root = _nullishCoalesce(_optionalChain([container, 'access', _11 => _11.startMarker, 'access', _12 => _12.getRootNode, 'optionalCall', _13 => _13()]), () => ( document));
+    const shadowRoot = root && root.nodeType === 11 && isShadowRoot(root) ? root : null;
+    connectObserver = new MutationObserver(() => {
+      if (disposed) return;
+      if (getConnectedParent()) {
+        disconnectObserver();
+        if (ensureEffectStarted()) {
+          _chunkUBFDB6OLcjs.flush.call(void 0, );
+        }
+      }
+    });
+    connectObserver.observe(document, { childList: true, subtree: true });
+    if (shadowRoot) {
+      connectObserver.observe(shadowRoot, { childList: true, subtree: true });
+    }
+  };
+  const scheduleStart = () => {
+    if (startScheduled || disposed || effectStarted) return;
+    startScheduled = true;
+    const run = () => {
+      startScheduled = false;
+      if (!ensureEffectStarted()) {
+        waitForConnection();
+      }
+    };
+    if (typeof queueMicrotask === "function") {
+      queueMicrotask(run);
+    } else {
+      Promise.resolve().then(run).catch(() => void 0);
+    }
+  };
+  scheduleStart();
+  return {
+    get marker() {
+      scheduleStart();
+      return fragment;
+    },
+    startMarker: container.startMarker,
+    endMarker: container.endMarker,
+    // Flush pending items - call after markers are inserted into DOM
+    flush: () => {
+      if (disposed) return;
+      scheduleStart();
+      if (ensureEffectStarted()) {
+        _chunkUBFDB6OLcjs.flush.call(void 0, );
+      } else {
+        waitForConnection();
+      }
+    },
+    dispose: () => {
+      disposed = true;
+      _optionalChain([effectDispose, 'optionalCall', _14 => _14()]);
+      disconnectObserver();
+      container.dispose();
+    }
+  };
+}
+
+
+
+
+
+
+exports.reconcileArrays = reconcileArrays; exports.moveNodesBefore = moveNodesBefore; exports.isNodeBetweenMarkers = isNodeBetweenMarkers; exports.createKeyedList = createKeyedList;
+//# sourceMappingURL=chunk-LBE6DC3V.cjs.map