ezh 0.2.0 → 0.2.2

package/lib/elements.js

@@ -1,1256 +0,0 @@
-import { Z, Q, O, R } from './RbTree';
-const S = {
-    '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 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 = {
-    id: '',
-    index: 0,
-    firstElement: null,
-    attachTo: A,
-    move: A,
-    detachFrom: A,
-    update: A,
-    refresh: A,
-    release: A,
-    version: 1,
-    markChanged: A,
-    watchMountChange: A,
-};
-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 a5 = aE;
-const av = {
-    'svg': (w, K) => {
-        K.a4();
-        return document.createElementNS('http://www.w3.org/2000/svg', w);
-    },
-    'math': (w, K) => {
-        K.a4();
-        return document.createElementNS('http://www.w3.org/1998/Math/MathML', w);
-    },
-    'foreignObject': (w, K) => {
-        if (w !== 'foreignObject') {
-            return document.createElement(w);
-        }
-        K.a4();
-        return document.createElementNS('http://www.w3.org/2000/svg', w);
-    },
-};
-const ai = () => {
-    if (++au >= H) {
-        for (const element of x) {
-            x.delete(element);
-            if (element.id) {
-                element.release();
-            }
-            else {
-                if (--au < H) {
-                    x.add(element);
-                    break;
-                }
-            }
-        }
-    }
-    else {
-        x.add(Object.create(at));
-    }
-    if (I) {
-        I = setTimeout(ai, ah);
-    }
-};
-const aw = (parent, l) => {
-    const ax = ['', l];
-    while (parent.constructor !== ag) {
-        ax.push(parent.id);
-        parent = parent.parent;
-    }
-    return ax.reverse().join(',');
-};
-const aF = () => {
-    let element;
-    while (element = E.ap(true)) {
-        const { id, newChildren, parent } = element;
-        if (newChildren) {
-            if (parent && aj(parent)) {
-                element.refresh(newChildren);
-                parent.currentBefore = undefined;
-            }
-            else if (element.version) {
-                a3._(id, element);
-            }
-        }
-    }
-    J++;
-    for (const { parent, element } of v) {
-        if (element.parent !== parent) {
-            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 O;
-                }, a6);
-            }
-        }
-        if (!element.parent) {
-            if (H) {
-                x.add(element);
-            }
-            else {
-                element.release();
-            }
-        }
-    }
-    v.length = 0;
-};
-const L = (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':
-                    L(a, f);
-                    break;
-                case 'function':
-                    a = a();
-                    continue;
-                case 'boolean':
-                case 'number':
-                case 'bigint':
-                    a = '' + a;
-                default:
-                    f.push(new ak('', a));
-            }
-        }
-        if (++from < children.length) {
-            a = children[from];
-        }
-        else {
-            break;
-        }
-    }
-    return f;
-};
-const a7 = (y, children, parent) => {
-    let f;
-    const length = y.length;
-    let newChildren = children;
-    let b = 0;
-    while (b < length) {
-        const ay = y[b];
-        if (ay !== newChildren[b]) {
-            if (b === newChildren.length) {
-                return newChildren;
-            }
-            const a = newChildren[b];
-            if (!a || a.id === undefined) {
-                newChildren = L(newChildren, newChildren.slice(0, b), b);
-                continue;
-            }
-            else if (f !== newChildren) {
-                break;
-            }
-        }
-        if (!f && ay.parent !== parent) {
-            f = y;
-        }
-        b++;
-    }
-    if (b === newChildren.length) {
-        return f;
-    }
-    return newChildren === children ? L(newChildren, y.slice(0, b), b) : newChildren;
-};
-const aj = (element) => {
-    let parent = element;
-    do {
-        if (parent.parent === parent) {
-            return true;
-        }
-        parent = parent.parent;
-    } while (parent);
-    return false;
-};
-const a8 = (y, newChildren, parent, aG) => {
-    let b, h;
-    let a;
-    if (newChildren !== y && y.length) {
-        const al = [];
-        let r;
-        h = newChildren.length;
-        b = 10000000;
-        while (--h >= 0) {
-            a = newChildren[h];
-            if (a.parent === parent) {
-                const az = h - a.index;
-                if (az === b) {
-                    r.C++;
-                    a.index = h;
-                }
-                else {
-                    r = {
-                        from: a.index,
-                        to: h,
-                        C: 1,
-                    };
-                    b = az;
-                    a.index = -al.push(r);
-                }
-            }
-            else if (b !== 10000000) {
-                b = 10000000;
-            }
-        }
-        const am = [];
-        h = y.length - 1;
-        while (h >= 0) {
-            a = y[h];
-            if (a.index < 0) {
-                r = al[-a.index - 1];
-                am.push(r);
-                h -= r.C;
-            }
-            else {
-                a.detachFrom(parent);
-                h--;
-            }
-        }
-        let M;
-        let a9;
-        let aa = 0;
-        h = newChildren.length - 1;
-        while (h >= 0) {
-            a = newChildren[h];
-            if (a.parent !== parent) {
-                a.index = h--;
-                a.attachTo(parent);
-            }
-            else {
-                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 (M.from > r.from) {
-                        b = aa;
-                        do {
-                            a9 -= M.C;
-                            M = am[++b];
-                        } while (M.from > r.from && a9 > 0);
-                        if (a9 > 0) {
-                            h -= r.C;
-                            parent.currentBefore = undefined;
-                            aa = b;
-                            continue;
-                        }
-                    }
-                }
-                b = h - r.C;
-                do {
-                    a.move();
-                } while (--h > b && (a = newChildren[h]));
-            }
-        }
-    }
-    else {
-        for (h = newChildren.length - 1; h >= 0; h--) {
-            a = newChildren[h];
-            a.index = h;
-            if (parent !== a.parent) {
-                a.attachTo(parent);
-            }
-        }
-    }
-    parent.currentBefore = undefined;
-};
-class ak {
-    constructor(id, text) {
-        this.id = id;
-        this.index = 0;
-        this.ab = text;
-    }
-    id;
-    parent;
-    index;
-    firstElement;
-    attachTo(target) {
-        if (!this.firstElement) {
-            this.firstElement = document.createTextNode(this.ab);
-        }
-        const { parent, firstElement, index } = this;
-        if (this.id) {
-            if (!parent) {
-                x.delete(this);
-            }
-            else {
-                v.push({ parent, element: this });
-                firstElement.remove();
-            }
-        }
-        this.parent = target;
-        let p = target.currentBefore;
-        if (p === undefined) {
-            p = target.findNextSiblingElement(index);
-        }
-        target.element.insertBefore(firstElement, p);
-        target.currentBefore = firstElement;
-    }
-    move() {
-        const { parent, index, firstElement } = this;
-        let p = parent.currentBefore;
-        if (p === undefined) {
-            p = parent.findNextSiblingElement(index);
-        }
-        parent.element.insertBefore(firstElement, p);
-        parent.currentBefore = firstElement;
-    }
-    detachFrom(target) {
-        if (this.parent === target) {
-            this.firstElement.remove();
-            this.parent = undefined;
-            if (this.id) {
-                v.push({ parent: target, element: this });
-            }
-        }
-    }
-    update(text) {
-        if (this.ab !== text) {
-            this.ab = text;
-            if (this.firstElement) {
-                this.firstElement.nodeValue = text;
-            }
-        }
-        return false;
-    }
-    refresh() { }
-    release(target) {
-        if (this.parent === target) {
-            if (target) {
-                this.firstElement.remove();
-            }
-            m.delete(this.id);
-        }
-    }
-    ab;
-}
-export class aH {
-    constructor(id, children, aI) {
-        this.id = id;
-        this.index = 0;
-        this.newChildren = this.d = aI ? L(children) : (children || U);
-    }
-    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 e = d[b].firstElement;
-            if (e) {
-                return e;
-            }
-        }
-        return null;
-    }
-    attachTo(target) {
-        const { parent, d, newChildren } = this;
-        if (!parent) {
-            x.delete(this);
-        }
-        else {
-            v.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) {
-            a8(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;
-            v.push({ parent: target, element: this });
-        }
-    }
-    update(n, children) {
-        if (children) {
-            const newChildren = a7(this.d, children, this);
-            if (newChildren) {
-                this.newChildren = newChildren;
-                return true;
-            }
-        }
-        return false;
-    }
-    refresh(newChildren) {
-        a8(this.d, newChildren, this);
-        this.d = newChildren;
-        this.newChildren = undefined;
-    }
-    release(target) {
-        if (this.parent === target) {
-            if (target) {
-                const { d } = this;
-                for (const a of d) {
-                    a.detachFrom(this);
-                }
-            }
-            m.delete(this.id);
-        }
-    }
-    findNextSiblingElement(index) {
-        const children = this.newChildren || this.d;
-        let e;
-        let b = index + 1;
-        let a = children[b];
-        while (a) {
-            e = a.firstElement;
-            if (e) {
-                return e;
-            }
-            a = children[++b];
-        }
-        e = this.parent.currentBefore;
-        return e !== undefined ? e : this.parent.findNextSiblingElement(this.index);
-    }
-    d;
-}
-export class aJ {
-    constructor(id, tag, props, children, check, mutableChild) {
-        this.id = id;
-        this.index = 0;
-        this.firstElement = this.element = a5(tag, this);
-        this.newChildren = this.d = mutableChild ? L(children) : (children || U);
-        if (props) {
-            this.n = a2;
-            this.s = -1;
-            if (tag === 'select') {
-                const an = this.element;
-                const ao = props;
-                const c = ao.value;
-                if (c) {
-                    ao.value = undefined;
-                    const aK = this.refresh;
-                    this.refresh = (newChildren) => {
-                        a8(this.d, newChildren, this);
-                        this.d = newChildren;
-                        this.newChildren = undefined;
-                        if (Array.isArray(c)) {
-                            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 {
-                            an.value = c;
-                        }
-                        ao.value = c;
-                        this.refresh = aK;
-                    };
-                }
-            }
-            this.update(props);
-            this.s = check ?? 0;
-        }
-        else {
-            this.n = props;
-            this.s = 0;
-        }
-    }
-    id;
-    element;
-    parent;
-    newChildren;
-    index;
-    currentBefore;
-    firstElement;
-    attachTo(target) {
-        const { parent, element, newChildren, index } = this;
-        if (!parent) {
-            x.delete(this);
-        }
-        else {
-            v.push({ parent, element: this });
-            element.remove();
-        }
-        this.parent = target;
-        if (newChildren) {
-            this.refresh(newChildren);
-        }
-        let p = target.currentBefore;
-        if (p === undefined) {
-            p = target.findNextSiblingElement(index);
-        }
-        target.element.insertBefore(element, p);
-        target.currentBefore = element;
-    }
-    move() {
-        const { parent, newChildren, index, element } = this;
-        if (newChildren) {
-            this.refresh(newChildren);
-        }
-        let p = parent.currentBefore;
-        if (p === undefined) {
-            p = parent.findNextSiblingElement(index);
-        }
-        parent.element.insertBefore(element, p);
-        parent.currentBefore = element;
-    }
-    detachFrom(target) {
-        if (this.parent === target) {
-            this.element.remove();
-            this.parent = undefined;
-            v.push({ parent: target, element: this });
-        }
-    }
-    update(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 = n[key];
-                if (c !== g) {
-                    if (c !== null && c !== undefined) {
-                        switch (typeof c) {
-                            case 'string': {
-                                const W = S[key];
-                                if (!W) {
-                                    element[key] = c;
-                                }
-                                else {
-                                    element.setAttribute(W, c);
-                                }
-                                break;
-                            }
-                            case 'number':
-                            case 'boolean':
-                            case 'function': {
-                                element[key] = c;
-                                break;
-                            }
-                            default: {
-                                if (Array.isArray(c)) {
-                                    const [state, V, N] = c;
-                                    if (g) {
-                                        const [aL, aM, aN, a_] = g;
-                                        if (aN !== N && element[key] !== N) {
-                                            element[key] = N;
-                                        }
-                                        if (aL === state && aM === V) {
-                                            c[3] = a_;
-                                        }
-                                        else {
-                                            const z = c[3] = (u) => state[V] = u.target[key];
-                                            element.removeEventListener('change', a_);
-                                            element.addEventListener('change', z);
-                                        }
-                                    }
-                                    else {
-                                        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 q = {};
-                                        let j = 0;
-                                        for (const k in c) {
-                                            const X = c[k];
-                                            q[k] = X;
-                                            j++;
-                                            style[k] = X;
-                                        }
-                                        props[key] = q;
-                                        q.j = j;
-                                        break;
-                                    }
-                                    const style = element.style;
-                                    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--;
-                                        }
-                                        j++;
-                                        if (G !== g[key]) {
-                                            style[k] = G;
-                                        }
-                                    }
-                                    props[key] = q;
-                                    q.j = j;
-                                    if (F) {
-                                        for (const k in g) {
-                                            if (!(k in c)) {
-                                                style[k] = null;
-                                                if (!--F) {
-                                                    break;
-                                                }
-                                            }
-                                        }
-                                    }
-                                    break;
-                                }
-                                element[key] = c;
-                            }
-                        }
-                    }
-                    else {
-                        switch (typeof g) {
-                            case 'string': {
-                                const W = S[key];
-                                if (!W) {
-                                    this.element[key] = c;
-                                }
-                                else {
-                                    this.element.removeAttribute(W);
-                                }
-                                break;
-                            }
-                            case 'object': {
-                                if (g) {
-                                    if (Array.isArray(g)) {
-                                        element.removeEventListener('change', g[3]);
-                                    }
-                                    else if (g === a2) {
-                                        element[key] = c;
-                                    }
-                                }
-                                else {
-                                    element[key] = c;
-                                }
-                                break;
-                            }
-                            default: {
-                                element[key] = c;
-                            }
-                        }
-                    }
-                }
-                if (!--j) {
-                    break;
-                }
-            }
-        }
-        if (children) {
-            const newChildren = a7(this.d, children, this);
-            if (newChildren) {
-                this.newChildren = newChildren;
-                return true;
-            }
-        }
-        return false;
-    }
-    refresh(newChildren) {
-        a8(this.d, newChildren, this);
-        this.d = newChildren;
-        this.newChildren = undefined;
-    }
-    release(target) {
-        if (this.parent === target) {
-            if (target) {
-                this.element.remove();
-            }
-            const { d } = this;
-            for (const a of d) {
-                a.release(this);
-            }
-            m.delete(this.id);
-        }
-    }
-    findNextSiblingElement(index) {
-        const children = this.newChildren || this.d;
-        let e;
-        let b = index + 1;
-        let a = children[b];
-        while (a) {
-            e = a.firstElement;
-            if (e) {
-                return e;
-            }
-            a = children[++b];
-        }
-        return null;
-    }
-    a4() {
-        this.update = this.aO;
-    }
-    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 = n[key];
-                if (c !== g) {
-                    if (c !== null && c !== undefined) {
-                        switch (typeof c) {
-                            case 'string': {
-                                element.setAttribute(S[key] ?? key, c);
-                                break;
-                            }
-                            case 'number':
-                            case 'boolean': {
-                                element.setAttribute(S[key] ?? key, '' + c);
-                                break;
-                            }
-                            case 'function': {
-                                element[key] = c;
-                                break;
-                            }
-                            default: {
-                                if (key === 'style') {
-                                    if (!g) {
-                                        const style = element.style;
-                                        const q = {};
-                                        let j = 0;
-                                        for (const k in c) {
-                                            const X = c[k];
-                                            q[k] = X;
-                                            j++;
-                                            style[k] = X;
-                                        }
-                                        props[key] = q;
-                                        q.j = j;
-                                        break;
-                                    }
-                                    const style = element.style;
-                                    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--;
-                                        }
-                                        j++;
-                                        if (G !== g[key]) {
-                                            style[k] = G;
-                                        }
-                                    }
-                                    props[key] = q;
-                                    q.j = j;
-                                    if (F) {
-                                        for (const k in g) {
-                                            if (!(k in c)) {
-                                                style[k] = null;
-                                                if (!--F) {
-                                                    break;
-                                                }
-                                            }
-                                        }
-                                    }
-                                    break;
-                                }
-                                element[key] = c;
-                            }
-                        }
-                    }
-                    else {
-                        const aP = typeof g;
-                        switch (aP) {
-                            case 'string':
-                            case 'number':
-                            case 'boolean': {
-                                element.removeAttribute(S[key] ?? key);
-                                break;
-                            }
-                            default: {
-                                element[key] = c;
-                            }
-                        }
-                    }
-                }
-                if (!--j) {
-                    break;
-                }
-            }
-        }
-        if (children) {
-            const newChildren = a7(this.d, children, this);
-            if (newChildren) {
-                this.newChildren = newChildren;
-                return true;
-            }
-        }
-        return false;
-    }
-    n;
-    d;
-    s;
-}
-export class aA {
-    constructor(id, entry, props, children, check, mutableChild) {
-        this.id = id;
-        this.index = 0;
-        this.version = 1;
-        this.aB = entry;
-        this.n = props;
-        this.newChildren = this.d = mutableChild ? L(children) : (children || U);
-        this.s = check ?? 0;
-    }
-    id;
-    parent;
-    newChildren;
-    index;
-    version;
-    get firstElement() {
-        return this.i?.firstElement || null;
-    }
-    attachTo(target) {
-        const { parent, newChildren, i } = this;
-        this.parent = target;
-        if (newChildren) {
-            this.refresh(newChildren);
-        }
-        else if (i) {
-            i.index = this.index;
-            i.attachTo(target);
-        }
-        if (!parent) {
-            x.delete(this);
-        }
-        else {
-            v.push({ parent, element: this });
-        }
-    }
-    move() {
-        const { newChildren, i } = this;
-        if (newChildren) {
-            this.refresh(newChildren);
-        }
-        else if (i) {
-            i.index = this.index;
-            i.move();
-        }
-    }
-    detachFrom(target) {
-        if (this.parent === target) {
-            this.i?.detachFrom(target);
-            this.parent = undefined;
-            v.push({ parent: target, element: this });
-        }
-    }
-    update(props, children) {
-        const { n, d, s } = this;
-        this.n = props;
-        if (children) {
-            const newChildren = a7(d, children, this.parent);
-            if (newChildren) {
-                this.newChildren = newChildren;
-                return true;
-            }
-        }
-        if (!this.newChildren && s) {
-            let j = s;
-            for (const key in n) {
-                if (n[key] !== props[key]) {
-                    this.newChildren = d;
-                    return true;
-                }
-                if (!--j) {
-                    break;
-                }
-            }
-        }
-        return false;
-    }
-    refresh(newChildren) {
-        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':
-                    t = '' + t;
-                case 'string':
-                    t = new ak('', t);
-                    this.i = t;
-                    t.index = index;
-                    t.attachTo(parent);
-                    i?.detachFrom(parent);
-                    break;
-                default:
-                    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 && aj(com.parent)) {
-                                    E._(Y, com);
-                                    return Q;
-                                }
-                                return Z;
-                            }, id);
-                        }
-                    }
-                    else {
-                        this.i = undefined;
-                        i?.detachFrom(parent);
-                    }
-            }
-        }
-        else if (i) {
-            if (i.parent !== parent) {
-                i.index = index;
-                i.attachTo(parent);
-            }
-            else if (i.index !== index) {
-                i.index = index;
-                i.move();
-            }
-        }
-        this.d = newChildren;
-        this.newChildren = undefined;
-        o = aQ;
-    }
-    release(target) {
-        if (this.parent === target) {
-            this.i?.release(target);
-            this.parent = undefined;
-            if (this.newChildren) {
-                a3.delete(this.id);
-            }
-            m.delete(this.id);
-        }
-    }
-    markChanged() {
-        if (!this.newChildren) {
-            this.newChildren = this.d;
-            return true;
-        }
-        return false;
-    }
-    watchMountChange(aR, z, a0) {
-        const a6 = aw(this.parent, this.id);
-        af._(a6 + aR, { z, a0 }, true);
-    }
-    aB;
-    n;
-    d;
-    s;
-    i;
-}
-class ag {
-    constructor(id, rootElement) {
-        this.id = id;
-        this.element = rootElement;
-        this.parent = this;
-    }
-    id;
-    element;
-    parent;
-    currentBefore;
-    findNextSiblingElement(aX) {
-        return null;
-    }
-    render(entry) {
-        if (!this.ac) {
-            this.ac = new aA(this.id, entry, null, U);
-            m.set(this.id, this.ac);
-            this.ac.attachTo(this);
-            J++;
-        }
-    }
-    ac;
-}
-export const addComReader = (readerRecord, key) => {
-    if (o.id) {
-        let D = readerRecord[key];
-        if (!D) {
-            D = new Map();
-            readerRecord[key] = D;
-        }
-        D.set(o.id, o.version);
-    }
-};
-export let refreshComReaders = (readerRecord, key) => {
-    const D = readerRecord[key];
-    if (D) {
-        for (const [Y, version] of D) {
-            const com = m.get(Y);
-            if (com?.version === version && com.markChanged()) {
-                if (E.ad()) {
-                    queueMicrotask(aF);
-                }
-                E._(Y, com);
-            }
-        }
-        D.clear();
-    }
-};
-export const aC = (replace) => refreshComReaders = replace;
-export const configGC = (waitIntervals, interval = 20000) => {
-    if (waitIntervals >= 0 && interval >= 1000) {
-        ah = interval;
-        if (H) {
-            clearTimeout(I);
-        }
-        if (waitIntervals) {
-            I = setTimeout(ai, ah);
-        }
-        else if (I) {
-            I = undefined;
-            for (let b = 0; b < H; b++) {
-                ai();
-            }
-        }
-        H = waitIntervals;
-        return true;
-    }
-    return false;
-};
-const aS = () => {
-    B = ar.pop();
-};
-export var $ezh;
-(function ($ezh) {
-    $ezh.render = (rootElement, 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 l = `${o.id}${id}${B}`;
-        let element = m.get(l);
-        if (element) {
-            if ((props || children) && element.update(props, children)) {
-                E._(l, element);
-            }
-            return 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 l = `${o.id}${id}${B}`;
-        let element = m.get(l);
-        if (element) {
-            if ((props || children) && element.update(props, children)) {
-                E._(l, element);
-            }
-            return element;
-        }
-        element = new aA(l, entry, props, children, check, mutableChild);
-        m.set(l, element);
-        return element;
-    };
-    $ezh.$f = (id, children, mutableChild) => {
-        const l = `${o.id}${id}${B}`;
-        let element = m.get(l);
-        if (element) {
-            if (children && element.update(null, children)) {
-                E._(l, element);
-            }
-            return element;
-        }
-        element = new aH(l, children, mutableChild);
-        m.set(l, element);
-        return element;
-    };
-    $ezh.$k = (key) => {
-        ar.push(B);
-        B = `${B || '{'}${key}}`;
-        return aS;
-    };
-    $ezh.$n = (ns) => {
-        const aT = a5;
-        a5 = av[ns];
-        return () => {
-            a5 = aT;
-        };
-    };
-    $ezh.$s = (cb, element) => {
-        cb();
-        return element;
-    };
-    $ezh.$t = (id, text, mayChange) => {
-        const l = `${o.id}${id}${B}`;
-        let element = m.get(l);
-        if (element) {
-            if (mayChange) {
-                element.update(text);
-            }
-            return element;
-        }
-        element = new ak(l, text);
-        m.set(element.id, element);
-        return element;
-    };
-})($ezh || ($ezh = {}));
-//# sourceMappingURL=elements.js.map