verstak 0.23.125 → 0.24.107

package/build/dist/source/core/Verstak.js

@@ -1,887 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { reactive, unobs, Transaction, options, Reentrance, Rx, MergeList, ObservableObject, raw } from "reactronic";
-import { ElKind, Priority, Mode, Align } from "./Interfaces.js";
-import { emitLetters, equalElCoords, parseElCoords, getCallerInfo } from "./Utils.js";
-export class Verstak {
-    static specify(driver, spec, base) {
-        var _a;
-        let result;
-        if (spec)
-            spec.base = base;
-        else
-            spec = base !== null && base !== void 0 ? base : {};
-        let key = spec.key;
-        const owner = gCurrent === null || gCurrent === void 0 ? void 0 : gCurrent.instance;
-        if (owner) {
-            let ex = undefined;
-            const children = owner.node.children;
-            if (driver.isSeparator) {
-                const last = children.lastMergedItem();
-                if (((_a = last === null || last === void 0 ? void 0 : last.instance) === null || _a === void 0 ? void 0 : _a.node.driver) === driver)
-                    ex = last;
-            }
-            ex !== null && ex !== void 0 ? ex : (ex = children.tryMergeAsExisting(key = key || generateKey(owner), undefined, "nested elements can be declared inside update function only"));
-            if (ex) {
-                result = ex.instance;
-                const node = result.node;
-                if (node.driver !== driver && driver !== undefined)
-                    throw new Error(`changing element driver is not yet supported: "${result.node.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
-                const exTriggers = node.spec.triggers;
-                if (triggersAreEqual(spec.triggers, exTriggers))
-                    spec.triggers = exTriggers;
-                node.spec = spec;
-            }
-            else {
-                result = new ElImpl(key || generateKey(owner), driver, owner, spec);
-                result.node.slot = children.mergeAsAdded(result);
-            }
-        }
-        else {
-            result = new ElImpl(key || "", driver, owner, spec);
-            result.node.slot = MergeList.createItem(result);
-            triggerUpdate(result.node.slot);
-        }
-        return result;
-    }
-    static get element() {
-        if (gCurrent === undefined)
-            throw new Error("current element is undefined");
-        return gCurrent.instance;
-    }
-    static triggerUpdate(element, triggers) {
-        const el = element;
-        const spec = el.node.spec;
-        if (!triggersAreEqual(triggers, spec.triggers)) {
-            spec.triggers = triggers;
-            triggerUpdate(el.node.slot);
-        }
-    }
-    static updateNestedTreesThenDo(action) {
-        runUpdateNestedTreesThenDo(undefined, action);
-    }
-    static getDefaultLoggingOptions() {
-        return ElImpl.logging;
-    }
-    static setDefaultLoggingOptions(logging) {
-        ElImpl.logging = logging;
-    }
-}
-Verstak.shortFrameDuration = 16;
-Verstak.longFrameDuration = 300;
-Verstak.currentUpdatePriority = Priority.Realtime;
-Verstak.frameDuration = Verstak.longFrameDuration;
-export class BaseDriver {
-    constructor(name, isSeparator, preset) {
-        this.name = name;
-        this.isSeparator = isSeparator;
-        this.preset = preset;
-    }
-    specify(element) {
-        chainedSpecify(element, element.node.spec);
-    }
-    create(element) {
-        chainedCreate(element, element.node.spec);
-    }
-    initialize(element) {
-        var _a;
-        (_a = this.preset) === null || _a === void 0 ? void 0 : _a.call(this, element);
-        chainedInitialize(element, element.node.spec);
-    }
-    mount(element) {
-    }
-    update(element) {
-        chainedUpdated(element, element.node.spec);
-    }
-    finalize(element, isLeader) {
-        chainedFinalize(element, element.node.spec);
-        return isLeader;
-    }
-    applyKind(element, value) { }
-    applyCoords(element, value) { }
-    applyWidthGrowth(element, value) { }
-    applyMinWidth(element, value) { }
-    applyMaxWidth(element, value) { }
-    applyHeightGrowth(element, value) { }
-    applyMinHeight(element, value) { }
-    applyMaxHeight(element, value) { }
-    applyContentAlignment(element, value) { }
-    applyElementAlignment(element, value) { }
-    applyContentWrapping(element, value) { }
-    applyOverlayVisible(element, value) { }
-    applyStyle(element, secondary, styleName, enabled) { }
-}
-BaseDriver.fragment = new BaseDriver("fragment", false, el => el.kind = ElKind.Group);
-function generateKey(owner) {
-    const n = owner.node.numerator++;
-    const lettered = emitLetters(n);
-    let result;
-    if (Rx.isLogging)
-        result = `·${getCallerInfo(lettered)}`;
-    else
-        result = `·${lettered}`;
-    return result;
-}
-function chainedMode(bb) {
-    var _a;
-    return (_a = bb === null || bb === void 0 ? void 0 : bb.mode) !== null && _a !== void 0 ? _a : ((bb === null || bb === void 0 ? void 0 : bb.base) ? chainedMode(bb === null || bb === void 0 ? void 0 : bb.base) : Mode.Default);
-}
-function chainedSpecify(element, elb) {
-    const specify = elb.specify;
-    const base = elb.base;
-    if (specify)
-        specify(element, base ? () => chainedSpecify(element, base) : NOP);
-    else if (base)
-        chainedSpecify(element, base);
-}
-function chainedCreate(element, elb) {
-    const create = elb.create;
-    const base = elb.base;
-    if (create)
-        create(element, base ? () => chainedCreate(element, base) : NOP);
-    else if (base)
-        chainedCreate(element, base);
-}
-function chainedInitialize(element, elb) {
-    const initialize = elb.initialize;
-    const base = elb.base;
-    if (initialize)
-        initialize(element, base ? () => chainedInitialize(element, base) : NOP);
-    else if (base)
-        chainedInitialize(element, base);
-}
-function chainedUpdated(element, elb) {
-    const update = elb.update;
-    const base = elb.base;
-    if (update)
-        update(element, base ? () => chainedUpdated(element, base) : NOP);
-    else if (base)
-        chainedUpdated(element, base);
-}
-function chainedFinalize(element, elb) {
-    const finalize = elb.finalize;
-    const base = elb.base;
-    if (finalize)
-        finalize(element, base ? () => chainedFinalize(element, base) : NOP);
-    else if (base)
-        chainedFinalize(element, base);
-}
-export class StaticDriver extends BaseDriver {
-    constructor(native, name, isRow, preset) {
-        super(name, isRow, preset);
-        this.native = native;
-    }
-    create(element) {
-        element.native = this.native;
-    }
-}
-export class CursorCommand {
-}
-export class CursorCommandDriver extends BaseDriver {
-    constructor() {
-        super("cursor", false, el => el.kind = ElKind.Cursor);
-    }
-    create(element) {
-        element.native = new CursorCommand();
-        super.create(element);
-    }
-}
-export class SubTreeVariable {
-    constructor(defaultValue) {
-        this.defaultValue = defaultValue;
-    }
-    set value(value) {
-        ElImpl.setSubTreeVariableValue(this, value);
-    }
-    get value() {
-        return ElImpl.useSubTreeVariableValue(this);
-    }
-    get valueOrUndefined() {
-        return ElImpl.tryUseSubTreeVariable(this);
-    }
-}
-class CursorPosition {
-    constructor(prev) {
-        this.x = prev.x;
-        this.y = prev.y;
-        this.runningMaxX = prev.runningMaxX;
-        this.runningMaxY = prev.runningMaxY;
-        this.flags = prev.flags & ~CursorFlags.OwnCursorPosition;
-    }
-}
-var CursorFlags;
-(function (CursorFlags) {
-    CursorFlags[CursorFlags["None"] = 0] = "None";
-    CursorFlags[CursorFlags["OwnCursorPosition"] = 1] = "OwnCursorPosition";
-    CursorFlags[CursorFlags["UsesRunningColumnCount"] = 2] = "UsesRunningColumnCount";
-    CursorFlags[CursorFlags["UsesRunningRowCount"] = 4] = "UsesRunningRowCount";
-})(CursorFlags || (CursorFlags = {}));
-const UndefinedElCoords = Object.freeze({ x1: 0, y1: 0, x2: 0, y2: 0 });
-const InitialCursorPosition = Object.freeze(new CursorPosition({ x: 1, y: 1, runningMaxX: 0, runningMaxY: 0, flags: CursorFlags.None }));
-class RxNodeCtxImpl extends ObservableObject {
-    constructor(variable, value) {
-        super();
-        this.next = undefined;
-        this.variable = variable;
-        this.value = value;
-    }
-}
-__decorate([
-    raw,
-    __metadata("design:type", Object)
-], RxNodeCtxImpl.prototype, "next", void 0);
-__decorate([
-    raw,
-    __metadata("design:type", SubTreeVariable)
-], RxNodeCtxImpl.prototype, "variable", void 0);
-class RxNodeImpl {
-    constructor(key, driver, spec, element, owner) {
-        this.key = key;
-        this.driver = driver;
-        this.spec = spec;
-        if (owner) {
-            const node = owner;
-            this.level = node.level + 1;
-            this.owner = owner;
-            this.outer = node.context ? owner : node.outer;
-        }
-        else {
-            this.level = 1;
-            this.owner = owner = this;
-            this.outer = this;
-        }
-        this.host = this;
-        this.children = new MergeList(getNodeKey, true);
-        this.slot = undefined;
-        this.stamp = Number.MAX_SAFE_INTEGER;
-        this.context = undefined;
-        this.numerator = 0;
-        this.priority = Priority.Realtime;
-        this.childrenShuffling = false;
-        RxNodeImpl.grandNodeCount++;
-        if (this.has(Mode.PinpointUpdate))
-            RxNodeImpl.disposableNodeCount++;
-    }
-    get isInitialUpdate() { return this.stamp === 1; }
-    get strictOrder() { return this.children.isStrict; }
-    set strictOrder(value) { this.children.isStrict = value; }
-    get isMoved() { return this.owner.children.isMoved(this.slot); }
-    has(mode) {
-        return (chainedMode(this.spec) & mode) === mode;
-    }
-    update(_triggers) {
-        updateNow(this.slot);
-    }
-}
-RxNodeImpl.grandNodeCount = 0;
-RxNodeImpl.disposableNodeCount = 0;
-__decorate([
-    reactive,
-    options({
-        reentrance: Reentrance.CancelPrevious,
-        triggeringArgs: true,
-        noSideEffects: false,
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
-], RxNodeImpl.prototype, "update", null);
-class ElImpl {
-    constructor(key, driver, owner, spec) {
-        this.node = new RxNodeImpl(key, driver, spec, this, owner === null || owner === void 0 ? void 0 : owner.node);
-        this.maxColumnCount = 0;
-        this.maxRowCount = 0;
-        this.cursorPosition = undefined;
-        this.native = undefined;
-        this.model = undefined;
-        this.controller = undefined;
-        this._kind = ElKind.Row;
-        this._area = undefined;
-        this._coords = UndefinedElCoords;
-        this._widthGrowth = 0;
-        this._minWidth = "";
-        this._maxWidth = "";
-        this._heightGrowth = 0;
-        this._minHeight = "";
-        this._maxHeight = "";
-        this._contentAlignment = Align.Default;
-        this._elementAlignment = Align.Default;
-        this._contentWrapping = true;
-        this._overlayVisible = undefined;
-        this._hasStyles = false;
-    }
-    prepareForUpdate() {
-        this._area = undefined;
-        this._hasStyles = false;
-    }
-    get isAuxiliary() { return this.kind > ElKind.Note; }
-    get isSection() { return this.kind === ElKind.Section; }
-    get isTable() { return this.kind === ElKind.Table; }
-    get kind() { return this._kind; }
-    set kind(value) {
-        if (value !== this._kind || this.node.stamp >= Number.MAX_SAFE_INTEGER - 1) {
-            this.node.driver.applyKind(this, value);
-            this._kind = value;
-        }
-    }
-    get area() { return this._area; }
-    set area(value) {
-        var _a, _b;
-        const node = this.node;
-        const driver = node.driver;
-        if (!driver.isSeparator) {
-            const owner = node.owner;
-            const ownerEl = owner.slot.instance;
-            const cursorPosition = (_b = (_a = node.slot.prev) === null || _a === void 0 ? void 0 : _a.instance.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
-            const newCursorPosition = this.cursorPosition = owner.children.isStrict ? new CursorPosition(cursorPosition) : undefined;
-            const isCursorElement = driver instanceof CursorCommandDriver;
-            const coords = getEffectiveElCoords(!isCursorElement, value, ownerEl.maxColumnCount, ownerEl.maxRowCount, cursorPosition, newCursorPosition);
-            if (!equalElCoords(coords, this._coords)) {
-                driver.applyCoords(this, coords);
-                this._coords = coords;
-            }
-            this._area = value !== null && value !== void 0 ? value : {};
-        }
-        else
-            this.rowBreak();
-    }
-    get widthGrowth() { return this._widthGrowth; }
-    set widthGrowth(value) {
-        if (value !== this._widthGrowth) {
-            this.node.driver.applyWidthGrowth(this, value);
-            this._widthGrowth = value;
-        }
-    }
-    get minWidth() { return this._minWidth; }
-    set minWidth(value) {
-        if (value !== this._minWidth) {
-            this.node.driver.applyMinWidth(this, value);
-            this._minWidth = value;
-        }
-    }
-    get maxWidth() { return this._maxWidth; }
-    set maxWidth(value) {
-        if (value !== this._maxWidth) {
-            this.node.driver.applyMaxWidth(this, value);
-            this._maxWidth = value;
-        }
-    }
-    get heightGrowth() { return this._heightGrowth; }
-    set heightGrowth(value) {
-        if (value !== this._heightGrowth) {
-            this.node.driver.applyHeightGrowth(this, value);
-            this._heightGrowth = value;
-        }
-    }
-    get minHeight() { return this._minHeight; }
-    set minHeight(value) {
-        if (value !== this._minHeight) {
-            this.node.driver.applyMinHeight(this, value);
-            this._minHeight = value;
-        }
-    }
-    get maxHeight() { return this._maxHeight; }
-    set maxHeight(value) {
-        if (value !== this._maxHeight) {
-            this.node.driver.applyMaxHeight(this, value);
-            this._maxHeight = value;
-        }
-    }
-    get contentAlignment() { return this._contentAlignment; }
-    set contentAlignment(value) {
-        if (value !== this._contentAlignment) {
-            this.node.driver.applyContentAlignment(this, value);
-            this._contentAlignment = value;
-        }
-    }
-    get elementAlignment() { return this._elementAlignment; }
-    set elementAlignment(value) {
-        if (value !== this._elementAlignment) {
-            this.node.driver.applyElementAlignment(this, value);
-            this._elementAlignment = value;
-        }
-    }
-    get contentWrapping() { return this._contentWrapping; }
-    set contentWrapping(value) {
-        if (value !== this._contentWrapping) {
-            this.node.driver.applyContentWrapping(this, value);
-            this._contentWrapping = value;
-        }
-    }
-    get overlayVisible() { return this._overlayVisible; }
-    set overlayVisible(value) {
-        if (value !== this._overlayVisible) {
-            this.node.driver.applyOverlayVisible(this, value);
-            this._overlayVisible = value;
-        }
-    }
-    useStyle(styleName, enabled) {
-        this.node.driver.applyStyle(this, this._hasStyles, styleName, enabled);
-        this._hasStyles = true;
-    }
-    configureReactronic(options) {
-        const node = this.node;
-        if (node.stamp < Number.MAX_SAFE_INTEGER - 1 || !node.has(Mode.PinpointUpdate))
-            throw new Error("reactronic can be configured only for elements with pinpoint update mode and only inside initialize");
-        return Rx.getReaction(node.update).configure(options);
-    }
-    static get curr() {
-        if (!gCurrent)
-            throw new Error("current element is undefined");
-        return gCurrent;
-    }
-    static tryUseSubTreeVariable(variable) {
-        var _a, _b;
-        let el = ElImpl.curr.instance;
-        while (((_a = el.node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && el.node.owner !== el.node)
-            el = el.node.outer.slot.instance;
-        return (_b = el.node.context) === null || _b === void 0 ? void 0 : _b.value;
-    }
-    static useSubTreeVariableValue(variable) {
-        var _a;
-        const result = (_a = ElImpl.tryUseSubTreeVariable(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
-        if (!result)
-            throw new Error("context doesn't exist");
-        return result;
-    }
-    static setSubTreeVariableValue(variable, value) {
-        const el = ElImpl.curr.instance;
-        const node = el.node;
-        const owner = node.owner;
-        const hostCtx = unobs(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
-        if (value && value !== hostCtx) {
-            if (hostCtx)
-                node.outer = owner;
-            else
-                node.outer = owner.outer;
-            Transaction.run({ separation: true }, () => {
-                const ctx = node.context;
-                if (ctx) {
-                    ctx.variable = variable;
-                    ctx.value = value;
-                }
-                else
-                    node.context = new RxNodeCtxImpl(variable, value);
-            });
-        }
-        else if (hostCtx)
-            node.outer = owner;
-        else
-            node.outer = owner.outer;
-    }
-    rowBreak() {
-        var _a, _b;
-        const node = this.node;
-        const cursorPosition = (_b = (_a = node.slot.prev) === null || _a === void 0 ? void 0 : _a.instance.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
-        const newCursorPosition = this.cursorPosition = new CursorPosition(cursorPosition);
-        newCursorPosition.x = 1;
-        newCursorPosition.y = newCursorPosition.runningMaxY + 1;
-    }
-}
-ElImpl.logging = undefined;
-function getNodeKey(element) {
-    const node = element.node;
-    return node.stamp >= 0 ? node.key : undefined;
-}
-function getEffectiveElCoords(isRegularElement, area, maxX, maxY, cursorPosition, newCursorPosition) {
-    var _a, _b;
-    let result;
-    if (typeof (area) === "string") {
-        result = parseElCoords(area, { x1: 0, y1: 0, x2: 0, y2: 0 });
-        absolutizeElCoords(result, cursorPosition.x, cursorPosition.y, maxX || Infinity, maxY || Infinity, result);
-        if (newCursorPosition) {
-            newCursorPosition.x = isRegularElement ? result.x2 + 1 : result.x1;
-            newCursorPosition.y = result.y1;
-            newCursorPosition.flags = CursorFlags.OwnCursorPosition;
-        }
-    }
-    else if (newCursorPosition) {
-        let dx;
-        let dy;
-        if (area) {
-            dx = (_a = area.cellsOverWidth) !== null && _a !== void 0 ? _a : 1;
-            dy = (_b = area.cellsOverHeight) !== null && _b !== void 0 ? _b : 1;
-        }
-        else
-            dx = dy = 1;
-        const runningX = maxX !== 0 ? maxX : cursorPosition.runningMaxX;
-        const runningY = maxY !== 0 ? maxY : cursorPosition.runningMaxY;
-        result = { x1: 0, y1: 0, x2: 0, y2: 0 };
-        if (dx === 0 && isRegularElement) {
-            dx = runningX || 1;
-            newCursorPosition.flags = CursorFlags.UsesRunningColumnCount;
-        }
-        if (dx >= 0) {
-            if (isRegularElement) {
-                result.x1 = cursorPosition.x;
-                result.x2 = absolutizePosition(result.x1 + dx - 1, 0, maxX || Infinity);
-                newCursorPosition.x = result.x2 + 1;
-            }
-            else {
-                result.x1 = result.x2 = cursorPosition.x + dx;
-                newCursorPosition.x = result.x2;
-            }
-        }
-        else {
-            if (isRegularElement) {
-                result.x1 = Math.max(cursorPosition.x + dx, 1);
-                result.x2 = cursorPosition.x;
-                newCursorPosition.x = result.x2 + 1;
-            }
-            else {
-                result.x1 = result.x2 = cursorPosition.x + dx;
-                newCursorPosition.x = result.x2;
-            }
-        }
-        if (dy === 0 && isRegularElement) {
-            dy = runningY || 1;
-            newCursorPosition.flags |= CursorFlags.UsesRunningRowCount;
-        }
-        if (dy >= 0) {
-            if (isRegularElement) {
-                result.y1 = cursorPosition.y;
-                result.y2 = absolutizePosition(result.y1 + dy - 1, 0, maxY || Infinity);
-                if (result.y2 > newCursorPosition.runningMaxY)
-                    newCursorPosition.runningMaxY = result.y2;
-            }
-            else
-                result.y1 = result.y2 = cursorPosition.y + dy;
-        }
-        else {
-            if (isRegularElement) {
-                result.y1 = Math.max(cursorPosition.y + dy, 1);
-                result.y2 = cursorPosition.y;
-            }
-            else
-                result.y1 = result.y2 = cursorPosition.y + dy;
-        }
-    }
-    else
-        throw new Error("relative layout requires sequential children");
-    return result;
-}
-function runUpdateNestedTreesThenDo(error, action) {
-    var _a;
-    const curr = ElImpl.curr;
-    const owner = curr.instance;
-    const children = owner.node.children;
-    if (children.isMergeInProgress) {
-        let promised = undefined;
-        try {
-            children.endMerge(error);
-            for (const slot of children.removedItems(true))
-                triggerFinalization(slot, true, true);
-            if (!error) {
-                const ownerIsSection = owner.isSection;
-                const sequential = children.isStrict;
-                let p1 = undefined;
-                let p2 = undefined;
-                let mounting = false;
-                let hostingRow = owner;
-                for (const slot of children.items()) {
-                    if (Transaction.isCanceled)
-                        break;
-                    const el = slot.instance;
-                    const isSeparator = el.node.driver.isSeparator;
-                    const host = isSeparator ? owner : hostingRow;
-                    const p = (_a = el.node.priority) !== null && _a !== void 0 ? _a : Priority.Realtime;
-                    mounting = markToMountIfNecessary(mounting, host, slot, children, sequential);
-                    if (p === Priority.Realtime)
-                        triggerUpdate(slot);
-                    else if (p === Priority.Normal)
-                        p1 = push(slot, p1);
-                    else
-                        p2 = push(slot, p2);
-                    if (ownerIsSection && isSeparator)
-                        hostingRow = el;
-                }
-                if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
-                    promised = startIncrementalUpdate(curr, children, p1, p2).then(() => action(error), e => action(e));
-            }
-        }
-        finally {
-            if (!promised)
-                action(error);
-        }
-    }
-}
-function markToMountIfNecessary(mounting, host, slot, children, sequential) {
-    const el = slot.instance;
-    const node = el.node;
-    if (el.native && !node.has(Mode.ManualMount)) {
-        if (mounting || node.host !== host.node) {
-            children.markAsMoved(slot);
-            mounting = false;
-        }
-    }
-    else if (sequential && children.isMoved(slot))
-        mounting = true;
-    node.host = host.node;
-    return mounting;
-}
-function startIncrementalUpdate(owner, allChildren, priority1, priority2) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const stamp = owner.instance.node.stamp;
-        if (priority1)
-            yield updateIncrementally(owner, stamp, allChildren, priority1, Priority.Normal);
-        if (priority2)
-            yield updateIncrementally(owner, stamp, allChildren, priority2, Priority.Background);
-    });
-}
-function updateIncrementally(owner, stamp, allChildren, items, priority) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield Transaction.requestNextFrame();
-        const el = owner.instance;
-        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, Verstak.shortFrameDuration / 3)) {
-            let outerPriority = Verstak.currentUpdatePriority;
-            Verstak.currentUpdatePriority = priority;
-            try {
-                if (el.node.childrenShuffling)
-                    shuffle(items);
-                const frameDurationLimit = priority === Priority.Background ? Verstak.shortFrameDuration : Infinity;
-                let frameDuration = Math.min(frameDurationLimit, Math.max(Verstak.frameDuration / 4, Verstak.shortFrameDuration));
-                for (const child of items) {
-                    triggerUpdate(child);
-                    if (Transaction.isFrameOver(1, frameDuration)) {
-                        Verstak.currentUpdatePriority = outerPriority;
-                        yield Transaction.requestNextFrame(0);
-                        outerPriority = Verstak.currentUpdatePriority;
-                        Verstak.currentUpdatePriority = priority;
-                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, Verstak.frameDuration));
-                    }
-                    if (Transaction.isCanceled && Transaction.isFrameOver(1, Verstak.shortFrameDuration / 3))
-                        break;
-                }
-            }
-            finally {
-                Verstak.currentUpdatePriority = outerPriority;
-            }
-        }
-    });
-}
-function triggerUpdate(slot) {
-    const el = slot.instance;
-    const node = el.node;
-    if (node.stamp >= 0) {
-        if (node.has(Mode.PinpointUpdate)) {
-            if (node.stamp === Number.MAX_SAFE_INTEGER) {
-                Transaction.outside(() => {
-                    if (Rx.isLogging)
-                        Rx.setLoggingHint(el, node.key);
-                    Rx.getReaction(node.update).configure({
-                        order: node.level,
-                    });
-                });
-            }
-            unobs(node.update, node.spec.triggers);
-        }
-        else
-            updateNow(slot);
-    }
-}
-function mountOrRemountIfNecessary(element) {
-    const node = element.node;
-    const driver = node.driver;
-    if (node.stamp === Number.MAX_SAFE_INTEGER) {
-        node.stamp = Number.MAX_SAFE_INTEGER - 1;
-        unobs(() => {
-            driver.create(element);
-            driver.initialize(element);
-            if (!node.has(Mode.ManualMount)) {
-                node.stamp = 0;
-                if (element.node.host !== element.node)
-                    driver.mount(element);
-            }
-            node.stamp = 0;
-        });
-    }
-    else if (node.isMoved && !node.has(Mode.ManualMount) && element.node.host !== element.node)
-        unobs(() => driver.mount(element));
-}
-function updateNow(slot) {
-    const el = slot.instance;
-    const node = el.node;
-    if (node.stamp >= 0) {
-        let result = undefined;
-        runInside(slot, () => {
-            mountOrRemountIfNecessary(el);
-            if (node.stamp < Number.MAX_SAFE_INTEGER - 1) {
-                try {
-                    node.stamp++;
-                    node.numerator = 0;
-                    el.prepareForUpdate();
-                    node.children.beginMerge();
-                    const driver = node.driver;
-                    result = driver.update(el);
-                    if (el.area === undefined && node.owner.slot.instance.isTable)
-                        el.area = undefined;
-                    if (result instanceof Promise)
-                        result.then(v => { runUpdateNestedTreesThenDo(undefined, NOP); return v; }, e => { console.log(e); runUpdateNestedTreesThenDo(e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
-                    else
-                        runUpdateNestedTreesThenDo(undefined, NOP);
-                }
-                catch (e) {
-                    runUpdateNestedTreesThenDo(e, NOP);
-                    console.log(`Update failed: ${node.key}`);
-                    console.log(`${e}`);
-                }
-            }
-        });
-    }
-}
-function triggerFinalization(slot, isLeader, individual) {
-    const el = slot.instance;
-    const node = el.node;
-    if (node.stamp >= 0) {
-        const driver = node.driver;
-        if (individual && node.key !== node.spec.key && !driver.isSeparator)
-            console.log(`WARNING: it is recommended to assign explicit key for conditional element in order to avoid unexpected side effects: ${node.key}`);
-        node.stamp = ~node.stamp;
-        const childrenAreLeaders = unobs(() => driver.finalize(el, isLeader));
-        el.native = null;
-        el.controller = null;
-        if (node.has(Mode.PinpointUpdate)) {
-            slot.aux = undefined;
-            const last = gLastToDispose;
-            if (last)
-                gLastToDispose = last.aux = slot;
-            else
-                gFirstToDispose = gLastToDispose = slot;
-            if (gFirstToDispose === slot)
-                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${slot.instance.node.key})` }, () => {
-                    void runDisposalLoop().then(NOP, error => console.log(error));
-                });
-        }
-        for (const slot of node.children.items())
-            triggerFinalization(slot, childrenAreLeaders, false);
-        RxNodeImpl.grandNodeCount--;
-    }
-}
-function runDisposalLoop() {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield Transaction.requestNextFrame();
-        let slot = gFirstToDispose;
-        while (slot !== undefined) {
-            if (Transaction.isFrameOver(500, 5))
-                yield Transaction.requestNextFrame();
-            Rx.dispose(slot.instance);
-            slot = slot.aux;
-            RxNodeImpl.disposableNodeCount--;
-        }
-        gFirstToDispose = gLastToDispose = undefined;
-    });
-}
-function wrapToRunInside(func) {
-    let wrappedToRunInside;
-    const current = gCurrent;
-    if (current)
-        wrappedToRunInside = (...args) => {
-            return runInside(current, func, ...args);
-        };
-    else
-        wrappedToRunInside = func;
-    return wrappedToRunInside;
-}
-function runInside(slot, func, ...args) {
-    const outer = gCurrent;
-    try {
-        gCurrent = slot;
-        return func(...args);
-    }
-    finally {
-        gCurrent = outer;
-    }
-}
-function triggersAreEqual(a1, a2) {
-    let result = a1 === a2;
-    if (!result) {
-        if (Array.isArray(a1)) {
-            result = Array.isArray(a2) &&
-                a1.length === a2.length &&
-                a1.every((t, i) => t === a2[i]);
-        }
-        else if (a1 === Object(a1) && a2 === Object(a2)) {
-            for (const p in a1) {
-                result = a1[p] === a2[p];
-                if (!result)
-                    break;
-            }
-        }
-    }
-    return result;
-}
-function absolutizeElCoords(area, cursorX, cursorY, maxWidth, maxHeight, result) {
-    const x1 = absolutizePosition(area.x1, cursorX, maxWidth);
-    const x2 = absolutizePosition(area.x2, x1, maxWidth);
-    if (x1 <= x2)
-        result.x1 = x1, result.x2 = x2;
-    else
-        result.x1 = x2, result.x2 = x1;
-    const y1 = absolutizePosition(area.y1, cursorY, maxHeight);
-    const y2 = absolutizePosition(area.y2, y1, maxHeight);
-    if (y1 <= y2)
-        result.y1 = y1, result.y2 = y2;
-    else
-        result.y1 = y2, result.y2 = y1;
-    return result;
-}
-function absolutizePosition(pos, cursor, max) {
-    if (pos === 0)
-        pos = cursor;
-    else if (pos < 0)
-        pos = Math.max(max + pos, 1);
-    else
-        pos = Math.min(pos, max);
-    return pos;
-}
-function push(item, array) {
-    if (array == undefined)
-        array = new Array();
-    array.push(item);
-    return array;
-}
-function shuffle(array) {
-    const n = array.length - 1;
-    let i = n;
-    while (i >= 0) {
-        const j = Math.floor(Math.random() * n);
-        const t = array[i];
-        array[i] = array[j];
-        array[j] = t;
-        i--;
-    }
-    return array;
-}
-const ORIGINAL_PROMISE_THEN = Promise.prototype.then;
-function reactronicDomHookedThen(resolve, reject) {
-    resolve = resolve ? wrapToRunInside(resolve) : defaultResolve;
-    reject = reject ? wrapToRunInside(reject) : defaultReject;
-    return ORIGINAL_PROMISE_THEN.call(this, resolve, reject);
-}
-function defaultResolve(value) {
-    return value;
-}
-function defaultReject(error) {
-    throw error;
-}
-Promise.prototype.then = reactronicDomHookedThen;
-const NOP = (...args) => { };
-let gCurrent = undefined;
-let gFirstToDispose = undefined;
-let gLastToDispose = undefined;