ezh 0.1.3 → 0.1.5

package/lib/elements.js

@@ -1,4 +1,4 @@
-import { a3, L, U, W } from './RbTree';
+import { a1, S, R, U } from './RbTree';
 const V = {
     'ariaAtomic': 'aria-atomic',
     'ariaAutoComplete': 'aria-autocomplete',
@@ -92,128 +92,132 @@ const V = {
     'wordSpacing': 'word-spacing',
     'writingMode': 'writing-mode',
 };
-const X = {};
-const Y = [];
-Object.freeze(X);
-Object.freeze(Y);
-const E = () => false;
-const y = [];
-const w = new Set();
-const a7 = new W();
-const ai = new W();
-const au = [];
-const av = [];
-const aj = {
+const a3 = {};
+const W = [];
+Object.freeze(a3);
+Object.freeze(W);
+const C = () => false;
+const w = [];
+const y = new Set();
+const a4 = new U();
+const ag = new U();
+const ar = [];
+const at = [];
+const au = {
     id: '',
     index: 0,
     firstElement: null,
-    attachTo: E,
-    move: E,
-    detachFrom: E,
-    update: E,
-    refresh: E,
-    release: E,
-    version: 0,
-    parentCom: {},
-    markChanged: E,
-    watchMountChange: E,
+    attachTo: C,
+    move: C,
+    detachFrom: C,
+    update: C,
+    refresh: C,
+    release: C,
+    version: 1,
+    markChanged: C,
+    watchMountChange: C,
 };
-let F = '';
-let ak = 20000;
-let A = 0;
-let aw = 0;
-let M = undefined;
-const G = new W();
-export const o = new Map();
-export let q = aj;
-export let N = 0;
-const aF = (z, aV) => {
-    return document.createElement(z);
+let D = '';
+let ai = 20000;
+let J = 0;
+let av = 0;
+let K = undefined;
+const G = new U();
+export const n = new Map();
+export let p = au;
+export let L = 1;
+const aF = (x, aV) => {
+    return document.createElement(x);
 };
-let aa = aF;
-const ax = {
-    'svg': (z, O) => {
-        O.a9();
-        return document.createElementNS('http://www.w3.org/2000/svg', z);
+let a6 = aF;
+const aw = {
+    'svg': (x, M) => {
+        M.a5();
+        return document.createElementNS('http://www.w3.org/2000/svg', x);
     },
-    'math': (z, O) => {
-        O.a9();
-        return document.createElementNS('http://www.w3.org/1998/Math/MathML', z);
+    'math': (x, M) => {
+        M.a5();
+        return document.createElementNS('http://www.w3.org/1998/Math/MathML', x);
     },
-    'foreignObject': (z, O) => {
-        if (z !== 'foreignObject') {
-            return document.createElement(z);
+    'foreignObject': (x, M) => {
+        if (x !== 'foreignObject') {
+            return document.createElement(x);
         }
-        O.a9();
-        return document.createElementNS('http://www.w3.org/2000/svg', z);
+        M.a5();
+        return document.createElementNS('http://www.w3.org/2000/svg', x);
     },
 };
-const al = () => {
-    if (++aw >= A) {
-        for (const element of w) {
-            w.delete(element);
+const aj = () => {
+    if (++av >= J) {
+        for (const element of y) {
+            y.delete(element);
             if (element.id) {
                 element.release();
             }
             else {
-                if (--aw < A) {
-                    w.add(element);
+                if (--av < J) {
+                    y.add(element);
                     break;
                 }
             }
         }
     }
     else {
-        w.add(Object.create(aj));
+        y.add(Object.create(au));
     }
-    if (M) {
-        M = setTimeout(al, ak);
+    if (K) {
+        K = setTimeout(aj, ai);
     }
 };
-const ay = (parent, m) => {
-    const az = ['', m];
-    while (parent.constructor !== a8) {
-        az.push(parent.id);
+const ax = (parent, m) => {
+    const ay = ['', m];
+    while (parent.constructor !== ah) {
+        ay.push(parent.id);
         parent = parent.parent;
     }
-    return az.reverse().join(',');
+    return ay.reverse().join(',');
 };
 const aG = () => {
-    do {
-        G.a5((id, element) => {
-            const { newChildren, parent } = element;
-            if (newChildren) {
-                if (parent && am(parent)) {
-                    element.refresh(newChildren);
-                    parent.currentBefore = undefined;
-                }
-                else if (element.constructor === an) {
-                    a7.C(id, element);
-                }
+    let element;
+    while (element = G.aq(true)) {
+        const { id, newChildren, parent } = element;
+        if (newChildren) {
+            if (parent && ak(parent)) {
+                element.refresh(newChildren);
+                parent.currentBefore = undefined;
+            }
+            else if (element.version) {
+                a4.A(id, element);
             }
-            return L;
-        });
-    } while (!G.a4());
-    N++;
-    for (const { parent, element } of y) {
-        element.detachFrom(X);
+        }
+    }
+    L++;
+    for (const { parent, element } of w) {
         if (element.parent !== parent) {
-            if (!ai.a4() && am(parent)) {
-                const a6 = !element.parent;
-                const ab = ay(parent, element.id);
-                ai.a5((key, value) => {
-                    if (key.startsWith(ab)) {
-                        value._(value.D, a6);
-                        return L;
+            if (!ag.ae() && ak(parent)) {
+                const a2 = !element.parent;
+                const a7 = ax(parent, element.id);
+                ag.af((key, value) => {
+                    if (key.startsWith(a7)) {
+                        value._(value.B, a2);
+                        return S;
                     }
-                    return U;
-                }, ab);
+                    return R;
+                }, a7);
+            }
+        }
+        if (!element.parent) {
+            if (J) {
+                y.add(element);
+            }
+            else {
+                element.release();
             }
         }
     }
-    y.length = 0;
+    w.length = 0;
 };
-const Q = (children, f = [], from = 0) => {
+const N = (children, f = [], from = 0) => {
     let a = children[from];
     for (;;) {
         if (a && a.id !== undefined) {
@@ -222,7 +226,7 @@ const Q = (children, f = [], from = 0) => {
         else if (a !== null && a !== undefined) {
             switch (typeof a) {
                 case 'object':
-                    Q(a, f);
+                    N(a, f);
                     break;
                 case 'function':
                     a = a();
@@ -232,7 +236,7 @@ const Q = (children, f = [], from = 0) => {
                 case 'bigint':
                     a = '' + a;
                 default:
-                    f.push(new ao('', a));
+                    f.push(new al('', a));
             }
         }
         if (++from < children.length) {
@@ -244,93 +248,93 @@ const Q = (children, f = [], from = 0) => {
     }
     return f;
 };
-const ac = (B, children, parent) => {
+const a8 = (z, children, parent) => {
     let f;
-    const length = B.length;
+    const length = z.length;
     let newChildren = children;
     let b = 0;
     while (b < length) {
-        const a$ = B[b];
-        if (a$ !== newChildren[b]) {
+        const az = z[b];
+        if (az !== newChildren[b]) {
             if (b === newChildren.length) {
                 return newChildren;
             }
             const a = newChildren[b];
             if (!a || a.id === undefined) {
-                newChildren = Q(newChildren, newChildren.slice(0, b), b);
+                newChildren = N(newChildren, newChildren.slice(0, b), b);
                 continue;
             }
             else if (f !== newChildren) {
                 break;
             }
         }
-        if (!f && a$.parent !== parent) {
-            f = B;
+        if (!f && az.parent !== parent) {
+            f = z;
         }
         b++;
     }
     if (b === newChildren.length) {
         return f;
     }
-    return newChildren === children ? Q(newChildren, B.slice(0, b), b) : newChildren;
+    return newChildren === children ? N(newChildren, z.slice(0, b), b) : newChildren;
 };
-const am = (element) => {
+const ak = (element) => {
     let parent = element;
     do {
-        if (parent.constructor === a8) {
+        if (parent.parent === parent) {
             return true;
         }
         parent = parent.parent;
     } while (parent);
     return false;
 };
-const ad = (B, newChildren, parent, aH) => {
+const a9 = (z, newChildren, parent, aH) => {
     let b, i;
     let a;
-    if (newChildren !== B && B.length) {
-        const ap = [];
-        let t;
+    if (newChildren !== z && z.length) {
+        const am = [];
+        let s;
         i = newChildren.length;
         b = 10000000;
         while (--i >= 0) {
             a = newChildren[i];
             if (a.parent === parent) {
-                const a_ = i - a.index;
-                if (a_ === b) {
-                    t.H++;
+                const a$ = i - a.index;
+                if (a$ === b) {
+                    s.E++;
                     a.index = i;
                 }
                 else {
-                    t = {
+                    s = {
                         from: a.index,
                         to: i,
-                        H: 1,
+                        E: 1,
                     };
-                    b = a_;
-                    a.index = -ap.push(t);
+                    b = a$;
+                    a.index = -am.push(s);
                 }
             }
             else if (b !== 10000000) {
                 b = 10000000;
             }
         }
-        const aq = [];
-        i = B.length - 1;
+        const an = [];
+        i = z.length - 1;
         while (i >= 0) {
-            a = B[i];
+            a = z[i];
             if (a.index < 0) {
-                t = ap[-a.index - 1];
-                aq.push(t);
-                i -= t.H;
+                s = am[-a.index - 1];
+                an.push(s);
+                i -= s.E;
             }
             else {
                 a.detachFrom(parent);
                 i--;
             }
         }
-        let R;
-        let ae;
-        let af = 0;
+        let O;
+        let aa;
+        let ab = 0;
         i = newChildren.length - 1;
         while (i >= 0) {
             a = newChildren[i];
@@ -339,32 +343,32 @@ const ad = (B, newChildren, parent, aH) => {
                 a.attachTo(parent);
             }
             else {
-                t = ap[-a.index - 1];
-                ae = t.H;
-                R = aq[af];
+                s = am[-a.index - 1];
+                aa = s.E;
+                O = an[ab];
                 a.index = i;
                 if (!aH) {
-                    if (R === t) {
-                        af++;
-                        i -= t.H;
+                    if (O === s) {
+                        ab++;
+                        i -= s.E;
                         parent.currentBefore = undefined;
                         continue;
                     }
-                    if (R.from > t.from) {
-                        b = af;
+                    if (O.from > s.from) {
+                        b = ab;
                         do {
-                            ae -= R.H;
-                            R = aq[++b];
-                        } while (R.from > t.from && ae > 0);
-                        if (ae > 0) {
-                            i -= t.H;
+                            aa -= O.E;
+                            O = an[++b];
+                        } while (O.from > s.from && aa > 0);
+                        if (aa > 0) {
+                            i -= s.E;
                             parent.currentBefore = undefined;
-                            af = b;
+                            ab = b;
                             continue;
                         }
                     }
                 }
-                b = i - t.H;
+                b = i - s.E;
                 do {
                     a.move();
                 } while (--i > b && (a = newChildren[i]));
@@ -382,13 +386,11 @@ const ad = (B, newChildren, parent, aH) => {
     }
     parent.currentBefore = undefined;
 };
-class ao {
+class al {
     constructor(id, text) {
         this.id = id;
-        this.parent = undefined;
         this.index = 0;
-        this.n = 0;
-        this.ag = text;
+        this.ac = text;
     }
     id;
     parent;
@@ -396,33 +398,33 @@ class ao {
     firstElement;
     attachTo(target) {
         if (!this.firstElement) {
-            this.firstElement = document.createTextNode(this.ag);
+            this.firstElement = document.createTextNode(this.ac);
         }
         const { parent, firstElement, index } = this;
         if (this.id) {
-            if (!this.n++) {
-                w.delete(this);
+            if (!parent) {
+                y.delete(this);
             }
-            if (parent) {
+            else {
+                w.push({ parent, element: this });
                 firstElement.remove();
-                y.push({ parent, element: this });
             }
         }
         this.parent = target;
-        let r = target.currentBefore;
-        if (r === undefined) {
-            r = target.findNextSiblingElement(index);
+        let q = target.currentBefore;
+        if (q === undefined) {
+            q = target.findNextSiblingElement(index);
         }
-        target.element.insertBefore(firstElement, r);
+        target.element.insertBefore(firstElement, q);
         target.currentBefore = firstElement;
     }
     move() {
         const { parent, index, firstElement } = this;
-        let r = parent.currentBefore;
-        if (r === undefined) {
-            r = parent.findNextSiblingElement(index);
+        let q = parent.currentBefore;
+        if (q === undefined) {
+            q = parent.findNextSiblingElement(index);
         }
-        parent.element.insertBefore(firstElement, r);
+        parent.element.insertBefore(firstElement, q);
         parent.currentBefore = firstElement;
     }
     detachFrom(target) {
@@ -430,23 +432,13 @@ class ao {
             this.firstElement.remove();
             this.parent = undefined;
             if (this.id) {
-                y.push({ parent: target, element: this });
-            }
-        }
-        else {
-            if (this.id && !--this.n) {
-                if (A) {
-                    w.add(this);
-                }
-                else {
-                    this.release();
-                }
+                w.push({ parent: target, element: this });
             }
         }
     }
     update(text) {
-        if (this.ag !== text) {
-            this.ag = text;
+        if (this.ac !== text) {
+            this.ac = text;
             if (this.firstElement) {
                 this.firstElement.nodeValue = text;
             }
@@ -455,25 +447,20 @@ class ao {
     }
     refresh() { }
     release(target) {
-        if (target && this.parent === target) {
-            this.firstElement.remove();
-            this.parent = undefined;
-        }
-        if (this.id && --this.n <= 0) {
-            o.delete(this.id);
+        if (this.parent === target) {
+            if (target) {
+                this.firstElement.remove();
+            }
+            n.delete(this.id);
         }
     }
-    n;
-    ag;
+    ac;
 }
 export class aI {
     constructor(id, children, aJ) {
         this.id = id;
-        this.parent = undefined;
         this.index = 0;
-        this.n = 0;
-        this.newChildren = this.d = aJ ? Q(children) : (children || Y);
-        this.currentBefore = undefined;
+        this.newChildren = this.d = aJ ? N(children) : (children || W);
     }
     id;
     parent;
@@ -495,11 +482,11 @@ export class aI {
     }
     attachTo(target) {
         const { parent, d, newChildren } = this;
-        if (!this.n++) {
-            w.delete(this);
+        if (!parent) {
+            y.delete(this);
         }
-        if (parent) {
-            y.push({ parent, element: this });
+        else {
+            w.push({ parent, element: this });
             for (let b = d.length - 1; b >= 0; b--) {
                 d[b].detachFrom(this);
             }
@@ -519,7 +506,7 @@ export class aI {
     move() {
         const { d, newChildren } = this;
         if (newChildren) {
-            ad(d, newChildren, this, true);
+            a9(d, newChildren, this, true);
             this.d = newChildren;
             this.newChildren = undefined;
         }
@@ -537,22 +524,12 @@ export class aI {
                 a.detachFrom(this);
             }
             this.parent = undefined;
-            y.push({ parent: target, element: this });
-        }
-        else {
-            if (!--this.n) {
-                if (A) {
-                    w.add(this);
-                }
-                else {
-                    this.release();
-                }
-            }
+            w.push({ parent: target, element: this });
         }
     }
-    update(p, children) {
+    update(o, children) {
         if (children) {
-            const newChildren = ac(this.d, children, this);
+            const newChildren = a8(this.d, children, this);
             if (newChildren) {
                 this.newChildren = newChildren;
                 return true;
@@ -561,20 +538,19 @@ export class aI {
         return false;
     }
     refresh(newChildren) {
-        ad(this.d, newChildren, this);
+        a9(this.d, newChildren, this);
         this.d = newChildren;
         this.newChildren = undefined;
     }
     release(target) {
-        if (target && this.parent === target) {
-            const { d } = this;
-            for (const a of d) {
-                a.detachFrom(this);
+        if (this.parent === target) {
+            if (target) {
+                const { d } = this;
+                for (const a of d) {
+                    a.detachFrom(this);
+                }
             }
-            this.parent = undefined;
-        }
-        if (--this.n <= 0) {
-            o.delete(this.id);
+            n.delete(this.id);
         }
     }
     findNextSiblingElement(index) {
@@ -592,53 +568,49 @@ export class aI {
         h = this.parent.currentBefore;
         return h !== undefined ? h : this.parent.findNextSiblingElement(this.index);
     }
-    n;
     d;
 }
 export class aK {
     constructor(id, tag, props, children, check, mutableChild) {
         this.id = id;
-        this.parent = undefined;
         this.index = 0;
-        this.n = 0;
-        this.firstElement = this.element = aa(tag, this);
-        this.newChildren = this.d = mutableChild ? Q(children) : (children || Y);
-        this.currentBefore = undefined;
+        this.firstElement = this.element = a6(tag, this);
+        this.newChildren = this.d = mutableChild ? N(children) : (children || W);
         if (props) {
-            this.p = X;
-            this.u = -1;
+            this.o = a3;
+            this.t = -1;
             if (tag === 'select') {
-                const ar = this.element;
-                const at = props;
-                const c = at.value;
+                const ao = this.element;
+                const ap = props;
+                const c = ap.value;
                 if (c) {
-                    at.value = undefined;
+                    ap.value = undefined;
                     const aL = this.refresh;
                     this.refresh = (newChildren) => {
-                        ad(this.d, newChildren, this);
+                        a9(this.d, newChildren, this);
                         this.d = newChildren;
                         this.newChildren = undefined;
                         if (Array.isArray(c)) {
-                            const aA = c;
-                            const [e, Z, S] = aA;
-                            ar.value = S;
-                            const _ = aA[3] = (x) => e[Z] = x.target.value;
-                            ar.addEventListener('change', _);
+                            const a_ = c;
+                            const [e, X, Q] = a_;
+                            ao.value = Q;
+                            const _ = a_[3] = (v) => e[X] = v.target.value;
+                            ao.addEventListener('change', _);
                         }
                         else {
-                            ar.value = c;
+                            ao.value = c;
                         }
-                        at.value = c;
+                        ap.value = c;
                         this.refresh = aL;
                     };
                 }
             }
             this.update(props);
-            this.u = check ?? 0;
+            this.t = check ?? 0;
         }
         else {
-            this.p = props;
-            this.u = 0;
+            this.o = props;
+            this.t = 0;
         }
     }
     id;
@@ -650,22 +622,22 @@ export class aK {
     firstElement;
     attachTo(target) {
         const { parent, element, newChildren, index } = this;
-        if (!this.n++) {
-            w.delete(this);
+        if (!parent) {
+            y.delete(this);
         }
-        if (parent) {
+        else {
+            w.push({ parent, element: this });
             element.remove();
-            y.push({ parent, element: this });
         }
         this.parent = target;
         if (newChildren) {
             this.refresh(newChildren);
         }
-        let r = target.currentBefore;
-        if (r === undefined) {
-            r = target.findNextSiblingElement(index);
+        let q = target.currentBefore;
+        if (q === undefined) {
+            q = target.findNextSiblingElement(index);
         }
-        target.element.insertBefore(element, r);
+        target.element.insertBefore(element, q);
         target.currentBefore = element;
     }
     move() {
@@ -673,48 +645,38 @@ export class aK {
         if (newChildren) {
             this.refresh(newChildren);
         }
-        let r = parent.currentBefore;
-        if (r === undefined) {
-            r = parent.findNextSiblingElement(index);
+        let q = parent.currentBefore;
+        if (q === undefined) {
+            q = parent.findNextSiblingElement(index);
         }
-        parent.element.insertBefore(element, r);
+        parent.element.insertBefore(element, q);
         parent.currentBefore = element;
     }
     detachFrom(target) {
         if (this.parent === target) {
             this.element.remove();
             this.parent = undefined;
-            y.push({ parent: target, element: this });
-        }
-        else {
-            if (!--this.n) {
-                if (A) {
-                    w.add(this);
-                }
-                else {
-                    this.release();
-                }
-            }
+            w.push({ parent: target, element: this });
         }
     }
     update(props, children) {
-        const { element, p, u } = this;
-        if (p && u) {
-            this.p = props;
-            let k = u;
+        const { element, o, t } = this;
+        if (o && t) {
+            this.o = props;
+            let k = t;
             for (const key in props) {
                 const c = props[key];
-                const g = p[key];
+                const g = o[key];
                 if (c !== g) {
                     if (c !== null && c !== undefined) {
                         switch (typeof c) {
                             case 'string': {
-                                const a0 = V[key];
-                                if (!a0) {
+                                const Y = V[key];
+                                if (!Y) {
                                     element[key] = c;
                                 }
                                 else {
-                                    element.setAttribute(a0, c);
+                                    element.setAttribute(Y, c);
                                 }
                                 break;
                             }
@@ -726,24 +688,24 @@ export class aK {
                             }
                             default: {
                                 if (Array.isArray(c)) {
-                                    const [e, Z, S] = c;
+                                    const [e, X, Q] = c;
                                     if (g) {
-                                        const [aM, aN, aO, aB] = g;
-                                        if (aO !== S && element[key] !== S) {
-                                            element[key] = S;
+                                        const [aM, aN, aO, aA] = g;
+                                        if (aO !== Q && element[key] !== Q) {
+                                            element[key] = Q;
                                         }
-                                        if (aM === e && aN === Z) {
-                                            c[3] = aB;
+                                        if (aM === e && aN === X) {
+                                            c[3] = aA;
                                         }
                                         else {
-                                            const _ = c[3] = (x) => e[Z] = x.target[key];
-                                            element.removeEventListener('change', aB);
+                                            const _ = c[3] = (v) => e[X] = v.target[key];
+                                            element.removeEventListener('change', aA);
                                             element.addEventListener('change', _);
                                         }
                                     }
                                     else {
-                                        element[key] = S;
-                                        const _ = c[3] = (x) => e[Z] = x.target[key];
+                                        element[key] = Q;
+                                        const _ = c[3] = (v) => e[X] = v.target[key];
                                         element.addEventListener('change', _);
                                     }
                                     break;
@@ -751,40 +713,40 @@ export class aK {
                                 if (key === 'style') {
                                     if (!g) {
                                         const style = element.style;
-                                        const s = {};
+                                        const r = {};
                                         let k = 0;
                                         for (const l in c) {
-                                            const a1 = c[l];
-                                            s[l] = a1;
+                                            const Z = c[l];
+                                            r[l] = Z;
                                             k++;
-                                            style[l] = a1;
+                                            style[l] = Z;
                                         }
-                                        props[key] = s;
-                                        s.k = k;
+                                        props[key] = r;
+                                        r.k = k;
                                         break;
                                     }
                                     const style = element.style;
-                                    const s = {};
+                                    const r = {};
                                     let k = 0;
-                                    let J = g.k;
+                                    let H = g.k;
                                     for (const l in c) {
-                                        const K = c[l];
-                                        s[l] = K;
+                                        const I = c[l];
+                                        r[l] = I;
                                         if (l in g) {
-                                            J--;
+                                            H--;
                                         }
                                         k++;
-                                        if (K !== g[key]) {
-                                            style[l] = K;
+                                        if (I !== g[key]) {
+                                            style[l] = I;
                                         }
                                     }
-                                    props[key] = s;
-                                    s.k = k;
-                                    if (J) {
+                                    props[key] = r;
+                                    r.k = k;
+                                    if (H) {
                                         for (const l in g) {
                                             if (!(l in c)) {
                                                 style[l] = null;
-                                                if (!--J) {
+                                                if (!--H) {
                                                     break;
                                                 }
                                             }
@@ -799,12 +761,12 @@ export class aK {
                     else {
                         switch (typeof g) {
                             case 'string': {
-                                const a0 = V[key];
-                                if (!a0) {
+                                const Y = V[key];
+                                if (!Y) {
                                     this.element[key] = c;
                                 }
                                 else {
-                                    this.element.removeAttribute(a0);
+                                    this.element.removeAttribute(Y);
                                 }
                                 break;
                             }
@@ -813,7 +775,7 @@ export class aK {
                                     if (Array.isArray(g)) {
                                         element.removeEventListener('change', g[3]);
                                     }
-                                    else if (g === X) {
+                                    else if (g === a3) {
                                         element[key] = c;
                                     }
                                 }
@@ -834,7 +796,7 @@ export class aK {
             }
         }
         if (children) {
-            const newChildren = ac(this.d, children, this);
+            const newChildren = a8(this.d, children, this);
             if (newChildren) {
                 this.newChildren = newChildren;
                 return true;
@@ -843,21 +805,20 @@ export class aK {
         return false;
     }
     refresh(newChildren) {
-        ad(this.d, newChildren, this);
+        a9(this.d, newChildren, this);
         this.d = newChildren;
         this.newChildren = undefined;
     }
     release(target) {
-        if (target && this.parent === target) {
-            this.element.remove();
-            this.parent = undefined;
-        }
-        if (--this.n <= 0) {
+        if (this.parent === target) {
+            if (target) {
+                this.element.remove();
+            }
             const { d } = this;
             for (const a of d) {
                 a.release(this);
             }
-            o.delete(this.id);
+            n.delete(this.id);
         }
     }
     findNextSiblingElement(index) {
@@ -874,17 +835,17 @@ export class aK {
         }
         return null;
     }
-    a9() {
+    a5() {
         this.update = this.aP;
     }
     aP(props, children) {
-        const { element, p, u } = this;
-        if (p && u) {
-            this.p = props;
-            let k = u;
+        const { element, o, t } = this;
+        if (o && t) {
+            this.o = props;
+            let k = t;
             for (const key in props) {
                 const c = props[key];
-                const g = p[key];
+                const g = o[key];
                 if (c !== g) {
                     if (c !== null && c !== undefined) {
                         switch (typeof c) {
@@ -905,40 +866,40 @@ export class aK {
                                 if (key === 'style') {
                                     if (!g) {
                                         const style = element.style;
-                                        const s = {};
+                                        const r = {};
                                         let k = 0;
                                         for (const l in c) {
-                                            const a1 = c[l];
-                                            s[l] = a1;
+                                            const Z = c[l];
+                                            r[l] = Z;
                                             k++;
-                                            style[l] = a1;
+                                            style[l] = Z;
                                         }
-                                        props[key] = s;
-                                        s.k = k;
+                                        props[key] = r;
+                                        r.k = k;
                                         break;
                                     }
                                     const style = element.style;
-                                    const s = {};
+                                    const r = {};
                                     let k = 0;
-                                    let J = g.k;
+                                    let H = g.k;
                                     for (const l in c) {
-                                        const K = c[l];
-                                        s[l] = K;
+                                        const I = c[l];
+                                        r[l] = I;
                                         if (l in g) {
-                                            J--;
+                                            H--;
                                         }
                                         k++;
-                                        if (K !== g[key]) {
-                                            style[l] = K;
+                                        if (I !== g[key]) {
+                                            style[l] = I;
                                         }
                                     }
-                                    props[key] = s;
-                                    s.k = k;
-                                    if (J) {
+                                    props[key] = r;
+                                    r.k = k;
+                                    if (H) {
                                         for (const l in g) {
                                             if (!(l in c)) {
                                                 style[l] = null;
-                                                if (!--J) {
+                                                if (!--H) {
                                                     break;
                                                 }
                                             }
@@ -971,7 +932,7 @@ export class aK {
             }
         }
         if (children) {
-            const newChildren = ac(this.d, children, this);
+            const newChildren = a8(this.d, children, this);
             if (newChildren) {
                 this.newChildren = newChildren;
                 return true;
@@ -979,26 +940,21 @@ export class aK {
         }
         return false;
     }
-    n;
-    p;
+    o;
     d;
-    u;
+    t;
 }
-export class an {
-    constructor(id, parentCom, entry, props, children, check, mutableChild) {
+export class aB {
+    constructor(id, entry, props, children, check, mutableChild) {
         this.id = id;
-        this.parentCom = parentCom;
-        this.parent = undefined;
         this.index = 0;
-        this.version = 0;
-        this.n = 0;
+        this.version = 1;
         this.aC = entry;
-        this.p = props;
-        this.newChildren = this.d = mutableChild ? Q(children) : (children || Y);
-        this.u = check ?? 0;
+        this.o = props;
+        this.newChildren = this.d = mutableChild ? N(children) : (children || W);
+        this.t = check ?? 0;
     }
     id;
-    parentCom;
     parent;
     newChildren;
     index;
@@ -1016,11 +972,11 @@ export class an {
             j.index = this.index;
             j.attachTo(target);
         }
-        if (!this.n++) {
-            w.delete(this);
+        if (!parent) {
+            y.delete(this);
         }
-        if (parent) {
-            y.push({ parent, element: this });
+        else {
+            w.push({ parent, element: this });
         }
     }
     move() {
@@ -1037,33 +993,23 @@ export class an {
         if (this.parent === target) {
             this.j?.detachFrom(target);
             this.parent = undefined;
-            y.push({ parent: target, element: this });
-        }
-        else {
-            if (!--this.n) {
-                if (A) {
-                    w.add(this);
-                }
-                else {
-                    this.release();
-                }
-            }
+            w.push({ parent: target, element: this });
         }
     }
     update(props, children) {
-        const { p, d, u } = this;
-        this.p = props;
+        const { o, d, t } = this;
+        this.o = props;
         if (children) {
-            const newChildren = ac(d, children, this.parent);
+            const newChildren = a8(d, children, this.parent);
             if (newChildren) {
                 this.newChildren = newChildren;
                 return true;
             }
         }
-        if (!this.newChildren && u) {
-            let k = u;
-            for (const key in p) {
-                if (p[key] !== props[key]) {
+        if (!this.newChildren && t) {
+            let k = t;
+            for (const key in o) {
+                if (o[key] !== props[key]) {
                     this.newChildren = d;
                     return true;
                 }
@@ -1076,38 +1022,38 @@ export class an {
     }
     refresh(newChildren) {
         const { id, parent, j, index } = this;
-        const aR = q;
-        q = this;
-        let v = this.aC(this.p || X, newChildren);
-        if (v !== j) {
-            switch (typeof v) {
+        const aR = p;
+        p = this;
+        let u = this.aC(this.o || a3, newChildren);
+        if (u !== j) {
+            switch (typeof u) {
                 case 'boolean':
                 case 'number':
                 case 'bigint':
-                    v = '' + v;
+                    u = '' + u;
                 case 'string':
-                    v = new ao('', v);
-                    this.j = v;
-                    v.index = index;
-                    v.attachTo(parent);
+                    u = new al('', u);
+                    this.j = u;
+                    u.index = index;
+                    u.attachTo(parent);
                     j?.detachFrom(parent);
                     break;
                 default:
-                    if (v) {
-                        this.j = v;
-                        v.index = index;
-                        v.attachTo(parent);
+                    if (u) {
+                        this.j = u;
+                        u.index = index;
+                        u.attachTo(parent);
                         j?.detachFrom(parent);
-                        if (!a7.a4()) {
-                            a7.a5((a2, com) => {
-                                if (!a2.startsWith(id)) {
-                                    return U;
+                        if (!a4.ae()) {
+                            a4.af((a0, com) => {
+                                if (!a0.startsWith(id)) {
+                                    return R;
                                 }
-                                if (com.parent && am(com.parent)) {
-                                    G.C(a2, com);
-                                    return L;
+                                if (com.parent && ak(com.parent)) {
+                                    G.A(a0, com);
+                                    return S;
                                 }
-                                return a3;
+                                return a1;
                             }, id);
                         }
                     }
@@ -1129,18 +1075,16 @@ export class an {
         }
         this.d = newChildren;
         this.newChildren = undefined;
-        q = aR;
+        p = aR;
     }
     release(target) {
-        if (target && this.parent === target) {
-            this.j?.detachFrom(target);
+        if (this.parent === target) {
+            this.j?.release(target);
             this.parent = undefined;
-        }
-        if (--this.n <= 0) {
             if (this.newChildren) {
-                a7.delete(this.id);
+                a4.delete(this.id);
             }
-            o.delete(this.id);
+            n.delete(this.id);
         }
     }
     markChanged() {
@@ -1150,22 +1094,21 @@ export class an {
         }
         return false;
     }
-    watchMountChange(aS, _, D) {
-        const ab = ay(this.parent, this.id);
-        ai.C(ab + aS, { _, D }, true);
+    watchMountChange(aS, _, B) {
+        const a7 = ax(this.parent, this.id);
+        ag.A(a7 + aS, { _, B }, true);
     }
-    n;
     aC;
-    p;
+    o;
     d;
-    u;
+    t;
     j;
 }
-class a8 {
+class ah {
     constructor(id, rootElement) {
         this.id = id;
         this.element = rootElement;
-        this.currentBefore = undefined;
+        this.parent = this;
     }
     id;
     element;
@@ -1175,121 +1118,121 @@ class a8 {
         return null;
     }
     render(entry) {
-        if (!this.ah) {
-            this.ah = new an(this.id, aj, entry, null, Y);
-            o.set(this.id, this.ah);
-            this.ah.attachTo(this);
-            N++;
+        if (!this.ad) {
+            this.ad = new aB(this.id, entry, null, W);
+            n.set(this.id, this.ad);
+            this.ad.attachTo(this);
+            L++;
         }
     }
-    ah;
+    ad;
 }
 export const addComReader = (readerRecord, key) => {
-    if (q.id) {
-        let I = readerRecord[key];
-        if (!I) {
-            I = new Map();
-            readerRecord[key] = I;
+    if (p.id) {
+        let F = readerRecord[key];
+        if (!F) {
+            F = new Map();
+            readerRecord[key] = F;
         }
-        I.set(q.id, q.version);
+        F.set(p.id, p.version);
     }
 };
 export let refreshComReaders = (readerRecord, key) => {
-    const I = readerRecord[key];
-    if (I) {
-        for (const [a2, version] of I) {
-            const com = o.get(a2);
+    const F = readerRecord[key];
+    if (F) {
+        for (const [a0, version] of F) {
+            const com = n.get(a0);
             if (com?.version === version && com.markChanged()) {
-                if (G.a4()) {
+                if (G.ae()) {
                     queueMicrotask(aG);
                 }
-                G.C(a2, com);
+                G.A(a0, com);
             }
         }
-        I.clear();
+        F.clear();
     }
 };
 export const aD = (replace) => refreshComReaders = replace;
 export const configGC = (waitIntervals, interval = 20000) => {
     if (waitIntervals >= 0 && interval >= 1000) {
-        ak = interval;
-        if (A) {
-            clearTimeout(M);
+        ai = interval;
+        if (J) {
+            clearTimeout(K);
         }
         if (waitIntervals) {
-            M = setTimeout(al, ak);
+            K = setTimeout(aj, ai);
         }
-        else if (M) {
-            M = undefined;
-            for (let b = 0; b < A; b++) {
-                al();
+        else if (K) {
+            K = undefined;
+            for (let b = 0; b < J; b++) {
+                aj();
             }
         }
-        A = waitIntervals;
+        J = waitIntervals;
         return true;
     }
     return false;
 };
 const aT = () => {
-    F = av.pop();
+    D = at.pop();
 };
 export var $ezh;
 (function ($ezh) {
     $ezh.render = (rootElement, entry) => {
-        const id = (au.length || '') + '|';
-        const aE = new a8(id, rootElement);
-        au.push(aE);
+        const id = (ar.length || '') + '|';
+        const aE = new ah(id, rootElement);
+        ar.push(aE);
         aE.render(entry);
     };
     $ezh.$ = (id, tag, props, children, check, mutableChild) => {
-        const m = `${q.id}${id}${F}`;
-        let element = o.get(m);
+        const m = `${p.id}${id}${D}`;
+        let element = n.get(m);
         if (element) {
             if ((props || children) && element.update(props, children)) {
-                G.C(m, element);
+                G.A(m, element);
             }
             return element;
         }
         element = new aK(m, tag, props, children, check, mutableChild);
-        o.set(m, element);
+        n.set(m, element);
         return element;
     };
     $ezh.$c = (id, entry, props, children, check, mutableChild) => {
-        const m = `${q.id}${id}${F}`;
-        let element = o.get(m);
+        const m = `${p.id}${id}${D}`;
+        let element = n.get(m);
         if (element) {
             if ((props || children) && element.update(props, children)) {
-                G.C(m, element);
+                G.A(m, element);
             }
             return element;
         }
-        element = new an(m, q, entry, props, children, check, mutableChild);
-        o.set(m, element);
+        element = new aB(m, entry, props, children, check, mutableChild);
+        n.set(m, element);
         return element;
     };
     $ezh.$f = (id, children, mutableChild) => {
-        const m = `${q.id}${id}${F}`;
-        let element = o.get(m);
+        const m = `${p.id}${id}${D}`;
+        let element = n.get(m);
         if (element) {
             if (children && element.update(null, children)) {
-                G.C(m, element);
+                G.A(m, element);
             }
             return element;
         }
         element = new aI(m, children, mutableChild);
-        o.set(m, element);
+        n.set(m, element);
         return element;
     };
     $ezh.$k = (key) => {
-        av.push(F);
-        F = `${F || '{'}${key}}`;
+        at.push(D);
+        D = `${D || '{'}${key}}`;
         return aT;
     };
     $ezh.$n = (ns) => {
-        const aU = aa;
-        aa = ax[ns];
+        const aU = a6;
+        a6 = aw[ns];
         return () => {
-            aa = aU;
+            a6 = aU;
         };
     };
     $ezh.$s = (cb, element) => {
@@ -1297,16 +1240,16 @@ export var $ezh;
         return element;
     };
     $ezh.$t = (id, text, mayChange) => {
-        const m = `${q.id}${id}${F}`;
-        let element = o.get(m);
+        const m = `${p.id}${id}${D}`;
+        let element = n.get(m);
         if (element) {
             if (mayChange) {
                 element.update(text);
             }
             return element;
         }
-        element = new ao(m, text);
-        o.set(element.id, element);
+        element = new al(m, text);
+        n.set(element.id, element);
         return element;
     };
 })($ezh || ($ezh = {}));