tutuca 0.9.2 → 0.9.3

package/dist/tutuca.js

@@ -1,706 +1,139 @@
-// deps/vdom.js
-function isHtmlAttribute(propName) {
-  return propName[4] === "-" && (propName[0] === "d" || propName[0] === "a");
-}
-function getDomProp(node, propName) {
-  return node[propName];
-}
-function setDomProp(node, propName, value) {
-  node[propName] = value;
-}
-function applyProperties(node, props, previous) {
-  for (const propName in props) {
-    const propValue = props[propName];
-    if (propValue === undefined) {
-      removeProperty(node, propName, previous);
-    } else if (isHtmlAttribute(propName)) {
-      node.setAttribute(propName, propValue);
-    } else {
-      if (typeof propValue === "object" && propValue !== null) {
-        patchObject(node, previous, propName, propValue);
-      } else {
-        setDomProp(node, propName, propValue);
-      }
-    }
-  }
-}
-function removeProperty(node, propName, previous) {
-  const previousValue = previous[propName];
-  if (isHtmlAttribute(propName)) {
-    node.removeAttribute(propName);
-  } else if (typeof previousValue === "string") {
-    setDomProp(node, propName, "");
-    const attrName = propName === "className" ? "class" : propName === "htmlFor" ? "for" : propName;
-    node.removeAttribute(attrName);
-  } else {
-    setDomProp(node, propName, null);
-  }
-}
-function patchObject(node, previous, propName, propValue) {
-  const previousValue = previous?.[propName];
-  if (previousValue && typeof previousValue === "object" && Object.getPrototypeOf(previousValue) !== Object.getPrototypeOf(propValue)) {
-    setDomProp(node, propName, propValue);
-    return;
-  }
-  let current = getDomProp(node, propName);
-  if (typeof current !== "object" || current === null) {
-    setDomProp(node, propName, {});
-    current = getDomProp(node, propName);
+// src/path.js
+class Step {
+  lookup(_v, dval = null) {
+    return dval;
   }
-  const target = current;
-  for (const k in propValue) {
-    target[k] = propValue[k];
+  setValue(root, _v) {
+    return root;
   }
+  updateBindings(_v, _o) {}
+  isFrame = true;
 }
 
-class Warning {
-  type;
-  message;
-  constructor(type, message) {
-    this.type = type;
-    this.message = message;
+class BindStep extends Step {
+  constructor(binds) {
+    super();
+    this.binds = binds;
   }
-}
-
-class DuplicatedKeysWarning extends Warning {
-  duplicatedKeys;
-  parentTag;
-  parentIndex;
-  constructor(duplicatedKeys, parentTag, parentIndex) {
-    const keys = [...duplicatedKeys].join(", ");
-    super("DuplicatedKeys", `Duplicate keys found: [${keys}] in ${parentTag || "fragment"} at index ${parentIndex}. Nodes with duplicated keys are matched positionally.`);
-    this.duplicatedKeys = duplicatedKeys;
-    this.parentTag = parentTag;
-    this.parentIndex = parentIndex;
+  lookup(v, _dval) {
+    return v;
   }
-}
-
-class VBase {
-  isEqualTo(other) {
-    return this === other;
+  setValue(_root, v) {
+    return v;
   }
-  toDom(_opts) {
-    return null;
+  withIndex(i) {
+    return new BindStep({ ...this.binds, key: i });
   }
-}
-function getKey(node) {
-  return node instanceof VNode ? node.key : undefined;
-}
-function effectiveKey(node, duplicatedKeys) {
-  const key = getKey(node);
-  return key && duplicatedKeys?.has(key) ? undefined : key;
-}
-function isIterable(obj) {
-  return obj != null && typeof obj !== "string" && typeof obj[Symbol.iterator] === "function";
-}
-function addChild(normalizedChildren, child) {
-  if (child == null) {
-    return;
+  withKey(key) {
+    return new BindStep({ ...this.binds, key });
   }
-  if (isIterable(child)) {
-    for (const c of child) {
-      addChild(normalizedChildren, c);
-    }
-  } else if (child instanceof VBase) {
-    if (child instanceof VFragment) {
-      normalizedChildren.push(...child.childs);
-    } else {
-      normalizedChildren.push(child);
-    }
-  } else {
-    normalizedChildren.push(new VText(child));
+  updateBindings(_v, o) {
+    Object.assign(o, this.binds);
   }
+  isFrame = false;
 }
 
-class VText extends VBase {
-  text;
-  constructor(text) {
+class FieldStep extends Step {
+  constructor(field) {
     super();
-    this.text = String(text);
+    this.field = field;
   }
-  get nodeType() {
-    return 3;
+  lookup(v, dval = null) {
+    return v?.get ? v.get(this.field, dval) : dval;
   }
-  isEqualTo(other) {
-    return other instanceof VText && this.text === other.text;
+  setValue(root, v) {
+    return root.set(this.field, v);
   }
-  toDom(opts) {
-    return opts.document.createTextNode(this.text);
+  withIndex(i) {
+    return new SeqIndexStep(this.field, i);
+  }
+  withKey(k) {
+    return new SeqKeyStep(this.field, k);
   }
 }
 
-class VComment extends VBase {
-  text;
-  constructor(text) {
+class FieldSeqStep extends Step {
+  constructor(field, key) {
     super();
-    this.text = text;
+    this.field = field;
+    this.key = key;
   }
-  get nodeType() {
-    return 8;
+  lookup(v, dval = null) {
+    const o = v?.get(this.field, null);
+    return o?.get ? o.get(this.key, dval) : dval;
   }
-  isEqualTo(other) {
-    return other instanceof VComment && this.text === other.text;
+  setValue(root, v) {
+    return root.set(this.field, root.get(this.field).set(this.key, v));
   }
-  toDom(opts) {
-    return opts.document.createComment(this.text);
+  updateBindings(_v, o) {
+    o.key = this.key;
   }
 }
 
-class VFragment extends VBase {
-  childs;
-  constructor(childs) {
+class SeqKeyStep extends FieldSeqStep {
+}
+
+class SeqIndexStep extends FieldSeqStep {
+}
+var NONE = Symbol("NONE");
+
+class SeqAccessStep extends Step {
+  constructor(seqField, keyField) {
     super();
-    const normalized = [];
-    addChild(normalized, childs);
-    this.childs = normalized;
+    this.seqField = seqField;
+    this.keyField = keyField;
   }
-  get nodeType() {
-    return 11;
+  lookup(v, dval = null) {
+    const seq = v?.get(this.seqField, NONE);
+    const key = v?.get(this.keyField, NONE);
+    return key !== NONE && seq?.get ? seq.get(key, dval) : dval;
   }
-  isEqualTo(other) {
-    if (!(other instanceof VFragment) || this.childs.length !== other.childs.length) {
-      return false;
-    }
-    for (let i = 0;i < this.childs.length; i++) {
-      if (!this.childs[i].isEqualTo(other.childs[i])) {
-        return false;
-      }
-    }
-    return true;
+  setValue(root, v) {
+    const seq = root?.get(this.seqField, NONE);
+    const key = root?.get(this.keyField, NONE);
+    return seq === NONE || key === NONE ? root : root.set(this.seqField, seq.set(key, v));
   }
-  toDom(opts) {
-    const fragment = opts.document.createDocumentFragment();
-    for (const child of this.childs) {
-      const childNode = child.toDom(opts);
-      if (childNode) {
-        fragment.appendChild(childNode);
-      }
-    }
-    return fragment;
+  updateBindings(v, o) {
+    o.key = v?.get(this.keyField, null);
   }
 }
 
-class VNode extends VBase {
-  tag;
-  attrs;
-  childs;
-  key;
-  namespace;
-  attrCount;
-  constructor(tag, attrs, childs, key, namespace) {
-    super();
-    this.tag = tag;
-    this.attrs = attrs ?? {};
-    this.childs = childs ?? [];
-    this.key = key != null ? String(key) : undefined;
-    this.namespace = typeof namespace === "string" ? namespace : null;
-    this.attrCount = Object.keys(this.attrs).length;
+class Path {
+  constructor(steps = []) {
+    this.steps = steps;
   }
-  get nodeType() {
-    return 1;
+  concat(steps) {
+    return new Path(this.steps.concat(steps));
   }
-  isEqualTo(other) {
-    if (!(other instanceof VNode) || this.tag !== other.tag || this.key !== other.key || this.namespace !== other.namespace || this.attrCount !== other.attrCount || this.childs.length !== other.childs.length) {
-      return false;
-    }
-    for (const key in this.attrs) {
-      if (this.attrs[key] !== other.attrs[key]) {
-        return false;
+  popStep() {
+    return new Path(this.steps.slice(0, -1));
+  }
+  lookup(v, dval = null) {
+    let curVal = v;
+    for (const step of this.steps) {
+      curVal = step.lookup(curVal, NONE);
+      if (curVal === NONE) {
+        return dval;
       }
     }
-    for (let i = 0;i < this.childs.length; i++) {
-      if (!this.childs[i].isEqualTo(other.childs[i])) {
-        return false;
+    return curVal;
+  }
+  setValue(root, v) {
+    const intermediates = new Array(this.steps.length);
+    let curVal = root;
+    for (let i = 0;i < this.steps.length; i++) {
+      intermediates[i] = curVal;
+      curVal = this.steps[i].lookup(curVal, NONE);
+      if (curVal === NONE) {
+        return root;
       }
     }
-    return true;
-  }
-  toDom(opts) {
-    const doc = opts.document;
-    const node = this.namespace === null ? doc.createElement(this.tag) : doc.createElementNS(this.namespace, this.tag);
-    applyProperties(node, this.attrs, {});
-    for (const child of this.childs) {
-      const childNode = child.toDom(opts);
-      if (childNode) {
-        node.appendChild(childNode);
-      }
-    }
-    return node;
-  }
-}
-function diffProps(a, b) {
-  let diff = null;
-  for (const aKey in a) {
-    if (!Object.hasOwn(b, aKey)) {
-      diff ??= {};
-      diff[aKey] = undefined;
-      continue;
-    }
-    const aValue = a[aKey];
-    const bValue = b[aKey];
-    if (aValue === bValue) {} else if (typeof aValue === "object" && aValue !== null && typeof bValue === "object" && bValue !== null) {
-      if (Object.getPrototypeOf(bValue) !== Object.getPrototypeOf(aValue)) {
-        diff ??= {};
-        diff[aKey] = bValue;
-      } else {
-        const objectDiff = diffProps(aValue, bValue);
-        if (objectDiff) {
-          diff ??= {};
-          diff[aKey] = objectDiff;
-        }
-      }
-    } else {
-      diff ??= {};
-      diff[aKey] = bValue;
-    }
-  }
-  for (const bKey in b) {
-    if (!Object.hasOwn(a, bKey)) {
-      diff ??= {};
-      diff[bKey] = b[bKey];
-    }
-  }
-  return diff;
-}
-function reorder(oldChildren, newChildren) {
-  const rawNew = keyIndex(newChildren);
-  if (rawNew.free.length === newChildren.length) {
-    return {
-      children: newChildren,
-      moves: null,
-      duplicatedKeys: rawNew.duplicatedKeys
-    };
-  }
-  const rawOld = keyIndex(oldChildren);
-  const duplicatedKeys = rawNew.duplicatedKeys || rawOld.duplicatedKeys ? new Set([...rawNew.duplicatedKeys || [], ...rawOld.duplicatedKeys || []]) : null;
-  if (rawOld.free.length === oldChildren.length) {
-    return {
-      children: newChildren,
-      moves: null,
-      duplicatedKeys
-    };
-  }
-  let newKeys;
-  let newFree;
-  let oldKeys;
-  if (duplicatedKeys) {
-    const updatedNew = keyIndex(newChildren, duplicatedKeys);
-    newKeys = updatedNew.keys;
-    newFree = updatedNew.free;
-    oldKeys = keyIndex(oldChildren, duplicatedKeys).keys;
-  } else {
-    newKeys = rawNew.keys;
-    newFree = rawNew.free;
-    oldKeys = rawOld.keys;
-  }
-  const reordered = [];
-  let freeIndex = 0;
-  const freeCount = newFree.length;
-  let deletedItems = 0;
-  for (let i = 0;i < oldChildren.length; i++) {
-    const oldItem = oldChildren[i];
-    const oldKey = effectiveKey(oldItem, duplicatedKeys);
-    if (oldKey) {
-      if (Object.hasOwn(newKeys, oldKey)) {
-        const itemIndex = newKeys[oldKey];
-        reordered.push(newChildren[itemIndex]);
-      } else {
-        deletedItems++;
-        reordered.push(null);
-      }
-    } else {
-      if (freeIndex < freeCount) {
-        const itemIndex = newFree[freeIndex++];
-        reordered.push(newChildren[itemIndex]);
-      } else {
-        deletedItems++;
-        reordered.push(null);
-      }
-    }
-  }
-  const lastFreeIndex = freeIndex >= newFree.length ? newChildren.length : newFree[freeIndex];
-  for (let j = 0;j < newChildren.length; j++) {
-    const newItem = newChildren[j];
-    const newKey = effectiveKey(newItem, duplicatedKeys);
-    if (newKey) {
-      if (!Object.hasOwn(oldKeys, newKey)) {
-        reordered.push(newItem);
-      }
-    } else if (j >= lastFreeIndex) {
-      reordered.push(newItem);
-    }
-  }
-  const moves = computeMoves(reordered, newChildren, newKeys, duplicatedKeys, deletedItems);
-  return { children: reordered, moves, duplicatedKeys };
-}
-function computeMoves(reordered, newChildren, newKeys, duplicatedKeys, deletedItems) {
-  const simulate = reordered.slice();
-  let simulateIndex = 0;
-  const removes = [];
-  const inserts = [];
-  const wantedKeys = new Array(newChildren.length);
-  for (let i = 0;i < newChildren.length; i++) {
-    wantedKeys[i] = effectiveKey(newChildren[i], duplicatedKeys);
-  }
-  for (let k = 0;k < newChildren.length; ) {
-    const wantedKey = wantedKeys[k];
-    let simulateItem = simulate[simulateIndex];
-    let simulateKey = effectiveKey(simulateItem, duplicatedKeys);
-    while (simulateItem === null && simulate.length) {
-      simulate.splice(simulateIndex, 1);
-      removes.push({ from: simulateIndex, key: null });
-      simulateItem = simulate[simulateIndex];
-      simulateKey = effectiveKey(simulateItem, duplicatedKeys);
-    }
-    if (simulateItem && simulateKey === wantedKey) {
-      simulateIndex++;
-      k++;
-      continue;
-    }
-    if (wantedKey) {
-      if (simulateKey && newKeys[simulateKey] !== k + 1) {
-        simulate.splice(simulateIndex, 1);
-        removes.push({ from: simulateIndex, key: simulateKey });
-        simulateItem = simulate[simulateIndex];
-        simulateKey = effectiveKey(simulateItem, duplicatedKeys);
-        if (simulateItem && simulateKey === wantedKey) {
-          simulateIndex++;
-          k++;
-          continue;
-        }
-      }
-      inserts.push({ key: wantedKey, to: k });
-      k++;
-      continue;
-    }
-    if (simulateKey) {
-      simulate.splice(simulateIndex, 1);
-      removes.push({ from: simulateIndex, key: simulateKey });
-      continue;
-    }
-    k++;
-  }
-  while (simulateIndex < simulate.length) {
-    const simulateItem = simulate[simulateIndex];
-    simulate.splice(simulateIndex, 1);
-    removes.push({
-      from: simulateIndex,
-      key: effectiveKey(simulateItem, duplicatedKeys)
-    });
-  }
-  if (removes.length === deletedItems && !inserts.length) {
-    return null;
-  }
-  return { removes, inserts };
-}
-function keyIndex(children, excludeKeys) {
-  const keys = {};
-  const free = [];
-  let duplicatedKeys = null;
-  for (let i = 0;i < children.length; i++) {
-    const key = getKey(children[i]);
-    if (key && !excludeKeys?.has(key)) {
-      if (key in keys) {
-        duplicatedKeys ??= new Set;
-        duplicatedKeys.add(key);
-      }
-      keys[key] = i;
-    } else {
-      free.push(i);
-    }
-  }
-  return { keys, free, duplicatedKeys };
-}
-function replaceNode(domNode, vnode, options) {
-  const parentNode = domNode.parentNode;
-  const newNode = vnode.toDom(options);
-  if (parentNode && newNode && newNode !== domNode) {
-    parentNode.replaceChild(newNode, domNode);
-  }
-  return newNode || domNode;
-}
-function morphNode(domNode, source, target, opts) {
-  if (source === target || source.isEqualTo(target))
-    return domNode;
-  if (source instanceof VText && target instanceof VText || source instanceof VComment && target instanceof VComment) {
-    domNode.data = target.text;
-    return domNode;
-  }
-  if (source instanceof VNode && target instanceof VNode && source.tag === target.tag && source.namespace === target.namespace && source.key === target.key) {
-    const propsDiff = diffProps(source.attrs, target.attrs);
-    if (propsDiff) {
-      applyProperties(domNode, propsDiff, source.attrs);
-    }
-    morphChildren(domNode, source.childs, target.childs, source.tag, opts);
-    return domNode;
-  }
-  if (source instanceof VFragment && target instanceof VFragment) {
-    morphChildren(domNode, source.childs, target.childs, null, opts);
-    return domNode;
-  }
-  return replaceNode(domNode, target, opts);
-}
-function morphChildren(parentDom, oldChilds, newChilds, parentTag, opts) {
-  if (oldChilds.length === 0) {
-    for (const child of newChilds) {
-      const node = child.toDom(opts);
-      if (node)
-        parentDom.appendChild(node);
-    }
-    return;
-  }
-  if (newChilds.length === 0) {
-    while (parentDom.firstChild) {
-      parentDom.removeChild(parentDom.firstChild);
-    }
-    return;
-  }
-  const orderedSet = reorder(oldChilds, newChilds);
-  const reorderedChilds = orderedSet.children;
-  if (orderedSet.duplicatedKeys && opts.onWarning) {
-    opts.onWarning(new DuplicatedKeysWarning(orderedSet.duplicatedKeys, parentTag, 0));
-  }
-  const domChildren = Array.from(parentDom.childNodes);
-  const oldLen = oldChilds.length;
-  const reorderedLen = reorderedChilds.length;
-  const len = Math.max(oldLen, reorderedLen);
-  const toRemove = [];
-  for (let i = 0;i < len; i++) {
-    const leftNode = oldChilds[i];
-    const rightNode = reorderedChilds[i];
-    if (!leftNode && rightNode) {
-      const newNode = rightNode.toDom(opts);
-      if (newNode)
-        parentDom.appendChild(newNode);
-    } else if (leftNode && rightNode) {
-      const domChild = domChildren[i];
-      if (domChild) {
-        morphNode(domChild, leftNode, rightNode, opts);
-      }
-    } else if (leftNode && !rightNode) {
-      if (!orderedSet.moves && domChildren[i]) {
-        toRemove.push(domChildren[i]);
-      }
-    }
-  }
-  for (const node of toRemove) {
-    if (node.parentNode === parentDom) {
-      parentDom.removeChild(node);
-    }
-  }
-  if (orderedSet.moves) {
-    applyMoves(parentDom, orderedSet.moves);
-  }
-}
-function applyMoves(domNode, moves) {
-  const childNodes = domNode.childNodes;
-  const keyMap = {};
-  for (const remove of moves.removes) {
-    const node = childNodes[remove.from];
-    if (remove.key)
-      keyMap[remove.key] = node;
-    domNode.removeChild(node);
-  }
-  let length = childNodes.length;
-  for (let j = 0;j < moves.inserts.length; j++) {
-    const insert = moves.inserts[j];
-    const node = keyMap[insert.key];
-    if (node) {
-      domNode.insertBefore(node, insert.to >= length++ ? null : childNodes[insert.to]);
-    }
-  }
-}
-var renderCache = new WeakMap;
-function render(vnode, container, options) {
-  const cached = renderCache.get(container);
-  const isFragment = vnode instanceof VFragment;
-  if (cached) {
-    const wasFragment = cached.vnode instanceof VFragment;
-    if (wasFragment === isFragment) {
-      const rootNode = wasFragment ? container : cached.dom;
-      const newDom = morphNode(rootNode, cached.vnode, vnode, options);
-      renderCache.set(container, {
-        vnode,
-        dom: isFragment ? container : newDom
-      });
-      return newDom;
-    }
-    renderCache.delete(container);
-  }
-  const domNode = vnode.toDom(options);
-  if (domNode) {
-    container.innerHTML = "";
-    container.appendChild(domNode);
-    renderCache.set(container, {
-      vnode,
-      dom: isFragment ? container : domNode
-    });
-  }
-  return domNode;
-}
-function h(tagName, properties, children) {
-  const tag = tagName.toUpperCase();
-  const props = {};
-  let key;
-  let namespace;
-  if (properties) {
-    for (const propName in properties) {
-      if (propName === "key") {
-        key = properties[propName];
-      } else if (propName === "namespace") {
-        namespace = properties[propName];
-      } else if (propName === "class") {
-        props.className = properties[propName];
-      } else if (propName === "for") {
-        props.htmlFor = properties[propName];
-      } else if (isHtmlAttribute(propName)) {
-        props[propName] = String(properties[propName]);
-      } else {
-        props[propName] = properties[propName];
-      }
-    }
-  }
-  const normalizedChildren = [];
-  addChild(normalizedChildren, children);
-  return new VNode(tag, props, normalizedChildren, key, namespace);
-}
-
-// src/path.js
-class Step {
-  lookup(_v, dval = null) {
-    return dval;
-  }
-  setValue(root, _v) {
-    return root;
-  }
-  updateBindings(_v, _o) {}
-  isFrame = true;
-}
-
-class BindStep extends Step {
-  constructor(binds) {
-    super();
-    this.binds = binds;
-  }
-  lookup(v, _dval) {
-    return v;
-  }
-  setValue(_root, v) {
-    return v;
-  }
-  withIndex(i) {
-    return new BindStep({ ...this.binds, key: i });
-  }
-  withKey(key) {
-    return new BindStep({ ...this.binds, key });
-  }
-  updateBindings(_v, o) {
-    Object.assign(o, this.binds);
-  }
-  isFrame = false;
-}
-
-class FieldStep extends Step {
-  constructor(field) {
-    super();
-    this.field = field;
-  }
-  lookup(v, dval = null) {
-    return v?.get ? v.get(this.field, dval) : dval;
-  }
-  setValue(root, v) {
-    return root.set(this.field, v);
-  }
-  withIndex(i) {
-    return new SeqIndexStep(this.field, i);
-  }
-  withKey(k) {
-    return new SeqKeyStep(this.field, k);
-  }
-}
-
-class FieldSeqStep extends Step {
-  constructor(field, key) {
-    super();
-    this.field = field;
-    this.key = key;
-  }
-  lookup(v, dval = null) {
-    const o = v?.get(this.field, null);
-    return o?.get ? o.get(this.key, dval) : dval;
-  }
-  setValue(root, v) {
-    return root.set(this.field, root.get(this.field).set(this.key, v));
-  }
-  updateBindings(_v, o) {
-    o.key = this.key;
-  }
-}
-
-class SeqKeyStep extends FieldSeqStep {
-}
-
-class SeqIndexStep extends FieldSeqStep {
-}
-var NONE = Symbol("NONE");
-
-class SeqAccessStep extends Step {
-  constructor(seqField, keyField) {
-    super();
-    this.seqField = seqField;
-    this.keyField = keyField;
-  }
-  lookup(v, dval = null) {
-    const seq = v?.get(this.seqField, NONE);
-    const key = v?.get(this.keyField, NONE);
-    return key !== NONE && seq?.get ? seq.get(key, dval) : dval;
-  }
-  setValue(root, v) {
-    const seq = root?.get(this.seqField, NONE);
-    const key = root?.get(this.keyField, NONE);
-    return seq === NONE || key === NONE ? root : root.set(this.seqField, seq.set(key, v));
-  }
-  updateBindings(v, o) {
-    o.key = v?.get(this.keyField, null);
-  }
-}
-
-class Path {
-  constructor(steps = []) {
-    this.steps = steps;
-  }
-  concat(steps) {
-    return new Path(this.steps.concat(steps));
-  }
-  popStep() {
-    return new Path(this.steps.slice(0, -1));
-  }
-  lookup(v, dval = null) {
-    let curVal = v;
-    for (const step of this.steps) {
-      curVal = step.lookup(curVal, NONE);
-      if (curVal === NONE) {
-        return dval;
-      }
-    }
-    return curVal;
-  }
-  setValue(root, v) {
-    const intermediates = new Array(this.steps.length);
-    let curVal = root;
-    for (let i = 0;i < this.steps.length; i++) {
-      intermediates[i] = curVal;
-      curVal = this.steps[i].lookup(curVal, NONE);
-      if (curVal === NONE) {
-        return root;
-      }
-    }
-    let newVal = v;
-    for (let i = this.steps.length - 1;i >= 0; i--) {
-      newVal = this.steps[i].setValue(intermediates[i], newVal);
-      intermediates[i] = newVal;
-    }
-    return newVal;
+    let newVal = v;
+    for (let i = this.steps.length - 1;i >= 0; i--) {
+      newVal = this.steps[i].setValue(intermediates[i], newVal);
+      intermediates[i] = newVal;
+    }
+    return newVal;
   }
   buildStack(stack) {
     const root = stack.it;
@@ -3701,28 +3134,28 @@ function hashCollection(collection) {
   }
   const ordered = isOrdered(collection);
   const keyed = isKeyed(collection);
-  let h2 = ordered ? 1 : 0;
+  let h = ordered ? 1 : 0;
   collection.__iterate(keyed ? ordered ? (v, k) => {
-    h2 = 31 * h2 + hashMerge(hash(v), hash(k)) | 0;
+    h = 31 * h + hashMerge(hash(v), hash(k)) | 0;
   } : (v, k) => {
-    h2 = h2 + hashMerge(hash(v), hash(k)) | 0;
+    h = h + hashMerge(hash(v), hash(k)) | 0;
   } : ordered ? (v) => {
-    h2 = 31 * h2 + hash(v) | 0;
+    h = 31 * h + hash(v) | 0;
   } : (v) => {
-    h2 = h2 + hash(v) | 0;
+    h = h + hash(v) | 0;
   });
-  return murmurHashOfSize(collection.size, h2);
+  return murmurHashOfSize(collection.size, h);
 }
 var hashMerge = (a, b) => a ^ b + 2654435769 + (a << 6) + (a >> 2) | 0;
-function murmurHashOfSize(size, h2) {
-  h2 = Math.imul(h2, 3432918353);
-  h2 = Math.imul(h2 << 15 | h2 >>> -15, 461845907);
-  h2 = Math.imul(h2 << 13 | h2 >>> -13, 5);
-  h2 = (h2 + 3864292196 | 0) ^ size;
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
-  h2 = Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 = smi(h2 ^ h2 >>> 16);
-  return h2;
+function murmurHashOfSize(size, h) {
+  h = Math.imul(h, 3432918353);
+  h = Math.imul(h << 15 | h >>> -15, 461845907);
+  h = Math.imul(h << 13 | h >>> -13, 5);
+  h = (h + 3864292196 | 0) ^ size;
+  h = Math.imul(h ^ h >>> 16, 2246822507);
+  h = Math.imul(h ^ h >>> 13, 3266489909);
+  h = smi(h ^ h >>> 16);
+  return h;
 }
 function quoteString(value) {
   try {
@@ -5831,7 +5264,7 @@ var List = (value) => {
   }
   assertNotInfinite(size);
   if (size > 0 && size < SIZE) {
-    return makeList(0, size, SHIFT, null, new VNode2(iter.toArray()));
+    return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));
   }
   return empty.withMutations((list) => {
     list.setSize(size);
@@ -6022,7 +5455,7 @@ class ListImpl extends IndexedCollectionImpl {
 }
 List.isList = isList;
 
-class VNode2 {
+class VNode {
   constructor(array, ownerID) {
     this.array = array;
     this.ownerID = ownerID;
@@ -6033,7 +5466,7 @@ class VNode2 {
     }
     const originIndex = index >>> level & MASK;
     if (originIndex >= this.array.length) {
-      return new VNode2([], ownerID);
+      return new VNode([], ownerID);
     }
     const removingFirst = originIndex === 0;
     let newChild;
@@ -6259,7 +5692,7 @@ function editableVNode(node, ownerID) {
   if (ownerID && ownerID === node?.ownerID) {
     return node;
   }
-  return new VNode2(node?.array.slice() ?? [], ownerID);
+  return new VNode(node?.array.slice() ?? [], ownerID);
 }
 function listNodeFor(list, rawIndex) {
   if (rawIndex >= getTailOffset(list._capacity)) {
@@ -6297,7 +5730,7 @@ function setListBounds(list, begin, end) {
   let newRoot = list._root;
   let offsetShift = 0;
   while (newOrigin + offsetShift < 0) {
-    newRoot = new VNode2(newRoot?.array.length ? [undefined, newRoot] : [], owner);
+    newRoot = new VNode(newRoot?.array.length ? [undefined, newRoot] : [], owner);
     newLevel += SHIFT;
     offsetShift += 1 << newLevel;
   }
@@ -6310,11 +5743,11 @@ function setListBounds(list, begin, end) {
   const oldTailOffset = getTailOffset(oldCapacity);
   const newTailOffset = getTailOffset(newCapacity);
   while (newTailOffset >= 1 << newLevel + SHIFT) {
-    newRoot = new VNode2(newRoot?.array.length ? [newRoot] : [], owner);
+    newRoot = new VNode(newRoot?.array.length ? [newRoot] : [], owner);
     newLevel += SHIFT;
   }
   const oldTail = list._tail;
-  let newTail = newTailOffset < oldTailOffset ? listNodeFor(list, newCapacity - 1) : newTailOffset > oldTailOffset ? new VNode2([], owner) : oldTail;
+  let newTail = newTailOffset < oldTailOffset ? listNodeFor(list, newCapacity - 1) : newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;
   if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) {
     newRoot = editableVNode(newRoot, owner);
     let node = newRoot;
@@ -6707,757 +6140,1310 @@ class StackImpl extends IndexedCollectionImpl {
       return result;
     });
   }
-  keys() {
-    return makeIndexKeys(this.size);
-  }
-}
-Stack2.isStack = isStack;
-function returnStack(stack, newSize, head) {
-  if (stack.__ownerID) {
-    stack.size = newSize;
-    stack._head = head;
-    stack.__hash = undefined;
-    stack.__altered = true;
-    return stack;
-  }
-  return makeStack(newSize, head);
-}
-var makeStack = (size, head, ownerID, hash2) => new StackImpl(size, head, ownerID, hash2);
-var EMPTY_STACK;
-var emptyStack = () => EMPTY_STACK || (EMPTY_STACK = makeStack(0));
-var Set2 = (value) => value === undefined || value === null ? emptySet() : isSet(value) && !isOrdered(value) ? value : emptySet().withMutations((set2) => {
-  const iter = SetCollection(value);
-  assertNotInfinite(iter.size);
-  iter.forEach((v) => set2.add(v));
-});
-Set2.of = (...values) => Set2(values);
-Set2.fromKeys = (value) => Set2(KeyedCollection(value).keySeq());
-Set2.intersect = (sets) => {
-  sets = Collection(sets).toArray();
-  return sets.length ? Set2(sets.pop()).intersect(...sets) : emptySet();
-};
-Set2.union = (sets) => {
-  const setArray = Collection(sets).toArray();
-  return setArray.length ? Set2(setArray.pop()).union(...setArray) : emptySet();
+  keys() {
+    return makeIndexKeys(this.size);
+  }
+}
+Stack2.isStack = isStack;
+function returnStack(stack, newSize, head) {
+  if (stack.__ownerID) {
+    stack.size = newSize;
+    stack._head = head;
+    stack.__hash = undefined;
+    stack.__altered = true;
+    return stack;
+  }
+  return makeStack(newSize, head);
+}
+var makeStack = (size, head, ownerID, hash2) => new StackImpl(size, head, ownerID, hash2);
+var EMPTY_STACK;
+var emptyStack = () => EMPTY_STACK || (EMPTY_STACK = makeStack(0));
+var Set2 = (value) => value === undefined || value === null ? emptySet() : isSet(value) && !isOrdered(value) ? value : emptySet().withMutations((set2) => {
+  const iter = SetCollection(value);
+  assertNotInfinite(iter.size);
+  iter.forEach((v) => set2.add(v));
+});
+Set2.of = (...values) => Set2(values);
+Set2.fromKeys = (value) => Set2(KeyedCollection(value).keySeq());
+Set2.intersect = (sets) => {
+  sets = Collection(sets).toArray();
+  return sets.length ? Set2(sets.pop()).intersect(...sets) : emptySet();
+};
+Set2.union = (sets) => {
+  const setArray = Collection(sets).toArray();
+  return setArray.length ? Set2(setArray.pop()).union(...setArray) : emptySet();
+};
+
+class SetImpl extends SetCollectionImpl {
+  static {
+    mixin(this, {
+      withMutations,
+      asImmutable,
+      asMutable,
+      [IS_SET_SYMBOL]: true,
+      [DELETE]: this.prototype.remove,
+      merge: this.prototype.union,
+      concat: this.prototype.union,
+      [Symbol.toStringTag]: "Immutable.Set"
+    });
+  }
+  constructor(map, ownerID) {
+    super();
+    this.size = map ? map.size : 0;
+    this._map = map;
+    this.__ownerID = ownerID;
+  }
+  create(value) {
+    return Set2(value);
+  }
+  toString() {
+    return this.__toString("Set {", "}");
+  }
+  has(value) {
+    return this._map.has(value);
+  }
+  add(value) {
+    return updateSet(this, this._map.set(value, value));
+  }
+  remove(value) {
+    return updateSet(this, this._map.remove(value));
+  }
+  clear() {
+    return updateSet(this, this._map.clear());
+  }
+  map(mapper, context) {
+    let didChanges = false;
+    const newMap = updateSet(this, this._map.mapEntries(([, v]) => {
+      const mapped = mapper.call(context, v, v, this);
+      if (mapped !== v) {
+        didChanges = true;
+      }
+      return [mapped, mapped];
+    }, context));
+    return didChanges ? newMap : this;
+  }
+  union(...iters) {
+    iters = iters.filter((x) => x.size !== 0);
+    if (iters.length === 0) {
+      return this;
+    }
+    if (this.size === 0 && !this.__ownerID && iters.length === 1) {
+      return Set2(iters[0]);
+    }
+    return this.withMutations((set2) => {
+      for (const iter of iters) {
+        if (typeof iter === "string") {
+          set2.add(iter);
+        } else {
+          SetCollection(iter).forEach((value) => set2.add(value));
+        }
+      }
+    });
+  }
+  intersect(...iters) {
+    return filterByIters(this, iters, (value, sets) => !sets.every((iter) => iter.includes(value)));
+  }
+  subtract(...iters) {
+    return filterByIters(this, iters, (value, sets) => sets.some((iter) => iter.includes(value)));
+  }
+  wasAltered() {
+    return this._map.wasAltered();
+  }
+  __iterator(reverse) {
+    return this._map.__iterator(reverse);
+  }
+  __empty() {
+    return emptySet();
+  }
+  __make(map, ownerID) {
+    return makeSet(map, ownerID);
+  }
+  __ensureOwner(ownerID) {
+    if (ownerID === this.__ownerID) {
+      return this;
+    }
+    const newMap = this._map.__ensureOwner(ownerID);
+    if (!ownerID) {
+      if (this.size === 0) {
+        return this.__empty();
+      }
+      this.__ownerID = ownerID;
+      this._map = newMap;
+      return this;
+    }
+    return this.__make(newMap, ownerID);
+  }
+}
+Set2.isSet = isSet;
+var makeSet = (map, ownerID) => new SetImpl(map, ownerID);
+var EMPTY_SET;
+var emptySet = () => EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
+function filterByIters(set2, iters, shouldRemove) {
+  if (iters.length === 0) {
+    return set2;
+  }
+  iters = iters.map((iter) => SetCollection(iter));
+  return set2.withMutations((s) => {
+    set2.forEach((value) => {
+      if (shouldRemove(value, iters)) {
+        s.remove(value);
+      }
+    });
+  });
+}
+function updateSet(set2, newMap) {
+  if (set2.__ownerID) {
+    set2.size = newMap.size;
+    set2._map = newMap;
+    return set2;
+  }
+  return newMap === set2._map ? set2 : newMap.size === 0 ? set2.__empty() : set2.__make(newMap);
+}
+var OrderedSet = (value) => value === undefined || value === null ? emptyOrderedSet() : isOrderedSet(value) ? value : emptyOrderedSet().withMutations((set2) => {
+  const iter = SetCollection(value);
+  assertNotInfinite(iter.size);
+  iter.forEach((v) => set2.add(v));
+});
+OrderedSet.of = (...values) => OrderedSet(values);
+OrderedSet.fromKeys = (value) => OrderedSet(KeyedCollection(value).keySeq());
+
+class OrderedSetImpl extends SetImpl {
+  static {
+    mixin(this, {
+      [IS_ORDERED_SYMBOL]: true,
+      [Symbol.toStringTag]: "Immutable.OrderedSet",
+      zip: IndexedCollectionPrototype.zip,
+      zipWith: IndexedCollectionPrototype.zipWith,
+      zipAll: IndexedCollectionPrototype.zipAll
+    });
+  }
+  create(value) {
+    return OrderedSet(value);
+  }
+  toString() {
+    return this.__toString("OrderedSet {", "}");
+  }
+  __empty() {
+    return emptyOrderedSet();
+  }
+  __make(map, ownerID) {
+    return makeOrderedSet(map, ownerID);
+  }
+}
+OrderedSet.isOrderedSet = isOrderedSet;
+var makeOrderedSet = (map, ownerID) => new OrderedSetImpl(map, ownerID);
+var emptyOrderedSet = () => makeOrderedSet(emptyOrderedMap());
+function throwOnInvalidDefaultValues(defaultValues) {
+  if (isRecord(defaultValues)) {
+    throw new Error("Can not call `Record` with an immutable Record as default values. Use a plain javascript object instead.");
+  }
+  if (isImmutable(defaultValues)) {
+    throw new Error("Can not call `Record` with an immutable Collection as default values. Use a plain javascript object instead.");
+  }
+  if (defaultValues === null || typeof defaultValues !== "object") {
+    throw new Error("Can not call `Record` with a non-object as default values. Use a plain javascript object instead.");
+  }
+}
+var Record = (defaultValues, name) => {
+  let hasInitialized;
+  throwOnInvalidDefaultValues(defaultValues);
+  const RecordType = function Record2(values) {
+    if (values instanceof RecordType) {
+      return values;
+    }
+    if (!(this instanceof RecordType)) {
+      return new RecordType(values);
+    }
+    if (!hasInitialized) {
+      hasInitialized = true;
+      const keys = Object.keys(defaultValues);
+      const indices = RecordTypePrototype._indices = {};
+      RecordTypePrototype._keys = keys;
+      RecordTypePrototype._defaultValues = defaultValues;
+      for (let i = 0;i < keys.length; i++) {
+        const propName = keys[i];
+        indices[propName] = i;
+        if (RecordTypePrototype[propName]) {
+          console.warn(`Cannot define ${recordName(this)} with property "${propName}" since that property name is part of the Record API.`);
+        } else {
+          setProp(RecordTypePrototype, propName);
+        }
+      }
+    }
+    this.__ownerID = undefined;
+    this._values = List().withMutations((l) => {
+      l.setSize(this._keys.length);
+      KeyedCollection(values).forEach((v, k) => {
+        l.set(this._indices[k], v === this._defaultValues[k] ? undefined : v);
+      });
+    });
+    return this;
+  };
+  const RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);
+  RecordTypePrototype.constructor = RecordType;
+  RecordTypePrototype.create = RecordType;
+  if (name) {
+    RecordType.displayName = name;
+  }
+  return RecordType;
 };
 
-class SetImpl extends SetCollectionImpl {
+class RecordImpl {
   static {
     mixin(this, {
-      withMutations,
       asImmutable,
       asMutable,
-      [IS_SET_SYMBOL]: true,
+      deleteIn,
+      getIn,
+      hasIn,
+      merge,
+      mergeWith,
+      mergeDeep,
+      mergeDeepWith,
+      mergeDeepIn,
+      mergeIn,
+      setIn,
+      toObject,
+      update,
+      updateIn,
+      withMutations,
+      removeIn: deleteIn,
+      toJSON: toObject,
+      [IS_RECORD_SYMBOL]: true,
       [DELETE]: this.prototype.remove,
-      merge: this.prototype.union,
-      concat: this.prototype.union,
-      [Symbol.toStringTag]: "Immutable.Set"
+      [Symbol.iterator]: this.prototype.entries,
+      [Symbol.toStringTag]: "Immutable.Record"
     });
   }
-  constructor(map, ownerID) {
-    super();
-    this.size = map ? map.size : 0;
-    this._map = map;
-    this.__ownerID = ownerID;
+  toString() {
+    const body = this._keys.map((k) => `${k}: ${quoteString(this.get(k))}`).join(", ");
+    return `${recordName(this)} { ${body} }`;
   }
-  create(value) {
-    return Set2(value);
+  equals(other) {
+    return this === other || isRecord(other) && recordSeq(this).equals(recordSeq(other));
   }
-  toString() {
-    return this.__toString("Set {", "}");
+  hashCode() {
+    return recordSeq(this).hashCode();
   }
-  has(value) {
-    return this._map.has(value);
+  has(k) {
+    return Object.hasOwn(this._indices, k);
   }
-  add(value) {
-    return updateSet(this, this._map.set(value, value));
+  get(k, notSetValue) {
+    if (!this.has(k)) {
+      return notSetValue;
+    }
+    const index = this._indices[k];
+    const value = this._values.get(index);
+    return value === undefined ? this._defaultValues[k] : value;
   }
-  remove(value) {
-    return updateSet(this, this._map.remove(value));
+  set(k, v) {
+    if (this.has(k)) {
+      const newValues = this._values.set(this._indices[k], v === this._defaultValues[k] ? undefined : v);
+      if (newValues !== this._values && !this.__ownerID) {
+        return makeRecord(this, newValues);
+      }
+    }
+    return this;
+  }
+  remove(k) {
+    return this.set(k);
   }
   clear() {
-    return updateSet(this, this._map.clear());
+    const newValues = this._values.clear().setSize(this._keys.length);
+    return this.__ownerID ? this : makeRecord(this, newValues);
   }
-  map(mapper, context) {
-    let didChanges = false;
-    const newMap = updateSet(this, this._map.mapEntries(([, v]) => {
-      const mapped = mapper.call(context, v, v, this);
-      if (mapped !== v) {
-        didChanges = true;
-      }
-      return [mapped, mapped];
-    }, context));
-    return didChanges ? newMap : this;
+  wasAltered() {
+    return this._values.wasAltered();
   }
-  union(...iters) {
-    iters = iters.filter((x) => x.size !== 0);
-    if (iters.length === 0) {
+  toSeq() {
+    return recordSeq(this);
+  }
+  toJS() {
+    return toJS(this);
+  }
+  entries() {
+    return this.__iterator();
+  }
+  __iterate(fn, reverse) {
+    return recordSeq(this).__iterate(fn, reverse);
+  }
+  __iterator(reverse) {
+    return recordSeq(this).__iterator(reverse);
+  }
+  __ensureOwner(ownerID) {
+    if (ownerID === this.__ownerID) {
       return this;
     }
-    if (this.size === 0 && !this.__ownerID && iters.length === 1) {
-      return Set2(iters[0]);
+    const newValues = this._values.__ensureOwner(ownerID);
+    if (!ownerID) {
+      this.__ownerID = ownerID;
+      this._values = newValues;
+      return this;
     }
-    return this.withMutations((set2) => {
-      for (const iter of iters) {
-        if (typeof iter === "string") {
-          set2.add(iter);
-        } else {
-          SetCollection(iter).forEach((value) => set2.add(value));
-        }
+    return makeRecord(this, newValues, ownerID);
+  }
+}
+Record.isRecord = isRecord;
+var recordName = (record) => record.constructor.displayName || record.constructor.name || "Record";
+
+class RecordSeq extends KeyedSeqImpl {
+  constructor(record) {
+    super();
+    this._record = record;
+    this.size = record._keys.length;
+  }
+  get(key, notSetValue) {
+    return this._record.get(key, notSetValue);
+  }
+  has(key) {
+    return this._record.has(key);
+  }
+  __iterateUncached(fn, reverse) {
+    const record = this._record;
+    const keys = record._keys;
+    const size = keys.length;
+    let i = 0;
+    while (i !== size) {
+      const ii = reverse ? size - ++i : i++;
+      const k = keys[ii];
+      if (fn(record.get(k), k, this) === false) {
+        break;
       }
-    });
+    }
+    return i;
   }
-  intersect(...iters) {
-    return filterByIters(this, iters, (value, sets) => !sets.every((iter) => iter.includes(value)));
+  __iteratorUncached(reverse) {
+    const record = this._record;
+    const keys = record._keys;
+    const size = keys.length;
+    let i = 0;
+    return makeEntryIterator((entry) => {
+      if (i === size) {
+        return false;
+      }
+      const ii = reverse ? size - ++i : i++;
+      const k = keys[ii];
+      entry[0] = k;
+      entry[1] = record.get(k);
+      return true;
+    });
   }
-  subtract(...iters) {
-    return filterByIters(this, iters, (value, sets) => sets.some((iter) => iter.includes(value)));
+}
+var recordSeq = (record) => new RecordSeq(record);
+Record.getDescriptiveName = recordName;
+var RecordPrototype = RecordImpl.prototype;
+function makeRecord(likeRecord, values, ownerID) {
+  const record = Object.create(Object.getPrototypeOf(likeRecord));
+  record._values = values;
+  record.__ownerID = ownerID;
+  return record;
+}
+function setProp(prototype, name) {
+  Object.defineProperty(prototype, name, {
+    get() {
+      return this.get(name);
+    },
+    set(value) {
+      invariant(this.__ownerID, "Cannot set on an immutable record.");
+      this.set(name, value);
+    }
+  });
+}
+var Range = (start, end, step = 1) => {
+  invariant(step !== 0, "Cannot step a Range by 0");
+  invariant(start !== undefined, "You must define a start value when using Range");
+  invariant(end !== undefined, "You must define an end value when using Range");
+  step = Math.abs(step);
+  if (end < start) {
+    step = -step;
   }
-  wasAltered() {
-    return this._map.wasAltered();
+  const size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
+  return new RangeImpl(start, end, step, size);
+};
+
+class RangeImpl extends IndexedSeqImpl {
+  _start;
+  _end;
+  _step;
+  constructor(start, end, step, size) {
+    super();
+    this._start = start;
+    this._end = end;
+    this._step = step;
+    this.size = size;
   }
-  __iterator(reverse) {
-    return this._map.__iterator(reverse);
+  toString() {
+    return this.size === 0 ? "Range []" : `Range [ ${this._start}...${this._end}${this._step !== 1 ? ` by ${this._step}` : ""} ]`;
   }
-  __empty() {
-    return emptySet();
+  get(index, notSetValue) {
+    return this.has(index) ? this._start + wrapIndex(this, index) * this._step : notSetValue;
   }
-  __make(map, ownerID) {
-    return makeSet(map, ownerID);
+  includes(searchValue) {
+    const possibleIndex = (searchValue - this._start) / this._step;
+    return possibleIndex >= 0 && possibleIndex < this.size && possibleIndex === Math.floor(possibleIndex);
   }
-  __ensureOwner(ownerID) {
-    if (ownerID === this.__ownerID) {
+  slice(begin, end) {
+    if (wholeSlice(begin, end, this.size)) {
       return this;
     }
-    const newMap = this._map.__ensureOwner(ownerID);
-    if (!ownerID) {
-      if (this.size === 0) {
-        return this.__empty();
+    begin = resolveBegin(begin, this.size);
+    end = resolveEnd(end, this.size);
+    if (end <= begin) {
+      return Range(0, 0);
+    }
+    return Range(this.get(begin, this._end), this.get(end, this._end), this._step);
+  }
+  indexOf(searchValue) {
+    const offsetValue = searchValue - this._start;
+    if (offsetValue % this._step === 0) {
+      const index = offsetValue / this._step;
+      if (index >= 0 && index < this.size) {
+        return index;
       }
-      this.__ownerID = ownerID;
-      this._map = newMap;
-      return this;
     }
-    return this.__make(newMap, ownerID);
+    return -1;
   }
-}
-Set2.isSet = isSet;
-var makeSet = (map, ownerID) => new SetImpl(map, ownerID);
-var EMPTY_SET;
-var emptySet = () => EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
-function filterByIters(set2, iters, shouldRemove) {
-  if (iters.length === 0) {
-    return set2;
+  lastIndexOf(searchValue) {
+    return this.indexOf(searchValue);
   }
-  iters = iters.map((iter) => SetCollection(iter));
-  return set2.withMutations((s) => {
-    set2.forEach((value) => {
-      if (shouldRemove(value, iters)) {
-        s.remove(value);
+  __iterateUncached(fn, reverse = false) {
+    const size = this.size;
+    const step = this._step;
+    let value = reverse ? this._start + (size - 1) * step : this._start;
+    let i = 0;
+    while (i !== size) {
+      const v = value;
+      value += reverse ? -step : step;
+      const ii = reverse ? size - ++i : i++;
+      if (fn(v, ii, this) === false) {
+        break;
       }
-    });
-  });
-}
-function updateSet(set2, newMap) {
-  if (set2.__ownerID) {
-    set2.size = newMap.size;
-    set2._map = newMap;
-    return set2;
+    }
+    return i;
   }
-  return newMap === set2._map ? set2 : newMap.size === 0 ? set2.__empty() : set2.__make(newMap);
-}
-var OrderedSet = (value) => value === undefined || value === null ? emptyOrderedSet() : isOrderedSet(value) ? value : emptyOrderedSet().withMutations((set2) => {
-  const iter = SetCollection(value);
-  assertNotInfinite(iter.size);
-  iter.forEach((v) => set2.add(v));
-});
-OrderedSet.of = (...values) => OrderedSet(values);
-OrderedSet.fromKeys = (value) => OrderedSet(KeyedCollection(value).keySeq());
-
-class OrderedSetImpl extends SetImpl {
-  static {
-    mixin(this, {
-      [IS_ORDERED_SYMBOL]: true,
-      [Symbol.toStringTag]: "Immutable.OrderedSet",
-      zip: IndexedCollectionPrototype.zip,
-      zipWith: IndexedCollectionPrototype.zipWith,
-      zipAll: IndexedCollectionPrototype.zipAll
+  __iteratorUncached(reverse = false) {
+    const size = this.size;
+    const step = this._step;
+    let value = reverse ? this._start + (size - 1) * step : this._start;
+    let i = 0;
+    return makeEntryIterator((entry) => {
+      if (i === size) {
+        return false;
+      }
+      const v = value;
+      value += reverse ? -step : step;
+      entry[0] = reverse ? size - ++i : i++;
+      entry[1] = v;
+      return true;
     });
   }
-  create(value) {
-    return OrderedSet(value);
+  values() {
+    const size = this.size;
+    const step = this._step;
+    let value = this._start;
+    let i = 0;
+    const result = {
+      done: false,
+      value: undefined
+    };
+    return makeIterator(() => {
+      if (i === size)
+        return DONE;
+      result.value = value;
+      value += step;
+      i++;
+      return result;
+    });
   }
-  toString() {
-    return this.__toString("OrderedSet {", "}");
+  keys() {
+    return makeIndexKeys(this.size);
   }
-  __empty() {
-    return emptyOrderedSet();
+  equals(other) {
+    return other instanceof RangeImpl ? this._start === other._start && this._end === other._end && this._step === other._step : deepEqual(this, other);
   }
-  __make(map, ownerID) {
-    return makeOrderedSet(map, ownerID);
+  static {
+    this.prototype[Symbol.iterator] = this.prototype.values;
   }
 }
-OrderedSet.isOrderedSet = isOrderedSet;
-var makeOrderedSet = (map, ownerID) => new OrderedSetImpl(map, ownerID);
-var emptyOrderedSet = () => makeOrderedSet(emptyOrderedMap());
-function throwOnInvalidDefaultValues(defaultValues) {
-  if (isRecord(defaultValues)) {
-    throw new Error("Can not call `Record` with an immutable Record as default values. Use a plain javascript object instead.");
+class RepeatImpl extends IndexedSeqImpl {
+  constructor(value, size) {
+    super();
+    this._value = value;
+    this.size = size;
   }
-  if (isImmutable(defaultValues)) {
-    throw new Error("Can not call `Record` with an immutable Collection as default values. Use a plain javascript object instead.");
+  toString() {
+    if (this.size === 0) {
+      return "Repeat []";
+    }
+    return `Repeat [ ${this._value} ${this.size} times ]`;
   }
-  if (defaultValues === null || typeof defaultValues !== "object") {
-    throw new Error("Can not call `Record` with a non-object as default values. Use a plain javascript object instead.");
+  get(index, notSetValue) {
+    return this.has(index) ? this._value : notSetValue;
   }
-}
-var Record = (defaultValues, name) => {
-  let hasInitialized;
-  throwOnInvalidDefaultValues(defaultValues);
-  const RecordType = function Record2(values) {
-    if (values instanceof RecordType) {
-      return values;
-    }
-    if (!(this instanceof RecordType)) {
-      return new RecordType(values);
+  includes(searchValue) {
+    return is(this._value, searchValue);
+  }
+  slice(begin, end) {
+    const size = this.size;
+    return wholeSlice(begin, end, size) ? this : new RepeatImpl(this._value, resolveEnd(end, size) - resolveBegin(begin, size));
+  }
+  reverse() {
+    return this;
+  }
+  indexOf(searchValue) {
+    if (is(this._value, searchValue)) {
+      return 0;
     }
-    if (!hasInitialized) {
-      hasInitialized = true;
-      const keys = Object.keys(defaultValues);
-      const indices = RecordTypePrototype._indices = {};
-      RecordTypePrototype._keys = keys;
-      RecordTypePrototype._defaultValues = defaultValues;
-      for (let i = 0;i < keys.length; i++) {
-        const propName = keys[i];
-        indices[propName] = i;
-        if (RecordTypePrototype[propName]) {
-          console.warn(`Cannot define ${recordName(this)} with property "${propName}" since that property name is part of the Record API.`);
-        } else {
-          setProp(RecordTypePrototype, propName);
-        }
-      }
+    return -1;
+  }
+  lastIndexOf(searchValue) {
+    if (is(this._value, searchValue)) {
+      return this.size;
     }
-    this.__ownerID = undefined;
-    this._values = List().withMutations((l) => {
-      l.setSize(this._keys.length);
-      KeyedCollection(values).forEach((v, k) => {
-        l.set(this._indices[k], v === this._defaultValues[k] ? undefined : v);
-      });
-    });
-    return this;
-  };
-  const RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);
-  RecordTypePrototype.constructor = RecordType;
-  RecordTypePrototype.create = RecordType;
-  if (name) {
-    RecordType.displayName = name;
+    return -1;
   }
-  return RecordType;
-};
-
-class RecordImpl {
-  static {
-    mixin(this, {
-      asImmutable,
-      asMutable,
-      deleteIn,
-      getIn,
-      hasIn,
-      merge,
-      mergeWith,
-      mergeDeep,
-      mergeDeepWith,
-      mergeDeepIn,
-      mergeIn,
-      setIn,
-      toObject,
-      update,
-      updateIn,
-      withMutations,
-      removeIn: deleteIn,
-      toJSON: toObject,
-      [IS_RECORD_SYMBOL]: true,
-      [DELETE]: this.prototype.remove,
-      [Symbol.iterator]: this.prototype.entries,
-      [Symbol.toStringTag]: "Immutable.Record"
+  __iterateUncached(fn, reverse) {
+    const size = this.size;
+    let i = 0;
+    while (i !== size) {
+      if (fn(this._value, reverse ? size - ++i : i++, this) === false) {
+        break;
+      }
+    }
+    return i;
+  }
+  __iteratorUncached(reverse) {
+    const size = this.size;
+    const val = this._value;
+    let i = 0;
+    return makeEntryIterator((entry) => {
+      if (i === size) {
+        return false;
+      }
+      entry[0] = reverse ? size - ++i : i++;
+      entry[1] = val;
+      return true;
     });
   }
-  toString() {
-    const body = this._keys.map((k) => `${k}: ${quoteString(this.get(k))}`).join(", ");
-    return `${recordName(this)} { ${body} }`;
+  values() {
+    const size = this.size;
+    const val = this._value;
+    let i = 0;
+    const result = {
+      done: false,
+      value: undefined
+    };
+    return makeIterator(() => {
+      if (i === size)
+        return DONE;
+      i++;
+      result.value = val;
+      return result;
+    });
+  }
+  keys() {
+    return makeIndexKeys(this.size);
   }
   equals(other) {
-    return this === other || isRecord(other) && recordSeq(this).equals(recordSeq(other));
+    return other instanceof RepeatImpl ? this.size === other.size && is(this._value, other._value) : deepEqual(this, other);
   }
-  hashCode() {
-    return recordSeq(this).hashCode();
+  static {
+    this.prototype[Symbol.iterator] = this.prototype.values;
   }
-  has(k) {
-    return Object.hasOwn(this._indices, k);
+}
+
+// src/renderer.js
+var DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk"];
+
+class Renderer {
+  constructor(comps, h, fragment, comment, renderFn, getSeqInfo, cache) {
+    this.comps = comps;
+    this.h = h;
+    this.fragment = fragment;
+    this.comment = comment;
+    this.renderFn = renderFn;
+    this.getSeqInfo = getSeqInfo ?? basicGetSeqInfo;
+    this.cache = cache ?? new WeakMapDomCache;
   }
-  get(k, notSetValue) {
-    if (!this.has(k)) {
-      return notSetValue;
-    }
-    const index = this._indices[k];
-    const value = this._values.get(index);
-    return value === undefined ? this._defaultValues[k] : value;
+  setNullCache() {
+    this.cache = new NullDomCache;
   }
-  set(k, v) {
-    if (this.has(k)) {
-      const newValues = this._values.set(this._indices[k], v === this._defaultValues[k] ? undefined : v);
-      if (newValues !== this._values && !this.__ownerID) {
-        return makeRecord(this, newValues);
+  renderToDOM(stack, val) {
+    const rootNode = document.createElement("div");
+    this.renderFn(this.h("div", null, [this.renderRoot(stack, val)]), rootNode);
+    return rootNode.childNodes[0];
+  }
+  renderToString(stack, val, cleanAttrs = true) {
+    const dom = this.renderToDOM(stack, val, this.renderFn);
+    if (cleanAttrs) {
+      const nodes = dom.querySelectorAll("[data-nid],[data-cid],[data-eid]");
+      for (const { dataset } of nodes) {
+        for (const name of DATASET_ATTRS) {
+          delete dataset[name];
+        }
       }
     }
-    return this;
-  }
-  remove(k) {
-    return this.set(k);
+    return dom.innerHTML;
   }
-  clear() {
-    const newValues = this._values.clear().setSize(this._keys.length);
-    return this.__ownerID ? this : makeRecord(this, newValues);
+  renderRoot(stack, val, viewName = null) {
+    const c = this.comps.getCompFor(val);
+    const nid = c.getView(viewName).anode.nodeId ?? null;
+    return c ? this._rValComp(stack, val, c, nid, "ROOT", viewName) : null;
   }
-  wasAltered() {
-    return this._values.wasAltered();
+  renderIt(stack, nodeId, key, viewName) {
+    const c = this.comps.getCompFor(stack.it);
+    return c ? this._rValComp(stack, stack.it, c, nodeId, key, viewName) : null;
   }
-  toSeq() {
-    return recordSeq(this);
+  _rValComp(stack, val, comp, nid, key, viewName) {
+    const cacheKey = `${viewName ?? stack.viewsId ?? ""}${nid}-${key}`;
+    const cachedNode = this.cache.get(val, cacheKey);
+    if (cachedNode) {
+      return cachedNode;
+    }
+    const view = viewName ? comp.getView(viewName) : stack.lookupBestView(comp.views, "main");
+    const meta = this.renderMetadata("Comp", { nid });
+    const dom = this.renderFragment([meta, view.render(stack, this)]);
+    this.cache.set(val, cacheKey, dom);
+    return dom;
   }
-  toJS() {
-    return toJS(this);
+  renderEach(stack, iterInfo, nodeId, viewName) {
+    const { seq, filter, loopWith } = iterInfo.eval(stack);
+    const [attrName, gen] = this.getSeqInfo(seq);
+    const r = [];
+    const iterData = loopWith.call(stack.it, seq);
+    for (const [key, value] of gen(seq)) {
+      if (filter.call(stack.it, key, value, iterData)) {
+        const newStack = stack.enter(value, { key }, true);
+        const dom = this.renderIt(newStack, nodeId, key, viewName);
+        r.push(this.renderMetadata("Each", { nid: nodeId, [attrName]: key }));
+        r.push(dom);
+      }
+    }
+    return r;
   }
-  entries() {
-    return this.__iterator();
+  renderEachWhen(stack, iterInfo, node, nid) {
+    const { seq, filter, loopWith, enricher } = iterInfo.eval(stack);
+    const [attrName, gen] = this.getSeqInfo(seq);
+    const hasEnricher = !!enricher;
+    const r = [];
+    const iterData = loopWith.call(stack.it, seq);
+    for (const [key, value] of gen(seq)) {
+      if (filter.call(stack.it, key, value, iterData)) {
+        const bindings = { key, value };
+        const cacheKey = `${nid}-${key}`;
+        let cachedNode;
+        if (hasEnricher) {
+          enricher.call(stack.it, bindings, key, value, iterData);
+          cachedNode = this.cache.get2(stack.it, value, cacheKey);
+        } else {
+          cachedNode = this.cache.get(value, cacheKey);
+        }
+        if (cachedNode) {
+          r.push(this.renderMetadata("Each", { nid, [attrName]: key }));
+          r.push(cachedNode);
+          continue;
+        }
+        const newStack = stack.enter(value, bindings, false);
+        const dom = node.render(newStack, this);
+        r.push(this.renderMetadata("Each", { nid, [attrName]: key }));
+        if (hasEnricher) {
+          this.cache.set2(stack.it, value, cacheKey, dom);
+        } else {
+          this.cache.set(value, cacheKey, dom);
+        }
+        r.push(dom);
+      }
+    }
+    return r;
   }
-  __iterate(fn, reverse) {
-    return recordSeq(this).__iterate(fn, reverse);
+  renderText(text) {
+    return text;
   }
-  __iterator(reverse) {
-    return recordSeq(this).__iterator(reverse);
+  renderMetadata(type, info) {
+    info.$ = type;
+    return this.renderComment(`§${JSON.stringify(info)}§`);
   }
-  __ensureOwner(ownerID) {
-    if (ownerID === this.__ownerID) {
-      return this;
-    }
-    const newValues = this._values.__ensureOwner(ownerID);
-    if (!ownerID) {
-      this.__ownerID = ownerID;
-      this._values = newValues;
-      return this;
-    }
-    return makeRecord(this, newValues, ownerID);
+  renderComment(text) {
+    return this.comment(text);
   }
-}
-Record.isRecord = isRecord;
-var recordName = (record) => record.constructor.displayName || record.constructor.name || "Record";
-
-class RecordSeq extends KeyedSeqImpl {
-  constructor(record) {
-    super();
-    this._record = record;
-    this.size = record._keys.length;
+  renderEmpty(_text) {
+    return null;
   }
-  get(key, notSetValue) {
-    return this._record.get(key, notSetValue);
+  renderTag(tagName, attrs, childs) {
+    return this.h(tagName, attrs, childs);
   }
-  has(key) {
-    return this._record.has(key);
+  renderFragment(childs) {
+    return this.fragment(childs);
   }
-  __iterateUncached(fn, reverse) {
-    const record = this._record;
-    const keys = record._keys;
-    const size = keys.length;
-    let i = 0;
-    while (i !== size) {
-      const ii = reverse ? size - ++i : i++;
-      const k = keys[ii];
-      if (fn(record.get(k), k, this) === false) {
-        break;
+}
+function* imIndexedEntries(seq) {
+  let i = 0;
+  for (const v of seq)
+    yield [i++, v];
+}
+function* imKeyedEntries(obj) {
+  for (const [key, value] of obj.toSeq().entries())
+    yield [key, value];
+}
+var seqInfoByClass = new Map;
+var idxInfo = ["si", imIndexedEntries];
+var keyInfo = ["sk", imKeyedEntries];
+var unkInfo = ["si", function* nullEntries(_obj) {}];
+function basicGetSeqInfo(seq) {
+  return isIndexed(seq) ? idxInfo : isKeyed(seq) ? keyInfo : seqInfoByClass.get(seq?.constructor) ?? unkInfo;
+}
+
+// src/vdom.js
+function isHtmlAttribute(propName) {
+  return propName[4] === "-" && (propName[0] === "d" || propName[0] === "a");
+}
+function getDomProp(node, propName) {
+  return node[propName];
+}
+function setDomProp(node, propName, value) {
+  node[propName] = value;
+}
+function applyProperties(node, props, previous) {
+  for (const propName in props) {
+    const propValue = props[propName];
+    if (propValue === undefined) {
+      removeProperty(node, propName, previous);
+    } else if (isHtmlAttribute(propName)) {
+      node.setAttribute(propName, propValue);
+    } else {
+      if (typeof propValue === "object" && propValue !== null) {
+        patchObject(node, previous, propName, propValue);
+      } else {
+        setDomProp(node, propName, propValue);
       }
     }
-    return i;
-  }
-  __iteratorUncached(reverse) {
-    const record = this._record;
-    const keys = record._keys;
-    const size = keys.length;
-    let i = 0;
-    return makeEntryIterator((entry) => {
-      if (i === size) {
-        return false;
-      }
-      const ii = reverse ? size - ++i : i++;
-      const k = keys[ii];
-      entry[0] = k;
-      entry[1] = record.get(k);
-      return true;
-    });
   }
 }
-var recordSeq = (record) => new RecordSeq(record);
-Record.getDescriptiveName = recordName;
-var RecordPrototype = RecordImpl.prototype;
-function makeRecord(likeRecord, values, ownerID) {
-  const record = Object.create(Object.getPrototypeOf(likeRecord));
-  record._values = values;
-  record.__ownerID = ownerID;
-  return record;
+function removeProperty(node, propName, previous) {
+  const previousValue = previous[propName];
+  if (isHtmlAttribute(propName)) {
+    node.removeAttribute(propName);
+  } else if (typeof previousValue === "string") {
+    setDomProp(node, propName, "");
+    const attrName = propName === "className" ? "class" : propName === "htmlFor" ? "for" : propName;
+    node.removeAttribute(attrName);
+  } else {
+    setDomProp(node, propName, null);
+  }
 }
-function setProp(prototype, name) {
-  Object.defineProperty(prototype, name, {
-    get() {
-      return this.get(name);
-    },
-    set(value) {
-      invariant(this.__ownerID, "Cannot set on an immutable record.");
-      this.set(name, value);
-    }
-  });
+function patchObject(node, previous, propName, propValue) {
+  const previousValue = previous?.[propName];
+  if (previousValue && typeof previousValue === "object" && Object.getPrototypeOf(previousValue) !== Object.getPrototypeOf(propValue)) {
+    setDomProp(node, propName, propValue);
+    return;
+  }
+  let current = getDomProp(node, propName);
+  if (typeof current !== "object" || current === null) {
+    setDomProp(node, propName, {});
+    current = getDomProp(node, propName);
+  }
+  const target = current;
+  for (const k in propValue) {
+    target[k] = propValue[k];
+  }
 }
-var Range = (start, end, step = 1) => {
-  invariant(step !== 0, "Cannot step a Range by 0");
-  invariant(start !== undefined, "You must define a start value when using Range");
-  invariant(end !== undefined, "You must define an end value when using Range");
-  step = Math.abs(step);
-  if (end < start) {
-    step = -step;
+
+class Warning {
+  constructor(type, message) {
+    this.type = type;
+    this.message = message;
   }
-  const size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
-  return new RangeImpl(start, end, step, size);
-};
+}
 
-class RangeImpl extends IndexedSeqImpl {
-  _start;
-  _end;
-  _step;
-  constructor(start, end, step, size) {
-    super();
-    this._start = start;
-    this._end = end;
-    this._step = step;
-    this.size = size;
+class DuplicatedKeysWarning extends Warning {
+  constructor(duplicatedKeys, parentTag, parentIndex) {
+    const keys = [...duplicatedKeys].join(", ");
+    super("DuplicatedKeys", `Duplicate keys found: [${keys}] in ${parentTag || "fragment"} at index ${parentIndex}. Nodes with duplicated keys are matched positionally.`);
+    this.duplicatedKeys = duplicatedKeys;
+    this.parentTag = parentTag;
+    this.parentIndex = parentIndex;
   }
-  toString() {
-    return this.size === 0 ? "Range []" : `Range [ ${this._start}...${this._end}${this._step !== 1 ? ` by ${this._step}` : ""} ]`;
+}
+
+class VBase {
+  isEqualTo(other) {
+    return this === other;
   }
-  get(index, notSetValue) {
-    return this.has(index) ? this._start + wrapIndex(this, index) * this._step : notSetValue;
+  toDom(_opts) {
+    return null;
   }
-  includes(searchValue) {
-    const possibleIndex = (searchValue - this._start) / this._step;
-    return possibleIndex >= 0 && possibleIndex < this.size && possibleIndex === Math.floor(possibleIndex);
+}
+function getKey(node) {
+  return node instanceof VNode2 ? node.key : undefined;
+}
+function effectiveKey(node, duplicatedKeys) {
+  const key = getKey(node);
+  return key && duplicatedKeys?.has(key) ? undefined : key;
+}
+function isIterable(obj) {
+  return obj != null && typeof obj !== "string" && typeof obj[Symbol.iterator] === "function";
+}
+function addChild(normalizedChildren, child) {
+  if (child == null) {
+    return;
   }
-  slice(begin, end) {
-    if (wholeSlice(begin, end, this.size)) {
-      return this;
+  if (isIterable(child)) {
+    for (const c of child) {
+      addChild(normalizedChildren, c);
     }
-    begin = resolveBegin(begin, this.size);
-    end = resolveEnd(end, this.size);
-    if (end <= begin) {
-      return Range(0, 0);
+  } else if (child instanceof VBase) {
+    if (child instanceof VFragment) {
+      normalizedChildren.push(...child.childs);
+    } else {
+      normalizedChildren.push(child);
     }
-    return Range(this.get(begin, this._end), this.get(end, this._end), this._step);
+  } else {
+    normalizedChildren.push(new VText(child));
   }
-  indexOf(searchValue) {
-    const offsetValue = searchValue - this._start;
-    if (offsetValue % this._step === 0) {
-      const index = offsetValue / this._step;
-      if (index >= 0 && index < this.size) {
-        return index;
-      }
-    }
-    return -1;
+}
+
+class VText extends VBase {
+  constructor(text) {
+    super();
+    this.text = String(text);
   }
-  lastIndexOf(searchValue) {
-    return this.indexOf(searchValue);
+  get nodeType() {
+    return 3;
   }
-  __iterateUncached(fn, reverse = false) {
-    const size = this.size;
-    const step = this._step;
-    let value = reverse ? this._start + (size - 1) * step : this._start;
-    let i = 0;
-    while (i !== size) {
-      const v = value;
-      value += reverse ? -step : step;
-      const ii = reverse ? size - ++i : i++;
-      if (fn(v, ii, this) === false) {
-        break;
-      }
-    }
-    return i;
+  isEqualTo(other) {
+    return other instanceof VText && this.text === other.text;
   }
-  __iteratorUncached(reverse = false) {
-    const size = this.size;
-    const step = this._step;
-    let value = reverse ? this._start + (size - 1) * step : this._start;
-    let i = 0;
-    return makeEntryIterator((entry) => {
-      if (i === size) {
-        return false;
-      }
-      const v = value;
-      value += reverse ? -step : step;
-      entry[0] = reverse ? size - ++i : i++;
-      entry[1] = v;
-      return true;
-    });
+  toDom(opts) {
+    return opts.document.createTextNode(this.text);
   }
-  values() {
-    const size = this.size;
-    const step = this._step;
-    let value = this._start;
-    let i = 0;
-    const result = {
-      done: false,
-      value: undefined
-    };
-    return makeIterator(() => {
-      if (i === size)
-        return DONE;
-      result.value = value;
-      value += step;
-      i++;
-      return result;
-    });
+}
+
+class VComment extends VBase {
+  constructor(text) {
+    super();
+    this.text = text;
   }
-  keys() {
-    return makeIndexKeys(this.size);
+  get nodeType() {
+    return 8;
   }
-  equals(other) {
-    return other instanceof RangeImpl ? this._start === other._start && this._end === other._end && this._step === other._step : deepEqual(this, other);
+  isEqualTo(other) {
+    return other instanceof VComment && this.text === other.text;
   }
-  static {
-    this.prototype[Symbol.iterator] = this.prototype.values;
+  toDom(opts) {
+    return opts.document.createComment(this.text);
   }
 }
-class RepeatImpl extends IndexedSeqImpl {
-  constructor(value, size) {
+
+class VFragment extends VBase {
+  constructor(childs) {
     super();
-    this._value = value;
-    this.size = size;
+    const normalized = [];
+    addChild(normalized, childs);
+    this.childs = normalized;
   }
-  toString() {
-    if (this.size === 0) {
-      return "Repeat []";
-    }
-    return `Repeat [ ${this._value} ${this.size} times ]`;
+  get nodeType() {
+    return 11;
   }
-  get(index, notSetValue) {
-    return this.has(index) ? this._value : notSetValue;
+  isEqualTo(other) {
+    if (!(other instanceof VFragment) || this.childs.length !== other.childs.length) {
+      return false;
+    }
+    for (let i = 0;i < this.childs.length; i++) {
+      if (!this.childs[i].isEqualTo(other.childs[i])) {
+        return false;
+      }
+    }
+    return true;
   }
-  includes(searchValue) {
-    return is(this._value, searchValue);
+  toDom(opts) {
+    const fragment = opts.document.createDocumentFragment();
+    for (const child of this.childs) {
+      const childNode = child.toDom(opts);
+      if (childNode) {
+        fragment.appendChild(childNode);
+      }
+    }
+    return fragment;
   }
-  slice(begin, end) {
-    const size = this.size;
-    return wholeSlice(begin, end, size) ? this : new RepeatImpl(this._value, resolveEnd(end, size) - resolveBegin(begin, size));
+}
+
+class VNode2 extends VBase {
+  constructor(tag, attrs, childs, key, namespace) {
+    super();
+    this.tag = tag;
+    this.attrs = attrs ?? {};
+    this.childs = childs ?? [];
+    this.key = key != null ? String(key) : undefined;
+    this.namespace = typeof namespace === "string" ? namespace : null;
+    this.attrCount = Object.keys(this.attrs).length;
   }
-  reverse() {
-    return this;
+  get nodeType() {
+    return 1;
   }
-  indexOf(searchValue) {
-    if (is(this._value, searchValue)) {
-      return 0;
+  isEqualTo(other) {
+    if (!(other instanceof VNode2) || this.tag !== other.tag || this.key !== other.key || this.namespace !== other.namespace || this.attrCount !== other.attrCount || this.childs.length !== other.childs.length) {
+      return false;
     }
-    return -1;
-  }
-  lastIndexOf(searchValue) {
-    if (is(this._value, searchValue)) {
-      return this.size;
+    for (const key in this.attrs) {
+      if (this.attrs[key] !== other.attrs[key]) {
+        return false;
+      }
     }
-    return -1;
+    for (let i = 0;i < this.childs.length; i++) {
+      if (!this.childs[i].isEqualTo(other.childs[i])) {
+        return false;
+      }
+    }
+    return true;
   }
-  __iterateUncached(fn, reverse) {
-    const size = this.size;
-    let i = 0;
-    while (i !== size) {
-      if (fn(this._value, reverse ? size - ++i : i++, this) === false) {
-        break;
+  toDom(opts) {
+    const doc = opts.document;
+    const node = this.namespace === null ? doc.createElement(this.tag) : doc.createElementNS(this.namespace, this.tag);
+    applyProperties(node, this.attrs, {});
+    for (const child of this.childs) {
+      const childNode = child.toDom(opts);
+      if (childNode) {
+        node.appendChild(childNode);
       }
     }
-    return i;
+    return node;
   }
-  __iteratorUncached(reverse) {
-    const size = this.size;
-    const val = this._value;
-    let i = 0;
-    return makeEntryIterator((entry) => {
-      if (i === size) {
-        return false;
+}
+function diffProps(a, b) {
+  let diff = null;
+  for (const aKey in a) {
+    if (!Object.hasOwn(b, aKey)) {
+      diff ??= {};
+      diff[aKey] = undefined;
+      continue;
+    }
+    const aValue = a[aKey];
+    const bValue = b[aKey];
+    if (aValue === bValue) {} else if (typeof aValue === "object" && aValue !== null && typeof bValue === "object" && bValue !== null) {
+      if (Object.getPrototypeOf(bValue) !== Object.getPrototypeOf(aValue)) {
+        diff ??= {};
+        diff[aKey] = bValue;
+      } else {
+        const objectDiff = diffProps(aValue, bValue);
+        if (objectDiff) {
+          diff ??= {};
+          diff[aKey] = objectDiff;
+        }
       }
-      entry[0] = reverse ? size - ++i : i++;
-      entry[1] = val;
-      return true;
-    });
+    } else {
+      diff ??= {};
+      diff[aKey] = bValue;
+    }
   }
-  values() {
-    const size = this.size;
-    const val = this._value;
-    let i = 0;
-    const result = {
-      done: false,
-      value: undefined
+  for (const bKey in b) {
+    if (!Object.hasOwn(a, bKey)) {
+      diff ??= {};
+      diff[bKey] = b[bKey];
+    }
+  }
+  return diff;
+}
+function reorder(oldChildren, newChildren) {
+  const rawNew = keyIndex(newChildren);
+  if (rawNew.free.length === newChildren.length) {
+    return {
+      children: newChildren,
+      moves: null,
+      duplicatedKeys: rawNew.duplicatedKeys
     };
-    return makeIterator(() => {
-      if (i === size)
-        return DONE;
-      i++;
-      result.value = val;
-      return result;
-    });
   }
-  keys() {
-    return makeIndexKeys(this.size);
+  const rawOld = keyIndex(oldChildren);
+  const duplicatedKeys = rawNew.duplicatedKeys || rawOld.duplicatedKeys ? new Set([...rawNew.duplicatedKeys || [], ...rawOld.duplicatedKeys || []]) : null;
+  if (rawOld.free.length === oldChildren.length) {
+    return {
+      children: newChildren,
+      moves: null,
+      duplicatedKeys
+    };
   }
-  equals(other) {
-    return other instanceof RepeatImpl ? this.size === other.size && is(this._value, other._value) : deepEqual(this, other);
+  let newKeys;
+  let newFree;
+  let oldKeys;
+  if (duplicatedKeys) {
+    const updatedNew = keyIndex(newChildren, duplicatedKeys);
+    newKeys = updatedNew.keys;
+    newFree = updatedNew.free;
+    oldKeys = keyIndex(oldChildren, duplicatedKeys).keys;
+  } else {
+    newKeys = rawNew.keys;
+    newFree = rawNew.free;
+    oldKeys = rawOld.keys;
   }
-  static {
-    this.prototype[Symbol.iterator] = this.prototype.values;
+  const reordered = [];
+  let freeIndex = 0;
+  const freeCount = newFree.length;
+  let deletedItems = 0;
+  for (let i = 0;i < oldChildren.length; i++) {
+    const oldItem = oldChildren[i];
+    const oldKey = effectiveKey(oldItem, duplicatedKeys);
+    if (oldKey) {
+      if (Object.hasOwn(newKeys, oldKey)) {
+        const itemIndex = newKeys[oldKey];
+        reordered.push(newChildren[itemIndex]);
+      } else {
+        deletedItems++;
+        reordered.push(null);
+      }
+    } else {
+      if (freeIndex < freeCount) {
+        const itemIndex = newFree[freeIndex++];
+        reordered.push(newChildren[itemIndex]);
+      } else {
+        deletedItems++;
+        reordered.push(null);
+      }
+    }
+  }
+  const lastFreeIndex = freeIndex >= newFree.length ? newChildren.length : newFree[freeIndex];
+  for (let j = 0;j < newChildren.length; j++) {
+    const newItem = newChildren[j];
+    const newKey = effectiveKey(newItem, duplicatedKeys);
+    if (newKey) {
+      if (!Object.hasOwn(oldKeys, newKey)) {
+        reordered.push(newItem);
+      }
+    } else if (j >= lastFreeIndex) {
+      reordered.push(newItem);
+    }
   }
+  const moves = computeMoves(reordered, newChildren, newKeys, duplicatedKeys, deletedItems);
+  return { children: reordered, moves, duplicatedKeys };
 }
-
-// src/renderer.js
-var DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk"];
-
-class Renderer {
-  constructor(comps, h2, fragment, comment, renderFn, getSeqInfo, cache) {
-    this.comps = comps;
-    this.h = h2;
-    this.fragment = fragment;
-    this.comment = comment;
-    this.renderFn = renderFn;
-    this.getSeqInfo = getSeqInfo ?? basicGetSeqInfo;
-    this.cache = cache ?? new WeakMapDomCache;
+function computeMoves(reordered, newChildren, newKeys, duplicatedKeys, deletedItems) {
+  const simulate = reordered.slice();
+  let simulateIndex = 0;
+  const removes = [];
+  const inserts = [];
+  const wantedKeys = new Array(newChildren.length);
+  for (let i = 0;i < newChildren.length; i++) {
+    wantedKeys[i] = effectiveKey(newChildren[i], duplicatedKeys);
   }
-  setNullCache() {
-    this.cache = new NullDomCache;
+  for (let k = 0;k < newChildren.length; ) {
+    const wantedKey = wantedKeys[k];
+    let simulateItem = simulate[simulateIndex];
+    let simulateKey = effectiveKey(simulateItem, duplicatedKeys);
+    while (simulateItem === null && simulate.length) {
+      simulate.splice(simulateIndex, 1);
+      removes.push({ from: simulateIndex, key: null });
+      simulateItem = simulate[simulateIndex];
+      simulateKey = effectiveKey(simulateItem, duplicatedKeys);
+    }
+    if (simulateItem && simulateKey === wantedKey) {
+      simulateIndex++;
+      k++;
+      continue;
+    }
+    if (wantedKey) {
+      if (simulateKey && newKeys[simulateKey] !== k + 1) {
+        simulate.splice(simulateIndex, 1);
+        removes.push({ from: simulateIndex, key: simulateKey });
+        simulateItem = simulate[simulateIndex];
+        simulateKey = effectiveKey(simulateItem, duplicatedKeys);
+        if (simulateItem && simulateKey === wantedKey) {
+          simulateIndex++;
+          k++;
+          continue;
+        }
+      }
+      inserts.push({ key: wantedKey, to: k });
+      k++;
+      continue;
+    }
+    if (simulateKey) {
+      simulate.splice(simulateIndex, 1);
+      removes.push({ from: simulateIndex, key: simulateKey });
+      continue;
+    }
+    k++;
+  }
+  while (simulateIndex < simulate.length) {
+    const simulateItem = simulate[simulateIndex];
+    simulate.splice(simulateIndex, 1);
+    removes.push({
+      from: simulateIndex,
+      key: effectiveKey(simulateItem, duplicatedKeys)
+    });
   }
-  renderToDOM(stack, val) {
-    const rootNode = document.createElement("div");
-    this.renderFn(this.h("div", null, [this.renderRoot(stack, val)]), rootNode);
-    return rootNode.childNodes[0];
+  if (removes.length === deletedItems && !inserts.length) {
+    return null;
   }
-  renderToString(stack, val, cleanAttrs = true) {
-    const dom = this.renderToDOM(stack, val, this.renderFn);
-    if (cleanAttrs) {
-      const nodes = dom.querySelectorAll("[data-nid],[data-cid],[data-eid]");
-      for (const { dataset } of nodes) {
-        for (const name of DATASET_ATTRS) {
-          delete dataset[name];
-        }
+  return { removes, inserts };
+}
+function keyIndex(children, excludeKeys) {
+  const keys = {};
+  const free = [];
+  let duplicatedKeys = null;
+  for (let i = 0;i < children.length; i++) {
+    const key = getKey(children[i]);
+    if (key && !excludeKeys?.has(key)) {
+      if (key in keys) {
+        duplicatedKeys ??= new Set;
+        duplicatedKeys.add(key);
       }
+      keys[key] = i;
+    } else {
+      free.push(i);
     }
-    return dom.innerHTML;
   }
-  renderRoot(stack, val, viewName = null) {
-    const c = this.comps.getCompFor(val);
-    const nid = c.getView(viewName).anode.nodeId ?? null;
-    return c ? this._rValComp(stack, val, c, nid, "ROOT", viewName) : null;
+  return { keys, free, duplicatedKeys };
+}
+function replaceNode(domNode, vnode, options) {
+  const parentNode = domNode.parentNode;
+  const newNode = vnode.toDom(options);
+  if (parentNode && newNode && newNode !== domNode) {
+    parentNode.replaceChild(newNode, domNode);
   }
-  renderIt(stack, nodeId, key, viewName) {
-    const c = this.comps.getCompFor(stack.it);
-    return c ? this._rValComp(stack, stack.it, c, nodeId, key, viewName) : null;
+  return newNode || domNode;
+}
+function morphNode(domNode, source, target, opts) {
+  if (source === target || source.isEqualTo(target))
+    return domNode;
+  if (source instanceof VText && target instanceof VText || source instanceof VComment && target instanceof VComment) {
+    domNode.data = target.text;
+    return domNode;
   }
-  _rValComp(stack, val, comp, nid, key, viewName) {
-    const cacheKey = `${viewName ?? stack.viewsId ?? ""}${nid}-${key}`;
-    const cachedNode = this.cache.get(val, cacheKey);
-    if (cachedNode) {
-      return cachedNode;
+  if (source instanceof VNode2 && target instanceof VNode2 && source.tag === target.tag && source.namespace === target.namespace && source.key === target.key) {
+    const propsDiff = diffProps(source.attrs, target.attrs);
+    if (propsDiff) {
+      applyProperties(domNode, propsDiff, source.attrs);
     }
-    const view = viewName ? comp.getView(viewName) : stack.lookupBestView(comp.views, "main");
-    const meta = this.renderMetadata("Comp", { nid });
-    const dom = this.renderFragment([meta, view.render(stack, this)]);
-    this.cache.set(val, cacheKey, dom);
-    return dom;
+    morphChildren(domNode, source.childs, target.childs, source.tag, opts);
+    return domNode;
   }
-  renderEach(stack, iterInfo, nodeId, viewName) {
-    const { seq, filter, loopWith } = iterInfo.eval(stack);
-    const [attrName, gen] = this.getSeqInfo(seq);
-    const r = [];
-    const iterData = loopWith.call(stack.it, seq);
-    for (const [key, value] of gen(seq)) {
-      if (filter.call(stack.it, key, value, iterData)) {
-        const newStack = stack.enter(value, { key }, true);
-        const dom = this.renderIt(newStack, nodeId, key, viewName);
-        r.push(this.renderMetadata("Each", { nid: nodeId, [attrName]: key }));
-        r.push(dom);
-      }
+  if (source instanceof VFragment && target instanceof VFragment) {
+    morphChildren(domNode, source.childs, target.childs, null, opts);
+    return domNode;
+  }
+  return replaceNode(domNode, target, opts);
+}
+function morphChildren(parentDom, oldChilds, newChilds, parentTag, opts) {
+  if (oldChilds.length === 0) {
+    for (const child of newChilds) {
+      const node = child.toDom(opts);
+      if (node)
+        parentDom.appendChild(node);
     }
-    return r;
+    return;
   }
-  renderEachWhen(stack, iterInfo, node, nid) {
-    const { seq, filter, loopWith, enricher } = iterInfo.eval(stack);
-    const [attrName, gen] = this.getSeqInfo(seq);
-    const hasEnricher = !!enricher;
-    const r = [];
-    const iterData = loopWith.call(stack.it, seq);
-    for (const [key, value] of gen(seq)) {
-      if (filter.call(stack.it, key, value, iterData)) {
-        const bindings = { key, value };
-        const cacheKey = `${nid}-${key}`;
-        let cachedNode;
-        if (hasEnricher) {
-          enricher.call(stack.it, bindings, key, value, iterData);
-          cachedNode = this.cache.get2(stack.it, value, cacheKey);
-        } else {
-          cachedNode = this.cache.get(value, cacheKey);
-        }
-        if (cachedNode) {
-          r.push(this.renderMetadata("Each", { nid, [attrName]: key }));
-          r.push(cachedNode);
-          continue;
-        }
-        const newStack = stack.enter(value, bindings, false);
-        const dom = node.render(newStack, this);
-        r.push(this.renderMetadata("Each", { nid, [attrName]: key }));
-        if (hasEnricher) {
-          this.cache.set2(stack.it, value, cacheKey, dom);
-        } else {
-          this.cache.set(value, cacheKey, dom);
-        }
-        r.push(dom);
-      }
+  if (newChilds.length === 0) {
+    while (parentDom.firstChild) {
+      parentDom.removeChild(parentDom.firstChild);
     }
-    return r;
+    return;
   }
-  renderText(text) {
-    return text;
+  const orderedSet = reorder(oldChilds, newChilds);
+  const reorderedChilds = orderedSet.children;
+  if (orderedSet.duplicatedKeys && opts.onWarning) {
+    opts.onWarning(new DuplicatedKeysWarning(orderedSet.duplicatedKeys, parentTag, 0));
   }
-  renderMetadata(type, info) {
-    info.$ = type;
-    return this.renderComment(`§${JSON.stringify(info)}§`);
+  const domChildren = Array.from(parentDom.childNodes);
+  const oldLen = oldChilds.length;
+  const reorderedLen = reorderedChilds.length;
+  const len = Math.max(oldLen, reorderedLen);
+  const toRemove = [];
+  for (let i = 0;i < len; i++) {
+    const leftNode = oldChilds[i];
+    const rightNode = reorderedChilds[i];
+    if (!leftNode && rightNode) {
+      const newNode = rightNode.toDom(opts);
+      if (newNode)
+        parentDom.appendChild(newNode);
+    } else if (leftNode && rightNode) {
+      const domChild = domChildren[i];
+      if (domChild) {
+        morphNode(domChild, leftNode, rightNode, opts);
+      }
+    } else if (leftNode && !rightNode) {
+      if (!orderedSet.moves && domChildren[i]) {
+        toRemove.push(domChildren[i]);
+      }
+    }
   }
-  renderComment(text) {
-    return this.comment(text);
+  for (const node of toRemove) {
+    if (node.parentNode === parentDom) {
+      parentDom.removeChild(node);
+    }
   }
-  renderEmpty(_text) {
-    return null;
+  if (orderedSet.moves) {
+    applyMoves(parentDom, orderedSet.moves);
   }
-  renderTag(tagName, attrs, childs) {
-    return this.h(tagName, attrs, childs);
+}
+function applyMoves(domNode, moves) {
+  const childNodes = domNode.childNodes;
+  const keyMap = {};
+  for (const remove2 of moves.removes) {
+    const node = childNodes[remove2.from];
+    if (remove2.key)
+      keyMap[remove2.key] = node;
+    domNode.removeChild(node);
   }
-  renderFragment(childs) {
-    return this.fragment(childs);
+  let length = childNodes.length;
+  for (let j = 0;j < moves.inserts.length; j++) {
+    const insert = moves.inserts[j];
+    const node = keyMap[insert.key];
+    if (node) {
+      domNode.insertBefore(node, insert.to >= length++ ? null : childNodes[insert.to]);
+    }
   }
 }
-function* imIndexedEntries(seq) {
-  let i = 0;
-  for (const v of seq)
-    yield [i++, v];
-}
-function* imKeyedEntries(obj) {
-  for (const [key, value] of obj.toSeq().entries())
-    yield [key, value];
+var renderCache = new WeakMap;
+function render(vnode, container, options) {
+  const cached = renderCache.get(container);
+  const isFragment = vnode instanceof VFragment;
+  if (cached) {
+    const wasFragment = cached.vnode instanceof VFragment;
+    if (wasFragment === isFragment) {
+      const rootNode = wasFragment ? container : cached.dom;
+      const newDom = morphNode(rootNode, cached.vnode, vnode, options);
+      renderCache.set(container, {
+        vnode,
+        dom: isFragment ? container : newDom
+      });
+      return newDom;
+    }
+    renderCache.delete(container);
+  }
+  const domNode = vnode.toDom(options);
+  if (domNode) {
+    container.innerHTML = "";
+    container.appendChild(domNode);
+    renderCache.set(container, {
+      vnode,
+      dom: isFragment ? container : domNode
+    });
+  }
+  return domNode;
 }
-var seqInfoByClass = new Map;
-var idxInfo = ["si", imIndexedEntries];
-var keyInfo = ["sk", imKeyedEntries];
-var unkInfo = ["si", function* nullEntries(_obj) {}];
-function basicGetSeqInfo(seq) {
-  return isIndexed(seq) ? idxInfo : isKeyed(seq) ? keyInfo : seqInfoByClass.get(seq?.constructor) ?? unkInfo;
+function h(tagName, properties, children) {
+  const tag = tagName.toUpperCase();
+  const props = {};
+  let key;
+  let namespace;
+  if (properties) {
+    for (const propName in properties) {
+      if (propName === "key") {
+        key = properties[propName];
+      } else if (propName === "namespace") {
+        namespace = properties[propName];
+      } else if (propName === "class") {
+        props.className = properties[propName];
+      } else if (propName === "for") {
+        props.htmlFor = properties[propName];
+      } else if (isHtmlAttribute(propName)) {
+        props[propName] = String(properties[propName]);
+      } else {
+        props[propName] = properties[propName];
+      }
+    }
+  }
+  const normalizedChildren = [];
+  addChild(normalizedChildren, children);
+  return new VNode2(tag, props, normalizedChildren, key, namespace);
 }
 // src/oo.js
 var BAD_VALUE = Symbol("BadValue");
@@ -7899,6 +7885,7 @@ export {
   isKeyed,
   isIndexed,
   isMap as isIMap,
+  injectCss,
   html,
   fieldsByClass,
   css,