ezh 0.1.0

package/lib/elements.js

@@ -0,0 +1,1313 @@
+import { a3, L, U, W } from './RbTree';
+const V = {
+    'ariaAtomic': 'aria-atomic',
+    'ariaAutoComplete': 'aria-autocomplete',
+    'ariaBrailleLabel': 'aria-braillelabel',
+    'ariaBrailleRoleDescription': 'aria-brailleroledescription',
+    'ariaBusy': 'aria-busy',
+    'ariaChecked': 'aria-checked',
+    'ariaColCount': 'aria-colcount',
+    'ariaColIndex': 'aria-colindex',
+    'ariaColIndexText': 'aria-colindextext',
+    'ariaColSpan': 'aria-colspan',
+    'ariaCurrent': 'aria-current',
+    'ariaDescription': 'aria-description',
+    'ariaDisabled': 'aria-disabled',
+    'ariaExpanded': 'aria-expanded',
+    'ariaHasPopup': 'aria-haspopup',
+    'ariaHidden': 'aria-hidden',
+    'ariaInvalid': 'aria-invalid',
+    'ariaKeyShortcuts': 'aria-keyshortcuts',
+    'ariaLabel': 'aria-label',
+    'ariaLevel': 'aria-level',
+    'ariaLive': 'aria-live',
+    'ariaModal': 'aria-modal',
+    'ariaMultiLine': 'aria-multiline',
+    'ariaMultiSelectable': 'aria-multiselectable',
+    'ariaOrientation': 'aria-orientation',
+    'ariaPlaceholder': 'aria-placeholder',
+    'ariaPosInSet': 'aria-posinset',
+    'ariaPressed': 'aria-pressed',
+    'ariaReadOnly': 'aria-readonly',
+    'ariaRequired': 'aria-required',
+    'ariaRoleDescription': 'aria-roledescription',
+    'ariaRowCount': 'aria-rowcount',
+    'ariaRowIndex': 'aria-rowindex',
+    'ariaRowIndexText': 'aria-rowindextext',
+    'ariaRowSpan': 'aria-rowspan',
+    'ariaSelected': 'aria-selected',
+    'ariaSetSize': 'aria-setsize',
+    'ariaSort': 'aria-sort',
+    'ariaValueMax': 'aria-valuemax',
+    'ariaValueMin': 'aria-valuemin',
+    'ariaValueNow': 'aria-valuenow',
+    'ariaValueText': 'aria-valuetext',
+    'alignmentBaseline': 'alignment-baseline',
+    'annotationXml': 'annotation-xml',
+    'baselineShift': 'baseline-shift',
+    'clipPath': 'clip-path',
+    'clipRule': 'clip-rule',
+    'colorInterpolation': 'color-interpolation',
+    'colorInterpolationFilters': 'color-interpolation-filters',
+    'colorProfile': 'color-profile',
+    'colorRendering': 'color-rendering',
+    'dominantBaseline': 'dominant-baseline',
+    'enableBackground': 'enable-background',
+    'fillOpacity': 'fill-opacity',
+    'fillRule': 'fill-rule',
+    'floodColor': 'flood-color',
+    'floodOpacity': 'flood-opacity',
+    'fontFamily': 'font-family',
+    'fontSize': 'font-size',
+    'fontSizeAdjust': 'font-size-adjust',
+    'fontStretch': 'font-stretch',
+    'fontStyle': 'font-style',
+    'fontVariant': 'font-variant',
+    'fontWeight': 'font-weight',
+    'glyphOrientationHorizontal': 'glyph-orientation-horizontal',
+    'glyphOrientationVertical': 'glyph-orientation-vertical',
+    'imageRendering': 'image-rendering',
+    'letterSpacing': 'letter-spacing',
+    'lightingColor': 'lighting-color',
+    'markerEnd': 'marker-end',
+    'markerMid': 'marker-mid',
+    'markerStart': 'marker-start',
+    'pointerEvents': 'pointer-events',
+    'shapeRendering': 'shape-rendering',
+    'stopColor': 'stop-color',
+    'stopOpacity': 'stop-opacity',
+    'strokeDasharray': 'stroke-dasharray',
+    'strokeDashoffset': 'stroke-dashoffset',
+    'strokeLinecap': 'stroke-linecap',
+    'strokeLinejoin': 'stroke-linejoin',
+    'strokeMiterlimit': 'stroke-miterlimit',
+    'strokeOpacity': 'stroke-opacity',
+    'strokeWidth': 'stroke-width',
+    'style': 'style',
+    'textAnchor': 'text-anchor',
+    'textDecoration': 'text-decoration',
+    'textRendering': 'text-rendering',
+    'unicodeBidi': 'unicode-bidi',
+    'vectorEffect': 'vector-effect',
+    'wordSpacing': 'word-spacing',
+    'writingMode': 'writing-mode',
+};
+const X = {};
+const Y = [];
+Object.freeze(X);
+Object.freeze(Y);
+const E = () => false;
+const y = [];
+const w = new Set();
+const a7 = new W();
+const ai = new W();
+const au = [];
+const av = [];
+const aj = {
+    id: '',
+    index: 0,
+    firstElement: null,
+    attachTo: E,
+    move: E,
+    detachFrom: E,
+    update: E,
+    refresh: E,
+    release: E,
+    version: 0,
+    parentCom: {},
+    markChanged: E,
+    watchMountChange: E,
+};
+let F = '';
+let ak = 20000;
+let A = 0;
+let aw = 0;
+let M = undefined;
+const G = new W();
+export const o = new Map();
+export let q = aj;
+export let N = 0;
+const aF = (z, aV) => {
+    return document.createElement(z);
+};
+let aa = aF;
+const ax = {
+    'svg': (z, O) => {
+        O.a9();
+        return document.createElementNS('http://www.w3.org/2000/svg', z);
+    },
+    'math': (z, O) => {
+        O.a9();
+        return document.createElementNS('http://www.w3.org/1998/Math/MathML', z);
+    },
+    'foreignObject': (z, O) => {
+        if (z !== 'foreignObject') {
+            return document.createElement(z);
+        }
+        O.a9();
+        return document.createElementNS('http://www.w3.org/2000/svg', z);
+    },
+};
+const al = () => {
+    if (++aw >= A) {
+        for (const element of w) {
+            w.delete(element);
+            if (element.id) {
+                element.release();
+            }
+            else {
+                if (--aw < A) {
+                    w.add(element);
+                    break;
+                }
+            }
+        }
+    }
+    else {
+        w.add(Object.create(aj));
+    }
+    if (M) {
+        M = setTimeout(al, ak);
+    }
+};
+const ay = (parent, m) => {
+    const az = ['', m];
+    while (parent.constructor !== a8) {
+        az.push(parent.id);
+        parent = parent.parent;
+    }
+    return az.reverse().join(',');
+};
+const aG = () => {
+    do {
+        G.a5((id, element) => {
+            const { newChildren, parent } = element;
+            if (newChildren) {
+                if (parent && am(parent)) {
+                    element.refresh(newChildren);
+                    parent.currentBefore = undefined;
+                }
+                else if (element.constructor === an) {
+                    a7.C(id, element);
+                }
+            }
+            return L;
+        });
+    } while (!G.a4());
+    N++;
+    for (const { parent, element } of y) {
+        element.detachFrom(X);
+        if (element.parent !== parent) {
+            if (!ai.a4() && am(parent)) {
+                const a6 = !element.parent;
+                const ab = ay(parent, element.id);
+                ai.a5((key, value) => {
+                    if (key.startsWith(ab)) {
+                        value._(value.D, a6);
+                        return L;
+                    }
+                    return U;
+                }, ab);
+            }
+        }
+    }
+    y.length = 0;
+};
+const Q = (children, f = [], from = 0) => {
+    let a = children[from];
+    for (;;) {
+        if (a && a.id !== undefined) {
+            f.push(a);
+        }
+        else if (a !== null && a !== undefined) {
+            switch (typeof a) {
+                case 'object':
+                    Q(a, f);
+                    break;
+                case 'function':
+                    a = a();
+                    continue;
+                case 'boolean':
+                case 'number':
+                case 'bigint':
+                    a = '' + a;
+                default:
+                    f.push(new ao('', a));
+            }
+        }
+        if (++from < children.length) {
+            a = children[from];
+        }
+        else {
+            break;
+        }
+    }
+    return f;
+};
+const ac = (B, children, parent) => {
+    let f;
+    const length = B.length;
+    let newChildren = children;
+    let b = 0;
+    while (b < length) {
+        const a$ = B[b];
+        if (a$ !== newChildren[b]) {
+            if (b === newChildren.length) {
+                return newChildren;
+            }
+            const a = newChildren[b];
+            if (!a || a.id === undefined) {
+                newChildren = Q(newChildren, newChildren.slice(0, b), b);
+                continue;
+            }
+            else if (f !== newChildren) {
+                break;
+            }
+        }
+        if (!f && a$.parent !== parent) {
+            f = B;
+        }
+        b++;
+    }
+    if (b === newChildren.length) {
+        return f;
+    }
+    return newChildren === children ? Q(newChildren, B.slice(0, b), b) : newChildren;
+};
+const am = (element) => {
+    let parent = element;
+    do {
+        if (parent.constructor === a8) {
+            return true;
+        }
+        parent = parent.parent;
+    } while (parent);
+    return false;
+};
+const ad = (B, newChildren, parent, aH) => {
+    let b, i;
+    let a;
+    if (newChildren !== B && B.length) {
+        const ap = [];
+        let t;
+        i = newChildren.length;
+        b = 10000000;
+        while (--i >= 0) {
+            a = newChildren[i];
+            if (a.parent === parent) {
+                const a_ = i - a.index;
+                if (a_ === b) {
+                    t.H++;
+                    a.index = i;
+                }
+                else {
+                    t = {
+                        from: a.index,
+                        to: i,
+                        H: 1,
+                    };
+                    b = a_;
+                    a.index = -ap.push(t);
+                }
+            }
+            else if (b !== 10000000) {
+                b = 10000000;
+            }
+        }
+        const aq = [];
+        i = B.length - 1;
+        while (i >= 0) {
+            a = B[i];
+            if (a.index < 0) {
+                t = ap[-a.index - 1];
+                aq.push(t);
+                i -= t.H;
+            }
+            else {
+                a.detachFrom(parent);
+                i--;
+            }
+        }
+        let R;
+        let ae;
+        let af = 0;
+        i = newChildren.length - 1;
+        while (i >= 0) {
+            a = newChildren[i];
+            if (a.parent !== parent) {
+                a.index = i--;
+                a.attachTo(parent);
+            }
+            else {
+                t = ap[-a.index - 1];
+                ae = t.H;
+                R = aq[af];
+                a.index = i;
+                if (!aH) {
+                    if (R === t) {
+                        af++;
+                        i -= t.H;
+                        parent.currentBefore = undefined;
+                        continue;
+                    }
+                    if (R.from > t.from) {
+                        b = af;
+                        do {
+                            ae -= R.H;
+                            R = aq[++b];
+                        } while (R.from > t.from && ae > 0);
+                        if (ae > 0) {
+                            i -= t.H;
+                            parent.currentBefore = undefined;
+                            af = b;
+                            continue;
+                        }
+                    }
+                }
+                b = i - t.H;
+                do {
+                    a.move();
+                } while (--i > b && (a = newChildren[i]));
+            }
+        }
+    }
+    else {
+        for (i = newChildren.length - 1; i >= 0; i--) {
+            a = newChildren[i];
+            a.index = i;
+            if (parent !== a.parent) {
+                a.attachTo(parent);
+            }
+        }
+    }
+    parent.currentBefore = undefined;
+};
+class ao {
+    constructor(id, text) {
+        this.id = id;
+        this.parent = undefined;
+        this.index = 0;
+        this.n = 0;
+        this.ag = text;
+    }
+    id;
+    parent;
+    index;
+    firstElement;
+    attachTo(target) {
+        if (!this.firstElement) {
+            this.firstElement = document.createTextNode(this.ag);
+        }
+        const { parent, firstElement, index } = this;
+        if (this.id) {
+            if (!this.n++) {
+                w.delete(this);
+            }
+            if (parent) {
+                firstElement.remove();
+                y.push({ parent, element: this });
+            }
+        }
+        this.parent = target;
+        let r = target.currentBefore;
+        if (r === undefined) {
+            r = target.findNextSiblingElement(index);
+        }
+        target.element.insertBefore(firstElement, r);
+        target.currentBefore = firstElement;
+    }
+    move() {
+        const { parent, index, firstElement } = this;
+        let r = parent.currentBefore;
+        if (r === undefined) {
+            r = parent.findNextSiblingElement(index);
+        }
+        parent.element.insertBefore(firstElement, r);
+        parent.currentBefore = firstElement;
+    }
+    detachFrom(target) {
+        if (this.parent === target) {
+            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();
+                }
+            }
+        }
+    }
+    update(text) {
+        if (this.ag !== text) {
+            this.ag = text;
+            if (this.firstElement) {
+                this.firstElement.nodeValue = text;
+            }
+        }
+        return false;
+    }
+    refresh() { }
+    release(target) {
+        if (target && this.parent === target) {
+            this.firstElement.remove();
+            this.parent = undefined;
+        }
+        if (this.id && --this.n <= 0) {
+            o.delete(this.id);
+        }
+    }
+    n;
+    ag;
+}
+export class aI {
+    constructor(id, children, aJ) {
+        this.id = id;
+        this.parent = undefined;
+        this.index = 0;
+        this.n = 0;
+        this.newChildren = this.d = aJ ? Q(children) : (children || Y);
+        this.currentBefore = undefined;
+    }
+    id;
+    parent;
+    index;
+    newChildren;
+    currentBefore;
+    get element() {
+        return this.parent.element;
+    }
+    get firstElement() {
+        const { d } = this;
+        for (let b = 0; b < d.length; b++) {
+            const h = d[b].firstElement;
+            if (h) {
+                return h;
+            }
+        }
+        return null;
+    }
+    attachTo(target) {
+        const { parent, d, newChildren } = this;
+        if (!this.n++) {
+            w.delete(this);
+        }
+        if (parent) {
+            y.push({ parent, element: this });
+            for (let b = d.length - 1; b >= 0; b--) {
+                d[b].detachFrom(this);
+            }
+        }
+        this.parent = target;
+        const children = newChildren || d;
+        for (let b = children.length - 1; b >= 0; b--) {
+            const a = children[b];
+            a.index = b;
+            a.attachTo(this);
+        }
+        target.currentBefore = this.currentBefore;
+        this.currentBefore = undefined;
+        this.d = children;
+        this.newChildren = undefined;
+    }
+    move() {
+        const { d, newChildren } = this;
+        if (newChildren) {
+            ad(d, newChildren, this, true);
+            this.d = newChildren;
+            this.newChildren = undefined;
+        }
+        else {
+            for (let b = d.length - 1; b >= 0; b--) {
+                d[b].move();
+            }
+            this.currentBefore = undefined;
+        }
+    }
+    detachFrom(target) {
+        if (this.parent === target) {
+            const { d } = this;
+            for (const a of d) {
+                a.detachFrom(this);
+            }
+            this.parent = undefined;
+            y.push({ parent: target, element: this });
+        }
+        else {
+            if (!--this.n) {
+                if (A) {
+                    w.add(this);
+                }
+                else {
+                    this.release();
+                }
+            }
+        }
+    }
+    update(p, children) {
+        if (children) {
+            const newChildren = ac(this.d, children, this);
+            if (newChildren) {
+                this.newChildren = newChildren;
+                return true;
+            }
+        }
+        return false;
+    }
+    refresh(newChildren) {
+        ad(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);
+            }
+            this.parent = undefined;
+        }
+        if (--this.n <= 0) {
+            o.delete(this.id);
+        }
+    }
+    findNextSiblingElement(index) {
+        const children = this.newChildren || this.d;
+        let h;
+        let b = index + 1;
+        let a = children[b];
+        while (a) {
+            h = a.firstElement;
+            if (h) {
+                return h;
+            }
+            a = children[++b];
+        }
+        h = this.parent.currentBefore;
+        return h !== undefined ? h : this.parent.findNextSiblingElement(this.index);
+    }
+    n;
+    d;
+}
+export class aK {
+    constructor(id, tag, props, children, check, mutableChild) {
+        this.id = id;
+        this.parent = undefined;
+        this.index = 0;
+        this.n = 0;
+        this.firstElement = this.element = aa(tag, this);
+        this.newChildren = this.d = mutableChild ? Q(children) : (children || Y);
+        this.currentBefore = undefined;
+        if (props) {
+            this.p = X;
+            this.u = -1;
+            if (tag === 'select') {
+                const ar = this.element;
+                const at = props;
+                const c = at.value;
+                if (c) {
+                    at.value = undefined;
+                    const aL = this.refresh;
+                    this.refresh = (newChildren) => {
+                        ad(this.d, newChildren, this);
+                        this.d = newChildren;
+                        this.newChildren = undefined;
+                        if (Array.isArray(c)) {
+                            const aA = c;
+                            const [e, Z, S] = aA;
+                            ar.value = S;
+                            const _ = aA[3] = (x) => e[Z] = x.target.value;
+                            ar.addEventListener('change', _);
+                        }
+                        else {
+                            ar.value = c;
+                        }
+                        at.value = c;
+                        this.refresh = aL;
+                    };
+                }
+            }
+            this.update(props);
+            this.u = check ?? 0;
+        }
+        else {
+            this.p = props;
+            this.u = 0;
+        }
+    }
+    id;
+    element;
+    parent;
+    newChildren;
+    index;
+    currentBefore;
+    firstElement;
+    attachTo(target) {
+        const { parent, element, newChildren, index } = this;
+        if (!this.n++) {
+            w.delete(this);
+        }
+        if (parent) {
+            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);
+        }
+        target.element.insertBefore(element, r);
+        target.currentBefore = element;
+    }
+    move() {
+        const { parent, newChildren, index, element } = this;
+        if (newChildren) {
+            this.refresh(newChildren);
+        }
+        let r = parent.currentBefore;
+        if (r === undefined) {
+            r = parent.findNextSiblingElement(index);
+        }
+        parent.element.insertBefore(element, r);
+        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();
+                }
+            }
+        }
+    }
+    update(props, children) {
+        const { element, p, u } = this;
+        if (p && u) {
+            this.p = props;
+            let k = u;
+            for (const key in props) {
+                const c = props[key];
+                const g = p[key];
+                if (c !== g) {
+                    if (c !== null && c !== undefined) {
+                        switch (typeof c) {
+                            case 'string': {
+                                const a0 = V[key];
+                                if (!a0) {
+                                    element[key] = c;
+                                }
+                                else {
+                                    element.setAttribute(a0, c);
+                                }
+                                break;
+                            }
+                            case 'number':
+                            case 'boolean':
+                            case 'function': {
+                                element[key] = c;
+                                break;
+                            }
+                            default: {
+                                if (Array.isArray(c)) {
+                                    const [e, Z, S] = c;
+                                    if (g) {
+                                        const [aM, aN, aO, aB] = g;
+                                        if (aO !== S && element[key] !== S) {
+                                            element[key] = S;
+                                        }
+                                        if (aM === e && aN === Z) {
+                                            c[3] = aB;
+                                        }
+                                        else {
+                                            const _ = c[3] = (x) => e[Z] = x.target[key];
+                                            element.removeEventListener('change', aB);
+                                            element.addEventListener('change', _);
+                                        }
+                                    }
+                                    else {
+                                        element[key] = S;
+                                        const _ = c[3] = (x) => e[Z] = x.target[key];
+                                        element.addEventListener('change', _);
+                                    }
+                                    break;
+                                }
+                                if (key === 'style') {
+                                    if (!g) {
+                                        const style = element.style;
+                                        const s = {};
+                                        let k = 0;
+                                        for (const l in c) {
+                                            const a1 = c[l];
+                                            s[l] = a1;
+                                            k++;
+                                            style[l] = a1;
+                                        }
+                                        props[key] = s;
+                                        s.k = k;
+                                        break;
+                                    }
+                                    const style = element.style;
+                                    const s = {};
+                                    let k = 0;
+                                    let J = g.k;
+                                    for (const l in c) {
+                                        const K = c[l];
+                                        s[l] = K;
+                                        if (l in g) {
+                                            J--;
+                                        }
+                                        k++;
+                                        if (K !== g[key]) {
+                                            style[l] = K;
+                                        }
+                                    }
+                                    props[key] = s;
+                                    s.k = k;
+                                    if (J) {
+                                        for (const l in g) {
+                                            if (!(l in c)) {
+                                                style[l] = null;
+                                                if (!--J) {
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    break;
+                                }
+                                element[key] = c;
+                            }
+                        }
+                    }
+                    else {
+                        switch (typeof g) {
+                            case 'string': {
+                                const a0 = V[key];
+                                if (!a0) {
+                                    this.element[key] = c;
+                                }
+                                else {
+                                    this.element.removeAttribute(a0);
+                                }
+                                break;
+                            }
+                            case 'object': {
+                                if (g) {
+                                    if (Array.isArray(g)) {
+                                        element.removeEventListener('change', g[3]);
+                                    }
+                                    else if (g === X) {
+                                        element[key] = c;
+                                    }
+                                }
+                                else {
+                                    element[key] = c;
+                                }
+                                break;
+                            }
+                            default: {
+                                element[key] = c;
+                            }
+                        }
+                    }
+                }
+                if (!--k) {
+                    break;
+                }
+            }
+        }
+        if (children) {
+            const newChildren = ac(this.d, children, this);
+            if (newChildren) {
+                this.newChildren = newChildren;
+                return true;
+            }
+        }
+        return false;
+    }
+    refresh(newChildren) {
+        ad(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) {
+            const { d } = this;
+            for (const a of d) {
+                a.release(this);
+            }
+            o.delete(this.id);
+        }
+    }
+    findNextSiblingElement(index) {
+        const children = this.newChildren || this.d;
+        let h;
+        let b = index + 1;
+        let a = children[b];
+        while (a) {
+            h = a.firstElement;
+            if (h) {
+                return h;
+            }
+            a = children[++b];
+        }
+        return null;
+    }
+    a9() {
+        this.update = this.aP;
+    }
+    aP(props, children) {
+        const { element, p, u } = this;
+        if (p && u) {
+            this.p = props;
+            let k = u;
+            for (const key in props) {
+                const c = props[key];
+                const g = p[key];
+                if (c !== g) {
+                    if (c !== null && c !== undefined) {
+                        switch (typeof c) {
+                            case 'string': {
+                                element.setAttribute(V[key] ?? key, c);
+                                break;
+                            }
+                            case 'number':
+                            case 'boolean': {
+                                element.setAttribute(V[key] ?? key, '' + c);
+                                break;
+                            }
+                            case 'function': {
+                                element[key] = c;
+                                break;
+                            }
+                            default: {
+                                if (key === 'style') {
+                                    if (!g) {
+                                        const style = element.style;
+                                        const s = {};
+                                        let k = 0;
+                                        for (const l in c) {
+                                            const a1 = c[l];
+                                            s[l] = a1;
+                                            k++;
+                                            style[l] = a1;
+                                        }
+                                        props[key] = s;
+                                        s.k = k;
+                                        break;
+                                    }
+                                    const style = element.style;
+                                    const s = {};
+                                    let k = 0;
+                                    let J = g.k;
+                                    for (const l in c) {
+                                        const K = c[l];
+                                        s[l] = K;
+                                        if (l in g) {
+                                            J--;
+                                        }
+                                        k++;
+                                        if (K !== g[key]) {
+                                            style[l] = K;
+                                        }
+                                    }
+                                    props[key] = s;
+                                    s.k = k;
+                                    if (J) {
+                                        for (const l in g) {
+                                            if (!(l in c)) {
+                                                style[l] = null;
+                                                if (!--J) {
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    break;
+                                }
+                                element[key] = c;
+                            }
+                        }
+                    }
+                    else {
+                        const aQ = typeof g;
+                        switch (aQ) {
+                            case 'string':
+                            case 'number':
+                            case 'boolean': {
+                                element.removeAttribute(V[key] ?? key);
+                                break;
+                            }
+                            default: {
+                                element[key] = c;
+                            }
+                        }
+                    }
+                }
+                if (!--k) {
+                    break;
+                }
+            }
+        }
+        if (children) {
+            const newChildren = ac(this.d, children, this);
+            if (newChildren) {
+                this.newChildren = newChildren;
+                return true;
+            }
+        }
+        return false;
+    }
+    n;
+    p;
+    d;
+    u;
+}
+export class an {
+    constructor(id, parentCom, entry, props, children, check, mutableChild) {
+        this.id = id;
+        this.parentCom = parentCom;
+        this.parent = undefined;
+        this.index = 0;
+        this.version = 0;
+        this.n = 0;
+        this.aC = entry;
+        this.p = props;
+        this.newChildren = this.d = mutableChild ? Q(children) : (children || Y);
+        this.u = check ?? 0;
+    }
+    id;
+    parentCom;
+    parent;
+    newChildren;
+    index;
+    version;
+    get firstElement() {
+        return this.j?.firstElement || null;
+    }
+    attachTo(target) {
+        const { parent, newChildren, j } = this;
+        this.parent = target;
+        if (newChildren) {
+            this.refresh(newChildren);
+        }
+        else if (j) {
+            j.index = this.index;
+            j.attachTo(target);
+        }
+        if (!this.n++) {
+            w.delete(this);
+        }
+        if (parent) {
+            y.push({ parent, element: this });
+        }
+    }
+    move() {
+        const { newChildren, j } = this;
+        if (newChildren) {
+            this.refresh(newChildren);
+        }
+        else if (j) {
+            j.index = this.index;
+            j.move();
+        }
+    }
+    detachFrom(target) {
+        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();
+                }
+            }
+        }
+    }
+    update(props, children) {
+        const { p, d, u } = this;
+        this.p = props;
+        if (children) {
+            const newChildren = ac(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]) {
+                    this.newChildren = d;
+                    return true;
+                }
+                if (!--k) {
+                    break;
+                }
+            }
+        }
+        return false;
+    }
+    refresh(newChildren) {
+        const { id, parent, j, index } = this;
+        const aR = q;
+        q = this;
+        let v = this.aC(this.p || X, newChildren);
+        if (v !== j) {
+            switch (typeof v) {
+                case 'boolean':
+                case 'number':
+                case 'bigint':
+                    v = '' + v;
+                case 'string':
+                    v = new ao('', v);
+                    this.j = v;
+                    v.index = index;
+                    v.attachTo(parent);
+                    j?.detachFrom(parent);
+                    break;
+                default:
+                    if (v) {
+                        this.j = v;
+                        v.index = index;
+                        v.attachTo(parent);
+                        j?.detachFrom(parent);
+                        if (!a7.a4()) {
+                            a7.a5((a2, com) => {
+                                if (!a2.startsWith(id)) {
+                                    return U;
+                                }
+                                if (com.parent && am(com.parent)) {
+                                    G.C(a2, com);
+                                    return L;
+                                }
+                                return a3;
+                            }, id);
+                        }
+                    }
+                    else {
+                        this.j = undefined;
+                        j?.detachFrom(parent);
+                    }
+            }
+        }
+        else if (j) {
+            if (j.parent !== parent) {
+                j.index = index;
+                j.attachTo(parent);
+            }
+            else if (j.index !== index) {
+                j.index = index;
+                j.move();
+            }
+        }
+        this.d = newChildren;
+        this.newChildren = undefined;
+        q = aR;
+    }
+    release(target) {
+        if (target && this.parent === target) {
+            this.j?.detachFrom(target);
+            this.parent = undefined;
+        }
+        if (--this.n <= 0) {
+            if (this.newChildren) {
+                a7.delete(this.id);
+            }
+            o.delete(this.id);
+        }
+    }
+    markChanged() {
+        if (!this.newChildren) {
+            this.newChildren = this.d;
+            return true;
+        }
+        return false;
+    }
+    watchMountChange(aS, _, D) {
+        const ab = ay(this.parent, this.id);
+        ai.C(ab + aS, { _, D }, true);
+    }
+    n;
+    aC;
+    p;
+    d;
+    u;
+    j;
+}
+class a8 {
+    constructor(id, rootElement) {
+        this.id = id;
+        this.element = rootElement;
+        this.currentBefore = undefined;
+    }
+    id;
+    element;
+    parent;
+    currentBefore;
+    findNextSiblingElement(aY) {
+        return null;
+    }
+    render(entry) {
+        if (!this.ah) {
+            this.ah = new an(this.id, aj, entry, null, Y);
+            o.set(this.id, this.ah);
+            this.ah.attachTo(this);
+            N++;
+        }
+    }
+    ah;
+}
+export const addComReader = (readerRecord, key) => {
+    if (q.id) {
+        let I = readerRecord[key];
+        if (!I) {
+            I = new Map();
+            readerRecord[key] = I;
+        }
+        I.set(q.id, q.version);
+    }
+};
+export let refreshComReaders = (readerRecord, key) => {
+    const I = readerRecord[key];
+    if (I) {
+        for (const [a2, version] of I) {
+            const com = o.get(a2);
+            if (com?.version === version && com.markChanged()) {
+                if (G.a4()) {
+                    queueMicrotask(aG);
+                }
+                G.C(a2, com);
+            }
+        }
+        I.clear();
+    }
+};
+export const aD = (replace) => refreshComReaders = replace;
+export const configGC = (waitIntervals, interval = 20000) => {
+    if (waitIntervals >= 0 && interval >= 1000) {
+        ak = interval;
+        if (A) {
+            clearTimeout(M);
+        }
+        if (waitIntervals) {
+            M = setTimeout(al, ak);
+        }
+        else if (M) {
+            M = undefined;
+            for (let b = 0; b < A; b++) {
+                al();
+            }
+        }
+        A = waitIntervals;
+        return true;
+    }
+    return false;
+};
+const aT = () => {
+    F = av.pop();
+};
+export var $ezh;
+(function ($ezh) {
+    $ezh.render = (rootElement, entry) => {
+        const id = (au.length || '') + '|';
+        const aE = new a8(id, rootElement);
+        au.push(aE);
+        aE.render(entry);
+    };
+    $ezh.$ = (id, tag, props, children, check, mutableChild) => {
+        const m = `${q.id}${id}${F}`;
+        let element = o.get(m);
+        if (element) {
+            if ((props || children) && element.update(props, children)) {
+                G.C(m, element);
+            }
+            return element;
+        }
+        element = new aK(m, tag, props, children, check, mutableChild);
+        o.set(m, element);
+        return element;
+    };
+    $ezh.$c = (id, entry, props, children, check, mutableChild) => {
+        const m = `${q.id}${id}${F}`;
+        let element = o.get(m);
+        if (element) {
+            if ((props || children) && element.update(props, children)) {
+                G.C(m, element);
+            }
+            return element;
+        }
+        element = new an(m, q, entry, props, children, check, mutableChild);
+        o.set(m, element);
+        return element;
+    };
+    $ezh.$f = (id, children, mutableChild) => {
+        const m = `${q.id}${id}${F}`;
+        let element = o.get(m);
+        if (element) {
+            if (children && element.update(null, children)) {
+                G.C(m, element);
+            }
+            return element;
+        }
+        element = new aI(m, children, mutableChild);
+        o.set(m, element);
+        return element;
+    };
+    $ezh.$k = (key) => {
+        av.push(F);
+        F = `${F || '{'}${key}}`;
+        return aT;
+    };
+    $ezh.$n = (ns) => {
+        const aU = aa;
+        aa = ax[ns];
+        return () => {
+            aa = aU;
+        };
+    };
+    $ezh.$s = (cb, element) => {
+        cb();
+        return element;
+    };
+    $ezh.$t = (id, text, mayChange) => {
+        const m = `${q.id}${id}${F}`;
+        let element = o.get(m);
+        if (element) {
+            if (mayChange) {
+                element.update(text);
+            }
+            return element;
+        }
+        element = new ao(m, text);
+        o.set(element.id, element);
+        return element;
+    };
+})($ezh || ($ezh = {}));
+//# sourceMappingURL=elements.js.map