creo 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,354 +1,30 @@
-// src/structures/list.ts
-var $next = Symbol("next");
-var $prev = Symbol("prev");
-var $owner = Symbol("owner");
-
-class ListNode {
-  [$owner];
-  [$next];
-  [$prev];
-  v;
-  constructor(node, prev = null, next = null, list) {
-    this[$prev] = prev;
-    this[$next] = next;
-    this[$owner] = list;
-    this.v = node;
-  }
-  isFirst() {
-    return this[$prev] == null;
-  }
-  isLast() {
-    return this[$next] == null;
-  }
-  delete() {
-    this[$owner]?.delete(this);
-  }
-  clearFields() {
-    this[$next] = null;
-    this[$prev] = null;
-    this[$owner] = null;
-  }
-  insertNext(value) {
-    const owner = this[$owner];
-    if (!owner) {
-      throw new Error("The item is detached from DataContainer");
-    }
-    return owner.insertNext(this, value);
-  }
-  insertPrev(value) {
-    const owner = this[$owner];
-    if (!owner) {
-      throw new Error("The item is detached from DataContainer");
-    }
-    return owner.insertPrev(this, value);
-  }
-  getNext() {
-    return this[$next];
-  }
-  getPrev() {
-    return this[$prev];
-  }
-  getList() {
-    return this[$owner];
-  }
-}
-
-class InternalList {
-  #head;
-  #tail;
-  #size = 0;
-  #cursorNode;
-  #cursorIndex = -1;
-  #invalidateCursor() {
-    this.#cursorNode = null;
-    this.#cursorIndex = -1;
-  }
-  insertStart(value) {
-    const node = new ListNode(value, null, this.#head, this);
-    if (this.#head != null) {
-      this.#head[$prev] = node;
-    } else {
-      this.#tail = node;
-    }
-    this.#head = node;
-    this.#size++;
-    this.#invalidateCursor();
-    return this.#head;
-  }
-  delete(node) {
-    const n = node;
-    const prev = n[$prev];
-    const next = n[$next];
-    if (next) {
-      next[$prev] = prev;
-    }
-    if (prev) {
-      prev[$next] = next;
-    }
-    if (node === this.#head) {
-      this.#head = next;
-    }
-    if (node === this.#tail) {
-      this.#tail = prev;
-    }
-    n.clearFields();
-    this.#size--;
-    this.#invalidateCursor();
-  }
-  at(n) {
-    if (n < 0)
-      n = this.#size + n;
-    if (n < 0 || n >= this.#size)
-      return;
-    let current;
-    let pos;
-    const distFromHead = n;
-    const distFromTail = this.#size - 1 - n;
-    const distFromCursor = this.#cursorNode != null ? Math.abs(n - this.#cursorIndex) : Infinity;
-    if (distFromCursor <= distFromHead && distFromCursor <= distFromTail) {
-      current = this.#cursorNode;
-      pos = this.#cursorIndex;
-    } else if (distFromHead <= distFromTail) {
-      current = this.#head;
-      pos = 0;
-    } else {
-      current = this.#tail;
-      pos = this.#size - 1;
-    }
-    while (pos < n && current != null) {
-      current = current[$next];
-      pos++;
-    }
-    while (pos > n && current != null) {
-      current = current[$prev];
-      pos--;
-    }
-    if (current != null) {
-      this.#cursorNode = current;
-      this.#cursorIndex = pos;
-    }
-    return current;
-  }
-  get size() {
-    return this.#size;
-  }
-  clear() {
-    this.#head = null;
-    this.#tail = null;
-    this.#size = 0;
-    this.#invalidateCursor();
-  }
-  first() {
-    return this.#head;
-  }
-  last() {
-    return this.#tail;
-  }
-  insertEnd(value) {
-    const node = new ListNode(value, this.#tail, null, this);
-    if (this.#tail != null) {
-      this.#tail[$next] = node;
-    } else {
-      this.#head = node;
-    }
-    this.#tail = node;
-    this.#size++;
-    return this.#tail;
-  }
-  insertNext(ref, value) {
-    const r = ref;
-    if (r[$owner] != this) {
-      throw new TypeError("The reference node does not belong to the current list");
-    }
-    const node = new ListNode(value, r, r[$next], this);
-    if (r[$next]) {
-      r[$next][$prev] = node;
-    } else {
-      this.#tail = node;
-    }
-    r[$next] = node;
-    this.#size++;
-    this.#invalidateCursor();
-    return node;
-  }
-  insertPrev(ref, value) {
-    const r = ref;
-    if (r[$owner] != this) {
-      throw new TypeError("The reference node does not belong to the current list");
-    }
-    const node = new ListNode(value, r[$prev], r, this);
-    if (r[$prev]) {
-      r[$prev][$next] = node;
-    } else {
-      this.#head = node;
-    }
-    r[$prev] = node;
-    this.#size++;
-    this.#invalidateCursor();
-    return node;
-  }
-  *[Symbol.iterator]() {
-    let current = this.#head;
-    while (current) {
-      const next = current[$next];
-      yield current;
-      current = next;
-    }
-  }
-}
-
-// src/structures/indexed_list.ts
-class IndexedList {
-  #list = new InternalList;
-  #map = new Map;
-  push(item) {
-    const existing = this.#map.get(item);
-    if (existing)
-      return existing;
-    const node = this.#list.insertEnd(item);
-    this.#map.set(item, node);
-    return node;
-  }
-  unshift(item) {
-    if (this.#map.has(item))
-      return;
-    const node = this.#list.insertStart(item);
-    this.#map.set(item, node);
-  }
-  insertAfter(ref, item) {
-    if (this.#map.has(item))
-      return;
-    const refNode = this.#map.get(ref);
-    if (!refNode) {
-      this.push(item);
-      return;
-    }
-    const node = refNode.insertNext(item);
-    this.#map.set(item, node);
-  }
-  delete(item) {
-    const node = this.#map.get(item);
-    if (!node)
-      return;
-    this.#map.delete(item);
-    node.delete();
-  }
-  has(item) {
-    return this.#map.has(item);
-  }
-  get length() {
-    return this.#map.size;
-  }
-  first() {
-    return this.#list.first()?.v;
-  }
-  last() {
-    return this.#list.last()?.v;
-  }
-  getNode(item) {
-    return this.#map.get(item);
-  }
-  at(index) {
-    return this.#list.at(index)?.v;
-  }
-  upsert(pos, item) {
-    const existing = this.#list.at(pos);
-    if (!existing) {
-      return this.push(item);
-    }
-    this.#map.delete(existing.v);
-    existing.v = item;
-    this.#map.set(item, existing);
-    return existing;
-  }
-  swap(a, b) {
-    const nodeA = this.#map.get(a);
-    const nodeB = this.#map.get(b);
-    if (!nodeA || !nodeB)
-      return;
-    nodeA.v = b;
-    nodeB.v = a;
-    this.#map.set(a, nodeB);
-    this.#map.set(b, nodeA);
-  }
-  clear() {
-    this.#list.clear();
-    this.#map.clear();
-  }
-  *[Symbol.iterator]() {
-    for (const node of this.#list) {
-      yield node.v;
-    }
+// src/internal/internal_view.ts
+var F_PENDING = 1;
+var F_DIRTY = 1 << 1;
+var F_MOVED = 1 << 2;
+var F_QUICK_RERENDER = 1 << 3;
+var F_PRIMITIVE = 1 << 4;
+var F_TEXT_CONTENT = 1 << 5;
+function hasScStructuralChange(prev, next) {
+  const prevLen = prev?.length ?? 0;
+  const nextLen = next?.length ?? 0;
+  if (prevLen === 0 && nextLen === 0)
+    return false;
+  if (!prev || !next)
+    return true;
+  if (prev.length !== next.length)
+    return true;
+  for (let i = 0;i < next.length; i++) {
+    if (next[i].viewFn !== prev[i].viewFn)
+      return true;
+    if (next[i].userKey !== prev[i].userKey)
+      return true;
   }
+  return false;
 }
 
-// src/internal/engine.ts
-class Engine {
-  renderer;
-  dirty = new IndexedList;
-  #scheduler;
-  #renderScheduled = false;
-  #collector;
-  constructor(renderer, scheduler) {
-    this.renderer = renderer;
-    this.#scheduler = scheduler ?? "scheduler" in globalThis ? (cb) => window.scheduler.postTask(cb) : (cb) => queueMicrotask(cb);
-  }
-  disposeView(view) {
-    this.dirty.delete(view);
-  }
-  schedule() {
-    if (this.#renderScheduled) {
-      return;
-    }
-    this.#renderScheduled = true;
-    this.#scheduler(() => {
-      this.#renderScheduled = false;
-      this.render();
-    });
-  }
-  markDirty(view) {
-    this.dirty.push(view);
-    this.schedule();
-  }
-  pendingView(view) {
-    this.#collector?.(view);
-  }
-  collect(slot) {
-    const list = [];
-    const prev = this.#collector;
-    this.#collector = list.push.bind(list);
-    slot();
-    this.#collector = prev;
-    return list;
-  }
-  #rendering = false;
-  render() {
-    if (this.#rendering)
-      return;
-    this.#rendering = true;
-    try {
-      const cbs = [];
-      while (this.dirty.length > 0) {
-        const view = this.dirty.first();
-        const isNew = view.renderRef == null;
-        if (!isNew)
-          view.onUpdateBefore();
-        this.renderer.render(view);
-        if (view.dirty) {
-          view.reconsile();
-          cbs.push(isNew ? view.onMount : view.onUpdateAfter);
-          view.dirty = false;
-        }
-        this.dirty.delete(view);
-      }
-      for (const cb of cbs) {
-        cb();
-      }
-    } finally {
-      this.#rendering = false;
-    }
-  }
-}
+// src/public/primitive.ts
+var $primitive = Symbol("primitive");
 
 // src/public/state.ts
 class State {
@@ -436,219 +112,484 @@ function shallowEqual(a, b) {
   if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
     return false;
   }
-  const keysA = Object.keys(a);
-  if (keysA.length !== Object.keys(b).length)
-    return false;
-  for (let i = 0;i < keysA.length; i++) {
-    const key = keysA[i];
-    if (!Object.is(a[key], b[key])) {
+  let countA = 0;
+  for (const key in a) {
+    countA++;
+    if (!Object.is(a[key], b[key]))
       return false;
+  }
+  let countB = 0;
+  for (const _ in b)
+    countB++;
+  return countA === countB;
+}
+
+// src/functional/lis.ts
+function lis(arr) {
+  const len = arr.length;
+  if (len === 0)
+    return new Set;
+  const tails = [];
+  const prev = new Array(len).fill(-1);
+  for (let i = 0;i < len; i++) {
+    if (arr[i] < 0)
+      continue;
+    const val = arr[i];
+    let lo = 0;
+    let hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (arr[tails[mid]] < val)
+        lo = mid + 1;
+      else
+        hi = mid;
     }
+    if (lo > 0)
+      prev[i] = tails[lo - 1];
+    tails[lo] = i;
+  }
+  const result = new Set;
+  if (tails.length === 0)
+    return result;
+  let idx = tails[tails.length - 1];
+  for (let k = tails.length - 1;k >= 0; k--) {
+    result.add(idx);
+    idx = prev[idx];
   }
-  return true;
+  return result;
 }
 
-// src/internal/internal_view.ts
-class View {
-  viewFn;
-  engine;
-  parent;
-  userKey;
-  renderRef;
-  props;
-  slotChildren;
-  body;
-  virtualDom;
-  keyToIndex;
-  dirty = true;
-  moved = false;
-  quickRerender = true;
-  #unsubscribe = [];
-  constructor(viewFn, initialProps, slot, engine, parent, userKey) {
-    this.viewFn = viewFn;
-    this.engine = engine;
-    this.parent = parent;
-    this.userKey = userKey;
-    this.props = initialProps;
-    this.body = viewFn({
-      props: () => this.props,
-      use: (storeOrInitial) => {
-        if (!isStore(storeOrInitial)) {
-          return new State(storeOrInitial, this.markDirty);
+// src/internal/orchestrator.ts
+class Orchestrator {
+  #currentEngine;
+  setCurrentEngine(engine) {
+    this.#currentEngine = engine;
+  }
+  currentEngine() {
+    return this.#currentEngine;
+  }
+}
+var orchestrator = new Orchestrator;
+
+// src/internal/engine.ts
+class Engine {
+  renderer;
+  #dirtyQueue = new Set;
+  #collector;
+  #collectFor;
+  #scheduler;
+  #renderScheduled = false;
+  #rendering = false;
+  constructor(renderer, scheduler) {
+    this.renderer = renderer;
+    this.#scheduler = scheduler ?? ((cb) => queueMicrotask(cb));
+    renderer.engine = this;
+  }
+  newView(viewFn, parent, props, slot, userKey) {
+    const res = {
+      viewFn,
+      userKey,
+      props,
+      slot,
+      body: null,
+      sc: null,
+      renderRef: null,
+      flags: F_PENDING | (viewFn[$primitive] != null ? F_PRIMITIVE : 0),
+      children: null,
+      keyToView: null,
+      unsubscribe: null,
+      parent,
+      scHost: null
+    };
+    if (slot) {
+      res.sc = this.#collect(slot, [], res);
+    }
+    return res;
+  }
+  view(viewFn, props, slot, userKey) {
+    const view = this.newView(viewFn, this.#collectFor, props, slot, userKey);
+    this.#collector?.push(view);
+    return view;
+  }
+  views(views) {
+    if (views)
+      this.#collector?.push(...views);
+  }
+  initViewBody(view) {
+    if (!(view.flags & F_PENDING))
+      return;
+    view.flags &= ~F_PENDING;
+    if (view.flags & F_PRIMITIVE) {
+      const engine = this;
+      view.body = {
+        render() {
+          engine.views(view.sc);
+        }
+      };
+      return;
+    }
+    view.body = view.viewFn({
+      props: () => view.props,
+      use: (storeOrState) => {
+        if (!isStore(storeOrState)) {
+          return new State(storeOrState, () => this.markDirty(view));
         }
-        const s = storeOrInitial;
-        this.#unsubscribe.push(this.markDirty);
+        const s = storeOrState;
+        const unsub = s.subscribe(() => this.markDirty(view));
+        if (!view.unsubscribe)
+          view.unsubscribe = [];
+        view.unsubscribe.push(unsub);
         return s;
       },
       slot: () => {
-        if (!this.slotChildren) {
+        if (!view.sc)
           return;
-        }
-        for (const child of this.slotChildren) {
-          this.engine.pendingView(child);
+        view.scHost = this.#collectFor ?? view;
+        for (const child of view.sc) {
+          child.parent = this.#collectFor ?? view;
+          this.#collector?.push(child);
         }
       }
     });
-    this.slotChildren = slot && this.engine.collect(slot);
-    this.markDirty();
   }
-  markDirty = () => {
-    this.dirty = true;
-    this.engine.markDirty(this);
-  };
-  markMove() {
-    this.moved = true;
-    this.engine.markDirty(this);
+  createRoot(children, props) {
+    orchestrator.setCurrentEngine(this);
+    const view = this.newView(({ slot }) => ({
+      render() {
+        slot();
+      }
+    }), null, props, children, null);
+    this.markDirty(view);
+    return view;
   }
-  shouldUpdate(nextProps) {
-    if (this.body.shouldUpdate) {
-      return this.body.shouldUpdate(nextProps);
+  markDirty(view) {
+    if (view.flags & F_DIRTY) {
+      return;
     }
-    return !shallowEqual(this.props, nextProps);
+    view.flags |= F_DIRTY;
+    this.#dirtyQueue.add(view);
+    this.schedule();
   }
-  onMount = () => {
-    this.quickRerender = false;
-    this.body.onMount?.();
-  };
-  onUpdateBefore() {
-    this.body.onUpdateBefore?.();
+  markMoved(view) {
+    if (view.flags & F_MOVED) {
+      return;
+    }
+    view.flags |= F_MOVED;
+    this.#dirtyQueue.add(view);
+    this.schedule();
   }
-  onUpdateAfter = () => {
-    this.quickRerender = false;
-    this.body.onUpdateBefore?.();
-  };
-  nextProps(nextProps, nextSlot) {
-    const prevChildren = this.slotChildren;
-    this.slotChildren = nextSlot && this.engine.collect(nextSlot);
-    if (this.shouldUpdate(nextProps) || hasNewChildren(prevChildren, this.slotChildren)) {
-      this.markDirty();
-      this.props = nextProps;
+  schedule() {
+    if (this.#renderScheduled)
+      return;
+    this.#renderScheduled = true;
+    this.#scheduler(() => {
+      this.#renderScheduled = false;
+      this.render();
+    });
+  }
+  #collect(render, collector, parent) {
+    const before = this.#collector;
+    const beforeParent = this.#collectFor;
+    this.#collector = collector;
+    this.#collectFor = parent;
+    render();
+    this.#collector = before;
+    this.#collectFor = beforeParent;
+    return collector;
+  }
+  nextProps(view, nextProps, nextSlot, preCollectedSc) {
+    const prevSc = view.sc;
+    view.slot = nextSlot;
+    if (preCollectedSc) {
+      for (const child of preCollectedSc)
+        child.parent = view;
+      view.sc = preCollectedSc;
+    } else {
+      view.sc = nextSlot ? this.#collect(nextSlot, [], view) : null;
+    }
+    const structChanged = hasScStructuralChange(prevSc, view.sc);
+    const shouldUpdate = view.body?.shouldUpdate ? view.body.shouldUpdate(nextProps) : !shallowEqual(view.props, nextProps);
+    if (shouldUpdate || structChanged) {
+      view.props = nextProps;
+      this.markDirty(view);
+    } else if (view.sc && view.scHost?.children) {
+      this.#propagateScProps(view);
+    } else if (view.sc && prevSc) {
+      for (let i = 0;i < view.sc.length; i++) {
+        if (view.sc[i].props !== prevSc[i].props) {
+          this.markDirty(view);
+          break;
+        }
+      }
     }
   }
-  reconsile() {
-    const children = this.engine.collect(this.body.render);
-    if (!this.virtualDom && children.length === 0)
+  #propagateScProps(owner) {
+    const host = owner.scHost;
+    const sc = owner.sc;
+    if (!host?.children || !sc)
       return;
-    if (!this.virtualDom)
-      this.virtualDom = new IndexedList;
-    this.quickRerender = true;
-    const vdom = this.virtualDom;
-    for (let i = 0;i < children.length; i++) {
-      const pending = children[i];
-      const expectedNext = vdom.at(i);
-      if (pending.userKey == null) {
-        if (expectedNext?.viewFn === pending.viewFn) {
-          this.quickRerender = false;
-          expectedNext.nextProps(pending.props, pending.slot);
-        } else {
-          if (expectedNext) {
-            if (expectedNext.userKey)
-              this.keyToIndex?.delete(expectedNext.userKey);
-            expectedNext[Symbol.dispose]();
+    if (host.keyToView) {
+      for (const item of sc) {
+        if (item.userKey != null) {
+          const live = host.keyToView.get(item.userKey);
+          if (live && live.viewFn === item.viewFn) {
+            this.nextProps(live, item.props, item.slot);
           }
-          vdom.upsert(i, new View(pending.viewFn, pending.props, pending.slot, this.engine, this, null));
         }
-      } else {
-        const matchedIndex = this.keyToIndex?.get(pending.userKey);
-        const matched = matchedIndex != null ? vdom.at(matchedIndex) : null;
-        if (matched && matched.viewFn === pending.viewFn) {
-          this.quickRerender = false;
-          matched.nextProps(pending.props, pending.slot);
-          if (expectedNext != null) {
-            if (matched !== expectedNext) {
-              matched.markMove();
-              expectedNext.markMove();
-              vdom.swap(matched, expectedNext);
-              if (this.keyToIndex) {
-                if (matched.userKey != null)
-                  this.keyToIndex.set(matched.userKey, i);
-                if (expectedNext.userKey != null)
-                  this.keyToIndex.set(expectedNext.userKey, matchedIndex);
-              }
-            }
-          } else {
-            matched.markMove();
-            vdom.upsert(i, matched);
-            if (this.keyToIndex && matched.userKey != null) {
-              this.keyToIndex.set(matched.userKey, i);
-            }
-          }
-        } else {
-          if (expectedNext) {
-            if (expectedNext.userKey)
-              this.keyToIndex?.delete(expectedNext.userKey);
-            expectedNext[Symbol.dispose]();
-          }
-          vdom.upsert(i, new View(pending.viewFn, pending.props, pending.slot, this.engine, this, pending.userKey));
-          if (!this.keyToIndex)
-            this.keyToIndex = new Map;
-          this.keyToIndex.set(pending.userKey, i);
+      }
+    } else {
+      const len = Math.min(sc.length, host.children.length);
+      for (let i = 0;i < len; i++) {
+        const live = host.children[i];
+        if (live.viewFn === sc[i].viewFn) {
+          this.nextProps(live, sc[i].props, sc[i].slot);
         }
       }
     }
-    if (children.length < vdom.length) {
-      for (let i = vdom.length;i >= children.length; i--) {
-        const removed = vdom.at(i);
-        if (removed) {
-          if (removed.userKey)
-            this.keyToIndex?.delete(removed.userKey);
-          removed[Symbol.dispose]();
-          vdom.delete(removed);
+  }
+  reconcile(view) {
+    let pendingChildren = null;
+    if (view.body?.render) {
+      pendingChildren = this.#collect(view.body.render, [], view);
+    }
+    if (pendingChildren == null || pendingChildren.length === 0) {
+      if (view.children)
+        for (const child of view.children)
+          this.dispose(child);
+      return;
+    }
+    if (view.children == null) {
+      view.children = pendingChildren;
+      for (const child of pendingChildren) {
+        this.initViewBody(child);
+        this.markDirty(child);
+        if (child.userKey != null) {
+          if (!view.keyToView)
+            view.keyToView = new Map;
+          view.keyToView.set(child.userKey, child);
         }
       }
+      return;
+    }
+    const hasKeys = pendingChildren.some((c) => c.userKey != null);
+    if (hasKeys) {
+      this.#reconcileKeyed(view, view.children, pendingChildren);
+    } else {
+      this.#reconcileNonKeyed(view, view.children, pendingChildren);
     }
   }
-  [Symbol.dispose]() {
-    if (this.virtualDom) {
-      for (const child of this.virtualDom) {
-        child[Symbol.dispose]();
+  #reconcileNonKeyed(view, oldChildren, pending) {
+    const oldLen = oldChildren.length;
+    const newLen = pending.length;
+    const minLen = Math.min(oldLen, newLen);
+    for (let i = 0;i < minLen; i++) {
+      const old = oldChildren[i];
+      const pend = pending[i];
+      this.#patchOrReplace(view, oldChildren, i, old, pend);
+    }
+    for (let i = oldLen;i < newLen; i++) {
+      oldChildren[i] = pending[i];
+      this.initViewBody(pending[i]);
+      this.markDirty(pending[i]);
+    }
+    for (let i = newLen;i < oldLen; i++) {
+      this.dispose(oldChildren[i]);
+    }
+    oldChildren.length = newLen;
+  }
+  #reconcileKeyed(view, oldChildren, pending) {
+    let i = 0;
+    let oldEnd = oldChildren.length - 1;
+    let newEnd = pending.length - 1;
+    while (i <= oldEnd && i <= newEnd) {
+      const oldView = oldChildren[i];
+      const pendView = pending[i];
+      if (oldView.userKey !== pendView.userKey)
+        break;
+      this.#patchOrReplace(view, oldChildren, i, oldView, pendView);
+      i++;
+    }
+    while (oldEnd >= i && newEnd >= i) {
+      const oldView = oldChildren[oldEnd];
+      const pendView = pending[newEnd];
+      if (oldView.userKey !== pendView.userKey)
+        break;
+      this.#patchOrReplace(view, oldChildren, oldEnd, oldView, pendView);
+      oldEnd--;
+      newEnd--;
+    }
+    if (i > oldEnd) {
+      for (let j = i;j <= newEnd; j++) {
+        this.initViewBody(pending[j]);
+        this.markDirty(pending[j]);
+        if (pending[j].userKey != null) {
+          if (!view.keyToView)
+            view.keyToView = new Map;
+          view.keyToView.set(pending[j].userKey, pending[j]);
+        }
+      }
+      view.children = [
+        ...oldChildren.slice(0, i),
+        ...pending.slice(i, newEnd + 1),
+        ...oldChildren.slice(i, oldEnd + 1)
+      ];
+      return;
+    }
+    if (i > newEnd) {
+      for (let j = i;j <= oldEnd; j++) {
+        this.dispose(oldChildren[j]);
       }
+      view.children = [
+        ...oldChildren.slice(0, i),
+        ...oldChildren.slice(oldEnd + 1)
+      ];
+      return;
+    }
+    const newKeyToIndex = new Map;
+    for (let j = i;j <= newEnd; j++) {
+      const key = pending[j].userKey;
+      if (key != null)
+        newKeyToIndex.set(key, j);
     }
-    this.engine.renderer.unmount(this);
-    this.engine.disposeView(this);
+    const middleLen = newEnd - i + 1;
+    const newIdxToOldIdx = new Array(middleLen).fill(-1);
+    const matched = new Set;
+    for (let j = i;j <= oldEnd; j++) {
+      const oldView = oldChildren[j];
+      const key = oldView.userKey;
+      if (key != null && newKeyToIndex.has(key)) {
+        const newIdx = newKeyToIndex.get(key);
+        newIdxToOldIdx[newIdx - i] = j;
+        matched.add(j);
+      }
+    }
+    for (let j = i;j <= oldEnd; j++) {
+      if (!matched.has(j)) {
+        this.dispose(oldChildren[j]);
+      }
+    }
+    const stable = lis(newIdxToOldIdx);
+    const newChildren = new Array(middleLen);
+    for (let j = middleLen - 1;j >= 0; j--) {
+      const newIdx = i + j;
+      const pendView = pending[newIdx];
+      if (newIdxToOldIdx[j] === -1) {
+        this.initViewBody(pendView);
+        this.markDirty(pendView);
+        if (pendView.userKey != null) {
+          if (!view.keyToView)
+            view.keyToView = new Map;
+          view.keyToView.set(pendView.userKey, pendView);
+        }
+        newChildren[j] = pendView;
+      } else {
+        const oldView = oldChildren[newIdxToOldIdx[j]];
+        this.#patchOrReplace(view, oldChildren, newIdxToOldIdx[j], oldView, pendView);
+        if (!stable.has(j)) {
+          this.markMoved(oldView);
+        }
+        newChildren[j] = oldView;
+      }
+    }
+    const head = oldChildren.slice(0, i);
+    const tail = oldChildren.slice(oldEnd + 1);
+    view.children = [...head, ...newChildren, ...tail];
   }
-}
-function hasNewChildren(prev, next) {
-  const prevLen = prev?.length ?? 0;
-  const nextLen = next?.length ?? 0;
-  if (prevLen === 0 && nextLen === 0)
-    return false;
-  if (!prev || !next)
-    return true;
-  if (prev.length !== next.length)
-    return true;
-  for (let i = 0;i < next.length; i++) {
-    if (next[i].viewFn !== prev[i].viewFn)
-      return true;
-    if (next[i].userKey !== prev[i].userKey)
-      return true;
-    if (next[i].props !== prev[i].props)
-      return true;
+  #patchOrReplace(parent, oldChildren, idx, oldView, pendView) {
+    if (oldView.viewFn === pendView.viewFn) {
+      this.nextProps(oldView, pendView.props, pendView.slot, pendView.sc);
+    } else {
+      this.dispose(oldView);
+      oldChildren[idx] = pendView;
+      this.initViewBody(pendView);
+      this.markDirty(pendView);
+      if (pendView.userKey != null) {
+        if (!parent.keyToView)
+          parent.keyToView = new Map;
+        parent.keyToView.set(pendView.userKey, pendView);
+      }
+    }
   }
-  return false;
-}
-
-// src/internal/orchestrator.ts
-class Orchestrator {
-  #currentEngine;
-  setCurrentEngine(engine) {
-    this.#currentEngine = engine;
+  dispose(view) {
+    const isPrimitiveWithDom = view.flags & F_PRIMITIVE && view.renderRef;
+    if (view.children) {
+      for (const child of view.children) {
+        if (isPrimitiveWithDom) {
+          this.#disposeVirtual(child);
+        } else {
+          this.dispose(child);
+        }
+      }
+    }
+    if (view.unsubscribe)
+      for (const unsub of view.unsubscribe)
+        unsub();
+    if (view.userKey != null)
+      view.parent?.keyToView?.delete(view.userKey);
+    this.renderer.unmount(view);
+    this.#dirtyQueue.delete(view);
+  }
+  #disposeVirtual(view) {
+    if (view.children) {
+      for (const child of view.children)
+        this.#disposeVirtual(child);
+    }
+    if (view.unsubscribe)
+      for (const unsub of view.unsubscribe)
+        unsub();
+    if (view.userKey != null)
+      view.parent?.keyToView?.delete(view.userKey);
+    view.renderRef = undefined;
+    this.#dirtyQueue.delete(view);
   }
-  currentEngine() {
-    return this.#currentEngine;
+  render() {
+    if (this.#rendering)
+      return;
+    orchestrator.setCurrentEngine(this);
+    this.#rendering = true;
+    try {
+      const cbs = [];
+      for (const view of this.#dirtyQueue) {
+        this.initViewBody(view);
+        const isNew = !view.renderRef;
+        if (!isNew)
+          view.body?.onUpdateBefore?.();
+        if (view.flags & F_DIRTY) {
+          this.reconcile(view);
+          this.renderer.render(view);
+          view.flags &= ~F_DIRTY;
+          view.flags &= ~F_MOVED;
+          if (isNew && view.body?.onMount) {
+            const b = view.body;
+            cbs.push(() => b.onMount());
+          } else if (!isNew && view.body?.onUpdateAfter) {
+            const b = view.body;
+            cbs.push(() => b.onUpdateAfter());
+          }
+        } else {
+          this.renderer.render(view);
+          view.flags &= ~F_MOVED;
+        }
+      }
+      this.#dirtyQueue.clear();
+      orchestrator.setCurrentEngine(null);
+      this.#rendering = false;
+      for (const cb of cbs)
+        cb();
+    } catch (e) {
+      orchestrator.setCurrentEngine(null);
+      this.#rendering = false;
+      throw e;
+    }
   }
 }
-var orchestrator = new Orchestrator;
 
 // src/public/app.ts
 function createApp(slot, renderer, options) {
   return {
     mount(props) {
       const engine = new Engine(renderer, options?.scheduler);
-      orchestrator.setCurrentEngine(engine);
-      new View(() => ({ render() {
-        slot();
-      } }), props ?? {}, null, engine, null, null);
+      engine.createRoot(slot, props ?? {});
       engine.render();
       return { engine };
     }
@@ -657,12 +598,7 @@ function createApp(slot, renderer, options) {
 // src/public/view.ts
 function view(body) {
   return (props, slot) => {
-    orchestrator.currentEngine().pendingView({
-      viewFn: body,
-      props,
-      slot,
-      userKey: maybeGetUserKey(props)
-    });
+    orchestrator.currentEngine().view(body, props, slot, maybeGetUserKey(props));
   };
 }
 function maybeGetUserKey(params) {
@@ -670,8 +606,6 @@ function maybeGetUserKey(params) {
     return params.key;
   }
 }
-// src/public/primitive.ts
-var $primitive = Symbol("primitive");
 // src/public/primitives/primitives.ts
 function html(tag) {
   const fn = ({
@@ -684,7 +618,10 @@ function html(tag) {
   fn[$primitive] = tag;
   return view(fn);
 }
-var text = html("text");
+var textViewFn = Object.assign(() => ({ render() {} }), { [$primitive]: "text" });
+function text(content) {
+  orchestrator.currentEngine().view(textViewFn, content, null, null);
+}
 var div = html("div");
 var span = html("span");
 var section = html("section");
@@ -792,20 +729,85 @@ var track = html("track");
 var map = html("map");
 var area = html("area");
 // src/render/html_render.ts
+function isEventProp(key) {
+  return key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.charCodeAt(2) >= 65 && key.charCodeAt(2) <= 90;
+}
 var DOM_EVENT = {
-  click: "click",
-  dblclick: "dblclick",
-  pointerDown: "pointerdown",
-  pointerUp: "pointerup",
-  pointerMove: "pointermove",
-  input: "input",
-  change: "change",
-  keyDown: "keydown",
-  keyUp: "keyup",
-  focus: "focus",
-  blur: "blur"
+  Click: "click",
+  Dblclick: "dblclick",
+  PointerDown: "pointerdown",
+  PointerUp: "pointerup",
+  PointerMove: "pointermove",
+  Input: "input",
+  Change: "change",
+  KeyDown: "keydown",
+  KeyUp: "keyup",
+  Focus: "focus",
+  Blur: "blur"
 };
-var SKIP_PROPS = new Set(["key"]);
+var $EV = Symbol.for("creo.ev");
+var containerState = new WeakMap;
+function getState(container) {
+  let state = containerState.get(container);
+  if (!state) {
+    state = {
+      counts: new Map,
+      handler(e) {
+        const domEvent = e.type;
+        let dom = e.target;
+        while (dom && dom !== container) {
+          const evObj = dom[$EV];
+          if (evObj) {
+            const handler = evObj[domEvent];
+            if (handler) {
+              handler(mapEventData(domEvent, e));
+              if (e.cancelBubble)
+                return;
+            }
+          }
+          dom = dom.parentElement;
+        }
+      }
+    };
+    containerState.set(container, state);
+  }
+  return state;
+}
+function ensureDelegated(container, domEvent) {
+  const state = getState(container);
+  const count = state.counts.get(domEvent) ?? 0;
+  if (count === 0) {
+    container.addEventListener(domEvent, state.handler);
+  }
+  state.counts.set(domEvent, count + 1);
+}
+function removeDelegated(container, domEvent) {
+  const state = getState(container);
+  const count = state.counts.get(domEvent) ?? 0;
+  if (count <= 1) {
+    state.counts.delete(domEvent);
+    container.removeEventListener(domEvent, state.handler);
+  } else {
+    state.counts.set(domEvent, count - 1);
+  }
+}
+function mapEventData(domEvent, e) {
+  let data2;
+  if (domEvent === "click" || domEvent === "dblclick" || domEvent === "pointerdown" || domEvent === "pointerup" || domEvent === "pointermove") {
+    const pe = e;
+    data2 = { x: pe.clientX, y: pe.clientY };
+  } else if (domEvent === "input" || domEvent === "change") {
+    data2 = { value: e.target.value };
+  } else if (domEvent === "keydown" || domEvent === "keyup") {
+    const ke = e;
+    data2 = { key: ke.key, code: ke.code };
+  } else {
+    data2 = {};
+  }
+  data2.stopPropagation = () => e.stopPropagation();
+  data2.preventDefault = () => e.preventDefault();
+  return data2;
+}
 var DOM_PROPERTIES = new Set([
   "value",
   "checked",
@@ -815,52 +817,62 @@ var DOM_PROPERTIES = new Set([
 
 class HtmlRender {
   container;
+  engine;
   constructor(container) {
     this.container = container;
   }
   render(view2) {
-    const ref = view2.renderRef;
-    if (!ref) {
-      const node = this.buildDom(view2);
-      const parent = view2.parent;
-      if (!parent) {
-        this.container.appendChild(node);
-      } else {
-        const parentNode = this.getParentDomNode(parent);
-        if (parentNode) {
-          parentNode.insertBefore(node, this.fastInsertionPoint(parent, view2));
+    if (!view2.renderRef) {
+      if (view2.flags & F_PRIMITIVE) {
+        const parentNode = this.findParentDom(view2);
+        const refNode = this.findInsertionPoint(view2);
+        const tag = view2.viewFn[$primitive];
+        if (tag === "text") {
+          const textNode = document.createTextNode(String(view2.props));
+          view2.renderRef = { element: textNode, prevProps: null };
+          parentNode.insertBefore(textNode, refNode);
+        } else {
+          const element = document.createElement(tag);
+          const props = view2.props;
+          const domRef = { element, prevProps: null };
+          view2.renderRef = domRef;
+          this.setAttributes(element, props);
+          if (view2.children?.length === 1) {
+            const child = view2.children[0];
+            if (child.flags & F_PRIMITIVE && child.viewFn[$primitive] === "text") {
+              element.textContent = String(child.props);
+              child.renderRef = { element, prevProps: null };
+              child.flags |= F_TEXT_CONTENT;
+            }
+          }
+          parentNode.insertBefore(element, refNode);
         }
-      }
-      const newRef = view2.renderRef;
-      if (newRef?.kind === "primitive" && newRef.element instanceof HTMLElement && view2.props?.autofocus) {
-        newRef.element.focus();
+      } else {
+        view2.renderRef = true;
       }
       return;
     }
-    if (view2.moved) {
-      view2.moved = false;
-      if (view2.parent) {
-        const expectedStart = this.fastInsertionPoint(view2.parent, view2);
-        const firstDom = this.getFirstDomNode(view2);
-        if (firstDom && firstDom !== expectedStart) {
-          const parentNode = this.getParentDomNode(view2.parent);
-          if (parentNode) {
-            if (ref.kind === "primitive") {
-              parentNode.insertBefore(ref.element, expectedStart);
-            } else {
-              if (view2.virtualDom) {
-                for (const child of view2.virtualDom) {
-                  this.moveDomNodes(child, parentNode, expectedStart);
-                }
-              }
-              parentNode.insertBefore(ref.endComment, expectedStart);
-            }
-          }
-        }
+    if (view2.flags & F_MOVED) {
+      const parentNode = this.findParentDom(view2);
+      const refNode = this.findInsertionPoint(view2);
+      if (view2.flags & F_PRIMITIVE) {
+        const ref2 = view2.renderRef;
+        parentNode.insertBefore(ref2.element, refNode);
+      } else {
+        this.moveDomNodes(view2, parentNode, refNode);
       }
     }
-    if (ref.kind !== "primitive")
+    if (!(view2.flags & F_PRIMITIVE))
+      return;
+    const ref = view2.renderRef;
+    if (view2.flags & F_TEXT_CONTENT) {
+      const parentEl = ref.element;
+      const nextText = String(view2.props);
+      if (parentEl.textContent !== nextText) {
+        parentEl.textContent = nextText;
+      }
       return;
+    }
     if (ref.element instanceof Text) {
       const nextText = String(view2.props);
       if (ref.element.textContent !== nextText) {
@@ -870,74 +882,70 @@ class HtmlRender {
     }
     const nextProps = view2.props;
     if (!ref.prevProps) {
-      this.setAttributes(ref, ref.element, nextProps);
-    } else {
-      this.diffAttributes(ref, ref.element, ref.prevProps, nextProps);
+      this.setAttributes(ref.element, nextProps);
+    } else if (ref.prevProps !== nextProps) {
+      this.diffAttributes(ref.element, ref.prevProps, nextProps);
     }
-    ref.prevProps = { ...nextProps };
+    ref.prevProps = nextProps;
   }
   unmount(view2) {
-    this.removeDomNodes(view2);
+    if (view2.flags & F_PRIMITIVE) {
+      this.removeDomNodes(view2);
+    }
     view2.renderRef = undefined;
   }
-  buildDom(view2) {
-    const tag = view2.viewFn[$primitive];
-    if (tag != null) {
-      if (tag === "text") {
-        const textNode = document.createTextNode(String(view2.props));
-        const ref2 = {
-          kind: "primitive",
-          element: textNode,
-          prevProps: null,
-          listeners: null
-        };
-        view2.renderRef = ref2;
-        return textNode;
+  findParentDom(view2) {
+    let parent = view2.parent;
+    while (parent) {
+      if (parent.flags & F_PRIMITIVE) {
+        const ref = parent.renderRef;
+        if (ref && ref.element instanceof HTMLElement)
+          return ref.element;
       }
-      const element = document.createElement(tag);
-      const props = view2.props;
-      const ref = {
-        kind: "primitive",
-        element,
-        prevProps: null,
-        listeners: null
-      };
-      view2.renderRef = ref;
-      this.setAttributes(ref, element, props);
-      return element;
+      parent = parent.parent;
     }
-    const endComment = document.createComment("");
-    view2.renderRef = {
-      kind: "composite",
-      endComment
-    };
-    return endComment;
+    return this.container;
   }
-  isEventProp(key, value) {
-    return key.length > 2 && key[0] === "o" && key[1] === "n" && key[2] >= "A" && key[2] <= "Z" && typeof value === "function";
+  findInsertionPoint(view2) {
+    const parent = view2.parent;
+    if (!parent?.children)
+      return null;
+    const children = parent.children;
+    if (children[children.length - 1] === view2) {
+      return this.#parentEndAnchor(parent);
+    }
+    const idx = children.indexOf(view2);
+    for (let i2 = idx + 1;i2 < children.length; i2++) {
+      const dom = this.getFirstDomNode(children[i2]);
+      if (dom)
+        return dom;
+    }
+    return this.#parentEndAnchor(parent);
   }
-  eventPropToCreoName(prop) {
-    return prop[2].toLowerCase() + prop.slice(3);
+  #parentEndAnchor(parent) {
+    if (parent.flags & F_PRIMITIVE)
+      return null;
+    return this.findInsertionPoint(parent);
   }
-  setAttributes(ref, element, props) {
+  setAttributes(element, props) {
     for (const key in props) {
       const value = props[key];
-      if (SKIP_PROPS.has(key) || value == null)
+      if (key === "key" || value == null)
         continue;
-      if (this.isEventProp(key, value)) {
-        this.bindEvent(ref, element, key, value);
+      if (isEventProp(key)) {
+        this.bindEvent(element, key, value);
         continue;
       }
       this.setAttribute(element, key, value);
     }
   }
-  diffAttributes(ref, element, prev, next) {
-    for (const key of Object.keys(prev)) {
-      if (SKIP_PROPS.has(key))
+  diffAttributes(element, prev, next) {
+    for (const key in prev) {
+      if (key === "key")
         continue;
       if (!(key in next) || next[key] == null) {
-        if (this.isEventProp(key, prev[key])) {
-          this.unbindEvent(ref, element, key);
+        if (isEventProp(key)) {
+          this.unbindEvent(element, key);
         } else {
           this.removeAttribute(element, key);
         }
@@ -945,54 +953,39 @@ class HtmlRender {
     }
     for (const key in next) {
       const value = next[key];
-      if (SKIP_PROPS.has(key) || value == null)
+      if (key === "key" || value == null)
         continue;
       if (prev[key] === value)
         continue;
-      if (this.isEventProp(key, value)) {
-        this.unbindEvent(ref, element, key);
-        this.bindEvent(ref, element, key, value);
+      if (isEventProp(key)) {
+        const creoName = key.slice(2);
+        const domEvent = DOM_EVENT[creoName] ?? creoName.toLowerCase();
+        const evObj = element[$EV];
+        if (evObj) {
+          evObj[domEvent] = value;
+        } else {
+          this.bindEvent(element, key, value);
+        }
       } else {
         this.setAttribute(element, key, value);
       }
     }
   }
-  bindEvent(ref, element, prop, handler) {
-    const creoEvent = this.eventPropToCreoName(prop);
-    const domEvent = DOM_EVENT[creoEvent] ?? creoEvent.toLowerCase();
-    const wrapped = (e) => {
-      const data2 = this.mapEventData(creoEvent, e);
-      data2.stopPropagation = () => e.stopPropagation();
-      data2.preventDefault = () => e.preventDefault();
-      handler(data2);
-    };
-    if (!ref.listeners)
-      ref.listeners = new Map;
-    ref.listeners.set(prop, wrapped);
-    element.addEventListener(domEvent, wrapped);
-  }
-  unbindEvent(ref, element, prop) {
-    const wrapped = ref.listeners?.get(prop);
-    if (!wrapped)
-      return;
-    const creoEvent = this.eventPropToCreoName(prop);
-    const domEvent = DOM_EVENT[creoEvent] ?? creoEvent.toLowerCase();
-    element.removeEventListener(domEvent, wrapped);
-    ref.listeners.delete(prop);
-  }
-  mapEventData(creoEvent, e) {
-    if (creoEvent === "click" || creoEvent === "dblclick" || creoEvent.startsWith("pointer")) {
-      const pe = e;
-      return { x: pe.clientX, y: pe.clientY };
-    }
-    if (creoEvent === "input" || creoEvent === "change") {
-      return { value: e.target.value };
-    }
-    if (creoEvent.startsWith("key")) {
-      const ke = e;
-      return { key: ke.key, code: ke.code };
+  bindEvent(element, prop, handler) {
+    const creoName = prop.slice(2);
+    const domEvent = DOM_EVENT[creoName] ?? creoName.toLowerCase();
+    const evObj = element[$EV] ?? (element[$EV] = {});
+    evObj[domEvent] = handler;
+    ensureDelegated(this.container, domEvent);
+  }
+  unbindEvent(element, prop) {
+    const creoName = prop.slice(2);
+    const domEvent = DOM_EVENT[creoName] ?? creoName.toLowerCase();
+    const evObj = element[$EV];
+    if (evObj) {
+      delete evObj[domEvent];
     }
-    return {};
+    removeDelegated(this.container, domEvent);
   }
   setAttribute(element, key, value) {
     if (key === "class") {
@@ -1002,11 +995,10 @@ class HtmlRender {
     } else if (DOM_PROPERTIES.has(key)) {
       element[key] = value;
     } else if (typeof value === "boolean") {
-      if (value) {
+      if (value)
         element.setAttribute(key, "");
-      } else {
+      else
         element.removeAttribute(key);
-      }
     } else {
       element.setAttribute(key, String(value));
     }
@@ -1022,94 +1014,52 @@ class HtmlRender {
       element.removeAttribute(key);
     }
   }
-  fastInsertionPoint(parent, view2) {
-    const vdom = parent.virtualDom;
-    if (vdom && vdom.length > 0) {
-      const node = vdom.getNode(view2);
-      if (node) {
-        if (node.isLast() || parent.quickRerender) {
-          const ref2 = parent.renderRef;
-          if (ref2?.kind === "composite") {
-            return ref2.endComment;
-          } else {
-            return null;
-          }
-        }
-        const prev = node.getPrev();
-        if (prev) {
-          const prevRef = prev.v.renderRef;
-          if (prevRef) {
-            return (prevRef.kind === "composite" ? prevRef.endComment : prevRef.element).nextSibling;
-          }
-          let cur = prev.getPrev();
-          while (cur) {
-            const curRef = cur.v.renderRef;
-            if (curRef) {
-              return (curRef.kind === "composite" ? curRef.endComment : curRef.element).nextSibling;
-            }
-            cur = cur.getPrev();
-          }
-        }
-      }
-    }
-    const ref = parent.renderRef;
-    if (!ref)
-      return null;
-    return ref.kind === "composite" ? ref.endComment : ref.element.firstChild;
-  }
-  getParentDomNode(parent) {
-    const ref = parent.renderRef;
-    if (!ref)
+  getFirstDomNode(view2) {
+    if (!view2.renderRef)
       return null;
-    if (ref.kind === "primitive") {
-      return ref.element;
+    if (view2.flags & F_PRIMITIVE)
+      return view2.renderRef.element;
+    if (view2.children) {
+      for (const child of view2.children) {
+        const dom = this.getFirstDomNode(child);
+        if (dom)
+          return dom;
+      }
     }
-    return ref.endComment.parentNode;
+    return null;
   }
   moveDomNodes(view2, parentNode, insertBefore) {
-    const ref = view2.renderRef;
-    if (!ref)
+    if (!view2.renderRef)
       return;
-    if (ref.kind === "primitive") {
-      parentNode.insertBefore(ref.element, insertBefore);
-    } else {
-      if (view2.virtualDom) {
-        for (const child of view2.virtualDom) {
-          this.moveDomNodes(child, parentNode, insertBefore);
-        }
+    if (view2.flags & F_PRIMITIVE) {
+      parentNode.insertBefore(view2.renderRef.element, insertBefore);
+    } else if (view2.children) {
+      for (const child of view2.children) {
+        this.moveDomNodes(child, parentNode, insertBefore);
       }
-      parentNode.insertBefore(ref.endComment, insertBefore);
     }
   }
-  getFirstDomNode(view2) {
-    const ref = view2.renderRef;
-    if (!ref)
-      return null;
-    if (ref.kind === "primitive")
-      return ref.element;
-    if (view2.virtualDom) {
-      for (const child of view2.virtualDom) {
-        const node = this.getFirstDomNode(child);
-        if (node)
-          return node;
-      }
-    }
-    return ref.endComment;
-  }
   removeDomNodes(view2) {
     const ref = view2.renderRef;
-    if (!ref)
-      return;
-    if (ref.kind === "primitive") {
-      ref.element.parentNode?.removeChild(ref.element);
+    if (!ref || !(view2.flags & F_PRIMITIVE))
       return;
+    const evObj = ref.element[$EV];
+    if (evObj) {
+      for (const domEvent in evObj) {
+        removeDelegated(this.container, domEvent);
+      }
+      delete ref.element[$EV];
     }
-    ref.endComment.parentNode?.removeChild(ref.endComment);
+    ref.element.parentNode?.removeChild(ref.element);
   }
 }
 // src/render/json_render.ts
 class JsonRender {
   root;
+  engine;
+  constructor() {
+    this.root = null;
+  }
   render(view2) {
     const existing = view2.renderRef;
     if (!existing) {
@@ -1118,23 +1068,25 @@ class JsonRender {
         this.root = node;
         return;
       }
-      const parentNode2 = view2.parent.renderRef;
-      if (parentNode2) {
-        parentNode2.children.push(node);
+      const parentNode = view2.parent.renderRef;
+      if (parentNode) {
+        const idx = view2.parent.children ? view2.parent.children.indexOf(view2) : -1;
+        if (idx >= 0 && idx < parentNode.children.length) {
+          parentNode.children.splice(idx, 0, node);
+        } else {
+          parentNode.children.push(node);
+        }
       }
       return;
     }
-    const parentNode = view2.parent?.renderRef;
-    if (parentNode) {
-      const oldIdx = parentNode.children.indexOf(existing);
-      if (oldIdx !== -1) {
-        const nextSibling = this.getNextSibling(view2);
-        const nextNode = nextSibling?.renderRef;
-        const expectedIdx = nextNode ? parentNode.children.indexOf(nextNode) : parentNode.children.length;
-        if (oldIdx !== expectedIdx && oldIdx !== expectedIdx - 1) {
+    if (view2.parent) {
+      const parentNode = view2.parent.renderRef;
+      if (parentNode) {
+        const oldIdx = parentNode.children.indexOf(existing);
+        const targetIdx = view2.parent.children ? view2.parent.children.indexOf(view2) : -1;
+        if (oldIdx !== -1 && targetIdx !== -1 && oldIdx !== targetIdx) {
           parentNode.children.splice(oldIdx, 1);
-          const insertIdx = nextNode ? parentNode.children.indexOf(nextNode) : parentNode.children.length;
-          parentNode.children.splice(insertIdx, 0, existing);
+          parentNode.children.splice(Math.min(targetIdx, parentNode.children.length), 0, existing);
         }
       }
     }
@@ -1143,16 +1095,15 @@ class JsonRender {
   }
   unmount(view2) {
     const childNode = view2.renderRef;
-    const parentNode = view2.parent?.renderRef;
-    if (parentNode && childNode) {
+    if (!childNode || !view2.parent)
+      return;
+    const parentNode = view2.parent.renderRef;
+    if (parentNode) {
       const idx = parentNode.children.indexOf(childNode);
       if (idx !== -1)
         parentNode.children.splice(idx, 1);
     }
   }
-  getNextSibling(view2) {
-    return view2.parent?.virtualDom?.getNode(view2)?.getNext()?.v;
-  }
   buildNode(view2) {
     const tag = view2.viewFn[$primitive];
     const props = tag === "text" ? { content: view2.props } : { ...view2.props };
@@ -1180,52 +1131,84 @@ var VOID_TAGS = new Set([
   "col",
   "wbr"
 ]);
+var DOM_PROPERTIES2 = new Set(["value", "checked", "selected", "indeterminate"]);
+function isEventProp2(key) {
+  return key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.charCodeAt(2) >= 65 && key.charCodeAt(2) <= 90;
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 
-class StringRender {
-  rootView;
+class HtmlStringRender {
+  root = null;
+  engine;
   render(view2) {
     if (!view2.parent) {
-      this.rootView = view2;
+      this.root = view2;
     }
   }
   unmount(_view) {}
   renderToString() {
-    if (!this.rootView)
+    if (!this.root)
       return "";
-    return this.buildString(this.rootView);
+    return this.buildString(this.root);
   }
-  buildString(view2) {
-    const tag = view2.viewFn[$primitive];
+  buildString(rec) {
+    const tag = rec.viewFn[$primitive];
     if (tag != null) {
       if (tag === "text") {
-        return `${view2.props}`;
+        return escapeHtml(String(rec.props));
       }
+      const attrs = this.buildAttrs(rec.props);
       if (VOID_TAGS.has(tag)) {
-        return this.buildVoidTag(tag, view2);
+        return `<${tag}${attrs}>`;
       }
-      return `<${tag}>${this.buildChildren(view2)}</${tag}>`;
+      return `<${tag}${attrs}>${this.buildChildren(rec)}</${tag}>`;
     }
-    return this.buildChildren(view2);
-  }
-  buildVoidTag(tag, view2) {
-    const props = view2.props;
-    let attrs = "";
-    if (props.src)
-      attrs += ` src="${props.src}"`;
-    if (props.alt)
-      attrs += ` alt="${props.alt}"`;
-    return `<${tag}${attrs} />`;
-  }
-  buildChildren(view2) {
+    return this.buildChildren(rec);
+  }
+  buildAttrs(props) {
     let result = "";
-    if (view2.virtualDom) {
-      for (const child of view2.virtualDom) {
-        result += this.buildString(child);
+    for (const key in props) {
+      const value = props[key];
+      if (key === "key" || value == null)
+        continue;
+      if (isEventProp2(key))
+        continue;
+      if (DOM_PROPERTIES2.has(key))
+        continue;
+      if (key === "style") {
+        let css = String(value);
+        css = css.trim();
+        if (css && !css.endsWith(";"))
+          css += ";";
+        result += ` style="${escapeAttr(css)}"`;
+        continue;
+      }
+      if (typeof value === "boolean") {
+        if (value)
+          result += ` ${key}=""`;
+      } else {
+        const attrName = key === "class" ? "class" : key;
+        result += ` ${attrName}="${escapeAttr(String(value))}"`;
       }
     }
     return result;
   }
+  buildChildren(rec) {
+    if (!rec.children)
+      return "";
+    let result = "";
+    for (const child of rec.children) {
+      result += this.buildString(child);
+    }
+    return result;
+  }
 }
+var StringRender = HtmlStringRender;
 // src/functional/maybe.ts
 function just(maybe, errorMessage) {
   if (maybe == null) {
@@ -1365,9 +1348,10 @@ export {
   Store,
   State,
   JsonRender,
+  HtmlStringRender,
   HtmlRender,
   Engine,
   $primitive
 };
 
-//# debugId=3A0F56854FC011F464756E2164756E21
+//# debugId=3138F663141CF77564756E2164756E21