ezh 0.1.4 → 0.1.5

package/lib/elements.js

@@ -1,4 +1,4 @@
-import { a3, U, S, W } from './RbTree';
+import { a1, S, R, U } from './RbTree';
 const V = {
     'ariaAtomic': 'aria-atomic',
     'ariaAutoComplete': 'aria-autocomplete',
@@ -92,126 +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 a5 = new W();
-const ai = new W();
-const av = [];
-const aw = [];
-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 ax = 0;
-let L = undefined;
-const I = new W();
-export const o = new Map();
-export let q = aj;
-export let M = 0;
-const aG = (z, aW) => {
-    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 a8 = aG;
-const ay = {
-    'svg': (z, N) => {
-        N.a7();
-        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, N) => {
-        N.a7();
-        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, N) => {
-        if (z !== 'foreignObject') {
-            return document.createElement(z);
+    'foreignObject': (x, M) => {
+        if (x !== 'foreignObject') {
+            return document.createElement(x);
         }
-        N.a7();
-        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 (++ax >= 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 (--ax < A) {
-                    w.add(element);
+                if (--av < J) {
+                    y.add(element);
                     break;
                 }
             }
         }
     }
     else {
-        w.add(Object.create(aj));
+        y.add(Object.create(au));
     }
-    if (L) {
-        L = setTimeout(al, ak);
+    if (K) {
+        K = setTimeout(aj, ai);
     }
 };
-const az = (parent, m) => {
-    const a$ = ['', m];
-    while (parent.constructor !== a6) {
-        a$.push(parent.id);
+const ax = (parent, m) => {
+    const ay = ['', m];
+    while (parent.constructor !== ah) {
+        ay.push(parent.id);
         parent = parent.parent;
     }
-    return a$.reverse().join(',');
+    return ay.reverse().join(',');
 };
-const aH = () => {
+const aG = () => {
     let element;
-    while (element = I.au(true)) {
+    while (element = G.aq(true)) {
         const { id, newChildren, parent } = element;
         if (newChildren) {
-            if (parent && am(parent)) {
+            if (parent && ak(parent)) {
                 element.refresh(newChildren);
                 parent.currentBefore = undefined;
             }
-            else if (element.constructor === an) {
-                a5.C(id, element);
+            else if (element.version) {
+                a4.A(id, element);
             }
         }
     }
-    M++;
-    for (const { parent, element } of y) {
-        element.detachFrom(X);
+    L++;
+    for (const { parent, element } of w) {
         if (element.parent !== parent) {
-            if (!ai.ag() && am(parent)) {
-                const a4 = !element.parent;
-                const a9 = az(parent, element.id);
-                ai.ah((key, value) => {
-                    if (key.startsWith(a9)) {
-                        value._(value.D, a4);
-                        return U;
+            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 S;
-                }, a9);
+                    return R;
+                }, a7);
+            }
+        }
+        if (!element.parent) {
+            if (J) {
+                y.add(element);
+            }
+            else {
+                element.release();
             }
         }
     }
-    y.length = 0;
+    w.length = 0;
 };
-const O = (children, f = [], from = 0) => {
+const N = (children, f = [], from = 0) => {
     let a = children[from];
     for (;;) {
         if (a && a.id !== undefined) {
@@ -220,7 +226,7 @@ const O = (children, f = [], from = 0) => {
         else if (a !== null && a !== undefined) {
             switch (typeof a) {
                 case 'object':
-                    O(a, f);
+                    N(a, f);
                     break;
                 case 'function':
                     a = a();
@@ -230,7 +236,7 @@ const O = (children, f = [], from = 0) => {
                 case 'bigint':
                     a = '' + a;
                 default:
-                    f.push(new ao('', a));
+                    f.push(new al('', a));
             }
         }
         if (++from < children.length) {
@@ -242,93 +248,93 @@ const O = (children, f = [], from = 0) => {
     }
     return f;
 };
-const aa = (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 = O(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 ? O(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 === a6) {
+        if (parent.parent === parent) {
             return true;
         }
         parent = parent.parent;
     } while (parent);
     return false;
 };
-const ab = (B, newChildren, parent, aI) => {
+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 aA = i - a.index;
-                if (aA === b) {
-                    t.G++;
+                const a$ = i - a.index;
+                if (a$ === b) {
+                    s.E++;
                     a.index = i;
                 }
                 else {
-                    t = {
+                    s = {
                         from: a.index,
                         to: i,
-                        G: 1,
+                        E: 1,
                     };
-                    b = aA;
-                    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.G;
+                s = am[-a.index - 1];
+                an.push(s);
+                i -= s.E;
             }
             else {
                 a.detachFrom(parent);
                 i--;
             }
         }
-        let Q;
-        let ac;
-        let ad = 0;
+        let O;
+        let aa;
+        let ab = 0;
         i = newChildren.length - 1;
         while (i >= 0) {
             a = newChildren[i];
@@ -337,32 +343,32 @@ const ab = (B, newChildren, parent, aI) => {
                 a.attachTo(parent);
             }
             else {
-                t = ap[-a.index - 1];
-                ac = t.G;
-                Q = aq[ad];
+                s = am[-a.index - 1];
+                aa = s.E;
+                O = an[ab];
                 a.index = i;
-                if (!aI) {
-                    if (Q === t) {
-                        ad++;
-                        i -= t.G;
+                if (!aH) {
+                    if (O === s) {
+                        ab++;
+                        i -= s.E;
                         parent.currentBefore = undefined;
                         continue;
                     }
-                    if (Q.from > t.from) {
-                        b = ad;
+                    if (O.from > s.from) {
+                        b = ab;
                         do {
-                            ac -= Q.G;
-                            Q = aq[++b];
-                        } while (Q.from > t.from && ac > 0);
-                        if (ac > 0) {
-                            i -= t.G;
+                            aa -= O.E;
+                            O = an[++b];
+                        } while (O.from > s.from && aa > 0);
+                        if (aa > 0) {
+                            i -= s.E;
                             parent.currentBefore = undefined;
-                            ad = b;
+                            ab = b;
                             continue;
                         }
                     }
                 }
-                b = i - t.G;
+                b = i - s.E;
                 do {
                     a.move();
                 } while (--i > b && (a = newChildren[i]));
@@ -380,13 +386,11 @@ const ab = (B, newChildren, parent, aI) => {
     }
     parent.currentBefore = undefined;
 };
-class ao {
+class al {
     constructor(id, text) {
         this.id = id;
-        this.parent = undefined;
         this.index = 0;
-        this.n = 0;
-        this.ae = text;
+        this.ac = text;
     }
     id;
     parent;
@@ -394,33 +398,33 @@ class ao {
     firstElement;
     attachTo(target) {
         if (!this.firstElement) {
-            this.firstElement = document.createTextNode(this.ae);
+            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) {
@@ -428,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.ae !== text) {
-            this.ae = text;
+        if (this.ac !== text) {
+            this.ac = text;
             if (this.firstElement) {
                 this.firstElement.nodeValue = text;
             }
@@ -453,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;
-    ae;
+    ac;
 }
-export class aJ {
-    constructor(id, children, aK) {
+export class aI {
+    constructor(id, children, aJ) {
         this.id = id;
-        this.parent = undefined;
         this.index = 0;
-        this.n = 0;
-        this.newChildren = this.d = aK ? O(children) : (children || Y);
-        this.currentBefore = undefined;
+        this.newChildren = this.d = aJ ? N(children) : (children || W);
     }
     id;
     parent;
@@ -493,11 +482,11 @@ export class aJ {
     }
     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);
             }
@@ -517,7 +506,7 @@ export class aJ {
     move() {
         const { d, newChildren } = this;
         if (newChildren) {
-            ab(d, newChildren, this, true);
+            a9(d, newChildren, this, true);
             this.d = newChildren;
             this.newChildren = undefined;
         }
@@ -535,22 +524,12 @@ export class aJ {
                 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 = aa(this.d, children, this);
+            const newChildren = a8(this.d, children, this);
             if (newChildren) {
                 this.newChildren = newChildren;
                 return true;
@@ -559,20 +538,19 @@ export class aJ {
         return false;
     }
     refresh(newChildren) {
-        ab(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) {
@@ -590,53 +568,49 @@ export class aJ {
         h = this.parent.currentBefore;
         return h !== undefined ? h : this.parent.findNextSiblingElement(this.index);
     }
-    n;
     d;
 }
-export class aL {
+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 = a8(tag, this);
-        this.newChildren = this.d = mutableChild ? O(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;
-                    const aM = this.refresh;
+                    ap.value = undefined;
+                    const aL = this.refresh;
                     this.refresh = (newChildren) => {
-                        ab(this.d, newChildren, this);
+                        a9(this.d, newChildren, this);
                         this.d = newChildren;
                         this.newChildren = undefined;
                         if (Array.isArray(c)) {
-                            const aB = c;
-                            const [e, Z, R] = aB;
-                            ar.value = R;
-                            const _ = aB[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;
-                        this.refresh = aM;
+                        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;
@@ -648,22 +622,22 @@ export class aL {
     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() {
@@ -671,48 +645,38 @@ export class aL {
         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;
                             }
@@ -724,24 +688,24 @@ export class aL {
                             }
                             default: {
                                 if (Array.isArray(c)) {
-                                    const [e, Z, R] = c;
+                                    const [e, X, Q] = c;
                                     if (g) {
-                                        const [aN, aO, aP, aC] = g;
-                                        if (aP !== R && element[key] !== R) {
-                                            element[key] = R;
+                                        const [aM, aN, aO, aA] = g;
+                                        if (aO !== Q && element[key] !== Q) {
+                                            element[key] = Q;
                                         }
-                                        if (aN === e && aO === Z) {
-                                            c[3] = aC;
+                                        if (aM === e && aN === X) {
+                                            c[3] = aA;
                                         }
                                         else {
-                                            const _ = c[3] = (x) => e[Z] = x.target[key];
-                                            element.removeEventListener('change', aC);
+                                            const _ = c[3] = (v) => e[X] = v.target[key];
+                                            element.removeEventListener('change', aA);
                                             element.addEventListener('change', _);
                                         }
                                     }
                                     else {
-                                        element[key] = R;
-                                        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;
@@ -749,40 +713,40 @@ export class aL {
                                 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;
                                                 }
                                             }
@@ -797,12 +761,12 @@ export class aL {
                     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;
                             }
@@ -811,7 +775,7 @@ export class aL {
                                     if (Array.isArray(g)) {
                                         element.removeEventListener('change', g[3]);
                                     }
-                                    else if (g === X) {
+                                    else if (g === a3) {
                                         element[key] = c;
                                     }
                                 }
@@ -832,7 +796,7 @@ export class aL {
             }
         }
         if (children) {
-            const newChildren = aa(this.d, children, this);
+            const newChildren = a8(this.d, children, this);
             if (newChildren) {
                 this.newChildren = newChildren;
                 return true;
@@ -841,21 +805,20 @@ export class aL {
         return false;
     }
     refresh(newChildren) {
-        ab(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) {
@@ -872,17 +835,17 @@ export class aL {
         }
         return null;
     }
-    a7() {
-        this.update = this.aQ;
+    a5() {
+        this.update = this.aP;
     }
-    aQ(props, children) {
-        const { element, p, u } = this;
-        if (p && u) {
-            this.p = props;
-            let k = u;
+    aP(props, children) {
+        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) {
@@ -903,40 +866,40 @@ export class aL {
                                 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;
                                                 }
                                             }
@@ -949,8 +912,8 @@ export class aL {
                         }
                     }
                     else {
-                        const aR = typeof g;
-                        switch (aR) {
+                        const aQ = typeof g;
+                        switch (aQ) {
                             case 'string':
                             case 'number':
                             case 'boolean': {
@@ -969,7 +932,7 @@ export class aL {
             }
         }
         if (children) {
-            const newChildren = aa(this.d, children, this);
+            const newChildren = a8(this.d, children, this);
             if (newChildren) {
                 this.newChildren = newChildren;
                 return true;
@@ -977,26 +940,21 @@ export class aL {
         }
         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.aD = entry;
-        this.p = props;
-        this.newChildren = this.d = mutableChild ? O(children) : (children || Y);
-        this.u = check ?? 0;
+        this.version = 1;
+        this.aC = entry;
+        this.o = props;
+        this.newChildren = this.d = mutableChild ? N(children) : (children || W);
+        this.t = check ?? 0;
     }
     id;
-    parentCom;
     parent;
     newChildren;
     index;
@@ -1014,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() {
@@ -1035,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 = aa(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;
                 }
@@ -1074,38 +1022,38 @@ export class an {
     }
     refresh(newChildren) {
         const { id, parent, j, index } = this;
-        const aS = q;
-        q = this;
-        let v = this.aD(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 (!a5.ag()) {
-                            a5.ah((a2, com) => {
-                                if (!a2.startsWith(id)) {
-                                    return S;
+                        if (!a4.ae()) {
+                            a4.af((a0, com) => {
+                                if (!a0.startsWith(id)) {
+                                    return R;
                                 }
-                                if (com.parent && am(com.parent)) {
-                                    I.C(a2, com);
-                                    return U;
+                                if (com.parent && ak(com.parent)) {
+                                    G.A(a0, com);
+                                    return S;
                                 }
-                                return a3;
+                                return a1;
                             }, id);
                         }
                     }
@@ -1127,18 +1075,16 @@ export class an {
         }
         this.d = newChildren;
         this.newChildren = undefined;
-        q = aS;
+        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) {
-                a5.delete(this.id);
+                a4.delete(this.id);
             }
-            o.delete(this.id);
+            n.delete(this.id);
         }
     }
     markChanged() {
@@ -1148,146 +1094,145 @@ export class an {
         }
         return false;
     }
-    watchMountChange(aT, _, D) {
-        const a9 = az(this.parent, this.id);
-        ai.C(a9 + aT, { _, D }, true);
+    watchMountChange(aS, _, B) {
+        const a7 = ax(this.parent, this.id);
+        ag.A(a7 + aS, { _, B }, true);
     }
-    n;
-    aD;
-    p;
+    aC;
+    o;
     d;
-    u;
+    t;
     j;
 }
-class a6 {
+class ah {
     constructor(id, rootElement) {
         this.id = id;
         this.element = rootElement;
-        this.currentBefore = undefined;
+        this.parent = this;
     }
     id;
     element;
     parent;
     currentBefore;
-    findNextSiblingElement(aZ) {
+    findNextSiblingElement(aY) {
         return null;
     }
     render(entry) {
-        if (!this.af) {
-            this.af = new an(this.id, aj, entry, null, Y);
-            o.set(this.id, this.af);
-            this.af.attachTo(this);
-            M++;
+        if (!this.ad) {
+            this.ad = new aB(this.id, entry, null, W);
+            n.set(this.id, this.ad);
+            this.ad.attachTo(this);
+            L++;
         }
     }
-    af;
+    ad;
 }
 export const addComReader = (readerRecord, key) => {
-    if (q.id) {
-        let H = readerRecord[key];
-        if (!H) {
-            H = new Map();
-            readerRecord[key] = H;
+    if (p.id) {
+        let F = readerRecord[key];
+        if (!F) {
+            F = new Map();
+            readerRecord[key] = F;
         }
-        H.set(q.id, q.version);
+        F.set(p.id, p.version);
     }
 };
 export let refreshComReaders = (readerRecord, key) => {
-    const H = readerRecord[key];
-    if (H) {
-        for (const [a2, version] of H) {
-            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 (I.ag()) {
-                    queueMicrotask(aH);
+                if (G.ae()) {
+                    queueMicrotask(aG);
                 }
-                I.C(a2, com);
+                G.A(a0, com);
             }
         }
-        H.clear();
+        F.clear();
     }
 };
-export const aE = (replace) => refreshComReaders = replace;
+export const aD = (replace) => refreshComReaders = replace;
 export const configGC = (waitIntervals, interval = 20000) => {
     if (waitIntervals >= 0 && interval >= 1000) {
-        ak = interval;
-        if (A) {
-            clearTimeout(L);
+        ai = interval;
+        if (J) {
+            clearTimeout(K);
         }
         if (waitIntervals) {
-            L = setTimeout(al, ak);
+            K = setTimeout(aj, ai);
         }
-        else if (L) {
-            L = 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 aU = () => {
-    F = aw.pop();
+const aT = () => {
+    D = at.pop();
 };
 export var $ezh;
 (function ($ezh) {
     $ezh.render = (rootElement, entry) => {
-        const id = (av.length || '') + '|';
-        const aF = new a6(id, rootElement);
-        av.push(aF);
-        aF.render(entry);
+        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)) {
-                I.C(m, element);
+                G.A(m, element);
             }
             return element;
         }
-        element = new aL(m, tag, props, children, check, mutableChild);
-        o.set(m, element);
+        element = new aK(m, tag, props, children, check, mutableChild);
+        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)) {
-                I.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)) {
-                I.C(m, element);
+                G.A(m, element);
             }
             return element;
         }
-        element = new aJ(m, children, mutableChild);
-        o.set(m, element);
+        element = new aI(m, children, mutableChild);
+        n.set(m, element);
         return element;
     };
     $ezh.$k = (key) => {
-        aw.push(F);
-        F = `${F || '{'}${key}}`;
-        return aU;
+        at.push(D);
+        D = `${D || '{'}${key}}`;
+        return aT;
     };
     $ezh.$n = (ns) => {
-        const aV = a8;
-        a8 = ay[ns];
+        const aU = a6;
+        a6 = aw[ns];
         return () => {
-            a8 = aV;
+            a6 = aU;
         };
     };
     $ezh.$s = (cb, element) => {
@@ -1295,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 = {}));