valyrian.js 7.2.10 → 7.2.12

package/dist/index.js

@@ -21,7 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var lib_exports = {};
 __export(lib_exports, {
   Vnode: () => Vnode,
-  createDomElement: () => createDomElement,
+  createElement: () => createElement,
   current: () => current,
   directive: () => directive,
   directives: () => directives,
@@ -46,166 +46,118 @@ __export(lib_exports, {
   v: () => v
 });
 module.exports = __toCommonJS(lib_exports);
-var textTag = "#text";
 var isNodeJs = Boolean(typeof process !== "undefined" && process.versions && process.versions.node);
-function createDomElement(tag, isSVG = false) {
-  return isSVG ? document.createElementNS("http://www.w3.org/2000/svg", tag) : document.createElement(tag);
-}
-var Vnode = function Vnode2(tag, props, children) {
-  this.tag = tag;
-  this.props = props;
-  this.children = children;
-};
-function isComponent(component) {
-  return Boolean(
-    component && (typeof component === "function" || typeof component === "object" && "view" in component)
-  );
-}
-var isVnode = (object) => {
-  return object instanceof Vnode;
+var Vnode = class {
+  constructor(tag, props, children, dom, isSVG) {
+    this.tag = tag;
+    this.props = props;
+    this.children = children;
+    this.dom = dom;
+    this.isSVG = isSVG;
+  }
 };
+var isComponent = (component) => Boolean(typeof component === "function" || component && typeof component === "object" && "view" in component);
+var isVnode = (object) => object instanceof Vnode;
 var isVnodeComponent = (object) => {
   return isVnode(object) && isComponent(object.tag);
 };
+function v(tagOrComponent, props, ...children) {
+  return new Vnode(tagOrComponent, props, children);
+}
+v.fragment = (_, ...children) => children;
 function domToVnode(dom) {
   if (dom.nodeType === 3) {
-    let vnode2 = new Vnode(textTag, {}, [dom.nodeValue]);
-    vnode2.dom = dom;
-    return vnode2;
+    return dom.nodeValue;
   }
-  let children = [];
-  for (let i = 0, l = dom.childNodes.length; i < l; i++) {
-    let childDom = dom.childNodes[i];
-    if (childDom.nodeType === 1 || childDom.nodeType === 3) {
-      children.push(domToVnode(childDom));
+  if (dom.nodeType === 1) {
+    const tag = dom.nodeName.toLowerCase();
+    const props = {};
+    const children = [];
+    for (let i = 0, l = dom.childNodes.length; i < l; i++) {
+      const childDom = dom.childNodes[i];
+      if (childDom.nodeType === 3) {
+        children.push(childDom.nodeValue);
+      } else if (childDom.nodeType === 1) {
+        const childVnode = domToVnode(childDom);
+        children.push(childVnode);
+      }
     }
+    const attributes = dom.attributes;
+    for (let i = 0, l = attributes.length; i < l; i++) {
+      const attr = attributes[i];
+      props[attr.nodeName] = attr.nodeValue;
+    }
+    return new Vnode(tag, props, children, dom, tag === "svg");
   }
-  let props = {};
-  for (let i = 0, l = dom.attributes.length; i < l; i++) {
-    let attr = dom.attributes[i];
-    props[attr.nodeName] = attr.nodeValue;
-  }
-  let vnode = new Vnode(dom.tagName.toLowerCase(), props, children);
-  vnode.dom = dom;
-  return vnode;
 }
 function trust(htmlString) {
-  let div = createDomElement("div");
+  const div = document.createElement("div");
   div.innerHTML = htmlString.trim();
-  return [].map.call(div.childNodes, (item) => domToVnode(item));
+  return Array.from(div.childNodes).map(domToVnode);
 }
 var mainComponent = null;
 var mainVnode = null;
 var isMounted = false;
 var current = {
   vnode: null,
-  oldVnode: null,
   component: null,
   event: null
 };
-var reservedProps = {
-  key: true,
-  state: true,
-  "v-keep": true,
-  // Built in directives
-  "v-if": true,
-  "v-unless": true,
-  "v-for": true,
-  "v-show": true,
-  "v-class": true,
-  "v-html": true,
-  "v-model": true,
-  "v-create": true,
-  "v-update": true,
-  "v-cleanup": true
-};
+var reservedProps = /* @__PURE__ */ new Set([
+  "key",
+  "state",
+  "v-keep",
+  "v-text",
+  "v-if",
+  "v-for",
+  "v-show",
+  "v-class",
+  "v-html",
+  "v-model",
+  "v-create",
+  "v-update",
+  "v-cleanup"
+]);
 var onCleanupSet = /* @__PURE__ */ new Set();
 var onMountSet = /* @__PURE__ */ new Set();
 var onUpdateSet = /* @__PURE__ */ new Set();
 var onUnmountSet = /* @__PURE__ */ new Set();
-function onMount(callback) {
-  if (!isMounted) {
-    onMountSet.add(callback);
-  }
-}
-function onUpdate(callback) {
-  onUpdateSet.add(callback);
-}
-function onCleanup(callback) {
-  onCleanupSet.add(callback);
-}
-function onUnmount(callback) {
-  if (!isMounted) {
-    onUnmountSet.add(callback);
-  }
-}
-function callSet(set) {
-  for (let callback of set) {
+var onMount = (callback) => !isMounted && onMountSet.add(callback);
+var onUpdate = (callback) => onUpdateSet.add(callback);
+var onCleanup = (callback) => onCleanupSet.add(callback);
+var onUnmount = (callback) => !isMounted && onUnmountSet.add(callback);
+var callSet = (set) => {
+  for (const callback of set) {
     callback();
   }
   set.clear();
-}
-var eventListenerNames = {};
-function eventListener(e) {
-  current.event = e;
-  let dom = e.target;
-  let name = `v-on${e.type}`;
-  while (dom) {
-    if (dom[name]) {
-      dom[name](e, dom);
-      if (!e.defaultPrevented) {
-        update();
+};
+var handleVIf = (shouldRender) => {
+  return (value, vnode) => {
+    const bool = shouldRender !== Boolean(value);
+    if (bool) {
+      const parentNode = vnode.dom?.parentNode;
+      if (parentNode) {
+        const newdom = document.createTextNode("");
+        parentNode.replaceChild(newdom, vnode.dom);
       }
-      return;
+      return false;
     }
-    dom = dom.parentNode;
-  }
-  current.event = null;
-}
-var hideDirective = (test) => (bool, vnode, oldnode) => {
-  let value = test ? bool : !bool;
-  if (value) {
-    let newdom = document.createTextNode("");
-    if (oldnode && oldnode.dom && oldnode.dom.parentNode) {
-      oldnode.dom.parentNode.replaceChild(newdom, oldnode.dom);
-    }
-    vnode.tag = "#text";
-    vnode.children = [];
-    vnode.props = {};
-    vnode.dom = newdom;
-    return false;
-  }
+  };
 };
 var directives = {
-  // The "v-if" directive hides an element if the given condition is false
-  "v-if": hideDirective(false),
-  // The "v-unless" directive hides an element if the given condition is true
-  "v-unless": hideDirective(true),
-  // The "v-for" directive creates a loop and applies a callback function to each item in the loop
-  "v-for": (set, vnode) => {
-    let newChildren = [];
-    let callback = vnode.children[0];
-    for (let i = 0, l = set.length; i < l; i++) {
-      newChildren.push(callback(set[i], i));
-    }
-    vnode.children = newChildren;
-  },
-  // The "v-show" directive shows or hides an element by setting the "display" style property
-  "v-show": (bool, vnode) => {
+  "v-if": handleVIf(true),
+  "v-unless": handleVIf(false),
+  "v-show": (value, vnode) => {
+    const bool = Boolean(value);
     vnode.dom.style.display = bool ? "" : "none";
   },
-  // The "v-class" directive adds or removes class names from an element based on a condition
-  "v-class": (classes, vnode) => {
-    for (let name in classes) {
-      vnode.dom.classList.toggle(name, classes[name]);
-    }
-  },
-  // The "v-html" directive sets the inner HTML of an element to the given HTML string
-  "v-html": (html, vnode) => {
-    vnode.children = [trust(html)];
+  "v-html": (value, vnode) => {
+    vnode.children = [trust(value)];
   },
   // The "v-model" directive binds the value of an input element to a model property
-  "v-model": ([model, property, event], vnode, oldVnode) => {
+  "v-model": (val, vnode) => {
+    let [model, property, event] = val;
     let value;
     let handler = (e) => model[property] = e.target.value;
     if (vnode.tag === "input") {
@@ -214,10 +166,10 @@ var directives = {
         case "checkbox": {
           if (Array.isArray(model[property])) {
             handler = (e) => {
-              let val = e.target.value;
-              let idx = model[property].indexOf(val);
+              const val2 = e.target.value;
+              const idx = model[property].indexOf(val2);
               if (idx === -1) {
-                model[property].push(val);
+                model[property].push(val2);
               } else {
                 model[property].splice(idx, 1);
               }
@@ -251,29 +203,29 @@ var directives = {
       event = event || "onclick";
       if (vnode.props.multiple) {
         handler = (e) => {
-          let val = e.target.value;
+          const val2 = e.target.value;
           if (e.ctrlKey) {
-            let idx = model[property].indexOf(val);
+            const idx = model[property].indexOf(val2);
             if (idx === -1) {
-              model[property].push(val);
+              model[property].push(val2);
             } else {
               model[property].splice(idx, 1);
             }
           } else {
             model[property].splice(0, model[property].length);
-            model[property].push(val);
+            model[property].push(val2);
           }
         };
         vnode.children.forEach((child) => {
           if (child.tag === "option") {
-            let value2 = "value" in child.props ? child.props.value : child.children.join("").trim();
+            const value2 = "value" in child.props ? child.props.value : child.children.join("").trim();
             child.props.selected = model[property].indexOf(value2) !== -1;
           }
         });
       } else {
         vnode.children.forEach((child) => {
           if (child.tag === "option") {
-            let value2 = "value" in child.props ? child.props.value : child.children.join("").trim();
+            const value2 = "value" in child.props ? child.props.value : child.children.join("").trim();
             child.props.selected = value2 === model[property];
           }
         });
@@ -282,7 +234,7 @@ var directives = {
       event = event || "oninput";
       vnode.children = [model[property]];
     }
-    let prevHandler = vnode.props[event];
+    const prevHandler = vnode.props[event];
     sharedSetAttribute(
       event,
       (e) => {
@@ -291,266 +243,368 @@ var directives = {
           prevHandler(e);
         }
       },
-      vnode,
-      oldVnode
+      vnode
     );
   },
-  // The "v-create" directive is called when a new virtual node is created.
-  // The provided callback function is called with the new virtual node as an argument.
-  // This directive is only called once per virtual node, when it is first created.
-  // eslint-disable-next-line no-unused-vars
-  "v-create": (callback, vnode, oldVnode) => {
-    if (!oldVnode) {
-      let cleanup = callback(vnode);
+  "v-create": (callback, vnode, oldProps) => {
+    if (!oldProps) {
+      const cleanup = callback(vnode);
       if (typeof cleanup === "function") {
         onCleanup(cleanup);
       }
     }
   },
-  // The "v-update" directive is called when an existing virtual node is updated.
-  // The provided callback function is called with the new and old virtual nodes as arguments.
-  // This directive is only called once per virtual node update.
-  "v-update": (callback, vnode, oldVnode) => {
-    if (oldVnode) {
-      let cleanup = callback(vnode, oldVnode);
+  "v-update": (callback, vnode, oldProps) => {
+    if (oldProps) {
+      const cleanup = callback(vnode, oldProps);
       if (typeof cleanup === "function") {
         onCleanup(cleanup);
       }
     }
   },
-  // The "v-cleanup" directive is called when the update is cleaned up.
-  // The provided callback function is called with the old virtual node as an argument.
-  // This directive is only called once per virtual node, when the update is cleaned up.
-  "v-cleanup": (callback, vnode, oldVnode) => {
-    onCleanup(() => callback(vnode, oldVnode));
+  "v-cleanup": (callback, vnode) => {
+    onCleanup(() => callback(vnode));
+  },
+  "v-class": (value, vnode) => {
+    if (typeof value === "string") {
+      vnode.dom.className = value;
+    } else if (Array.isArray(value)) {
+      vnode.dom.className = value.join(" ");
+    } else if (typeof value === "object") {
+      const classList = vnode.dom.classList;
+      for (const name in value) {
+        const val = typeof value[name] === "function" ? value[name]() : value[name];
+        classList.toggle(name, val);
+      }
+    }
+  },
+  // Frequent used properties
+  class(value, vnode) {
+    if (vnode.dom.className !== value) {
+      vnode.dom.className = value;
+    }
+  },
+  className(value, vnode) {
+    directives.class(value, vnode, null);
+  },
+  id: (value, vnode) => {
+    vnode.dom.id = value;
+  },
+  style: (value, vnode) => {
+    if (typeof value === "string") {
+      vnode.dom.style = value;
+    } else if (typeof value === "object") {
+      vnode.dom.style = "";
+      const domStyle = vnode.dom.style;
+      for (const name in value) {
+        domStyle[name] = value[name];
+      }
+    }
   }
 };
 function directive(name, directive2) {
-  let directiveName = `v-${name}`;
+  const directiveName = `v-${name}`;
   directives[directiveName] = directive2;
-  reservedProps[directiveName] = true;
+  reservedProps.add(directiveName);
 }
-function sharedSetAttribute(name, value, newVnode, oldVnode) {
+var eventListenerNames = /* @__PURE__ */ new Set();
+function eventListener(e) {
+  current.event = e;
+  let dom = e.target;
+  const name = `on${e.type}`;
+  while (dom) {
+    const oldProps = dom.props;
+    if (oldProps && oldProps[name]) {
+      oldProps[name](e, dom);
+      if (!e.defaultPrevented) {
+        update();
+      }
+      return;
+    }
+    dom = dom.parentNode;
+  }
+  current.event = null;
+}
+function sharedSetAttribute(name, value, newVnode) {
+  const newVnodeDom = newVnode.dom;
   if (typeof value === "function") {
-    if (name in eventListenerNames === false) {
+    if (!eventListenerNames.has(name)) {
       mainVnode.dom.addEventListener(name.slice(2), eventListener);
-      eventListenerNames[name] = true;
+      eventListenerNames.add(name);
     }
-    newVnode.dom[`v-${name}`] = value;
     return;
   }
-  if (name in newVnode.dom && newVnode.isSVG === false) {
-    if (newVnode.dom[name] != value) {
-      newVnode.dom[name] = value;
-    }
+  if (name in newVnodeDom) {
+    newVnodeDom[name] = value;
     return;
   }
-  if (!oldVnode || value !== oldVnode.props[name]) {
-    if (value === false) {
-      newVnode.dom.removeAttribute(name);
-    } else {
-      newVnode.dom.setAttribute(name, value);
-    }
+  if (value === false) {
+    newVnodeDom.removeAttribute(name);
+  } else {
+    newVnodeDom.setAttribute(name, value);
   }
 }
-function setAttribute(name, value, newVnode, oldVnode) {
-  if (name in reservedProps) {
-    return;
+function setAttribute(name, value, newVnode) {
+  if (!reservedProps.has(name)) {
+    newVnode.props[name] = value;
+    sharedSetAttribute(name, value, newVnode);
   }
-  newVnode.props[name] = value;
-  sharedSetAttribute(name, value, newVnode, oldVnode);
 }
-function updateAttributes(newVnode, oldVnode) {
-  if (oldVnode) {
-    for (let name in oldVnode.props) {
-      if (name in newVnode.props === false && name in eventListenerNames === false && name in reservedProps === false) {
-        if (name in newVnode.dom && newVnode.isSVG === false) {
-          newVnode.dom[name] = null;
-        } else {
-          newVnode.dom.removeAttribute(name);
-        }
+function removeAttributes(vnode, oldProps) {
+  if (!oldProps) {
+    return;
+  }
+  const vnodeDom = vnode.dom;
+  const vnodeProps = vnode.props;
+  for (const name in oldProps) {
+    if (name in vnodeProps === false && !eventListenerNames.has(name) && !reservedProps.has(name)) {
+      if (name in vnodeDom) {
+        vnodeDom[name] = null;
+      } else {
+        vnodeDom.removeAttribute(name);
       }
     }
   }
-  for (let name in newVnode.props) {
-    if (name in reservedProps) {
-      if (name in directives && directives[name](newVnode.props[name], newVnode, oldVnode) === false) {
+}
+function addProperties(vnode, oldProps) {
+  const vnodeProps = vnode.props;
+  for (const name in vnodeProps) {
+    if (directives[name]) {
+      if (directives[name](vnodeProps[name], vnode, oldProps) === false) {
         break;
       }
       continue;
     }
-    sharedSetAttribute(name, newVnode.props[name], newVnode, oldVnode);
+    if (reservedProps.has(name)) {
+      continue;
+    }
+    sharedSetAttribute(name, vnodeProps[name], vnode);
   }
 }
-function patch(newVnode, oldVnode) {
-  if (newVnode.children.length === 0) {
-    newVnode.dom.textContent = "";
-    return;
-  }
-  let newTree = newVnode.children;
-  let oldTree = oldVnode?.children || [];
-  let oldTreeLength = oldTree.length;
-  if (oldTreeLength && newTree[0] instanceof Vnode && "key" in newTree[0].props && "key" in oldTree[0].props) {
-    let newTreeLength = newTree.length;
-    let oldKeyedList = {};
-    for (let i = 0; i < oldTreeLength; i++) {
-      oldKeyedList[oldTree[i].props.key] = i;
-    }
-    let newKeyedList = {};
-    for (let i = 0; i < newTreeLength; i++) {
-      newKeyedList[newTree[i].props.key] = i;
-    }
-    for (let i = 0; i < newTreeLength; i++) {
-      let newChild = newTree[i];
-      let oldChild = oldTree[oldKeyedList[newChild.props.key]];
-      let shouldPatch = true;
-      if (oldChild) {
-        newChild.dom = oldChild.dom;
-        if ("v-keep" in newChild.props && newChild.props["v-keep"] === oldChild.props["v-keep"]) {
-          newChild.children = oldChild.children;
-          shouldPatch = false;
-        } else {
-          updateAttributes(newChild, oldChild);
-        }
-      } else {
-        newChild.dom = createDomElement(newChild.tag, newChild.isSVG);
-        updateAttributes(newChild);
+function updateAttributes(newVnode, oldProps) {
+  removeAttributes(newVnode, oldProps);
+  addProperties(newVnode, oldProps);
+}
+function createElement(tag, isSVG) {
+  return isSVG ? document.createElementNS("http://www.w3.org/2000/svg", tag) : document.createElement(tag);
+}
+function flatTree(newVnode, children) {
+  current.vnode = newVnode;
+  let i = 0;
+  while (i < children.length) {
+    const newChild = children[i];
+    if (newChild == null) {
+      children.splice(i, 1);
+      continue;
+    }
+    if (Array.isArray(newChild)) {
+      children.splice(i, 1, ...newChild);
+      continue;
+    }
+    if (newChild instanceof Vnode) {
+      if (newChild.props === null) {
+        newChild.props = {};
       }
-      if (!newVnode.dom.childNodes[i]) {
-        newVnode.dom.appendChild(newChild.dom);
-      } else if (newVnode.dom.childNodes[i] !== newChild.dom) {
-        newVnode.dom.replaceChild(newChild.dom, newVnode.dom.childNodes[i]);
+      if (typeof newChild.tag !== "string") {
+        const component = newChild.tag;
+        current.component = newChild.tag;
+        children[i] = ("view" in component ? component.view : component).bind(component)(
+          newChild.props,
+          newChild.children
+        );
+        continue;
+      } else {
+        newChild.isSVG = newVnode.isSVG || newChild.tag === "svg";
       }
-      shouldPatch && patch(newChild, oldChild);
     }
-    for (let i = newTreeLength; i < oldTreeLength; i++) {
-      if (!newKeyedList[oldTree[i].props.key]) {
-        oldTree[i].dom.parentNode && oldTree[i].dom.parentNode.removeChild(oldTree[i].dom);
-      }
+    i++;
+  }
+  return children;
+}
+function handleVFor(newVnode) {
+  if ("v-for" in newVnode.props) {
+    const set = newVnode.props["v-for"];
+    const children = [];
+    const callback = newVnode.children[0];
+    children.length = set.length;
+    for (let i = 0, l = set.length; i < l; i++) {
+      children[i] = callback(set[i], i);
     }
+    return children;
+  }
+  return [...newVnode.children];
+}
+function createNewElement(newChild, newVnode, oldChild) {
+  const dom = createElement(newChild.tag, newChild.isSVG);
+  if (oldChild) {
+    newVnode.dom.replaceChild(dom, oldChild);
+  } else {
+    newVnode.dom.appendChild(dom);
+  }
+  newChild.dom = dom;
+  addProperties(newChild, null);
+  newChild.dom.props = newChild.props;
+  if ("v-text" in newChild.props) {
+    newChild.dom.textContent = newChild.props["v-text"];
     return;
   }
-  if (newTree.length === 0) {
-    newVnode.dom.textContent = "";
+  const children = flatTree(newChild, handleVFor(newChild));
+  if (children.length === 0) {
+    newChild.dom.textContent = "";
     return;
   }
-  current.vnode = newVnode;
-  current.oldVnode = oldVnode;
-  for (let i = 0; i < newTree.length; i++) {
-    let newChild = newTree[i];
-    if (newChild instanceof Vnode) {
-      if (typeof newChild.tag !== "string") {
-        current.component = newChild.tag;
-        newTree.splice(
-          i--,
-          1,
-          ("view" in newChild.tag ? newChild.tag.view.bind(newChild.tag) : newChild.tag.bind(newChild.tag))(
-            newChild.props,
-            ...newChild.children
-          )
-        );
-      }
+  for (let i = 0, l = children.length; i < l; i++) {
+    if (children[i] instanceof Vnode === false) {
+      newChild.dom.appendChild(document.createTextNode(children[i]));
       continue;
     }
-    if (Array.isArray(newChild)) {
-      newTree.splice(i--, 1, ...newChild);
-      continue;
+    createNewElement(children[i], newChild, null);
+  }
+}
+function patchKeyed(newVnode, children) {
+  const oldTree = [...Array.from(newVnode.dom.childNodes)];
+  const childNodes = newVnode.dom.childNodes;
+  const oldKeyedList = {};
+  const newKeyedList = {};
+  for (let i = 0, l = oldTree.length; i < l; i++) {
+    const oldProps = oldTree[i].props;
+    if (oldProps) {
+      oldKeyedList[oldProps.key] = i;
     }
-    if (newChild === null || newChild === void 0) {
-      newTree.splice(i--, 1);
+    if (i < children.length && children[i] instanceof Vnode) {
+      newKeyedList[children[i].props.key] = i;
+    }
+  }
+  for (let i = 0, l = children.length; i < l; i++) {
+    const newChild = children[i];
+    const oldChild = oldTree[oldKeyedList[newChild.props.key]];
+    if (!oldChild) {
+      createNewElement(newChild, newVnode, childNodes[i]);
       continue;
     }
-    newTree[i] = new Vnode(textTag, {}, [newChild]);
+    newChild.dom = oldChild;
+    const currentChild = childNodes[i];
+    if (!currentChild) {
+      newVnode.dom.appendChild(oldChild);
+    } else if (currentChild !== oldChild) {
+      newVnode.dom.replaceChild(oldChild, currentChild);
+    }
+    if ("v-keep" in newChild.props === false || oldChild.props["v-keep"] !== newChild.props["v-keep"]) {
+      updateAttributes(newChild, oldChild.props);
+      oldChild.props = newChild.props;
+      if ("v-text" in newChild.props) {
+        if (oldChild.textContent != newChild.props["v-text"]) {
+          oldChild.textContent = newChild.props["v-text"];
+        }
+        continue;
+      }
+      patch(newChild);
+    }
+  }
+  for (let i = children.length, l = childNodes.length; i < l; i++) {
+    childNodes[i]?.remove();
+  }
+}
+function patch(newVnode) {
+  const children = flatTree(newVnode, handleVFor(newVnode));
+  const dom = newVnode.dom;
+  if (children.length === 0) {
+    if (dom.childNodes.length) {
+      dom.textContent = "";
+    }
+    return;
+  }
+  const oldDomChildren = dom.childNodes;
+  const oldChildrenLength = oldDomChildren.length;
+  if (oldChildrenLength > 0) {
+    const firstOldProps = oldDomChildren[0].props;
+    const firstVnode = children[0];
+    if (firstOldProps && firstVnode instanceof Vnode && "key" in firstVnode.props && "key" in firstOldProps) {
+      patchKeyed(newVnode, children);
+      return;
+    }
   }
-  for (let i = 0; i < newTree.length; i++) {
-    let newChild = newTree[i];
-    if (newChild.tag === textTag) {
-      if (i >= oldTreeLength) {
-        newChild.dom = document.createTextNode(newChild.children[0]);
-        newVnode.dom.appendChild(newChild.dom);
+  const childrenLength = children.length;
+  if (oldChildrenLength === 0) {
+    for (let i = 0; i < childrenLength; i++) {
+      if (children[i] instanceof Vnode === false) {
+        dom.appendChild(document.createTextNode(children[i]));
         continue;
       }
-      let oldChild2 = oldTree[i];
-      if (oldChild2.tag !== textTag) {
-        newChild.dom = document.createTextNode(newChild.children[0]);
-        newVnode.dom.replaceChild(newChild.dom, oldChild2.dom);
+      createNewElement(children[i], newVnode, null);
+    }
+    return;
+  }
+  for (let i = 0; i < childrenLength; i++) {
+    const oldChild = oldDomChildren[i];
+    const newChild = children[i];
+    if (!oldChild) {
+      createNewElement(newChild, newVnode, null);
+      continue;
+    }
+    if (newChild instanceof Vnode === false) {
+      if (oldChild.nodeType !== 3) {
+        newVnode.dom.replaceChild(document.createTextNode(newChild), oldChild);
         continue;
       }
-      newChild.dom = oldChild2.dom;
-      if (newChild.children[0] != oldChild2.dom.textContent) {
-        oldChild2.dom.textContent = newChild.children[0];
+      if (oldChild.nodeValue != newChild) {
+        oldChild.nodeValue = newChild;
       }
       continue;
     }
-    newChild.isSVG = newVnode.isSVG || newChild.tag === "svg";
-    if (i >= oldTreeLength) {
-      newChild.dom = createDomElement(newChild.tag, newChild.isSVG);
-      updateAttributes(newChild);
-      newVnode.dom.appendChild(newChild.dom);
-      patch(newChild);
-      continue;
+    if ("v-keep" in newChild.props) {
+      if (oldChild.props && oldChild.props["v-keep"] === newChild.props["v-keep"]) {
+        continue;
+      }
+      const nextOldChild = oldDomChildren[i + 1];
+      if (nextOldChild && nextOldChild.props && nextOldChild.props["v-keep"] === newChild.props["v-keep"]) {
+        oldChild.remove();
+        continue;
+      }
     }
-    let oldChild = oldTree[i];
-    if (newChild.tag !== oldChild.tag) {
-      newChild.dom = createDomElement(newChild.tag, newChild.isSVG);
-      updateAttributes(newChild);
-      newVnode.dom.replaceChild(newChild.dom, oldChild.dom);
-      patch(newChild);
+    if (newChild.tag !== oldChild.nodeName.toLowerCase()) {
+      createNewElement(newChild, newVnode, oldChild);
       continue;
     }
-    newChild.dom = oldChild.dom;
-    if ("v-keep" in newChild.props && newChild.props["v-keep"] === oldChild.props["v-keep"]) {
-      newChild.children = oldChild.children;
+    newChild.dom = oldChild;
+    updateAttributes(newChild, oldChild.props || null);
+    oldChild.props = newChild.props;
+    if ("v-text" in newChild.props) {
+      if (newChild.dom.textContent != newChild.props["v-text"]) {
+        newChild.dom.textContent = newChild.props["v-text"];
+      }
       continue;
     }
-    updateAttributes(newChild, oldChild);
-    patch(newChild, oldChild);
+    patch(newChild);
   }
-  for (let i = newTree.length; i < oldTreeLength; i++) {
-    newVnode.dom.removeChild(oldTree[i].dom);
-  }
-}
-function update() {
-  if (mainVnode) {
-    callSet(onCleanupSet);
-    let oldMainVnode = mainVnode;
-    mainVnode = new Vnode(oldMainVnode.tag, oldMainVnode.props, [mainComponent]);
-    mainVnode.dom = oldMainVnode.dom;
-    mainVnode.isSVG = oldMainVnode.isSVG;
-    patch(mainVnode, oldMainVnode);
-    callSet(isMounted ? onUpdateSet : onMountSet);
-    isMounted = true;
-    current.vnode = null;
-    current.oldVnode = null;
-    current.component = null;
-    if (isNodeJs) {
-      return mainVnode.dom.innerHTML;
-    }
+  for (let i = childrenLength, l = oldDomChildren.length; i < l; i++) {
+    oldDomChildren[i]?.remove();
   }
 }
-function updateVnode(vnode, oldVnode) {
+function updateVnode(vnode) {
   callSet(onCleanupSet);
-  patch(vnode, oldVnode);
-  oldVnode.tag = vnode.tag;
-  oldVnode.props = { ...vnode.props };
-  oldVnode.children = [...vnode.children];
-  oldVnode.dom = vnode.dom;
-  oldVnode.isSVG = vnode.isSVG;
+  vnode.props = vnode.props || {};
+  patch(vnode);
   callSet(isMounted ? onUpdateSet : onMountSet);
   isMounted = true;
   current.vnode = null;
-  current.oldVnode = null;
   current.component = null;
   if (isNodeJs) {
     return vnode.dom.innerHTML;
   }
 }
+function update() {
+  if (mainVnode) {
+    mainVnode.children = [mainComponent];
+    return updateVnode(mainVnode);
+  }
+}
 function unmount() {
   if (mainVnode) {
-    mainComponent = new Vnode(() => null, {}, []);
-    let result = update();
+    mainComponent = v(() => null, {});
+    const result = update();
     callSet(onUnmountSet);
-    for (let name in eventListenerNames) {
+    for (const name in eventListenerNames) {
       mainVnode.dom.removeEventListener(name.slice(2).toLowerCase(), eventListener);
       Reflect.deleteProperty(eventListenerNames, name);
     }
@@ -558,22 +612,20 @@ function unmount() {
     mainVnode = null;
     isMounted = false;
     current.vnode = null;
-    current.oldVnode = null;
     current.component = null;
+    current.event = null;
     return result;
   }
 }
 function mount(dom, component) {
-  let container = typeof dom === "string" ? isNodeJs ? createDomElement(dom, dom === "svg") : document.querySelectorAll(dom)[0] : dom;
-  let vnodeComponent = isVnodeComponent(component) ? component : isComponent(component) ? new Vnode(component, {}, []) : new Vnode(() => component, {}, []);
-  if (mainComponent && mainComponent.tag !== vnodeComponent.tag) {
-    unmount();
+  const container = typeof dom === "string" ? isNodeJs ? createElement(dom, dom === "svg") : document.querySelector(dom) : dom;
+  if (isComponent(component)) {
+    mainComponent = new Vnode(component, {}, []);
+  } else if (isVnodeComponent(component)) {
+    mainComponent = component;
+  } else {
+    mainComponent = new Vnode(() => component, {}, []);
   }
-  mainComponent = vnodeComponent;
   mainVnode = domToVnode(container);
   return update();
 }
-var v = (tagOrComponent, props = {}, ...children) => {
-  return new Vnode(tagOrComponent, props || {}, children);
-};
-v.fragment = (_, ...children) => children;