ezh 0.1.0

package/README.md

@@ -0,0 +1,4 @@
+# ezh
+[![ezh npm version](https://img.shields.io/npm/v/ezh.svg?style=popout&color=blue&label=ezh)](https://www.npmjs.com/package/ezh)
+
+A frontend framework that using tsx syntax, simple, tiny and fast.

package/lib/RbTree.js

@@ -0,0 +1,675 @@
+export { a3, U, L, E, W, J, };
+class F {
+    a4() {
+        return !this.k;
+    }
+    G(a) {
+        while (a.parent?.e) {
+            let parent = a.parent;
+            let m = parent.parent;
+            if (parent === m.c) {
+                const x = m.d;
+                if (x?.e) {
+                    parent.e = false;
+                    x.e = false;
+                    m.e = true;
+                    a = m;
+                }
+                else {
+                    if (a === parent.d) {
+                        a = parent;
+                        this.y(a);
+                        parent = a.parent;
+                        m = parent.parent;
+                    }
+                    parent.e = false;
+                    m.e = true;
+                    this.z(m);
+                }
+            }
+            else {
+                const x = m.c;
+                if (x?.e === true) {
+                    parent.e = false;
+                    x.e = false;
+                    m.e = true;
+                    a = m;
+                }
+                else {
+                    if (a === parent.c) {
+                        a = parent;
+                        this.z(a);
+                        parent = a.parent;
+                        m = parent.parent;
+                    }
+                    parent.e = false;
+                    m.e = true;
+                    this.y(m);
+                }
+            }
+        }
+        this.k.e = false;
+    }
+    v(a) {
+        const { c, d, parent } = a;
+        if (!c) {
+            if (!parent) {
+                this.k = d;
+                if (d) {
+                    d.parent = undefined;
+                    d.e = false;
+                }
+                return;
+            }
+            if (parent.c === a) {
+                parent.c = d;
+            }
+            else {
+                parent.d = d;
+            }
+            if (d) {
+                d.parent = parent;
+                d.e = false;
+                return;
+            }
+            if (!a.e) {
+                this.H(parent);
+            }
+            return;
+        }
+        if (!d) {
+            if (parent) {
+                if (parent.c === a) {
+                    parent.c = c;
+                }
+                else {
+                    parent.d = c;
+                }
+            }
+            else {
+                this.k = c;
+            }
+            c.parent = parent;
+            c.e = false;
+            return;
+        }
+        let t;
+        let replace;
+        let target = d;
+        if (!target.c) {
+            t = target;
+            replace = target.d;
+        }
+        else {
+            do {
+                target = target.c;
+            } while (target.c);
+            replace = target.d;
+            t = target.parent;
+            if (t.c === target) {
+                t.c = replace;
+            }
+            else {
+                t.d = replace;
+            }
+            if (replace) {
+                replace.parent = t;
+            }
+            target.d = d;
+            d.parent = target;
+        }
+        if (parent) {
+            if (parent.c === a) {
+                parent.c = target;
+            }
+            else {
+                parent.d = target;
+            }
+        }
+        else {
+            this.k = target;
+        }
+        target.parent = parent;
+        target.c = c;
+        c.parent = target;
+        const M = target.e;
+        target.e = a.e;
+        if (replace) {
+            replace.e = false;
+            return;
+        }
+        if (!M) {
+            this.H(t);
+        }
+    }
+    H(parent) {
+        let a;
+        let h;
+        for (;;) {
+            if (a === parent.c) {
+                h = parent.d;
+                if (h.e) {
+                    this.y(parent);
+                    h.e = false;
+                    parent.e = true;
+                    h = parent.d;
+                    continue;
+                }
+                if (h.d?.e) {
+                    this.y(parent);
+                    h.e = parent.e;
+                    parent.e = false;
+                    h.d.e = false;
+                    return;
+                }
+                if (h.c?.e) {
+                    h.c.e = false;
+                    this.z(h);
+                    h.e = true;
+                    h = parent.d;
+                    continue;
+                }
+            }
+            else {
+                h = parent.c;
+                if (h.e) {
+                    this.z(parent);
+                    h.e = false;
+                    parent.e = true;
+                    h = parent.c;
+                    continue;
+                }
+                if (h.c?.e) {
+                    this.z(parent);
+                    h.e = parent.e;
+                    parent.e = false;
+                    h.c.e = false;
+                    return;
+                }
+                if (h.d?.e) {
+                    h.d.e = false;
+                    this.y(h);
+                    h.e = true;
+                    h = parent.c;
+                    continue;
+                }
+            }
+            if (parent.e) {
+                parent.e = false;
+                h.e = true;
+                return;
+            }
+            h.e = true;
+            a = parent;
+            if (!a.parent) {
+                return;
+            }
+            parent = a.parent;
+        }
+    }
+    y(a) {
+        const r = a.d;
+        a.d = r?.c;
+        if (r?.c) {
+            r.c.parent = a;
+        }
+        r.parent = a.parent;
+        if (!a.parent) {
+            this.k = r;
+        }
+        else if (a === a.parent.c) {
+            a.parent.c = r;
+        }
+        else {
+            a.parent.d = r;
+        }
+        r.c = a;
+        a.parent = r;
+    }
+    z(a) {
+        const s = a.c;
+        a.c = s?.d;
+        if (s?.d) {
+            s.d.parent = a;
+        }
+        s.parent = a.parent;
+        if (!a.parent) {
+            this.k = s;
+        }
+        else if (a === a.parent.d) {
+            a.parent.d = s;
+        }
+        else {
+            a.parent.c = s;
+        }
+        s.d = a;
+        a.parent = s;
+    }
+    k;
+}
+const _ = 1;
+const A = 2;
+const a3 = 0;
+const U = 1;
+const L = 2;
+const E = 3;
+class W extends F {
+    search(key) {
+        return this.I(key)?.value;
+    }
+    delete(key) {
+        const a = this.I(key);
+        if (a) {
+            this.v(a);
+            return a.value;
+        }
+        return;
+    }
+    C(key, value, $) {
+        let a = this.k;
+        if (a) {
+            let i;
+            while (key !== a.key) {
+                if (key < a.key) {
+                    if (a.c) {
+                        a = a.c;
+                        continue;
+                    }
+                    i = { key, value, e: true, parent: a, c: undefined, d: undefined };
+                    a.c = i;
+                }
+                else {
+                    if (a.d) {
+                        a = a.d;
+                        continue;
+                    }
+                    i = { key, value, e: true, parent: a, c: undefined, d: undefined };
+                    a.d = i;
+                }
+                this.G(i);
+                return;
+            }
+            const g = a.value;
+            if ($) {
+                a.value = value;
+            }
+            return g;
+        }
+        this.k = { key, value, e: false, parent: undefined, c: undefined, d: undefined };
+        return;
+    }
+    a5(o, n) {
+        let f = 0;
+        let a = this.k;
+        if (a) {
+            const stack = [];
+            if (n !== undefined) {
+                for (;;) {
+                    if (n < a.key) {
+                        if (a.c) {
+                            stack.push(a);
+                            a = a.c;
+                            continue;
+                        }
+                    }
+                    else if (n > a.key) {
+                        if (a.d) {
+                            a = a.d;
+                            continue;
+                        }
+                        return f;
+                    }
+                    break;
+                }
+            }
+            else {
+                while (a.c) {
+                    stack.push(a);
+                    a = a.c;
+                }
+            }
+            let j;
+            for (;;) {
+                const p = o(a.key, a.value);
+                f++;
+                if (p & A) {
+                    (j ?? (j = [])).push(a);
+                }
+                if (p & _) {
+                    f = -f;
+                    break;
+                }
+                if (a.d) {
+                    a = a.d;
+                    while (a.c) {
+                        stack.push(a);
+                        a = a.c;
+                    }
+                }
+                else {
+                    a = stack.pop();
+                    if (!a) {
+                        break;
+                    }
+                }
+            }
+            if (j) {
+                let b = j.length;
+                while (b > 0) {
+                    this.v(j[--b]);
+                }
+            }
+        }
+        return f;
+    }
+    O(o, n) {
+        let f = 0;
+        let a = this.k;
+        if (a) {
+            const stack = [];
+            if (n !== undefined) {
+                for (;;) {
+                    if (n > a.key) {
+                        if (a.d) {
+                            stack.push(a);
+                            a = a.d;
+                            continue;
+                        }
+                    }
+                    else if (n < a.key) {
+                        if (a.c) {
+                            a = a.c;
+                            continue;
+                        }
+                        return f;
+                    }
+                    break;
+                }
+            }
+            else {
+                while (a.d) {
+                    stack.push(a);
+                    a = a.d;
+                }
+            }
+            let j;
+            for (;;) {
+                const p = o(a.key, a.value);
+                f++;
+                if (p & A) {
+                    (j ?? (j = [])).push(a);
+                }
+                if (p & _) {
+                    f = -f;
+                    break;
+                }
+                if (a.c) {
+                    a = a.c;
+                    while (a.d) {
+                        stack.push(a);
+                        a = a.d;
+                    }
+                }
+                else {
+                    a = stack.pop();
+                    if (!a) {
+                        break;
+                    }
+                }
+            }
+            if (j) {
+                let b = j.length;
+                while (b > 0) {
+                    this.v(j[--b]);
+                }
+            }
+        }
+        return f;
+    }
+    I(key) {
+        let a = this.k;
+        if (a) {
+            while (key !== a.key) {
+                if (key < a.key) {
+                    if (a.c) {
+                        a = a.c;
+                        continue;
+                    }
+                }
+                else {
+                    if (a.d) {
+                        a = a.d;
+                        continue;
+                    }
+                }
+                return;
+            }
+        }
+        return a;
+    }
+}
+class J extends F {
+    search(key) {
+        let a = this.k;
+        if (a) {
+            const { w: D } = this;
+            let q;
+            while ((q = D(key, a)) !== 0) {
+                if (q < 0) {
+                    if (a.c) {
+                        a = a.c;
+                        continue;
+                    }
+                }
+                else {
+                    if (a.d) {
+                        a = a.d;
+                        continue;
+                    }
+                }
+                return;
+            }
+        }
+        return a;
+    }
+    delete(key) {
+        const a = this.search(key);
+        if (a) {
+            this.v(a);
+            a.e = undefined;
+            return a;
+        }
+        return;
+    }
+    C(i, $) {
+        if (i.e !== undefined) {
+            throw new Error('Cannot insert a node which is already in an ObjRbTree');
+        }
+        let a = this.k;
+        if (a) {
+            const { w: D } = this;
+            let q;
+            while ((q = D(i, a)) !== 0) {
+                if (q < 0) {
+                    if (a.c) {
+                        a = a.c;
+                        continue;
+                    }
+                    i.e = true;
+                    i.parent = a;
+                    a.c = i;
+                }
+                else {
+                    if (a.d) {
+                        a = a.d;
+                        continue;
+                    }
+                    i.e = true;
+                    i.parent = a;
+                    a.d = i;
+                }
+                this.G(i);
+                return;
+            }
+            if ($) {
+                const { parent, c, d, e } = a;
+                i.parent = parent;
+                i.e = e;
+                i.c = c;
+                i.d = d;
+                if (parent) {
+                    if (parent.c === a) {
+                        parent.c = i;
+                    }
+                    else {
+                        parent.d = i;
+                    }
+                }
+                if (c) {
+                    c.parent = i;
+                }
+                if (d) {
+                    d.parent = i;
+                }
+                a.e = undefined;
+            }
+            return a;
+        }
+        i.e = false;
+        this.k = i;
+        return;
+    }
+    a5(o, n) {
+        let f = 0;
+        let a = this.k;
+        if (a) {
+            const stack = [];
+            if (n) {
+                const { w } = this;
+                for (;;) {
+                    const q = w(n, a);
+                    if (q < 0) {
+                        if (a.c) {
+                            stack.push(a);
+                            a = a.c;
+                            continue;
+                        }
+                    }
+                    else if (q > 0) {
+                        if (a.d) {
+                            a = a.d;
+                            continue;
+                        }
+                        return f;
+                    }
+                    break;
+                }
+            }
+            else {
+                while (a.c) {
+                    stack.push(a);
+                    a = a.c;
+                }
+            }
+            let j;
+            for (;;) {
+                const p = o(a);
+                f++;
+                if (p & A) {
+                    (j ?? (j = [])).push(a);
+                }
+                if (p & _) {
+                    f = -f;
+                    break;
+                }
+                if (a.d) {
+                    a = a.d;
+                    while (a.c) {
+                        stack.push(a);
+                        a = a.c;
+                    }
+                }
+                else {
+                    a = stack.pop();
+                    if (!a) {
+                        break;
+                    }
+                }
+            }
+            if (j) {
+                let b = j.length;
+                while (b > 0) {
+                    this.v(j[--b]);
+                }
+            }
+        }
+        return f;
+    }
+    O(o, n) {
+        let f = 0;
+        let a = this.k;
+        if (a) {
+            const stack = [];
+            if (n) {
+                const { w } = this;
+                for (;;) {
+                    const q = w(n, a);
+                    if (q > 0) {
+                        if (a.d) {
+                            stack.push(a);
+                            a = a.d;
+                            continue;
+                        }
+                    }
+                    else if (q < 0) {
+                        if (a.c) {
+                            a = a.c;
+                            continue;
+                        }
+                        return f;
+                    }
+                    break;
+                }
+            }
+            else {
+                while (a.d) {
+                    stack.push(a);
+                    a = a.d;
+                }
+            }
+            let j;
+            for (;;) {
+                const p = o(a);
+                f++;
+                if (p & A) {
+                    (j ?? (j = [])).push(a);
+                }
+                if (p & _) {
+                    f = -f;
+                    break;
+                }
+                if (a.c) {
+                    a = a.c;
+                    while (a.d) {
+                        stack.push(a);
+                        a = a.d;
+                    }
+                }
+                else {
+                    a = stack.pop();
+                    if (!a) {
+                        break;
+                    }
+                }
+            }
+            if (j) {
+                let b = j.length;
+                while (b > 0) {
+                    this.v(j[--b]);
+                }
+            }
+        }
+        return f;
+    }
+}
+//# sourceMappingURL=RbTree.js.map