ks-fwork 4.1.0 → 4.1.1

package/dist/ks-fwork.js

@@ -1,794 +1,575 @@
-function addEventListeners(listeners = {}, el, hostComponent = null) {
-    const addedListeners = {};
-    Object.entries(listeners).forEach(([eventName, handler]) => {
-        addedListeners[eventName] = addEventListener(eventName, handler, el, hostComponent);
-    });
-    return addedListeners;
-}
-function addEventListener(eventName, handler, el, hostComponent = null) {
-    function boundHandler() {
-        hostComponent ? handler.apply(hostComponent, arguments) : handler(...arguments);
-    }
-    el.addEventListener(eventName, boundHandler);
-    return boundHandler;
-}
-function removeEventListeners(listeners = {}, el) {
-    Object.entries(listeners).forEach(([eventName, handler]) => {
-        el.removeEventListener(eventName, handler);
-    });
-}
-
-function withoutNulls(arr) {
-    return arr.filter((item) => item != null);
-}
-function arraysDiff(oldArray, newArray) {
-    return {
-        added: newArray.filter(
-            (newItem) => !oldArray.includes(newItem)
-        ),
-        removed: oldArray.filter(
-            (oldItem) => !newArray.includes(oldItem)
-        ),
-    }
-}
-const ARRAY_DIFF_OP = {
-    ADD: 'add',
-    REMOVE: 'remove',
-    MOVE: 'move',
-    NOOP: 'noop'
+//#region \0rolldown/runtime.js
+var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescriptor, r = Object.getOwnPropertyNames, i = Object.getPrototypeOf, a = Object.prototype.hasOwnProperty, o = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), s = (e, i, o, s) => {
+	if (i && typeof i == "object" || typeof i == "function") for (var c = r(i), l = 0, u = c.length, d; l < u; l++) d = c[l], !a.call(e, d) && d !== o && t(e, d, {
+		get: ((e) => i[e]).bind(null, d),
+		enumerable: !(s = n(i, d)) || s.enumerable
+	});
+	return e;
+}, c = (n, r, a) => (a = n == null ? {} : e(i(n)), s(r || !n || !n.__esModule ? t(a, "default", {
+	value: n,
+	enumerable: !0
+}) : a, n));
+//#endregion
+//#region src/events.js
+function l(e = {}, t, n = null) {
+	let r = {};
+	return Object.entries(e).forEach(([e, i]) => {
+		r[e] = u(e, i, t, n);
+	}), r;
+}
+function u(e, t, n, r = null) {
+	function i() {
+		r ? t.apply(r, arguments) : t(...arguments);
+	}
+	return n.addEventListener(e, i), i;
+}
+function d(e = {}, t) {
+	Object.entries(e).forEach(([e, n]) => {
+		t.removeEventListener(e, n);
+	});
+}
+//#endregion
+//#region src/utils/arrays.js
+function f(e) {
+	return e.filter((e) => e != null);
+}
+function p(e, t) {
+	return {
+		added: t.filter((t) => !e.includes(t)),
+		removed: e.filter((e) => !t.includes(e))
+	};
+}
+var m = {
+	ADD: "add",
+	REMOVE: "remove",
+	MOVE: "move",
+	NOOP: "noop"
+}, h = class {
+	#e = [];
+	#t = [];
+	#n;
+	constructor(e, t) {
+		this.#e = [...e], this.#t = e.map((e, t) => t), this.#n = t;
+	}
+	get length() {
+		return this.#e.length;
+	}
+	originalIndexAt(e) {
+		return this.#t[e];
+	}
+	isAddition(e, t) {
+		return this.findIndexFrom(e, t) === -1;
+	}
+	addItem(e, t) {
+		let n = {
+			op: m.ADD,
+			index: t,
+			item: e
+		};
+		return this.#e.splice(t, 0, e), this.#t.splice(t, 0, -1), n;
+	}
+	isRemoval(e, t) {
+		if (e >= this.length) return !1;
+		let n = this.#e[e];
+		return t.findIndex((e) => this.#n(n, e)) === -1;
+	}
+	removeItem(e) {
+		let t = {
+			op: m.REMOVE,
+			index: e,
+			item: this.#e[e]
+		};
+		return this.#e.splice(e, 1), this.#t.splice(e, 1), t;
+	}
+	moveItem(e, t) {
+		let n = this.findIndexFrom(e, t), r = {
+			op: m.MOVE,
+			originalIndex: this.originalIndexAt(n),
+			from: n,
+			index: t,
+			item: this.#e[n]
+		}, [i] = this.#e.splice(n, 1);
+		this.#e.splice(t, 0, i);
+		let [a] = this.#t.splice(n, 1);
+		return this.#t.splice(t, 0, a), r;
+	}
+	isNoop(e, t) {
+		if (e >= this.length) return !1;
+		let n = this.#e[e], r = t[e];
+		return this.#n(n, r);
+	}
+	noopItem(e) {
+		return {
+			op: m.NOOP,
+			originalIndex: this.originalIndexAt(e),
+			index: e,
+			item: this.#e[e]
+		};
+	}
+	removeItemsAfter(e) {
+		let t = [];
+		for (; this.length > e;) t.push(this.removeItem(e));
+		return t;
+	}
+	findIndexFrom(e, t) {
+		for (let n = t; n < this.length; n++) if (this.#n(e, this.#e[n])) return n;
+		return -1;
+	}
 };
-class ArrayWithOriginalIndices {
-    #oldArray = [];
-    #originalIndices = [];
-    #equalsFn;
-    constructor(array, equalsFn) {
-        this.#oldArray = [...array];
-        this.#originalIndices = array.map((value, index) => index);
-        this.#equalsFn = equalsFn;
-    }
-    get length() {
-        return this.#oldArray.length;
-    }
-    originalIndexAt(index) {
-        return this.#originalIndices[index];
-    }
-    isAddition(item, startIndex) {
-        return this.findIndexFrom(item, startIndex) === -1;
-    }
-    addItem(item, index) {
-        const operation = {
-            op: ARRAY_DIFF_OP.ADD,
-            index,
-            item
-        };
-        this.#oldArray.splice(index, 0, item);
-        this.#originalIndices.splice(index, 0, -1);
-        return operation;
-    }
-    isRemoval(index, newArray) {
-        if (index >= this.length) { return false; }
-        const item = this.#oldArray[index];
-        const indexInNewArray = newArray.findIndex((newArrayItem) => this.#equalsFn(item, newArrayItem));
-        return indexInNewArray === -1;
-    }
-    removeItem(index) {
-        const operation = {
-            op: ARRAY_DIFF_OP.REMOVE,
-            index,
-            item: this.#oldArray[index],
-        };
-        this.#oldArray.splice(index, 1);
-        this.#originalIndices.splice(index, 1);
-        return operation;
-    }
-    moveItem(item, toIndex) {
-        const fromIndex = this.findIndexFrom(item, toIndex);
-        const operation = {
-            op: ARRAY_DIFF_OP.MOVE,
-            originalIndex: this.originalIndexAt(fromIndex),
-            from: fromIndex,
-            index: toIndex,
-            item: this.#oldArray[fromIndex],
-        };
-        const [itemToMove] = this.#oldArray.splice(fromIndex, 1);
-        this.#oldArray.splice(toIndex, 0, itemToMove);
-        const [originalIndex] = this.#originalIndices.splice(fromIndex, 1);
-        this.#originalIndices.splice(toIndex, 0, originalIndex);
-        return operation;
-    }
-    isNoop(index, newArray) {
-        if (index >= this.length) {return false; }
-        const item = this.#oldArray[index];
-        const newArrayItem = newArray[index];
-        return this.#equalsFn(item, newArrayItem);
-    }
-    noopItem(index) {
-        return {
-            op: ARRAY_DIFF_OP.NOOP,
-            originalIndex: this.originalIndexAt(index),
-            index,
-            item: this.#oldArray[index],
-        }
-    }
-    removeItemsAfter(index) {
-        const operations = [];
-        while (this.length > index) {
-            operations.push(this.removeItem(index));
-        }
-        return operations;
-    }
-    findIndexFrom(item, startIndex) {
-        for (let i = startIndex; i < this.length; i++) {
-            if (this.#equalsFn(item, this.#oldArray[i])) {
-                return i;
-            }
-        }
-        return -1;
-    }
-}
-function arraysDiffSequence(oldArray, newArray, equalsFn = (a, b) => a === b) {
-    const sequence = [];
-    const array = new ArrayWithOriginalIndices(oldArray, equalsFn);
-    for (let index = 0; index < newArray.length; index++) {
-        if (array.isRemoval(index, newArray)) {
-            sequence.push(array.removeItem(index));
-            index--;
-            continue;
-        }
-        if (array.isNoop(index, newArray)) {
-            sequence.push(array.noopItem(index));
-            continue;
-        }
-        const item = newArray[index];
-        if (array.isAddition(item, index)) {
-            sequence.push(array.addItem(item, index));
-            continue;
-        }
-        sequence.push(array.moveItem(item, index));
-    }
-    sequence.push(...array.removeItemsAfter(newArray.length));
-    return sequence;
-}
-
-const DOM_TYPES = {
-    TEXT: 'text',
-    ELEMENT: 'element',
-    FRAGMENT: 'fragment',
-    COMPONENT: 'component'
+function ee(e, t, n = (e, t) => e === t) {
+	let r = [], i = new h(e, n);
+	for (let e = 0; e < t.length; e++) {
+		if (i.isRemoval(e, t)) {
+			r.push(i.removeItem(e)), e--;
+			continue;
+		}
+		if (i.isNoop(e, t)) {
+			r.push(i.noopItem(e));
+			continue;
+		}
+		let n = t[e];
+		if (i.isAddition(n, e)) {
+			r.push(i.addItem(n, e));
+			continue;
+		}
+		r.push(i.moveItem(n, e));
+	}
+	return r.push(...i.removeItemsAfter(t.length)), r;
+}
+//#endregion
+//#region src/h.js
+var g = {
+	TEXT: "text",
+	ELEMENT: "element",
+	FRAGMENT: "fragment",
+	COMPONENT: "component"
 };
-function h(tag, props = {}, children = []) {
-    const type = typeof tag === 'string' ? DOM_TYPES.ELEMENT : DOM_TYPES.COMPONENT;
-    return {
-        tag,
-        props,
-        type,
-        children: mapTextNodes(withoutNulls(children)),
-    }
-}
-function hString(str) {
-    return {
-        type: DOM_TYPES.TEXT,
-        value: str
-    };
-}
-function hFragment(vNodes) {
-    return {
-        children: mapTextNodes(withoutNulls(vNodes)),
-        type: DOM_TYPES.FRAGMENT,
-    }
-}
-function mapTextNodes(children) {
-    return children.map((child) =>
-        typeof child === 'string' ? hString(child) : child
-    )
-}
-function extractChildren(vNode) {
-    if (vNode.children == null) return [];
-    const children = [];
-    for (const child of vNode.children) {
-        if (child.type === DOM_TYPES.FRAGMENT) {
-            children.push(...extractChildren(child));
-        } else {
-            children.push(child);
-        }
-    }
-    return children;
-}
-
-let isScheduled = false;
-const jobs = [];
-function enqueueJob(job) {
-    jobs.push(job);
-    scheduleUpdate();
-}
-function scheduleUpdate() {
-    if (isScheduled) return;
-    isScheduled = true;
-    queueMicrotask(processJobs);
-}
-function processJobs() {
-    while (jobs.length > 0) {
-        const job = jobs.shift();
-        try {
-            Promise.resolve(job()).catch((error) => {
-                console.error(`[scheduler]: ${error}`);
-            });
-        } catch (error) {
-            console.error(`[scheduler]: ${error}`);
-        }
-    }
-    isScheduled = false;
-}
-function nextTick() {
-    scheduleUpdate();
-    return flushPromises();
-}
-function flushPromises() {
-    return new Promise((resolve) => setTimeout(resolve));
-}
-
-function destroyDOM(vNode) {
-    const { type } = vNode;
-    switch (type) {
-        case DOM_TYPES.TEXT: {
-            removeTextNode(vNode);
-            break;
-        }
-        case DOM_TYPES.ELEMENT: {
-            removeElementNode(vNode);
-            break;
-        }
-        case DOM_TYPES.FRAGMENT: {
-            removeFragmentNode(vNode);
-            break;
-        }
-        case DOM_TYPES.COMPONENT: {
-            vNode.component.unmount();
-            enqueueJob(() => vNode.component.onUnmounted());
-            break;
-        }
-        default: {
-            throw new Error(`Can't destroy virtual node of type: ${vNode.type}`);
-        }
-    }
-    delete vNode.el;
-}
-function removeTextNode(vNode) {
-    const { el } = vNode;
-    el.remove();
-}
-function removeElementNode(vNode) {
-    const { el, children, listeners } = vNode;
-    children.forEach(destroyDOM);
-    if (listeners) {
-        removeEventListeners(listeners, el);
-        delete vNode.listeners;
-    }
-    el.remove();
-}
-function removeFragmentNode(vNode) {
-    const { children } = vNode;
-    children.forEach(destroyDOM);
-}
-
-function setAttributes(el, attrs) {
-    const { class: className, style, ...otherAttrs } = attrs;
-    if (className) {
-        setClass(el, className);
-    }
-    if (style) {
-        Object.entries(style).forEach(([prop, value]) => {
-            setStyle(el, prop, value);
-        });
-    }
-    for (const [name, value] of Object.entries(otherAttrs)) {
-        setAttribute(el, name, value);
-    }
-}
-function setClass(el, className) {
-    el.className = '';
-    if (typeof className === 'string') {
-        el.className = className;
-    }
-    if (Array.isArray(className)) {
-        el.classList.add(...className);
-    }
-}
-function setStyle(el, name, value) {
-    el.style[name] = value;
-}
-function removeStyle(el, name) {
-    el.style[name] = null;
-}
-function setAttribute(el, name, value) {
-    if (value == null) {
-        removeAttribute(el, name);
-    } else if (name.startsWith('data-')) {
-        el.setAttribute(name, value);
-    } else {
-        el[name] = value;
-    }
-}
-function removeAttribute(el, name) {
-    el[name] = null;
-    el.removeAttribute(name);
-}
-
-function extractPropsAndEvents(vNode) {
-    const { on: events = {}, ...props } = vNode.props;
-    delete props.key;
-    return { props, events }
-}
-
-function mountDOM(vNode, parentEl, index, hostComponent = null) {
-    switch (vNode.type) {
-        case DOM_TYPES.TEXT: {
-            createTextNode(vNode, parentEl, index);
-            break;
-        }
-        case DOM_TYPES.ELEMENT: {
-            createElementNode(vNode, parentEl, index, hostComponent);
-            break;
-        }
-        case DOM_TYPES.FRAGMENT: {
-            createFragmentNode(vNode, parentEl, index, hostComponent);
-            break;
-        }
-        case DOM_TYPES.COMPONENT: {
-            createComponentNode(vNode, parentEl, index, hostComponent);
-            enqueueJob(() => vNode.component.onMounted());
-            break;
-        }
-        default: {
-            throw new Error(`Can't mount virtual node of type: ${vNode.type}`);
-        }
-    }
-}
-function createTextNode(vNode, parentEl, index) {
-    const { value } = vNode;
-    const textNode = document.createTextNode(value);
-    vNode.el = textNode;
-    insert(textNode, parentEl, index);
-}
-function createElementNode(vNode, parentEl, index, hostComponent) {
-    const { tag, children } = vNode;
-    const el = document.createElement(tag);
-    addProps(el, vNode, hostComponent);
-    vNode.el = el;
-    children.forEach((child) => mountDOM(child, el, null, hostComponent));
-    insert(el, parentEl, index);
-}
-function createFragmentNode(vNode, parentEl, index, hostComponent) {
-    const { children } = vNode;
-    vNode.el = parentEl;
-    children.forEach((child, i) => {
-        mountDOM(child, parentEl, index ? index + i : null, hostComponent);
-    });
-}
-function createComponentNode(vNode, parentEl, index, hostComponent) {
-    const Component = vNode.tag;
-    const { props, events } = extractPropsAndEvents(vNode);
-    const component = new Component(props, events, hostComponent);
-    component.mount(parentEl, index);
-    vNode.component = component;
-    vNode.el = component.firstElement;
-}
-function addProps(el, vNode, hostComponent) {
-    const { props: attrs, events} = extractPropsAndEvents(vNode);
-    vNode.listeners = addEventListeners(events, el, hostComponent);
-    setAttributes(el, attrs);
-}
-function insert(el, parentEl, index) {
-    if (index == null) {
-        parentEl.append(el);
-        return;
-    }
-    if (index < 0) {
-        throw new Error(`Index must be a positive number, got ${index}`);
-    }
-    const children = parentEl.childNodes;
-    if (index >= children.length) {
-        parentEl.append(el);
-    } else {
-        parentEl.insertBefore(el, children[index]);
-    }
-}
-
-function createApp(RootComponent, props = {}) {
-    let parentEl = null;
-    let rootNode = null;
-    let isMounted = false;
-    function reset() {
-        parentEl = null;
-        rootNode = null;
-        isMounted = false;
-    }
-    return {
-        mount(_parentEl) {
-            if (isMounted) throw new Error('The application is already mounted');
-            parentEl = _parentEl;
-            rootNode = h(RootComponent, props);
-            mountDOM(rootNode, parentEl);
-            isMounted = true;
-        },
-        unmount() {
-            if (!isMounted) throw new Error('The application is not mounted');
-            destroyDOM(rootNode);
-            reset();
-        },
-    }
-}
-
-function areNodesEqual(nodeOne, nodeTwo) {
-    if (nodeOne.type !== nodeTwo.type) return false;
-    if (nodeOne.type === DOM_TYPES.ELEMENT) {
-        const { tag: tagOne, props: { key: keyOne } } = nodeOne;
-        const { tag: tagTwo, props: { key: keyTwo } } = nodeTwo;
-        return tagOne === tagTwo && keyOne === keyTwo;
-    }
-    if (nodeOne.type === DOM_TYPES.COMPONENT) {
-        const { tag: componentOne, props: { key: keyOne } } = nodeOne;
-        const { tag: componentTwo, props: { key: keyTwo } } = nodeTwo;
-        return componentOne === componentTwo && keyOne === keyTwo;
-    }
-    return true;
-}
-
-function objectsDiff(oldObj, newObj) {
-    const oldKeys = Object.keys(oldObj);
-    const newKeys = Object.keys(newObj);
-    return {
-        added: newKeys.filter((newKey) => !(newKey in oldObj)),
-        removed: oldKeys.filter((oldKey) => !(oldKey in newObj)),
-        updated: newKeys.filter(
-            (key) => key in oldObj && oldObj[key] !== newObj[key]
-        ),
-    }
-}
-function hasOwnProperty(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-
-function isNotEmptyString(str) {
-    return str !== '';
-}
-function isNotBlankOrEmptyString(str) {
-    return isNotEmptyString(str.trim());
-}
-
-function patchDOM(oldVNode, newVNode, parentEl, hostComponent = null) {
-    if (!areNodesEqual(oldVNode, newVNode)) {
-        const index = findIndexInParent(parentEl, oldVNode.el);
-        destroyDOM(oldVNode);
-        mountDOM(newVNode, parentEl, index, hostComponent);
-        return newVNode;
-    }
-    newVNode.el = oldVNode.el;
-    switch (newVNode.type) {
-        case DOM_TYPES.TEXT: {
-            patchText(oldVNode, newVNode);
-            return newVNode;
-        }
-        case DOM_TYPES.ELEMENT: {
-            patchElement(oldVNode, newVNode, hostComponent);
-            break;
-        }
-        case DOM_TYPES.COMPONENT: {
-            patchComponent(oldVNode, newVNode);
-            break;
-        }
-    }
-    patchChildren(oldVNode, newVNode, hostComponent);
-    return newVNode;
-}
-function findIndexInParent(parentEl, el) {
-    const index = Array.from(parentEl.childNodes).indexOf(el);
-    if (index < 0) return null;
-    return index;
-}
-function patchText(oldVNode, newVNode) {
-    const el = oldVNode.el;
-    const { value: oldText } = oldVNode;
-    const { value: newText } = newVNode;
-    if (oldText !== newText) {
-        el.nodeValue = newText;
-    }
-}
-function patchElement(oldVNode, newVNode, hostComponent) {
-    const el = oldVNode.el;
-    const {
-        class: oldClass,
-        style: oldStyle,
-        on: oldEvents,
-        ...oldAttrs
-    } = oldVNode.props;
-    const {
-        class: newClass,
-        style: newStyle,
-        on: newEvents,
-        ...newAttrs
-    } = newVNode.props;
-    const { listeners: oldListeners } = oldVNode;
-    patchAttrs(el, oldAttrs, newAttrs);
-    patchClasses(el, oldClass, newClass);
-    patchStyles(el, oldStyle, newStyle);
-    newVNode.listeners = patchEvents(el, oldListeners, oldEvents, newEvents, hostComponent);
-}
-function patchComponent(oldVNode, newVNode) {
-    const { component } = oldVNode;
-    const { props } = extractPropsAndEvents(newVNode);
-    component.updateProps(props);
-    newVNode.component = component;
-    newVNode.el = component.firstElement;
-}
-function patchAttrs(el, oldAttrs, newAttrs) {
-    const { added, removed, updated } = objectsDiff(oldAttrs, newAttrs);
-    for (const attr of removed) {
-        removeAttribute(el, attr);
-    }
-    for (const attr of added.concat(updated)) {
-        setAttribute(el, attr, newAttrs[attr]);
-    }
-}
-function patchClasses(el, oldClass, newClass) {
-    const oldClasses = toClassList(oldClass);
-    const newClasses = toClassList(newClass);
-    const { added, removed } = arraysDiff(oldClasses, newClasses);
-    if (removed.length > 0) {
-        el.classList.remove(...removed);
-    }
-    if (added.length > 0) {
-        el.classList.add(...added);
-    }
-}
-function toClassList(classes = '') {
-    return Array.isArray(classes)
-        ? classes.filter(isNotBlankOrEmptyString)
-        : classes.split(/(\s+)/).filter(isNotBlankOrEmptyString);
-}
-function patchStyles(el, oldStyle = {}, newStyle = {}) {
-    const { added, removed, updated} = objectsDiff(oldStyle, newStyle);
-    for (const style of removed) {
-        removeStyle(el, style);
-    }
-    for (const style of added.concat(updated)) {
-        setStyle(el, style, newStyle[style]);
-    }
-}
-function patchEvents(el, oldListeners = {}, oldEvents = {}, newEvents = {}, hostComponent) {
-    const { removed, added, updated}  = objectsDiff(oldEvents, newEvents);
-    for (const eventName of removed.concat(updated)) {
-        el.removeEventListener(eventName, oldListeners[eventName]);
-    }
-    const addedListeners = {};
-    for (const eventName of added.concat(updated)) {
-        addedListeners[eventName] = addEventListener(eventName, newEvents[eventName], el, hostComponent);
-    }
-    return addedListeners;
-}
-function patchChildren(oldVNode, newVNode, hostComponent) {
-    const oldChildren = extractChildren(oldVNode);
-    const newChildren = extractChildren(newVNode);
-    const parentEl = oldVNode.el;
-    const diffSeq = arraysDiffSequence(oldChildren, newChildren, areNodesEqual);
-    for (const operation of diffSeq) {
-        const { originalIndex, from, index, item } = operation;
-        const offset = hostComponent?.offset ?? 0;
-        switch (operation.op) {
-            case ARRAY_DIFF_OP.ADD: {
-                mountDOM(item, parentEl, index, hostComponent);
-                break;
-            }
-            case ARRAY_DIFF_OP.REMOVE: {
-                destroyDOM(item);
-                break;
-            }
-            case ARRAY_DIFF_OP.MOVE: {
-                const el = oldChildren[from].el;
-                const elAtTargetIndex = parentEl.childNodes[index + offset];
-                parentEl.insertBefore(el, elAtTargetIndex);
-                patchDOM(oldChildren[from], newChildren[index], parentEl, hostComponent);
-                break;
-            }
-            case ARRAY_DIFF_OP.NOOP: {
-                patchDOM(oldChildren[originalIndex], newChildren[index], parentEl, hostComponent);
-                break;
-            }
-        }
-    }
-}
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var fastDeepEqual;
-var hasRequiredFastDeepEqual;
-function requireFastDeepEqual () {
-	if (hasRequiredFastDeepEqual) return fastDeepEqual;
-	hasRequiredFastDeepEqual = 1;
-	fastDeepEqual = function equal(a, b) {
-	  if (a === b) return true;
-	  if (a && b && typeof a == 'object' && typeof b == 'object') {
-	    if (a.constructor !== b.constructor) return false;
-	    var length, i, keys;
-	    if (Array.isArray(a)) {
-	      length = a.length;
-	      if (length != b.length) return false;
-	      for (i = length; i-- !== 0;)
-	        if (!equal(a[i], b[i])) return false;
-	      return true;
-	    }
-	    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
-	    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
-	    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
-	    keys = Object.keys(a);
-	    length = keys.length;
-	    if (length !== Object.keys(b).length) return false;
-	    for (i = length; i-- !== 0;)
-	      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
-	    for (i = length; i-- !== 0;) {
-	      var key = keys[i];
-	      if (!equal(a[key], b[key])) return false;
-	    }
-	    return true;
-	  }
-	  return a!==a && b!==b;
+function _(e, t = {}, n = []) {
+	return {
+		tag: e,
+		props: t,
+		type: typeof e == "string" ? g.ELEMENT : g.COMPONENT,
+		children: b(f(n))
+	};
+}
+function v(e) {
+	return {
+		type: g.TEXT,
+		value: e
+	};
+}
+function y(e) {
+	return {
+		children: b(f(e)),
+		type: g.FRAGMENT
+	};
+}
+function b(e) {
+	return e.map((e) => typeof e == "string" ? v(e) : e);
+}
+function x(e) {
+	if (e.children == null) return [];
+	let t = [];
+	for (let n of e.children) n.type === g.FRAGMENT ? t.push(...x(n)) : t.push(n);
+	return t;
+}
+//#endregion
+//#region src/scheduler.js
+var S = !1, C = [];
+function w(e) {
+	C.push(e), T();
+}
+function T() {
+	S || (S = !0, queueMicrotask(E));
+}
+function E() {
+	for (; C.length > 0;) {
+		let e = C.shift();
+		try {
+			Promise.resolve(e()).catch((e) => {
+				console.error(`[scheduler]: ${e}`);
+			});
+		} catch (e) {
+			console.error(`[scheduler]: ${e}`);
+		}
+	}
+	S = !1;
+}
+function te() {
+	return T(), D();
+}
+function D() {
+	return new Promise((e) => setTimeout(e));
+}
+//#endregion
+//#region src/destroy-dom.js
+function O(e) {
+	let { type: t } = e;
+	switch (t) {
+		case g.TEXT:
+			k(e);
+			break;
+		case g.ELEMENT:
+			A(e);
+			break;
+		case g.FRAGMENT:
+			j(e);
+			break;
+		case g.COMPONENT:
+			e.component.unmount(), w(() => e.component.onUnmounted());
+			break;
+		default: throw Error(`Can't destroy virtual node of type: ${e.type}`);
+	}
+	delete e.el;
+}
+function k(e) {
+	let { el: t } = e;
+	t.remove();
+}
+function A(e) {
+	let { el: t, children: n, listeners: r } = e;
+	n.forEach(O), r && (d(r, t), delete e.listeners), t.remove();
+}
+function j(e) {
+	let { children: t } = e;
+	t.forEach(O);
+}
+//#endregion
+//#region src/attributes.js
+function M(e, t) {
+	let { class: n, style: r, ...i } = t;
+	n && ne(e, n), r && Object.entries(r).forEach(([t, n]) => {
+		N(e, t, n);
+	});
+	for (let [t, n] of Object.entries(i)) F(e, t, n);
+}
+function ne(e, t) {
+	e.className = "", typeof t == "string" && (e.className = t), Array.isArray(t) && e.classList.add(...t);
+}
+function N(e, t, n) {
+	e.style[t] = n;
+}
+function P(e, t) {
+	e.style[t] = null;
+}
+function F(e, t, n) {
+	n == null ? I(e, t) : t.startsWith("data-") ? e.setAttribute(t, n) : e[t] = n;
+}
+function I(e, t) {
+	e[t] = null, e.removeAttribute(t);
+}
+//#endregion
+//#region src/utils/props.js
+function L(e) {
+	let { on: t = {}, ...n } = e.props;
+	return delete n.key, {
+		props: n,
+		events: t
+	};
+}
+//#endregion
+//#region src/mount-dom.js
+function R(e, t, n, r = null) {
+	switch (e.type) {
+		case g.TEXT:
+			z(e, t, n);
+			break;
+		case g.ELEMENT:
+			B(e, t, n, r);
+			break;
+		case g.FRAGMENT:
+			V(e, t, n, r);
+			break;
+		case g.COMPONENT:
+			H(e, t, n, r), w(() => e.component.onMounted());
+			break;
+		default: throw Error(`Can't mount virtual node of type: ${e.type}`);
+	}
+}
+function z(e, t, n) {
+	let { value: r } = e, i = document.createTextNode(r);
+	e.el = i, W(i, t, n);
+}
+function B(e, t, n, r) {
+	let { tag: i, children: a } = e, o = document.createElement(i);
+	U(o, e, r), e.el = o, a.forEach((e) => R(e, o, null, r)), W(o, t, n);
+}
+function V(e, t, n, r) {
+	let { children: i } = e;
+	e.el = t, i.forEach((e, i) => {
+		R(e, t, n ? n + i : null, r);
+	});
+}
+function H(e, t, n, r) {
+	let i = e.tag, { props: a, events: o } = L(e), s = new i(a, o, r);
+	s.mount(t, n), e.component = s, e.el = s.firstElement;
+}
+function U(e, t, n) {
+	let { props: r, events: i } = L(t);
+	t.listeners = l(i, e, n), M(e, r);
+}
+function W(e, t, n) {
+	if (n == null) {
+		t.append(e);
+		return;
+	}
+	if (n < 0) throw Error(`Index must be a positive number, got ${n}`);
+	let r = t.childNodes;
+	n >= r.length ? t.append(e) : t.insertBefore(e, r[n]);
+}
+//#endregion
+//#region src/app.js
+function G(e, t = {}) {
+	let n = null, r = null, i = !1;
+	function a() {
+		n = null, r = null, i = !1;
+	}
+	return {
+		mount(a) {
+			if (i) throw Error("The application is already mounted");
+			n = a, r = _(e, t), R(r, n), i = !0;
+		},
+		unmount() {
+			if (!i) throw Error("The application is not mounted");
+			O(r), a();
+		}
+	};
+}
+//#endregion
+//#region src/nodes-equal.js
+function K(e, t) {
+	if (e.type !== t.type) return !1;
+	if (e.type === g.ELEMENT) {
+		let { tag: n, props: { key: r } } = e, { tag: i, props: { key: a } } = t;
+		return n === i && r === a;
+	}
+	if (e.type === g.COMPONENT) {
+		let { tag: n, props: { key: r } } = e, { tag: i, props: { key: a } } = t;
+		return n === i && r === a;
+	}
+	return !0;
+}
+//#endregion
+//#region src/utils/objects.js
+function q(e, t) {
+	let n = Object.keys(e), r = Object.keys(t);
+	return {
+		added: r.filter((t) => !(t in e)),
+		removed: n.filter((e) => !(e in t)),
+		updated: r.filter((n) => n in e && e[n] !== t[n])
+	};
+}
+function J(e, t) {
+	return Object.prototype.hasOwnProperty.call(e, t);
+}
+//#endregion
+//#region src/utils/strings.js
+function Y(e) {
+	return e !== "";
+}
+function X(e) {
+	return Y(e.trim());
+}
+//#endregion
+//#region src/patch-dom.js
+function Z(e, t, n, r = null) {
+	if (!K(e, t)) {
+		let i = re(n, e.el);
+		return O(e), R(t, n, i, r), t;
+	}
+	switch (t.el = e.el, t.type) {
+		case g.TEXT: return ie(e, t), t;
+		case g.ELEMENT:
+			ae(e, t, r);
+			break;
+		case g.COMPONENT:
+			oe(e, t);
+			break;
+	}
+	return de(e, t, r), t;
+}
+function re(e, t) {
+	let n = Array.from(e.childNodes).indexOf(t);
+	return n < 0 ? null : n;
+}
+function ie(e, t) {
+	let n = e.el, { value: r } = e, { value: i } = t;
+	r !== i && (n.nodeValue = i);
+}
+function ae(e, t, n) {
+	let r = e.el, { class: i, style: a, on: o, ...s } = e.props, { class: c, style: l, on: u, ...d } = t.props, { listeners: f } = e;
+	se(r, s, d), ce(r, i, c), le(r, a, l), t.listeners = ue(r, f, o, u, n);
+}
+function oe(e, t) {
+	let { component: n } = e, { props: r } = L(t);
+	n.updateProps(r), t.component = n, t.el = n.firstElement;
+}
+function se(e, t, n) {
+	let { added: r, removed: i, updated: a } = q(t, n);
+	for (let t of i) I(e, t);
+	for (let t of r.concat(a)) F(e, t, n[t]);
+}
+function ce(e, t, n) {
+	let { added: r, removed: i } = p(Q(t), Q(n));
+	i.length > 0 && e.classList.remove(...i), r.length > 0 && e.classList.add(...r);
+}
+function Q(e = "") {
+	return Array.isArray(e) ? e.filter(X) : e.split(/(\s+)/).filter(X);
+}
+function le(e, t = {}, n = {}) {
+	let { added: r, removed: i, updated: a } = q(t, n);
+	for (let t of i) P(e, t);
+	for (let t of r.concat(a)) N(e, t, n[t]);
+}
+function ue(e, t = {}, n = {}, r = {}, i) {
+	let { removed: a, added: o, updated: s } = q(n, r);
+	for (let n of a.concat(s)) e.removeEventListener(n, t[n]);
+	let c = {};
+	for (let t of o.concat(s)) c[t] = u(t, r[t], e, i);
+	return c;
+}
+function de(e, t, n) {
+	let r = x(e), i = x(t), a = e.el, o = ee(r, i, K);
+	for (let e of o) {
+		let { originalIndex: t, from: o, index: s, item: c } = e, l = n?.offset ?? 0;
+		switch (e.op) {
+			case m.ADD:
+				R(c, a, s, n);
+				break;
+			case m.REMOVE:
+				O(c);
+				break;
+			case m.MOVE: {
+				let e = r[o].el, t = a.childNodes[s + l];
+				a.insertBefore(e, t), Z(r[o], i[s], a, n);
+				break;
+			}
+			case m.NOOP:
+				Z(r[t], i[s], a, n);
+				break;
+		}
+	}
+}
+//#endregion
+//#region src/dispatcher.js
+var fe = /* @__PURE__ */ c((/* @__PURE__ */ o(((e, t) => {
+	t.exports = function e(t, n) {
+		if (t === n) return !0;
+		if (t && n && typeof t == "object" && typeof n == "object") {
+			if (t.constructor !== n.constructor) return !1;
+			var r, i, a;
+			if (Array.isArray(t)) {
+				if (r = t.length, r != n.length) return !1;
+				for (i = r; i-- !== 0;) if (!e(t[i], n[i])) return !1;
+				return !0;
+			}
+			if (t.constructor === RegExp) return t.source === n.source && t.flags === n.flags;
+			if (t.valueOf !== Object.prototype.valueOf) return t.valueOf() === n.valueOf();
+			if (t.toString !== Object.prototype.toString) return t.toString() === n.toString();
+			if (a = Object.keys(t), r = a.length, r !== Object.keys(n).length) return !1;
+			for (i = r; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(n, a[i])) return !1;
+			for (i = r; i-- !== 0;) {
+				var o = a[i];
+				if (!e(t[o], n[o])) return !1;
+			}
+			return !0;
+		}
+		return t !== t && n !== n;
 	};
-	return fastDeepEqual;
-}
-
-var fastDeepEqualExports = requireFastDeepEqual();
-var equal = /*@__PURE__*/getDefaultExportFromCjs(fastDeepEqualExports);
-
-class Dispatcher {
-    #handlersByCommand = new Map();
-    #afterHandlers = [];
-    subscribe(commandName, handler) {
-        if (!this.#handlersByCommand.has(commandName)) {
-            this.#handlersByCommand.set(commandName, []);
-        }
-        const handlers = this.#handlersByCommand.get(commandName);
-        if (handlers.includes(handler)) {
-            return () => {}
-        }
-        handlers.push(handler);
-        return () => {
-            const index = handlers.indexOf(handler);
-            handlers.splice(index, 1);
-        }
-    }
-    afterEveryCommand(handler) {
-        this.#afterHandlers.push(handler);
-        return () => {
-            const index = this.#afterHandlers.indexOf(handler);
-            this.#afterHandlers.splice(index, 1);
-        }
-    }
-    dispatch(commandName, payload) {
-        if (this.#handlersByCommand.has(commandName)) {
-            this.#handlersByCommand.get(commandName).forEach((handler) => handler(payload));
-        } else {
-            console.warn(`No handlers for command: ${commandName}`);
-        }
-        this.#afterHandlers.forEach((handler) => handler());
-    }
-}
-
-const emptyFn = () => {};
-function defineComponent({ render, state, onMounted = emptyFn, onUnmounted = emptyFn, ...methods }) {
-    class Component {
-        #isMounted = false;
-        #vNode = null;
-        #hostEl = null;
-        #eventHandlers = null;
-        #parentComponent = null;
-        #dispatcher = new Dispatcher();
-        #subscriptions = [];
-        constructor(props = {}, eventHandlers = {}, parentComponent = null) {
-            this.props = props;
-            this.state = state ? state(props) : {};
-            this.#eventHandlers = eventHandlers;
-            this.#parentComponent = parentComponent;
-        }
-        onMounted() {
-            return Promise.resolve(onMounted.call(this));
-        }
-        onUnmounted() {
-            return Promise.resolve(onUnmounted.call(this));
-        }
-        get elements() {
-            if (this.#vNode == null) {
-                return [];
-            }
-            if (this.#vNode.type === DOM_TYPES.FRAGMENT) {
-                return extractChildren(this.#vNode).flatMap((child) => {
-                    if (child.type === DOM_TYPES.COMPONENT) {
-                        return child.component.elements;
-                    }
-                    return [child.el];
-                });
-            }
-            return [this.#vNode.el];
-        }
-        get firstElement() {
-            return this.elements[0];
-        }
-        get offset() {
-            if(this.#vNode.type === DOM_TYPES.FRAGMENT) {
-                return Array.from(this.#hostEl.children).indexOf(this.firstElement);
-            }
-            return 0;
-        }
-        updateProps(props) {
-            const newProps = { ...this.props, ...props };
-            if (equal(this.props, newProps)) {
-                return;
-            }
-            this.props = newProps;
-            this.#patch();
-        }
-        updateState(state) {
-            this.state = { ...this.state, ...state };
-            this.#patch();
-        }
-        render() {
-            return render.call(this);
-        }
-        emit(eventName, payload) {
-            this.#dispatcher.dispatch(eventName, payload);
-        }
-        mount(hostEl, index = null) {
-            if (this.#isMounted) {
-                throw new Error('Component is already mounted');
-            }
-            this.#vNode = this.render();
-            mountDOM(this.#vNode, hostEl, index, this);
-            this.#wireEventHandlers();
-            this.#hostEl = hostEl;
-            this.#isMounted = true;
-        }
-        unmount() {
-            if (!this.#isMounted) {
-                throw new Error('Component is not mounted');
-            }
-            destroyDOM(this.#vNode);
-            this.#subscriptions.forEach((unsubscribe) => unsubscribe());
-            this.#vNode = null;
-            this.#hostEl = null;
-            this.#isMounted = false;
-            this.#subscriptions = [];
-        }
-        #patch() {
-            if (!this.#isMounted) {
-                throw new Error('Component is not mounted');
-            }
-            const vNode = this.render();
-            this.#vNode = patchDOM(this.#vNode, vNode, this.#hostEl, this);
-        }
-        #wireEventHandlers() {
-            this.#subscriptions = Object.entries(this.#eventHandlers).map(
-                ([eventName, handler]) =>
-                    this.#wireEventHandler(eventName, handler)
-            );
-        }
-        #wireEventHandler(eventName, handler) {
-            return this.#dispatcher.subscribe(eventName, (payload) => {
-                if (this.#parentComponent) {
-                    handler.call(this.#parentComponent, payload);
-                } else {
-                    handler(payload);
-                }
-            })
-        }
-    }
-    for (const methodName in methods) {
-        if (hasOwnProperty(Component, methodName)) {
-            throw new Error(`Method "${methodName}()" already exists in the component.`);
-        }
-        Component.prototype[methodName] = methods[methodName];
-    }
-    return Component;
-}
-
-export { createApp, defineComponent, h, hFragment, hString, nextTick };
+})))(), 1), pe = class {
+	#e = /* @__PURE__ */ new Map();
+	#t = [];
+	subscribe(e, t) {
+		this.#e.has(e) || this.#e.set(e, []);
+		let n = this.#e.get(e);
+		return n.includes(t) ? () => {} : (n.push(t), () => {
+			let e = n.indexOf(t);
+			n.splice(e, 1);
+		});
+	}
+	afterEveryCommand(e) {
+		return this.#t.push(e), () => {
+			let t = this.#t.indexOf(e);
+			this.#t.splice(t, 1);
+		};
+	}
+	dispatch(e, t) {
+		this.#e.has(e) ? this.#e.get(e).forEach((e) => e(t)) : console.warn(`No handlers for command: ${e}`), this.#t.forEach((e) => e());
+	}
+}, $ = () => {};
+function me({ render: e, state: t, onMounted: n = $, onUnmounted: r = $, ...i }) {
+	class a {
+		#e = !1;
+		#t = null;
+		#n = null;
+		#r = null;
+		#i = null;
+		#a = new pe();
+		#o = [];
+		constructor(e = {}, n = {}, r = null) {
+			this.props = e, this.state = t ? t(e) : {}, this.#r = n, this.#i = r;
+		}
+		onMounted() {
+			return Promise.resolve(n.call(this));
+		}
+		onUnmounted() {
+			return Promise.resolve(r.call(this));
+		}
+		get elements() {
+			return this.#t == null ? [] : this.#t.type === g.FRAGMENT ? x(this.#t).flatMap((e) => e.type === g.COMPONENT ? e.component.elements : [e.el]) : [this.#t.el];
+		}
+		get firstElement() {
+			return this.elements[0];
+		}
+		get offset() {
+			return this.#t.type === g.FRAGMENT ? Array.from(this.#n.children).indexOf(this.firstElement) : 0;
+		}
+		updateProps(e) {
+			let t = {
+				...this.props,
+				...e
+			};
+			(0, fe.default)(this.props, t) || (this.props = t, this.#s());
+		}
+		updateState(e) {
+			this.state = {
+				...this.state,
+				...e
+			}, this.#s();
+		}
+		render() {
+			return e.call(this);
+		}
+		emit(e, t) {
+			this.#a.dispatch(e, t);
+		}
+		mount(e, t = null) {
+			if (this.#e) throw Error("Component is already mounted");
+			this.#t = this.render(), R(this.#t, e, t, this), this.#c(), this.#n = e, this.#e = !0;
+		}
+		unmount() {
+			if (!this.#e) throw Error("Component is not mounted");
+			O(this.#t), this.#o.forEach((e) => e()), this.#t = null, this.#n = null, this.#e = !1, this.#o = [];
+		}
+		#s() {
+			if (!this.#e) throw Error("Component is not mounted");
+			let e = this.render();
+			this.#t = Z(this.#t, e, this.#n, this);
+		}
+		#c() {
+			this.#o = Object.entries(this.#r).map(([e, t]) => this.#l(e, t));
+		}
+		#l(e, t) {
+			return this.#a.subscribe(e, (e) => {
+				this.#i ? t.call(this.#i, e) : t(e);
+			});
+		}
+	}
+	for (let e in i) {
+		if (J(a, e)) throw Error(`Method "${e}()" already exists in the component.`);
+		a.prototype[e] = i[e];
+	}
+	return a;
+}
+//#endregion
+export { G as createApp, me as defineComponent, _ as h, y as hFragment, v as hString, te as nextTick };