@fictjs/runtime 0.0.13 → 0.0.14

package/dist/internal.cjs

@@ -0,0 +1,901 @@
+"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 _chunk624QY53Acjs = require('./chunk-624QY53A.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkPMF6MWEVcjs = require('./chunk-PMF6MWEV.cjs');
+
+// src/store.ts
+var PROXY = Symbol("fict:store-proxy");
+var TARGET = Symbol("fict:store-target");
+var ITERATE_KEY = Symbol("fict:iterate");
+function createStore(initialValue) {
+  const unwrapped = unwrap2(initialValue);
+  const wrapped = wrap(unwrapped);
+  function setStore(fn) {
+    _chunkPMF6MWEVcjs.batch.call(void 0, () => {
+      const result = fn(wrapped);
+      if (result !== void 0) {
+        reconcile(wrapped, result);
+      }
+    });
+  }
+  return [wrapped, setStore];
+}
+var proxyCache = /* @__PURE__ */ new WeakMap();
+var signalCache = /* @__PURE__ */ new WeakMap();
+function wrap(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (value[PROXY]) return value;
+  if (proxyCache.has(value)) return proxyCache.get(value);
+  const handler = {
+    get(target, prop2, receiver) {
+      if (prop2 === PROXY) return true;
+      if (prop2 === TARGET) return target;
+      const value2 = Reflect.get(target, prop2, receiver);
+      track(target, prop2);
+      return wrap(value2);
+    },
+    has(target, prop2) {
+      const result = Reflect.has(target, prop2);
+      track(target, prop2);
+      return result;
+    },
+    ownKeys(target) {
+      track(target, ITERATE_KEY);
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(target, prop2) {
+      track(target, prop2);
+      return Reflect.getOwnPropertyDescriptor(target, prop2);
+    },
+    set(target, prop2, value2, receiver) {
+      if (prop2 === PROXY || prop2 === TARGET) return false;
+      const hadKey = Object.prototype.hasOwnProperty.call(target, prop2);
+      const oldValue = Reflect.get(target, prop2, receiver);
+      if (oldValue === value2) return true;
+      const result = Reflect.set(target, prop2, value2, receiver);
+      if (result) {
+        trigger(target, prop2);
+        if (!hadKey) {
+          trigger(target, ITERATE_KEY);
+        }
+      }
+      return result;
+    },
+    deleteProperty(target, prop2) {
+      const hadKey = Object.prototype.hasOwnProperty.call(target, prop2);
+      const result = Reflect.deleteProperty(target, prop2);
+      if (result) {
+        trigger(target, prop2);
+        if (hadKey) {
+          trigger(target, ITERATE_KEY);
+        }
+      }
+      return result;
+    }
+  };
+  const proxy = new Proxy(value, handler);
+  proxyCache.set(value, proxy);
+  return proxy;
+}
+function unwrap2(value) {
+  if (value && typeof value === "object" && value[PROXY]) {
+    return value[TARGET];
+  }
+  return value;
+}
+function track(target, prop2) {
+  let signals = signalCache.get(target);
+  if (!signals) {
+    signals = /* @__PURE__ */ new Map();
+    signalCache.set(target, signals);
+  }
+  let s = signals.get(prop2);
+  if (!s) {
+    const initial = prop2 === ITERATE_KEY ? Reflect.ownKeys(target).length : getLastValue(target, prop2);
+    s = _chunkPMF6MWEVcjs.signal.call(void 0, initial);
+    signals.set(prop2, s);
+  }
+  s();
+}
+function trigger(target, prop2) {
+  const signals = signalCache.get(target);
+  if (signals) {
+    const s = signals.get(prop2);
+    if (s) {
+      if (prop2 === ITERATE_KEY) {
+        s(Reflect.ownKeys(target).length);
+      } else {
+        s(getLastValue(target, prop2));
+      }
+    }
+  }
+}
+function getLastValue(target, prop2) {
+  return target[prop2];
+}
+function reconcile(target, value) {
+  if (target === value) return;
+  if (value === null || typeof value !== "object") {
+    throw new Error(
+      `[Fict] Cannot replace store with primitive value: ${String(
+        value
+      )}. setStore should return an object/array to merge.`
+    );
+  }
+  const realTarget = unwrap2(target);
+  const realValue = unwrap2(value);
+  const keys = /* @__PURE__ */ new Set([...Object.keys(realTarget), ...Object.keys(realValue)]);
+  for (const key of keys) {
+    if (realValue[key] === void 0 && realTarget[key] !== void 0) {
+      delete target[key];
+    } else if (realTarget[key] !== realValue[key]) {
+      target[key] = realValue[key];
+    }
+  }
+  if (Array.isArray(target) && target.length !== realValue.length) {
+    target.length = realValue.length;
+  }
+}
+
+// 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 = true ? false : typeof process === "undefined" || _optionalChain([process, 'access', _7 => _7.env, 'optionalAccess', _8 => _8.NODE_ENV]) !== "production";
+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);
+            continue;
+          } catch (e2) {
+          }
+        }
+        throw e;
+      }
+    }
+    anchor = node;
+  }
+}
+var MAX_SAFE_VERSION = 9007199254740991;
+function createVersionedSignalAccessor(initialValue) {
+  let current = initialValue;
+  let version = 0;
+  const track2 = _chunkPMF6MWEVcjs.signal.call(void 0, version);
+  function accessor(value) {
+    if (arguments.length === 0) {
+      track2();
+      return current;
+    }
+    current = value;
+    version = version >= MAX_SAFE_VERSION ? 1 : version + 1;
+    track2(version);
+  }
+  return accessor;
+}
+function createKeyedListContainer() {
+  const startMarker = document.createComment("fict:list:start");
+  const endMarker = document.createComment("fict:list:end");
+  const dispose = () => {
+    for (const block of container.blocks.values()) {
+      _chunkPMF6MWEVcjs.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 ? _chunkPMF6MWEVcjs.signal.call(void 0, index) : ((next) => {
+    if (arguments.length === 0) return index;
+    index = next;
+    return index;
+  });
+  const root = _chunkPMF6MWEVcjs.createRootContext.call(void 0, hostRoot);
+  const prevRoot = _chunkPMF6MWEVcjs.pushRoot.call(void 0, root);
+  let nodes = [];
+  let scopeDispose;
+  const prevSub = _chunkPMF6MWEVcjs.setActiveSub.call(void 0, void 0);
+  try {
+    scopeDispose = _chunkPMF6MWEVcjs.effectScope.call(void 0, () => {
+      const rendered = render(itemSig, indexSig, key);
+      if (rendered instanceof Node || Array.isArray(rendered) && rendered.every((n) => n instanceof Node)) {
+        nodes = _chunkPMF6MWEVcjs.toNodeArray.call(void 0, rendered);
+      } else {
+        const element = _chunkPMF6MWEVcjs.createElement.call(void 0, rendered);
+        nodes = _chunkPMF6MWEVcjs.toNodeArray.call(void 0, element);
+      }
+    });
+    if (scopeDispose) {
+      root.cleanups.push(scopeDispose);
+    }
+  } finally {
+    _chunkPMF6MWEVcjs.setActiveSub.call(void 0, prevSub);
+    _chunkPMF6MWEVcjs.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) {
+  const resolvedNeedsIndex = arguments.length >= 4 ? !!needsIndex : renderItem.length > 1;
+  return createFineGrainedKeyedList(getItems, keyFn, renderItem, resolvedNeedsIndex);
+}
+function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
+  const container = createKeyedListContainer();
+  const hostRoot = _chunkPMF6MWEVcjs.getCurrentRoot.call(void 0, );
+  const fragment = document.createDocumentFragment();
+  fragment.append(container.startMarker, container.endMarker);
+  let disposed = false;
+  let effectDispose;
+  let connectObserver = null;
+  let effectStarted = false;
+  let startScheduled = false;
+  const getConnectedParent = () => {
+    const endParent = container.endMarker.parentNode;
+    const startParent = container.startMarker.parentNode;
+    if (endParent && startParent && endParent === startParent && endParent.nodeType !== 11) {
+      return endParent;
+    }
+    return null;
+  };
+  const performDiff = () => {
+    if (disposed) return;
+    const parent = getConnectedParent();
+    if (!parent) return;
+    _chunkPMF6MWEVcjs.batch2.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 (newItems.length === 0) {
+        if (oldBlocks.size > 0) {
+          for (const block of oldBlocks.values()) {
+            _chunkPMF6MWEVcjs.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.`
+              );
+            }
+            _chunkPMF6MWEVcjs.destroyRoot.call(void 0, existingBlock.root);
+            _chunkPMF6MWEVcjs.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) {
+            _chunkPMF6MWEVcjs.destroyRoot.call(void 0, prior.root);
+            _chunkPMF6MWEVcjs.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) {
+          _chunkPMF6MWEVcjs.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) {
+            _chunkPMF6MWEVcjs.flushOnMount.call(void 0, block.root);
+          }
+        }
+        return;
+      }
+      if (oldBlocks.size > 0) {
+        for (const block of oldBlocks.values()) {
+          _chunkPMF6MWEVcjs.destroyRoot.call(void 0, block.root);
+          _chunkPMF6MWEVcjs.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) {
+          _chunkPMF6MWEVcjs.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 parent = getConnectedParent();
+    if (!parent) return false;
+    const start = () => {
+      effectDispose = _chunkPMF6MWEVcjs.createRenderEffect.call(void 0, performDiff);
+      effectStarted = true;
+    };
+    if (hostRoot) {
+      const prev = _chunkPMF6MWEVcjs.pushRoot.call(void 0, hostRoot);
+      try {
+        start();
+      } finally {
+        _chunkPMF6MWEVcjs.popRoot.call(void 0, prev);
+      }
+    } else {
+      start();
+    }
+    return true;
+  };
+  const waitForConnection = () => {
+    if (connectObserver || typeof MutationObserver === "undefined") return;
+    connectObserver = new MutationObserver(() => {
+      if (disposed) return;
+      if (getConnectedParent()) {
+        disconnectObserver();
+        if (ensureEffectStarted()) {
+          _chunkPMF6MWEVcjs.flush.call(void 0, );
+        }
+      }
+    });
+    connectObserver.observe(document, { 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()) {
+        _chunkPMF6MWEVcjs.flush.call(void 0, );
+      } else {
+        waitForConnection();
+      }
+    },
+    dispose: () => {
+      disposed = true;
+      _optionalChain([effectDispose, 'optionalCall', _11 => _11()]);
+      disconnectObserver();
+      container.dispose();
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Aliases = _chunkPMF6MWEVcjs.Aliases; exports.BooleanAttributes = _chunkPMF6MWEVcjs.BooleanAttributes; exports.ChildProperties = _chunkPMF6MWEVcjs.ChildProperties; exports.DelegatedEvents = _chunkPMF6MWEVcjs.DelegatedEvents; exports.Fragment = _chunkPMF6MWEVcjs.Fragment; exports.Properties = _chunkPMF6MWEVcjs.Properties; exports.SVGElements = _chunkPMF6MWEVcjs.SVGElements; exports.SVGNamespace = _chunkPMF6MWEVcjs.SVGNamespace; exports.UnitlessStyles = _chunkPMF6MWEVcjs.UnitlessStyles; exports.__fictPopContext = _chunkPMF6MWEVcjs.__fictPopContext; exports.__fictProp = _chunkPMF6MWEVcjs.__fictProp; exports.__fictPropsRest = _chunkPMF6MWEVcjs.__fictPropsRest; exports.__fictPushContext = _chunkPMF6MWEVcjs.__fictPushContext; exports.__fictRender = _chunkPMF6MWEVcjs.__fictRender; exports.__fictResetContext = _chunkPMF6MWEVcjs.__fictResetContext; exports.__fictUseContext = _chunkPMF6MWEVcjs.__fictUseContext; exports.__fictUseEffect = _chunkPMF6MWEVcjs.__fictUseEffect; exports.__fictUseMemo = _chunkPMF6MWEVcjs.__fictUseMemo; exports.__fictUseSignal = _chunkPMF6MWEVcjs.__fictUseSignal; exports.addEventListener = _chunkPMF6MWEVcjs.addEventListener; exports.assign = _chunkPMF6MWEVcjs.assign; exports.bindAttribute = _chunkPMF6MWEVcjs.bindAttribute; exports.bindClass = _chunkPMF6MWEVcjs.bindClass; exports.bindEvent = _chunkPMF6MWEVcjs.bindEvent; exports.bindProperty = _chunkPMF6MWEVcjs.bindProperty; exports.bindRef = _chunkPMF6MWEVcjs.bindRef; exports.bindStyle = _chunkPMF6MWEVcjs.bindStyle; exports.bindText = _chunkPMF6MWEVcjs.bindText; exports.callEventHandler = _chunkPMF6MWEVcjs.callEventHandler; exports.classList = _chunkPMF6MWEVcjs.classList; exports.clearDelegatedEvents = _chunkPMF6MWEVcjs.clearDelegatedEvents; exports.createConditional = _chunkPMF6MWEVcjs.createConditional; exports.createEffect = _chunkPMF6MWEVcjs.createEffect; exports.createElement = _chunkPMF6MWEVcjs.createElement; exports.createKeyedList = createKeyedList; exports.createMemo = _chunkPMF6MWEVcjs.createMemo; exports.createPortal = _chunkPMF6MWEVcjs.createPortal; exports.createPropsProxy = _chunkPMF6MWEVcjs.createPropsProxy; exports.createRenderEffect = _chunkPMF6MWEVcjs.createRenderEffect; exports.createSelector = _chunkPMF6MWEVcjs.createSelector; exports.createSignal = _chunkPMF6MWEVcjs.signal; exports.createStore = createStore; exports.delegateEvents = _chunkPMF6MWEVcjs.delegateEvents; exports.getPropAlias = _chunkPMF6MWEVcjs.getPropAlias; exports.insert = _chunkPMF6MWEVcjs.insert; exports.insertNodesBefore = _chunkPMF6MWEVcjs.insertNodesBefore; exports.isNodeBetweenMarkers = isNodeBetweenMarkers; exports.isReactive = _chunkPMF6MWEVcjs.isReactive; exports.mergeProps = _chunkPMF6MWEVcjs.mergeProps; exports.moveNodesBefore = moveNodesBefore; exports.onDestroy = _chunkPMF6MWEVcjs.onDestroy; exports.prop = _chunkPMF6MWEVcjs.prop; exports.reconcileArrays = reconcileArrays; exports.removeNodes = _chunkPMF6MWEVcjs.removeNodes; exports.runInScope = _chunk624QY53Acjs.runInScope; exports.spread = _chunkPMF6MWEVcjs.spread; exports.template = _chunkPMF6MWEVcjs.template; exports.toNodeArray = _chunkPMF6MWEVcjs.toNodeArray; exports.unwrap = _chunkPMF6MWEVcjs.unwrap;
+//# sourceMappingURL=internal.cjs.map