verstak 0.23.107 → 0.23.109

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

@@ -0,0 +1,877 @@
+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, nonreactive, Transaction, options, Reentrance, Rx, Collection, ObservableObject, raw } from "reactronic";
+import { BlockKind, Priority, Mode, Align } from "./Interfaces";
+import { emitLetters, equalBlockCoords, parseBlockCoords, getCallerInfo } from "./Utils";
+export class Verstak {
+    static claim(driver, builder, base) {
+        var _a;
+        let result;
+        if (builder)
+            builder.base = base;
+        else
+            builder = base !== null && base !== void 0 ? base : {};
+        let key = builder.key;
+        const owner = gCurrent === null || gCurrent === void 0 ? void 0 : gCurrent.instance;
+        if (owner) {
+            let ex = undefined;
+            const children = owner.descriptor.children;
+            if (driver.isRow) {
+                const last = children.lastClaimedItem();
+                if (((_a = last === null || last === void 0 ? void 0 : last.instance) === null || _a === void 0 ? void 0 : _a.descriptor.driver) === driver)
+                    ex = last;
+            }
+            ex !== null && ex !== void 0 ? ex : (ex = children.claim(key = key || generateKey(owner), undefined, "nested blocks can be declared inside render function only"));
+            if (ex) {
+                result = ex.instance;
+                const d = result.descriptor;
+                if (d.driver !== driver && driver !== undefined)
+                    throw new Error(`changing block driver is not yet supported: "${result.descriptor.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
+                const exTriggers = d.builder.triggers;
+                if (triggersAreEqual(builder.triggers, exTriggers))
+                    builder.triggers = exTriggers;
+                d.builder = builder;
+            }
+            else {
+                result = new BlockImpl(key || generateKey(owner), driver, owner, builder);
+                result.descriptor.item = children.add(result);
+            }
+        }
+        else {
+            result = new BlockImpl(key || "", driver, owner, builder);
+            result.descriptor.item = Collection.createItem(result);
+            triggerRendering(result.descriptor.item);
+        }
+        return result;
+    }
+    static get block() {
+        if (gCurrent === undefined)
+            throw new Error("current block is undefined");
+        return gCurrent.instance;
+    }
+    static renderNestedTreesThenDo(action) {
+        runRenderNestedTreesThenDo(undefined, action);
+    }
+    static getDefaultLoggingOptions() {
+        return BlockImpl.logging;
+    }
+    static setDefaultLoggingOptions(logging) {
+        BlockImpl.logging = logging;
+    }
+}
+Verstak.shortFrameDuration = 16;
+Verstak.longFrameDuration = 300;
+Verstak.currentRenderingPriority = Priority.Realtime;
+Verstak.frameDuration = Verstak.longFrameDuration;
+export class BaseDriver {
+    constructor(name, isRow, preset) {
+        this.name = name;
+        this.isRow = isRow;
+        this.preset = preset;
+    }
+    claim(block) {
+        const b = block;
+        chainedClaim(b, b.descriptor.builder);
+    }
+    create(block, b) {
+        chainedCreate(block, block.descriptor.builder);
+    }
+    initialize(block) {
+        var _a;
+        const b = block;
+        (_a = this.preset) === null || _a === void 0 ? void 0 : _a.call(this, b);
+        chainedInitialize(b, b.descriptor.builder);
+    }
+    mount(block) {
+    }
+    render(block) {
+        chainedRender(block, block.descriptor.builder);
+    }
+    finalize(block, isLeader) {
+        const b = block;
+        chainedFinalize(b, b.descriptor.builder);
+        return isLeader;
+    }
+    applyKind(block, value) { }
+    applyCoords(block, value) { }
+    applyWidthGrowth(block, value) { }
+    applyMinWidth(block, value) { }
+    applyMaxWidth(block, value) { }
+    applyHeightGrowth(block, value) { }
+    applyMinHeight(block, value) { }
+    applyMaxHeight(block, value) { }
+    applyContentAlignment(block, value) { }
+    applyBlockAlignment(block, value) { }
+    applyContentWrapping(block, value) { }
+    applyOverlayVisible(block, value) { }
+    applyStyle(block, secondary, styleName, enabled) { }
+}
+BaseDriver.fragment = new BaseDriver("fragment", false, b => b.kind = BlockKind.Group);
+function generateKey(owner) {
+    const n = owner.descriptor.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 chainedClaim(block, bb) {
+    const claim = bb.claim;
+    const base = bb.base;
+    if (claim)
+        claim(block, base ? () => chainedClaim(block, base) : NOP);
+    else if (base)
+        chainedClaim(block, base);
+}
+function chainedCreate(block, bb) {
+    const create = bb.create;
+    const base = bb.base;
+    if (create)
+        create(block, base ? () => chainedCreate(block, base) : NOP);
+    else if (base)
+        chainedCreate(block, base);
+}
+function chainedInitialize(block, bb) {
+    const initialize = bb.initialize;
+    const base = bb.base;
+    if (initialize)
+        initialize(block, base ? () => chainedInitialize(block, base) : NOP);
+    else if (base)
+        chainedInitialize(block, base);
+}
+function chainedRender(block, bb) {
+    const render = bb.render;
+    const base = bb.base;
+    if (render)
+        render(block, base ? () => chainedRender(block, base) : NOP);
+    else if (base)
+        chainedRender(block, base);
+}
+function chainedFinalize(block, bb) {
+    const finalize = bb.finalize;
+    const base = bb.base;
+    if (finalize)
+        finalize(block, base ? () => chainedFinalize(block, base) : NOP);
+    else if (base)
+        chainedFinalize(block, base);
+}
+export class StaticDriver extends BaseDriver {
+    constructor(element, name, isRow, preset) {
+        super(name, isRow, preset);
+        this.element = element;
+    }
+    create(block, b) {
+        b.native = this.element;
+    }
+}
+export class CursorCommand {
+}
+export class CursorCommandDriver extends BaseDriver {
+    constructor() {
+        super("cursor", false, b => b.kind = BlockKind.Cursor);
+    }
+    create(block, b) {
+        b.native = new CursorCommand();
+        super.create(block, b);
+    }
+}
+export class ContextVariable {
+    constructor(defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+    set value(value) {
+        BlockImpl.setContextVariableValue(this, value);
+    }
+    get value() {
+        return BlockImpl.useContextVariableValue(this);
+    }
+    get valueOrUndefined() {
+        return BlockImpl.tryUseContextVariable(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 UndefinedBlockCoords = 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 BlockCtxImpl extends ObservableObject {
+    constructor(variable, value) {
+        super();
+        this.next = undefined;
+        this.variable = variable;
+        this.value = value;
+    }
+}
+__decorate([
+    raw,
+    __metadata("design:type", Object)
+], BlockCtxImpl.prototype, "next", void 0);
+__decorate([
+    raw,
+    __metadata("design:type", ContextVariable)
+], BlockCtxImpl.prototype, "variable", void 0);
+class BlockDescriptorImpl {
+    constructor(key, driver, builder, self, owner) {
+        this.maxColumnCount = 0;
+        this.maxRowCount = 0;
+        this.key = key;
+        this.driver = driver;
+        this.builder = builder;
+        if (owner) {
+            const d = owner.descriptor;
+            this.level = d.level + 1;
+            this.owner = owner;
+            this.outer = d.context ? owner : d.outer;
+        }
+        else {
+            this.level = 1;
+            this.owner = owner = self;
+            this.outer = self;
+        }
+        this.host = self;
+        this.children = new Collection(getBlockKey, true);
+        this.item = undefined;
+        this.stamp = 0;
+        this.context = undefined;
+        this.numerator = 0;
+        this.maxColumnCount = 0;
+        this.maxRowCount = 0;
+        this.cursorPosition = undefined;
+    }
+}
+class BlockImpl {
+    constructor(key, driver, owner, builder) {
+        this.descriptor = new BlockDescriptorImpl(key, driver, builder, this, owner);
+        this.native = undefined;
+        this.model = undefined;
+        this.controller = undefined;
+        this._kind = BlockKind.Row;
+        this._area = undefined;
+        this._coords = UndefinedBlockCoords;
+        this._widthGrowth = 0;
+        this._minWidth = "";
+        this._maxWidth = "";
+        this._heightGrowth = 0;
+        this._minHeight = "";
+        this._maxHeight = "";
+        this._contentAlignment = Align.Default;
+        this._blockAlignment = Align.Default;
+        this._contentWrapping = false;
+        this._overlayVisible = undefined;
+        this._hasStyles = false;
+        this.childrenShuffling = false;
+        this.renderingPriority = Priority.Realtime;
+        BlockImpl.grandCount++;
+        if (this.isOn(Mode.PinpointRefresh))
+            BlockImpl.disposableCount++;
+    }
+    render(_triggers) {
+        renderNow(this.descriptor.item);
+    }
+    prepareForRender() {
+        this._area = undefined;
+        this._hasStyles = false;
+    }
+    isOn(mode) {
+        return (chainedMode(this.descriptor.builder) & mode) === mode;
+    }
+    get isInitialRendering() { return this.descriptor.stamp === 2; }
+    get isSequential() { return this.descriptor.children.isStrict; }
+    set isSequential(value) { this.descriptor.children.isStrict = value; }
+    get isAuxiliary() { return this.kind > BlockKind.Note; }
+    get isBand() { return this.kind === BlockKind.Band; }
+    get isTable() { return this.kind === BlockKind.Table; }
+    get isAutoMountingEnabled() { return !this.isOn(Mode.ManualMounting) && this.descriptor.host !== this; }
+    get isMoved() { return this.descriptor.owner.descriptor.children.isMoved(this.descriptor.item); }
+    get kind() { return this._kind; }
+    set kind(value) {
+        if (value !== this._kind || this.descriptor.stamp < 2) {
+            this.descriptor.driver.applyKind(this, value);
+            this._kind = value;
+        }
+    }
+    get area() { return this._area; }
+    set area(value) {
+        var _a, _b;
+        const d = this.descriptor;
+        const driver = d.driver;
+        if (!driver.isRow) {
+            const owner = d.owner.descriptor;
+            const cursorPosition = (_b = (_a = d.item.prev) === null || _a === void 0 ? void 0 : _a.instance.descriptor.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
+            const newCursorPosition = d.cursorPosition = owner.children.isStrict ? new CursorPosition(cursorPosition) : undefined;
+            const isCursorBlock = driver instanceof CursorCommandDriver;
+            const coords = getEffectiveBlockCoords(!isCursorBlock, value, owner.maxColumnCount, owner.maxRowCount, cursorPosition, newCursorPosition);
+            if (!equalBlockCoords(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.descriptor.driver.applyWidthGrowth(this, value);
+            this._widthGrowth = value;
+        }
+    }
+    get minWidth() { return this._minWidth; }
+    set minWidth(value) {
+        if (value !== this._minWidth) {
+            this.descriptor.driver.applyMinWidth(this, value);
+            this._minWidth = value;
+        }
+    }
+    get maxWidth() { return this._maxWidth; }
+    set maxWidth(value) {
+        if (value !== this._maxWidth) {
+            this.descriptor.driver.applyMaxWidth(this, value);
+            this._maxWidth = value;
+        }
+    }
+    get heightGrowth() { return this._heightGrowth; }
+    set heightGrowth(value) {
+        if (value !== this._heightGrowth) {
+            this.descriptor.driver.applyHeightGrowth(this, value);
+            this._heightGrowth = value;
+        }
+    }
+    get minHeight() { return this._minHeight; }
+    set minHeight(value) {
+        if (value !== this._minHeight) {
+            this.descriptor.driver.applyMinHeight(this, value);
+            this._minHeight = value;
+        }
+    }
+    get maxHeight() { return this._maxHeight; }
+    set maxHeight(value) {
+        if (value !== this._maxHeight) {
+            this.descriptor.driver.applyMaxHeight(this, value);
+            this._maxHeight = value;
+        }
+    }
+    get contentAlignment() { return this._contentAlignment; }
+    set contentAlignment(value) {
+        if (value !== this._contentAlignment) {
+            this.descriptor.driver.applyContentAlignment(this, value);
+            this._contentAlignment = value;
+        }
+    }
+    get blockAlignment() { return this._blockAlignment; }
+    set blockAlignment(value) {
+        if (value !== this._blockAlignment) {
+            this.descriptor.driver.applyBlockAlignment(this, value);
+            this._blockAlignment = value;
+        }
+    }
+    get contentWrapping() { return this._contentWrapping; }
+    set contentWrapping(value) {
+        if (value !== this._contentWrapping) {
+            this.descriptor.driver.applyContentWrapping(this, value);
+            this._contentWrapping = value;
+        }
+    }
+    get overlayVisible() { return this._overlayVisible; }
+    set overlayVisible(value) {
+        if (value !== this._overlayVisible) {
+            this.descriptor.driver.applyOverlayVisible(this, value);
+            this._overlayVisible = value;
+        }
+    }
+    useStyle(styleName, enabled) {
+        this.descriptor.driver.applyStyle(this, this._hasStyles, styleName, enabled);
+        this._hasStyles = true;
+    }
+    configureReactronic(options) {
+        if (this.descriptor.stamp !== 1 || !this.isOn(Mode.PinpointRefresh))
+            throw new Error("reactronic can be configured only for blocks with separate reaction mode and only inside initialize");
+        return Rx.getController(this.render).configure(options);
+    }
+    static get curr() {
+        if (!gCurrent)
+            throw new Error("current block is undefined");
+        return gCurrent;
+    }
+    static tryUseContextVariable(variable) {
+        var _a, _b;
+        let b = BlockImpl.curr.instance;
+        while (((_a = b.descriptor.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && b.descriptor.owner !== b)
+            b = b.descriptor.outer;
+        return (_b = b.descriptor.context) === null || _b === void 0 ? void 0 : _b.value;
+    }
+    static useContextVariableValue(variable) {
+        var _a;
+        const result = (_a = BlockImpl.tryUseContextVariable(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
+        if (!result)
+            throw new Error("context doesn't exist");
+        return result;
+    }
+    static setContextVariableValue(variable, value) {
+        const b = BlockImpl.curr.instance;
+        const d = b.descriptor;
+        const owner = d.owner;
+        const hostCtx = nonreactive(() => { var _a; return (_a = owner.descriptor.context) === null || _a === void 0 ? void 0 : _a.value; });
+        if (value && value !== hostCtx) {
+            if (hostCtx)
+                d.outer = owner;
+            else
+                d.outer = owner.descriptor.outer;
+            Transaction.run({ separation: true }, () => {
+                const ctx = d.context;
+                if (ctx) {
+                    ctx.variable = variable;
+                    ctx.value = value;
+                }
+                else
+                    d.context = new BlockCtxImpl(variable, value);
+            });
+        }
+        else if (hostCtx)
+            d.outer = owner;
+        else
+            d.outer = owner.descriptor.outer;
+    }
+    rowBreak() {
+        var _a, _b;
+        const d = this.descriptor;
+        const cursorPosition = (_b = (_a = d.item.prev) === null || _a === void 0 ? void 0 : _a.instance.descriptor.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
+        const newCursorPosition = this.descriptor.cursorPosition = new CursorPosition(cursorPosition);
+        newCursorPosition.x = 1;
+        newCursorPosition.y = newCursorPosition.runningMaxY + 1;
+    }
+}
+BlockImpl.grandCount = 0;
+BlockImpl.disposableCount = 0;
+BlockImpl.logging = undefined;
+__decorate([
+    reactive,
+    options({
+        reentrance: Reentrance.CancelPrevious,
+        triggeringArgs: true,
+        noSideEffects: false,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], BlockImpl.prototype, "render", null);
+function getBlockKey(block) {
+    const d = block.descriptor;
+    return d.stamp >= 0 ? d.key : undefined;
+}
+function getEffectiveBlockCoords(isRegularBlock, area, maxX, maxY, cursorPosition, newCursorPosition) {
+    var _a, _b;
+    let result;
+    if (typeof (area) === "string") {
+        result = parseBlockCoords(area, { x1: 0, y1: 0, x2: 0, y2: 0 });
+        absolutizeBlockCoords(result, cursorPosition.x, cursorPosition.y, maxX || Infinity, maxY || Infinity, result);
+        if (newCursorPosition) {
+            newCursorPosition.x = isRegularBlock ? 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 && isRegularBlock) {
+            dx = runningX || 1;
+            newCursorPosition.flags = CursorFlags.UsesRunningColumnCount;
+        }
+        if (dx >= 0) {
+            if (isRegularBlock) {
+                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 (isRegularBlock) {
+                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 && isRegularBlock) {
+            dy = runningY || 1;
+            newCursorPosition.flags |= CursorFlags.UsesRunningRowCount;
+        }
+        if (dy >= 0) {
+            if (isRegularBlock) {
+                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 (isRegularBlock) {
+                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 runRenderNestedTreesThenDo(error, action) {
+    var _a;
+    const curr = BlockImpl.curr;
+    const owner = curr.instance;
+    const children = owner.descriptor.children;
+    if (children.isMergeInProgress) {
+        let promised = undefined;
+        try {
+            children.endMerge(error);
+            for (const item of children.removedItems(true))
+                triggerFinalization(item, true, true);
+            if (!error) {
+                const ownerIsBand = owner.isBand;
+                const sequential = children.isStrict;
+                let p1 = undefined;
+                let p2 = undefined;
+                let mounting = false;
+                let hostingRow = owner;
+                for (const item of children.items()) {
+                    if (Transaction.isCanceled)
+                        break;
+                    const block = item.instance;
+                    const isRow = block.descriptor.driver.isRow;
+                    const host = isRow ? owner : hostingRow;
+                    const p = (_a = block.renderingPriority) !== null && _a !== void 0 ? _a : Priority.Realtime;
+                    mounting = markToMountIfNecessary(mounting, host, item, children, sequential);
+                    if (p === Priority.Realtime)
+                        triggerRendering(item);
+                    else if (p === Priority.Normal)
+                        p1 = push(item, p1);
+                    else
+                        p2 = push(item, p2);
+                    if (ownerIsBand && isRow)
+                        hostingRow = block;
+                }
+                if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
+                    promised = startIncrementalRendering(curr, children, p1, p2).then(() => action(error), e => action(e));
+            }
+        }
+        finally {
+            if (!promised)
+                action(error);
+        }
+    }
+}
+function markToMountIfNecessary(mounting, host, item, children, sequential) {
+    const b = item.instance;
+    const d = b.descriptor;
+    if (b.native && !b.isOn(Mode.ManualMounting)) {
+        if (mounting || d.host !== host) {
+            children.markAsMoved(item);
+            mounting = false;
+        }
+    }
+    else if (sequential && children.isMoved(item))
+        mounting = true;
+    d.host = host;
+    return mounting;
+}
+function startIncrementalRendering(owner, allChildren, priority1, priority2) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const stamp = owner.instance.descriptor.stamp;
+        if (priority1)
+            yield renderIncrementally(owner, stamp, allChildren, priority1, Priority.Normal);
+        if (priority2)
+            yield renderIncrementally(owner, stamp, allChildren, priority2, Priority.Background);
+    });
+}
+function renderIncrementally(owner, stamp, allChildren, items, priority) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Transaction.requestNextFrame();
+        const block = owner.instance;
+        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, Verstak.shortFrameDuration / 3)) {
+            let outerPriority = Verstak.currentRenderingPriority;
+            Verstak.currentRenderingPriority = priority;
+            try {
+                if (block.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) {
+                    triggerRendering(child);
+                    if (Transaction.isFrameOver(1, frameDuration)) {
+                        Verstak.currentRenderingPriority = outerPriority;
+                        yield Transaction.requestNextFrame(0);
+                        outerPriority = Verstak.currentRenderingPriority;
+                        Verstak.currentRenderingPriority = priority;
+                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, Verstak.frameDuration));
+                    }
+                    if (Transaction.isCanceled && Transaction.isFrameOver(1, Verstak.shortFrameDuration / 3))
+                        break;
+                }
+            }
+            finally {
+                Verstak.currentRenderingPriority = outerPriority;
+            }
+        }
+    });
+}
+function triggerRendering(item) {
+    const b = item.instance;
+    const d = b.descriptor;
+    if (d.stamp >= 0) {
+        if (b.isOn(Mode.PinpointRefresh)) {
+            if (d.stamp === 0) {
+                Transaction.outside(() => {
+                    if (Rx.isLogging)
+                        Rx.setLoggingHint(b, d.key);
+                    Rx.getController(b.render).configure({
+                        order: d.level,
+                    });
+                });
+            }
+            nonreactive(b.render, d.builder.triggers);
+        }
+        else
+            renderNow(item);
+    }
+}
+function mountIfNecessary(block) {
+    const d = block.descriptor;
+    const driver = d.driver;
+    if (d.stamp === 0) {
+        d.stamp = 1;
+        nonreactive(() => {
+            driver.create(block, block);
+            driver.initialize(block);
+            if (block.isAutoMountingEnabled)
+                driver.mount(block);
+        });
+    }
+    else if (block.isMoved && block.isAutoMountingEnabled)
+        nonreactive(() => driver.mount(block));
+}
+function renderNow(item) {
+    const b = item.instance;
+    const d = b.descriptor;
+    if (d.stamp >= 0) {
+        let result = undefined;
+        runInside(item, () => {
+            try {
+                mountIfNecessary(b);
+                d.stamp++;
+                d.numerator = 0;
+                b.prepareForRender();
+                d.children.beginMerge();
+                const driver = d.driver;
+                result = driver.render(b);
+                if (b.area === undefined && d.owner.isTable)
+                    b.area = undefined;
+                if (result instanceof Promise)
+                    result.then(v => { runRenderNestedTreesThenDo(undefined, NOP); return v; }, e => { console.log(e); runRenderNestedTreesThenDo(e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
+                else
+                    runRenderNestedTreesThenDo(undefined, NOP);
+            }
+            catch (e) {
+                runRenderNestedTreesThenDo(e, NOP);
+                console.log(`Rendering failed: ${d.key}`);
+                console.log(`${e}`);
+            }
+        });
+    }
+}
+function triggerFinalization(item, isLeader, individual) {
+    const b = item.instance;
+    const d = b.descriptor;
+    if (d.stamp >= 0) {
+        const driver = d.driver;
+        if (individual && d.key !== d.builder.key && !driver.isRow)
+            console.log(`WARNING: it is recommended to assign explicit key for conditionally rendered block in order to avoid unexpected side effects: ${d.key}`);
+        d.stamp = ~d.stamp;
+        const childrenAreLeaders = nonreactive(() => driver.finalize(b, isLeader));
+        b.native = null;
+        b.controller = null;
+        if (b.isOn(Mode.PinpointRefresh)) {
+            item.aux = undefined;
+            const last = gLastToDispose;
+            if (last)
+                gLastToDispose = last.aux = item;
+            else
+                gFirstToDispose = gLastToDispose = item;
+            if (gFirstToDispose === item)
+                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${item.instance.descriptor.key})` }, () => {
+                    void runDisposalLoop().then(NOP, error => console.log(error));
+                });
+        }
+        for (const item of d.children.items())
+            triggerFinalization(item, childrenAreLeaders, false);
+        BlockImpl.grandCount--;
+    }
+}
+function runDisposalLoop() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Transaction.requestNextFrame();
+        let item = gFirstToDispose;
+        while (item !== undefined) {
+            if (Transaction.isFrameOver(500, 5))
+                yield Transaction.requestNextFrame();
+            Rx.dispose(item.instance);
+            item = item.aux;
+            BlockImpl.disposableCount--;
+        }
+        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(item, func, ...args) {
+    const outer = gCurrent;
+    try {
+        gCurrent = item;
+        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 absolutizeBlockCoords(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;