ezh 0.1.6 → 0.2.0

package/lib/elements.js

@@ -1,5 +1,5 @@
-import { a1, S, R, U } from './RbTree';
-const V = {
+import { Z, Q, O, R } from './RbTree';
+const S = {
     'ariaAtomic': 'aria-atomic',
     'ariaAutoComplete': 'aria-autocomplete',
     'ariaBrailleLabel': 'aria-braillelabel',
@@ -92,132 +92,132 @@ const V = {
     'wordSpacing': 'word-spacing',
     'writingMode': 'writing-mode',
 };
-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 a2 = {};
+const U = [];
+Object.freeze(a2);
+Object.freeze(U);
+const A = () => false;
+const v = [];
+const x = new Set();
+const a3 = new R();
+const af = new R();
+const aq = [];
 const ar = [];
-const at = [];
-const au = {
+const at = {
     id: '',
     index: 0,
     firstElement: null,
-    attachTo: C,
-    move: C,
-    detachFrom: C,
-    update: C,
-    refresh: C,
-    release: C,
+    attachTo: A,
+    move: A,
+    detachFrom: A,
+    update: A,
+    refresh: A,
+    release: A,
     version: 1,
-    markChanged: C,
-    watchMountChange: C,
+    markChanged: A,
+    watchMountChange: A,
 };
-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 B = '';
+let ah = 20000;
+let H = 0;
+let au = 0;
+let I = undefined;
+const E = new R();
+export const m = new Map();
+export let o = at;
+export let J = 1;
+const aE = (w, aU) => {
+    return document.createElement(w);
 };
-let a6 = aF;
-const aw = {
-    'svg': (x, M) => {
-        M.a5();
-        return document.createElementNS('http://www.w3.org/2000/svg', x);
+let a5 = aE;
+const av = {
+    'svg': (w, K) => {
+        K.a4();
+        return document.createElementNS('http://www.w3.org/2000/svg', w);
     },
-    'math': (x, M) => {
-        M.a5();
-        return document.createElementNS('http://www.w3.org/1998/Math/MathML', x);
+    'math': (w, K) => {
+        K.a4();
+        return document.createElementNS('http://www.w3.org/1998/Math/MathML', w);
     },
-    'foreignObject': (x, M) => {
-        if (x !== 'foreignObject') {
-            return document.createElement(x);
+    'foreignObject': (w, K) => {
+        if (w !== 'foreignObject') {
+            return document.createElement(w);
         }
-        M.a5();
-        return document.createElementNS('http://www.w3.org/2000/svg', x);
+        K.a4();
+        return document.createElementNS('http://www.w3.org/2000/svg', w);
     },
 };
-const aj = () => {
-    if (++av >= J) {
-        for (const element of y) {
-            y.delete(element);
+const ai = () => {
+    if (++au >= H) {
+        for (const element of x) {
+            x.delete(element);
             if (element.id) {
                 element.release();
             }
             else {
-                if (--av < J) {
-                    y.add(element);
+                if (--au < H) {
+                    x.add(element);
                     break;
                 }
             }
         }
     }
     else {
-        y.add(Object.create(au));
+        x.add(Object.create(at));
     }
-    if (K) {
-        K = setTimeout(aj, ai);
+    if (I) {
+        I = setTimeout(ai, ah);
     }
 };
-const ax = (parent, m) => {
-    const ay = ['', m];
-    while (parent.constructor !== ah) {
-        ay.push(parent.id);
+const aw = (parent, l) => {
+    const ax = ['', l];
+    while (parent.constructor !== ag) {
+        ax.push(parent.id);
         parent = parent.parent;
     }
-    return ay.reverse().join(',');
+    return ax.reverse().join(',');
 };
-const aG = () => {
+const aF = () => {
     let element;
-    while (element = G.aq(true)) {
+    while (element = E.ap(true)) {
         const { id, newChildren, parent } = element;
         if (newChildren) {
-            if (parent && ak(parent)) {
+            if (parent && aj(parent)) {
                 element.refresh(newChildren);
                 parent.currentBefore = undefined;
             }
             else if (element.version) {
-                a4.A(id, element);
+                a3._(id, element);
             }
         }
     }
-    L++;
-    for (const { parent, element } of w) {
+    J++;
+    for (const { parent, element } of v) {
         if (element.parent !== parent) {
-            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;
+            if (!af.ad() && aj(parent)) {
+                const a1 = !element.parent;
+                const a6 = aw(parent, element.id);
+                af.ae((key, value) => {
+                    if (key.startsWith(a6)) {
+                        value.z(value.a0, a1);
+                        return Q;
                     }
-                    return R;
-                }, a7);
+                    return O;
+                }, a6);
             }
         }
         if (!element.parent) {
-            if (J) {
-                y.add(element);
+            if (H) {
+                x.add(element);
             }
             else {
                 element.release();
             }
         }
     }
-    w.length = 0;
+    v.length = 0;
 };
-const N = (children, f = [], from = 0) => {
+const L = (children, f = [], from = 0) => {
     let a = children[from];
     for (;;) {
         if (a && a.id !== undefined) {
@@ -226,7 +226,7 @@ const N = (children, f = [], from = 0) => {
         else if (a !== null && a !== undefined) {
             switch (typeof a) {
                 case 'object':
-                    N(a, f);
+                    L(a, f);
                     break;
                 case 'function':
                     a = a();
@@ -236,7 +236,7 @@ const N = (children, f = [], from = 0) => {
                 case 'bigint':
                     a = '' + a;
                 default:
-                    f.push(new al('', a));
+                    f.push(new ak('', a));
             }
         }
         if (++from < children.length) {
@@ -248,37 +248,37 @@ const N = (children, f = [], from = 0) => {
     }
     return f;
 };
-const a8 = (z, children, parent) => {
+const a7 = (y, children, parent) => {
     let f;
-    const length = z.length;
+    const length = y.length;
     let newChildren = children;
     let b = 0;
     while (b < length) {
-        const az = z[b];
-        if (az !== newChildren[b]) {
+        const ay = y[b];
+        if (ay !== newChildren[b]) {
             if (b === newChildren.length) {
                 return newChildren;
             }
             const a = newChildren[b];
             if (!a || a.id === undefined) {
-                newChildren = N(newChildren, newChildren.slice(0, b), b);
+                newChildren = L(newChildren, newChildren.slice(0, b), b);
                 continue;
             }
             else if (f !== newChildren) {
                 break;
             }
         }
-        if (!f && az.parent !== parent) {
-            f = z;
+        if (!f && ay.parent !== parent) {
+            f = y;
         }
         b++;
     }
     if (b === newChildren.length) {
         return f;
     }
-    return newChildren === children ? N(newChildren, z.slice(0, b), b) : newChildren;
+    return newChildren === children ? L(newChildren, y.slice(0, b), b) : newChildren;
 };
-const ak = (element) => {
+const aj = (element) => {
     let parent = element;
     do {
         if (parent.parent === parent) {
@@ -288,97 +288,97 @@ const ak = (element) => {
     } while (parent);
     return false;
 };
-const a9 = (z, newChildren, parent, aH) => {
-    let b, i;
+const a8 = (y, newChildren, parent, aG) => {
+    let b, h;
     let a;
-    if (newChildren !== z && z.length) {
-        const am = [];
-        let s;
-        i = newChildren.length;
+    if (newChildren !== y && y.length) {
+        const al = [];
+        let r;
+        h = newChildren.length;
         b = 10000000;
-        while (--i >= 0) {
-            a = newChildren[i];
+        while (--h >= 0) {
+            a = newChildren[h];
             if (a.parent === parent) {
-                const a$ = i - a.index;
-                if (a$ === b) {
-                    s.E++;
-                    a.index = i;
+                const az = h - a.index;
+                if (az === b) {
+                    r.C++;
+                    a.index = h;
                 }
                 else {
-                    s = {
+                    r = {
                         from: a.index,
-                        to: i,
-                        E: 1,
+                        to: h,
+                        C: 1,
                     };
-                    b = a$;
-                    a.index = -am.push(s);
+                    b = az;
+                    a.index = -al.push(r);
                 }
             }
             else if (b !== 10000000) {
                 b = 10000000;
             }
         }
-        const an = [];
-        i = z.length - 1;
-        while (i >= 0) {
-            a = z[i];
+        const am = [];
+        h = y.length - 1;
+        while (h >= 0) {
+            a = y[h];
             if (a.index < 0) {
-                s = am[-a.index - 1];
-                an.push(s);
-                i -= s.E;
+                r = al[-a.index - 1];
+                am.push(r);
+                h -= r.C;
             }
             else {
                 a.detachFrom(parent);
-                i--;
+                h--;
             }
         }
-        let O;
-        let aa;
-        let ab = 0;
-        i = newChildren.length - 1;
-        while (i >= 0) {
-            a = newChildren[i];
+        let M;
+        let a9;
+        let aa = 0;
+        h = newChildren.length - 1;
+        while (h >= 0) {
+            a = newChildren[h];
             if (a.parent !== parent) {
-                a.index = i--;
+                a.index = h--;
                 a.attachTo(parent);
             }
             else {
-                s = am[-a.index - 1];
-                aa = s.E;
-                O = an[ab];
-                a.index = i;
-                if (!aH) {
-                    if (O === s) {
-                        ab++;
-                        i -= s.E;
+                r = al[-a.index - 1];
+                a9 = r.C;
+                M = am[aa];
+                a.index = h;
+                if (!aG) {
+                    if (M === r) {
+                        aa++;
+                        h -= r.C;
                         parent.currentBefore = undefined;
                         continue;
                     }
-                    if (O.from > s.from) {
-                        b = ab;
+                    if (M.from > r.from) {
+                        b = aa;
                         do {
-                            aa -= O.E;
-                            O = an[++b];
-                        } while (O.from > s.from && aa > 0);
-                        if (aa > 0) {
-                            i -= s.E;
+                            a9 -= M.C;
+                            M = am[++b];
+                        } while (M.from > r.from && a9 > 0);
+                        if (a9 > 0) {
+                            h -= r.C;
                             parent.currentBefore = undefined;
-                            ab = b;
+                            aa = b;
                             continue;
                         }
                     }
                 }
-                b = i - s.E;
+                b = h - r.C;
                 do {
                     a.move();
-                } while (--i > b && (a = newChildren[i]));
+                } while (--h > b && (a = newChildren[h]));
             }
         }
     }
     else {
-        for (i = newChildren.length - 1; i >= 0; i--) {
-            a = newChildren[i];
-            a.index = i;
+        for (h = newChildren.length - 1; h >= 0; h--) {
+            a = newChildren[h];
+            a.index = h;
             if (parent !== a.parent) {
                 a.attachTo(parent);
             }
@@ -386,11 +386,11 @@ const a9 = (z, newChildren, parent, aH) => {
     }
     parent.currentBefore = undefined;
 };
-class al {
+class ak {
     constructor(id, text) {
         this.id = id;
         this.index = 0;
-        this.ac = text;
+        this.ab = text;
     }
     id;
     parent;
@@ -398,33 +398,33 @@ class al {
     firstElement;
     attachTo(target) {
         if (!this.firstElement) {
-            this.firstElement = document.createTextNode(this.ac);
+            this.firstElement = document.createTextNode(this.ab);
         }
         const { parent, firstElement, index } = this;
         if (this.id) {
             if (!parent) {
-                y.delete(this);
+                x.delete(this);
             }
             else {
-                w.push({ parent, element: this });
+                v.push({ parent, element: this });
                 firstElement.remove();
             }
         }
         this.parent = target;
-        let q = target.currentBefore;
-        if (q === undefined) {
-            q = target.findNextSiblingElement(index);
+        let p = target.currentBefore;
+        if (p === undefined) {
+            p = target.findNextSiblingElement(index);
         }
-        target.element.insertBefore(firstElement, q);
+        target.element.insertBefore(firstElement, p);
         target.currentBefore = firstElement;
     }
     move() {
         const { parent, index, firstElement } = this;
-        let q = parent.currentBefore;
-        if (q === undefined) {
-            q = parent.findNextSiblingElement(index);
+        let p = parent.currentBefore;
+        if (p === undefined) {
+            p = parent.findNextSiblingElement(index);
         }
-        parent.element.insertBefore(firstElement, q);
+        parent.element.insertBefore(firstElement, p);
         parent.currentBefore = firstElement;
     }
     detachFrom(target) {
@@ -432,13 +432,13 @@ class al {
             this.firstElement.remove();
             this.parent = undefined;
             if (this.id) {
-                w.push({ parent: target, element: this });
+                v.push({ parent: target, element: this });
             }
         }
     }
     update(text) {
-        if (this.ac !== text) {
-            this.ac = text;
+        if (this.ab !== text) {
+            this.ab = text;
             if (this.firstElement) {
                 this.firstElement.nodeValue = text;
             }
@@ -451,16 +451,16 @@ class al {
             if (target) {
                 this.firstElement.remove();
             }
-            n.delete(this.id);
+            m.delete(this.id);
         }
     }
-    ac;
+    ab;
 }
-export class aI {
-    constructor(id, children, aJ) {
+export class aH {
+    constructor(id, children, aI) {
         this.id = id;
         this.index = 0;
-        this.newChildren = this.d = aJ ? N(children) : (children || W);
+        this.newChildren = this.d = aI ? L(children) : (children || U);
     }
     id;
     parent;
@@ -473,9 +473,9 @@ export class aI {
     get firstElement() {
         const { d } = this;
         for (let b = 0; b < d.length; b++) {
-            const h = d[b].firstElement;
-            if (h) {
-                return h;
+            const e = d[b].firstElement;
+            if (e) {
+                return e;
             }
         }
         return null;
@@ -483,10 +483,10 @@ export class aI {
     attachTo(target) {
         const { parent, d, newChildren } = this;
         if (!parent) {
-            y.delete(this);
+            x.delete(this);
         }
         else {
-            w.push({ parent, element: this });
+            v.push({ parent, element: this });
             for (let b = d.length - 1; b >= 0; b--) {
                 d[b].detachFrom(this);
             }
@@ -506,7 +506,7 @@ export class aI {
     move() {
         const { d, newChildren } = this;
         if (newChildren) {
-            a9(d, newChildren, this, true);
+            a8(d, newChildren, this, true);
             this.d = newChildren;
             this.newChildren = undefined;
         }
@@ -524,12 +524,12 @@ export class aI {
                 a.detachFrom(this);
             }
             this.parent = undefined;
-            w.push({ parent: target, element: this });
+            v.push({ parent: target, element: this });
         }
     }
-    update(o, children) {
+    update(n, children) {
         if (children) {
-            const newChildren = a8(this.d, children, this);
+            const newChildren = a7(this.d, children, this);
             if (newChildren) {
                 this.newChildren = newChildren;
                 return true;
@@ -538,7 +538,7 @@ export class aI {
         return false;
     }
     refresh(newChildren) {
-        a9(this.d, newChildren, this);
+        a8(this.d, newChildren, this);
         this.d = newChildren;
         this.newChildren = undefined;
     }
@@ -550,67 +550,67 @@ export class aI {
                     a.detachFrom(this);
                 }
             }
-            n.delete(this.id);
+            m.delete(this.id);
         }
     }
     findNextSiblingElement(index) {
         const children = this.newChildren || this.d;
-        let h;
+        let e;
         let b = index + 1;
         let a = children[b];
         while (a) {
-            h = a.firstElement;
-            if (h) {
-                return h;
+            e = a.firstElement;
+            if (e) {
+                return e;
             }
             a = children[++b];
         }
-        h = this.parent.currentBefore;
-        return h !== undefined ? h : this.parent.findNextSiblingElement(this.index);
+        e = this.parent.currentBefore;
+        return e !== undefined ? e : this.parent.findNextSiblingElement(this.index);
     }
     d;
 }
-export class aK {
+export class aJ {
     constructor(id, tag, props, children, check, mutableChild) {
         this.id = id;
         this.index = 0;
-        this.firstElement = this.element = a6(tag, this);
-        this.newChildren = this.d = mutableChild ? N(children) : (children || W);
+        this.firstElement = this.element = a5(tag, this);
+        this.newChildren = this.d = mutableChild ? L(children) : (children || U);
         if (props) {
-            this.o = a3;
-            this.t = -1;
+            this.n = a2;
+            this.s = -1;
             if (tag === 'select') {
-                const ao = this.element;
-                const ap = props;
-                const c = ap.value;
+                const an = this.element;
+                const ao = props;
+                const c = ao.value;
                 if (c) {
-                    ap.value = undefined;
-                    const aL = this.refresh;
+                    ao.value = undefined;
+                    const aK = this.refresh;
                     this.refresh = (newChildren) => {
-                        a9(this.d, newChildren, this);
+                        a8(this.d, newChildren, this);
                         this.d = newChildren;
                         this.newChildren = undefined;
                         if (Array.isArray(c)) {
-                            const a_ = c;
-                            const [e, X, Q] = a_;
-                            ao.value = Q;
-                            const _ = a_[3] = (v) => e[X] = v.target.value;
-                            ao.addEventListener('change', _);
+                            const a$ = c;
+                            const [state, V, N] = a$;
+                            an.value = N;
+                            const z = a$[3] = (u) => state[V] = u.target.value;
+                            an.addEventListener('change', z);
                         }
                         else {
-                            ao.value = c;
+                            an.value = c;
                         }
-                        ap.value = c;
-                        this.refresh = aL;
+                        ao.value = c;
+                        this.refresh = aK;
                     };
                 }
             }
             this.update(props);
-            this.t = check ?? 0;
+            this.s = check ?? 0;
         }
         else {
-            this.o = props;
-            this.t = 0;
+            this.n = props;
+            this.s = 0;
         }
     }
     id;
@@ -623,21 +623,21 @@ export class aK {
     attachTo(target) {
         const { parent, element, newChildren, index } = this;
         if (!parent) {
-            y.delete(this);
+            x.delete(this);
         }
         else {
-            w.push({ parent, element: this });
+            v.push({ parent, element: this });
             element.remove();
         }
         this.parent = target;
         if (newChildren) {
             this.refresh(newChildren);
         }
-        let q = target.currentBefore;
-        if (q === undefined) {
-            q = target.findNextSiblingElement(index);
+        let p = target.currentBefore;
+        if (p === undefined) {
+            p = target.findNextSiblingElement(index);
         }
-        target.element.insertBefore(element, q);
+        target.element.insertBefore(element, p);
         target.currentBefore = element;
     }
     move() {
@@ -645,38 +645,38 @@ export class aK {
         if (newChildren) {
             this.refresh(newChildren);
         }
-        let q = parent.currentBefore;
-        if (q === undefined) {
-            q = parent.findNextSiblingElement(index);
+        let p = parent.currentBefore;
+        if (p === undefined) {
+            p = parent.findNextSiblingElement(index);
         }
-        parent.element.insertBefore(element, q);
+        parent.element.insertBefore(element, p);
         parent.currentBefore = element;
     }
     detachFrom(target) {
         if (this.parent === target) {
             this.element.remove();
             this.parent = undefined;
-            w.push({ parent: target, element: this });
+            v.push({ parent: target, element: this });
         }
     }
     update(props, children) {
-        const { element, o, t } = this;
-        if (o && t) {
-            this.o = props;
-            let k = t;
+        const { element, n, s } = this;
+        if (n && s) {
+            this.n = props;
+            let j = s;
             for (const key in props) {
                 const c = props[key];
-                const g = o[key];
+                const g = n[key];
                 if (c !== g) {
                     if (c !== null && c !== undefined) {
                         switch (typeof c) {
                             case 'string': {
-                                const Y = V[key];
-                                if (!Y) {
+                                const W = S[key];
+                                if (!W) {
                                     element[key] = c;
                                 }
                                 else {
-                                    element.setAttribute(Y, c);
+                                    element.setAttribute(W, c);
                                 }
                                 break;
                             }
@@ -688,65 +688,65 @@ export class aK {
                             }
                             default: {
                                 if (Array.isArray(c)) {
-                                    const [e, X, Q] = c;
+                                    const [state, V, N] = c;
                                     if (g) {
-                                        const [aM, aN, aO, aA] = g;
-                                        if (aO !== Q && element[key] !== Q) {
-                                            element[key] = Q;
+                                        const [aL, aM, aN, a_] = g;
+                                        if (aN !== N && element[key] !== N) {
+                                            element[key] = N;
                                         }
-                                        if (aM === e && aN === X) {
-                                            c[3] = aA;
+                                        if (aL === state && aM === V) {
+                                            c[3] = a_;
                                         }
                                         else {
-                                            const _ = c[3] = (v) => e[X] = v.target[key];
-                                            element.removeEventListener('change', aA);
-                                            element.addEventListener('change', _);
+                                            const z = c[3] = (u) => state[V] = u.target[key];
+                                            element.removeEventListener('change', a_);
+                                            element.addEventListener('change', z);
                                         }
                                     }
                                     else {
-                                        element[key] = Q;
-                                        const _ = c[3] = (v) => e[X] = v.target[key];
-                                        element.addEventListener('change', _);
+                                        element[key] = N;
+                                        const z = c[3] = (u) => state[V] = u.target[key];
+                                        element.addEventListener('change', z);
                                     }
                                     break;
                                 }
                                 if (key === 'style') {
                                     if (!g) {
                                         const style = element.style;
-                                        const r = {};
-                                        let k = 0;
-                                        for (const l in c) {
-                                            const Z = c[l];
-                                            r[l] = Z;
-                                            k++;
-                                            style[l] = Z;
+                                        const q = {};
+                                        let j = 0;
+                                        for (const k in c) {
+                                            const X = c[k];
+                                            q[k] = X;
+                                            j++;
+                                            style[k] = X;
                                         }
-                                        props[key] = r;
-                                        r.k = k;
+                                        props[key] = q;
+                                        q.j = j;
                                         break;
                                     }
                                     const style = element.style;
-                                    const r = {};
-                                    let k = 0;
-                                    let H = g.k;
-                                    for (const l in c) {
-                                        const I = c[l];
-                                        r[l] = I;
-                                        if (l in g) {
-                                            H--;
+                                    const q = {};
+                                    let j = 0;
+                                    let F = g.j;
+                                    for (const k in c) {
+                                        const G = c[k];
+                                        q[k] = G;
+                                        if (k in g) {
+                                            F--;
                                         }
-                                        k++;
-                                        if (I !== g[key]) {
-                                            style[l] = I;
+                                        j++;
+                                        if (G !== g[key]) {
+                                            style[k] = G;
                                         }
                                     }
-                                    props[key] = r;
-                                    r.k = k;
-                                    if (H) {
-                                        for (const l in g) {
-                                            if (!(l in c)) {
-                                                style[l] = null;
-                                                if (!--H) {
+                                    props[key] = q;
+                                    q.j = j;
+                                    if (F) {
+                                        for (const k in g) {
+                                            if (!(k in c)) {
+                                                style[k] = null;
+                                                if (!--F) {
                                                     break;
                                                 }
                                             }
@@ -761,12 +761,12 @@ export class aK {
                     else {
                         switch (typeof g) {
                             case 'string': {
-                                const Y = V[key];
-                                if (!Y) {
+                                const W = S[key];
+                                if (!W) {
                                     this.element[key] = c;
                                 }
                                 else {
-                                    this.element.removeAttribute(Y);
+                                    this.element.removeAttribute(W);
                                 }
                                 break;
                             }
@@ -775,7 +775,7 @@ export class aK {
                                     if (Array.isArray(g)) {
                                         element.removeEventListener('change', g[3]);
                                     }
-                                    else if (g === a3) {
+                                    else if (g === a2) {
                                         element[key] = c;
                                     }
                                 }
@@ -790,13 +790,13 @@ export class aK {
                         }
                     }
                 }
-                if (!--k) {
+                if (!--j) {
                     break;
                 }
             }
         }
         if (children) {
-            const newChildren = a8(this.d, children, this);
+            const newChildren = a7(this.d, children, this);
             if (newChildren) {
                 this.newChildren = newChildren;
                 return true;
@@ -805,7 +805,7 @@ export class aK {
         return false;
     }
     refresh(newChildren) {
-        a9(this.d, newChildren, this);
+        a8(this.d, newChildren, this);
         this.d = newChildren;
         this.newChildren = undefined;
     }
@@ -818,44 +818,44 @@ export class aK {
             for (const a of d) {
                 a.release(this);
             }
-            n.delete(this.id);
+            m.delete(this.id);
         }
     }
     findNextSiblingElement(index) {
         const children = this.newChildren || this.d;
-        let h;
+        let e;
         let b = index + 1;
         let a = children[b];
         while (a) {
-            h = a.firstElement;
-            if (h) {
-                return h;
+            e = a.firstElement;
+            if (e) {
+                return e;
             }
             a = children[++b];
         }
         return null;
     }
-    a5() {
-        this.update = this.aP;
+    a4() {
+        this.update = this.aO;
     }
-    aP(props, children) {
-        const { element, o, t } = this;
-        if (o && t) {
-            this.o = props;
-            let k = t;
+    aO(props, children) {
+        const { element, n, s } = this;
+        if (n && s) {
+            this.n = props;
+            let j = s;
             for (const key in props) {
                 const c = props[key];
-                const g = o[key];
+                const g = n[key];
                 if (c !== g) {
                     if (c !== null && c !== undefined) {
                         switch (typeof c) {
                             case 'string': {
-                                element.setAttribute(V[key] ?? key, c);
+                                element.setAttribute(S[key] ?? key, c);
                                 break;
                             }
                             case 'number':
                             case 'boolean': {
-                                element.setAttribute(V[key] ?? key, '' + c);
+                                element.setAttribute(S[key] ?? key, '' + c);
                                 break;
                             }
                             case 'function': {
@@ -866,40 +866,40 @@ export class aK {
                                 if (key === 'style') {
                                     if (!g) {
                                         const style = element.style;
-                                        const r = {};
-                                        let k = 0;
-                                        for (const l in c) {
-                                            const Z = c[l];
-                                            r[l] = Z;
-                                            k++;
-                                            style[l] = Z;
+                                        const q = {};
+                                        let j = 0;
+                                        for (const k in c) {
+                                            const X = c[k];
+                                            q[k] = X;
+                                            j++;
+                                            style[k] = X;
                                         }
-                                        props[key] = r;
-                                        r.k = k;
+                                        props[key] = q;
+                                        q.j = j;
                                         break;
                                     }
                                     const style = element.style;
-                                    const r = {};
-                                    let k = 0;
-                                    let H = g.k;
-                                    for (const l in c) {
-                                        const I = c[l];
-                                        r[l] = I;
-                                        if (l in g) {
-                                            H--;
+                                    const q = {};
+                                    let j = 0;
+                                    let F = g.j;
+                                    for (const k in c) {
+                                        const G = c[k];
+                                        q[k] = G;
+                                        if (k in g) {
+                                            F--;
                                         }
-                                        k++;
-                                        if (I !== g[key]) {
-                                            style[l] = I;
+                                        j++;
+                                        if (G !== g[key]) {
+                                            style[k] = G;
                                         }
                                     }
-                                    props[key] = r;
-                                    r.k = k;
-                                    if (H) {
-                                        for (const l in g) {
-                                            if (!(l in c)) {
-                                                style[l] = null;
-                                                if (!--H) {
+                                    props[key] = q;
+                                    q.j = j;
+                                    if (F) {
+                                        for (const k in g) {
+                                            if (!(k in c)) {
+                                                style[k] = null;
+                                                if (!--F) {
                                                     break;
                                                 }
                                             }
@@ -912,12 +912,12 @@ export class aK {
                         }
                     }
                     else {
-                        const aQ = typeof g;
-                        switch (aQ) {
+                        const aP = typeof g;
+                        switch (aP) {
                             case 'string':
                             case 'number':
                             case 'boolean': {
-                                element.removeAttribute(V[key] ?? key);
+                                element.removeAttribute(S[key] ?? key);
                                 break;
                             }
                             default: {
@@ -926,13 +926,13 @@ export class aK {
                         }
                     }
                 }
-                if (!--k) {
+                if (!--j) {
                     break;
                 }
             }
         }
         if (children) {
-            const newChildren = a8(this.d, children, this);
+            const newChildren = a7(this.d, children, this);
             if (newChildren) {
                 this.newChildren = newChildren;
                 return true;
@@ -940,19 +940,19 @@ export class aK {
         }
         return false;
     }
-    o;
+    n;
     d;
-    t;
+    s;
 }
-export class aB {
+export class aA {
     constructor(id, entry, props, children, check, mutableChild) {
         this.id = id;
         this.index = 0;
         this.version = 1;
-        this.aC = entry;
-        this.o = props;
-        this.newChildren = this.d = mutableChild ? N(children) : (children || W);
-        this.t = check ?? 0;
+        this.aB = entry;
+        this.n = props;
+        this.newChildren = this.d = mutableChild ? L(children) : (children || U);
+        this.s = check ?? 0;
     }
     id;
     parent;
@@ -960,60 +960,60 @@ export class aB {
     index;
     version;
     get firstElement() {
-        return this.j?.firstElement || null;
+        return this.i?.firstElement || null;
     }
     attachTo(target) {
-        const { parent, newChildren, j } = this;
+        const { parent, newChildren, i } = this;
         this.parent = target;
         if (newChildren) {
             this.refresh(newChildren);
         }
-        else if (j) {
-            j.index = this.index;
-            j.attachTo(target);
+        else if (i) {
+            i.index = this.index;
+            i.attachTo(target);
         }
         if (!parent) {
-            y.delete(this);
+            x.delete(this);
         }
         else {
-            w.push({ parent, element: this });
+            v.push({ parent, element: this });
         }
     }
     move() {
-        const { newChildren, j } = this;
+        const { newChildren, i } = this;
         if (newChildren) {
             this.refresh(newChildren);
         }
-        else if (j) {
-            j.index = this.index;
-            j.move();
+        else if (i) {
+            i.index = this.index;
+            i.move();
         }
     }
     detachFrom(target) {
         if (this.parent === target) {
-            this.j?.detachFrom(target);
+            this.i?.detachFrom(target);
             this.parent = undefined;
-            w.push({ parent: target, element: this });
+            v.push({ parent: target, element: this });
         }
     }
     update(props, children) {
-        const { o, d, t } = this;
-        this.o = props;
+        const { n, d, s } = this;
+        this.n = props;
         if (children) {
-            const newChildren = a8(d, children, this.parent);
+            const newChildren = a7(d, children, this.parent);
             if (newChildren) {
                 this.newChildren = newChildren;
                 return true;
             }
         }
-        if (!this.newChildren && t) {
-            let k = t;
-            for (const key in o) {
-                if (o[key] !== props[key]) {
+        if (!this.newChildren && s) {
+            let j = s;
+            for (const key in n) {
+                if (n[key] !== props[key]) {
                     this.newChildren = d;
                     return true;
                 }
-                if (!--k) {
+                if (!--j) {
                     break;
                 }
             }
@@ -1021,70 +1021,70 @@ export class aB {
         return false;
     }
     refresh(newChildren) {
-        const { id, parent, j, index } = this;
-        const aR = p;
-        p = this;
-        let u = this.aC(this.o || a3, newChildren);
-        if (u !== j) {
-            switch (typeof u) {
+        const { id, parent, i, index } = this;
+        const aQ = o;
+        o = this;
+        let t = this.aB(this.n || a2, newChildren);
+        if (t !== i) {
+            switch (typeof t) {
                 case 'boolean':
                 case 'number':
                 case 'bigint':
-                    u = '' + u;
+                    t = '' + t;
                 case 'string':
-                    u = new al('', u);
-                    this.j = u;
-                    u.index = index;
-                    u.attachTo(parent);
-                    j?.detachFrom(parent);
+                    t = new ak('', t);
+                    this.i = t;
+                    t.index = index;
+                    t.attachTo(parent);
+                    i?.detachFrom(parent);
                     break;
                 default:
-                    if (u) {
-                        this.j = u;
-                        u.index = index;
-                        u.attachTo(parent);
-                        j?.detachFrom(parent);
-                        if (!a4.ae()) {
-                            a4.af((a0, com) => {
-                                if (!a0.startsWith(id)) {
-                                    return R;
+                    if (t) {
+                        this.i = t;
+                        t.index = index;
+                        t.attachTo(parent);
+                        i?.detachFrom(parent);
+                        if (!a3.ad()) {
+                            a3.ae((Y, com) => {
+                                if (!Y.startsWith(id)) {
+                                    return O;
                                 }
-                                if (com.parent && ak(com.parent)) {
-                                    G.A(a0, com);
-                                    return S;
+                                if (com.parent && aj(com.parent)) {
+                                    E._(Y, com);
+                                    return Q;
                                 }
-                                return a1;
+                                return Z;
                             }, id);
                         }
                     }
                     else {
-                        this.j = undefined;
-                        j?.detachFrom(parent);
+                        this.i = undefined;
+                        i?.detachFrom(parent);
                     }
             }
         }
-        else if (j) {
-            if (j.parent !== parent) {
-                j.index = index;
-                j.attachTo(parent);
+        else if (i) {
+            if (i.parent !== parent) {
+                i.index = index;
+                i.attachTo(parent);
             }
-            else if (j.index !== index) {
-                j.index = index;
-                j.move();
+            else if (i.index !== index) {
+                i.index = index;
+                i.move();
             }
         }
         this.d = newChildren;
         this.newChildren = undefined;
-        p = aR;
+        o = aQ;
     }
     release(target) {
         if (this.parent === target) {
-            this.j?.release(target);
+            this.i?.release(target);
             this.parent = undefined;
             if (this.newChildren) {
-                a4.delete(this.id);
+                a3.delete(this.id);
             }
-            n.delete(this.id);
+            m.delete(this.id);
         }
     }
     markChanged() {
@@ -1094,17 +1094,17 @@ export class aB {
         }
         return false;
     }
-    watchMountChange(aS, _, B) {
-        const a7 = ax(this.parent, this.id);
-        ag.A(a7 + aS, { _, B }, true);
+    watchMountChange(aR, z, a0) {
+        const a6 = aw(this.parent, this.id);
+        af._(a6 + aR, { z, a0 }, true);
     }
-    aC;
-    o;
+    aB;
+    n;
     d;
-    t;
-    j;
+    s;
+    i;
 }
-class ah {
+class ag {
     constructor(id, rootElement) {
         this.id = id;
         this.element = rootElement;
@@ -1114,125 +1114,125 @@ class ah {
     element;
     parent;
     currentBefore;
-    findNextSiblingElement(aY) {
+    findNextSiblingElement(aX) {
         return null;
     }
     render(entry) {
-        if (!this.ad) {
-            this.ad = new aB(this.id, entry, null, W);
-            n.set(this.id, this.ad);
-            this.ad.attachTo(this);
-            L++;
+        if (!this.ac) {
+            this.ac = new aA(this.id, entry, null, U);
+            m.set(this.id, this.ac);
+            this.ac.attachTo(this);
+            J++;
         }
     }
-    ad;
+    ac;
 }
 export const addComReader = (readerRecord, key) => {
-    if (p.id) {
-        let F = readerRecord[key];
-        if (!F) {
-            F = new Map();
-            readerRecord[key] = F;
+    if (o.id) {
+        let D = readerRecord[key];
+        if (!D) {
+            D = new Map();
+            readerRecord[key] = D;
         }
-        F.set(p.id, p.version);
+        D.set(o.id, o.version);
     }
 };
 export let refreshComReaders = (readerRecord, key) => {
-    const F = readerRecord[key];
-    if (F) {
-        for (const [a0, version] of F) {
-            const com = n.get(a0);
+    const D = readerRecord[key];
+    if (D) {
+        for (const [Y, version] of D) {
+            const com = m.get(Y);
             if (com?.version === version && com.markChanged()) {
-                if (G.ae()) {
-                    queueMicrotask(aG);
+                if (E.ad()) {
+                    queueMicrotask(aF);
                 }
-                G.A(a0, com);
+                E._(Y, com);
             }
         }
-        F.clear();
+        D.clear();
     }
 };
-export const aD = (replace) => refreshComReaders = replace;
+export const aC = (replace) => refreshComReaders = replace;
 export const configGC = (waitIntervals, interval = 20000) => {
     if (waitIntervals >= 0 && interval >= 1000) {
-        ai = interval;
-        if (J) {
-            clearTimeout(K);
+        ah = interval;
+        if (H) {
+            clearTimeout(I);
         }
         if (waitIntervals) {
-            K = setTimeout(aj, ai);
+            I = setTimeout(ai, ah);
         }
-        else if (K) {
-            K = undefined;
-            for (let b = 0; b < J; b++) {
-                aj();
+        else if (I) {
+            I = undefined;
+            for (let b = 0; b < H; b++) {
+                ai();
             }
         }
-        J = waitIntervals;
+        H = waitIntervals;
         return true;
     }
     return false;
 };
-const aT = () => {
-    D = at.pop();
+const aS = () => {
+    B = ar.pop();
 };
 export var $ezh;
 (function ($ezh) {
     $ezh.render = (rootElement, entry) => {
-        const id = (ar.length || '') + '|';
-        const aE = new ah(id, rootElement);
-        ar.push(aE);
-        aE.render(entry);
+        const id = (aq.length || '') + '|';
+        const aD = new ag(id, rootElement);
+        aq.push(aD);
+        aD.render(entry);
     };
     $ezh.$ = (id, tag, props, children, check, mutableChild) => {
-        const m = `${p.id}${id}${D}`;
-        let element = n.get(m);
+        const l = `${o.id}${id}${B}`;
+        let element = m.get(l);
         if (element) {
             if ((props || children) && element.update(props, children)) {
-                G.A(m, element);
+                E._(l, element);
             }
             return element;
         }
-        element = new aK(m, tag, props, children, check, mutableChild);
-        n.set(m, element);
+        element = new aJ(l, tag, props, children, check, mutableChild);
+        m.set(l, element);
         return element;
     };
     $ezh.$c = (id, entry, props, children, check, mutableChild) => {
-        const m = `${p.id}${id}${D}`;
-        let element = n.get(m);
+        const l = `${o.id}${id}${B}`;
+        let element = m.get(l);
         if (element) {
             if ((props || children) && element.update(props, children)) {
-                G.A(m, element);
+                E._(l, element);
             }
             return element;
         }
-        element = new aB(m, entry, props, children, check, mutableChild);
-        n.set(m, element);
+        element = new aA(l, entry, props, children, check, mutableChild);
+        m.set(l, element);
         return element;
     };
     $ezh.$f = (id, children, mutableChild) => {
-        const m = `${p.id}${id}${D}`;
-        let element = n.get(m);
+        const l = `${o.id}${id}${B}`;
+        let element = m.get(l);
         if (element) {
             if (children && element.update(null, children)) {
-                G.A(m, element);
+                E._(l, element);
             }
             return element;
         }
-        element = new aI(m, children, mutableChild);
-        n.set(m, element);
+        element = new aH(l, children, mutableChild);
+        m.set(l, element);
         return element;
     };
     $ezh.$k = (key) => {
-        at.push(D);
-        D = `${D || '{'}${key}}`;
-        return aT;
+        ar.push(B);
+        B = `${B || '{'}${key}}`;
+        return aS;
     };
     $ezh.$n = (ns) => {
-        const aU = a6;
-        a6 = aw[ns];
+        const aT = a5;
+        a5 = av[ns];
         return () => {
-            a6 = aU;
+            a5 = aT;
         };
     };
     $ezh.$s = (cb, element) => {
@@ -1240,16 +1240,16 @@ export var $ezh;
         return element;
     };
     $ezh.$t = (id, text, mayChange) => {
-        const m = `${p.id}${id}${D}`;
-        let element = n.get(m);
+        const l = `${o.id}${id}${B}`;
+        let element = m.get(l);
         if (element) {
             if (mayChange) {
                 element.update(text);
             }
             return element;
         }
-        element = new al(m, text);
-        n.set(element.id, element);
+        element = new ak(l, text);
+        m.set(element.id, element);
         return element;
     };
 })($ezh || ($ezh = {}));