verstak 0.23.107 → 0.23.109

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

@@ -1,745 +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, nonreactive, Transaction, options, Reentrance, Rx, Collection, ObservableObject, raw } from "reactronic";
-import { getCallerInfo } from "./Utils";
-import { emitLetters, equalCellRanges } from "./CellRange";
-import { Cursor, Align, TableCursor } from "./Cursor";
-export var Priority;
-(function (Priority) {
-    Priority[Priority["Realtime"] = 0] = "Realtime";
-    Priority[Priority["Normal"] = 1] = "Normal";
-    Priority[Priority["Background"] = 2] = "Background";
-})(Priority || (Priority = {}));
-export function Fragment(builder, base) {
-    return VBlock.claim(Driver.fragment, builder, base);
-}
-export class VBlock {
-    get isInitialRendering() {
-        return this.stamp === 2;
-    }
-    static root(render) {
-        gSysRoot.instance.builder.render = render;
-        triggerRendering(gSysRoot);
-    }
-    static get current() {
-        return gCurrent.instance;
-    }
-    static renderNestedTreesThenDo(action) {
-        runRenderNestedTreesThenDo(undefined, action);
-    }
-    static runForAllBlocks(action) {
-        forEachChildRecursively(gSysRoot, action);
-    }
-    static claim(driver, builder, base) {
-        var _a;
-        let result;
-        const owner = gCurrent.instance;
-        const children = owner.children;
-        let ex = undefined;
-        if (builder)
-            builder.base = base;
-        else
-            builder = base !== null && base !== void 0 ? base : {};
-        let key = builder.key;
-        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.driver) === driver)
-                ex = last;
-        }
-        ex !== null && ex !== void 0 ? ex : (ex = children.claim(key = key || VBlock.generateKey(owner), undefined, "nested blocks can be declared inside render function only"));
-        if (ex) {
-            result = ex.instance;
-            if (result.driver !== driver && driver !== undefined)
-                throw new Error(`changing block driver is not yet supported: "${result.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
-            const exTriggers = result.builder.triggers;
-            if (triggersAreEqual(builder.triggers, exTriggers))
-                builder.triggers = exTriggers;
-            result.builder = builder;
-        }
-        else {
-            result = new VBlockImpl(key || VBlock.generateKey(owner), driver, owner, builder);
-            result.item = children.add(result);
-            VBlockImpl.grandCount++;
-            if (isReaction(builder))
-                VBlockImpl.disposableCount++;
-        }
-        return result;
-    }
-    static generateKey(owner) {
-        const n = owner.numerator++;
-        const lettered = emitLetters(n);
-        let result;
-        if (Rx.isLogging)
-            result = `·${getCallerInfo(lettered)}`;
-        else
-            result = `·${lettered}`;
-        return result;
-    }
-    static getDefaultLoggingOptions() {
-        return VBlockImpl.logging;
-    }
-    static setDefaultLoggingOptions(logging) {
-        VBlockImpl.logging = logging;
-    }
-}
-VBlock.shortFrameDuration = 16;
-VBlock.longFrameDuration = 300;
-VBlock.currentRenderingPriority = Priority.Realtime;
-VBlock.frameDuration = VBlock.longFrameDuration;
-export var Layout;
-(function (Layout) {
-    Layout[Layout["Section"] = 0] = "Section";
-    Layout[Layout["Table"] = 1] = "Table";
-    Layout[Layout["Row"] = 2] = "Row";
-    Layout[Layout["Group"] = 3] = "Group";
-    Layout[Layout["Note"] = 4] = "Note";
-})(Layout || (Layout = {}));
-export class Driver {
-    constructor(name, isRow, preset) {
-        this.name = name;
-        this.isRow = isRow;
-        this.preset = preset;
-    }
-    create(block, b) {
-    }
-    claim(block) {
-        const b = block;
-        invokeClaim(b, b.builder);
-    }
-    initialize(block) {
-        var _a;
-        const b = block;
-        (_a = this.preset) === null || _a === void 0 ? void 0 : _a.call(this, b);
-        invokeInitialize(b, b.builder);
-    }
-    deploy(block) {
-    }
-    render(block) {
-        invokeRender(block, block.builder);
-    }
-    finalize(block, isLeader) {
-        const b = block;
-        invokeFinalize(b, b.builder);
-        return isLeader;
-    }
-    applyChildrenLayout(block, value) {
-        const b = block;
-        if (value === Layout.Table)
-            b.cursor = new TableCursor();
-        else
-            b.cursor = new Cursor();
-    }
-    applyCellRange(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) {
-    }
-}
-Driver.fragment = new Driver("fragment", false, b => b.childrenLayout = Layout.Group);
-function isReaction(builder) {
-    var _a;
-    return (_a = builder === null || builder === void 0 ? void 0 : builder.reaction) !== null && _a !== void 0 ? _a : ((builder === null || builder === void 0 ? void 0 : builder.base) ? isReaction(builder === null || builder === void 0 ? void 0 : builder.base) : false);
-}
-function invokeClaim(block, builder) {
-    const claim = builder.claim;
-    const base = builder.base;
-    if (claim)
-        claim(block, base ? () => invokeClaim(block, base) : NOP);
-    else if (base)
-        invokeClaim(block, base);
-}
-function invokeInitialize(block, builder) {
-    const initialize = builder.initialize;
-    const base = builder.base;
-    if (initialize)
-        initialize(block, base ? () => invokeInitialize(block, base) : NOP);
-    else if (base)
-        invokeInitialize(block, base);
-}
-function invokeRender(block, builder) {
-    const render = builder.render;
-    const base = builder.base;
-    if (render)
-        render(block, base ? () => invokeRender(block, base) : NOP);
-    else if (base)
-        invokeRender(block, base);
-}
-function invokeFinalize(block, builder) {
-    const finalize = builder.finalize;
-    const base = builder.base;
-    if (finalize)
-        finalize(block, base ? () => invokeFinalize(block, base) : NOP);
-    else if (base)
-        invokeFinalize(block, base);
-}
-export class StaticDriver extends Driver {
-    constructor(element, name, isRow, preset) {
-        super(name, isRow, preset);
-        this.element = element;
-    }
-    create(block, b) {
-        b.native = this.element;
-    }
-}
-export class ContextVariable {
-    constructor(defaultValue) {
-        this.defaultValue = defaultValue;
-    }
-    set value(value) {
-        VBlockImpl.setContextVariableValue(this, value);
-    }
-    get value() {
-        return VBlockImpl.useContextVariableValue(this);
-    }
-    get valueOrUndefined() {
-        return VBlockImpl.tryUseContextVariable(this);
-    }
-}
-function getBlockKey(block) {
-    return block.stamp >= 0 ? block.key : undefined;
-}
-class VBlockContext extends ObservableObject {
-    constructor(variable, value) {
-        super();
-        this.next = undefined;
-        this.variable = variable;
-        this.value = value;
-    }
-}
-__decorate([
-    raw,
-    __metadata("design:type", Object)
-], VBlockContext.prototype, "next", void 0);
-__decorate([
-    raw,
-    __metadata("design:type", ContextVariable)
-], VBlockContext.prototype, "variable", void 0);
-class VBlockImpl extends VBlock {
-    constructor(key, driver, owner, builder) {
-        super();
-        this.key = key;
-        this.driver = driver;
-        this.builder = builder;
-        this.model = undefined;
-        this.appliedChildrenLayout = Layout.Row;
-        this.appliedPlacement = undefined;
-        this.appliedCellRange = Cursor.UndefinedCellRange;
-        this.appliedWidthGrowth = 0;
-        this.appliedMinWidth = "";
-        this.appliedMaxWidth = "";
-        this.appliedHeightGrowth = 0;
-        this.appliedMinHeight = "";
-        this.appliedMaxHeight = "";
-        this.appliedContentAlignment = Align.Default;
-        this.appliedBlockAlignment = Align.Default;
-        this.appliedContentWrapping = false;
-        this.appliedOverlayVisible = undefined;
-        this.wasStyleApplied = false;
-        this.childrenShuffling = false;
-        this.renderingPriority = Priority.Realtime;
-        this.level = owner.level + 1;
-        this.host = owner;
-        this.children = new Collection(getBlockKey, this.isSequential);
-        this.numerator = 0;
-        this.item = undefined;
-        this.stamp = 0;
-        this.native = undefined;
-        this.controller = undefined;
-        this.cursor = new Cursor();
-        this.outer = owner.context ? owner : owner.outer;
-        this.context = undefined;
-    }
-    render(_triggers) {
-        renderNow(this.item);
-    }
-    get isSequential() { return (this.childrenLayout & 1) === 0; }
-    get isAuxiliary() { return (this.childrenLayout & 2) === 2; }
-    get isSection() { return this.childrenLayout === Layout.Section; }
-    get isTable() { return this.childrenLayout === Layout.Table; }
-    get isMoved() {
-        let owner = this.host;
-        if (owner.driver.isRow)
-            owner = owner.host;
-        return owner.children.isMoved(this.item);
-    }
-    get childrenLayout() { return this.appliedChildrenLayout; }
-    set childrenLayout(value) {
-        if (value !== this.appliedChildrenLayout || this.stamp < 2) {
-            this.driver.applyChildrenLayout(this, value);
-            this.appliedChildrenLayout = value;
-        }
-    }
-    get placement() { return this.appliedPlacement; }
-    set placement(value) {
-        if (this.appliedPlacement !== undefined)
-            throw new Error("cells can be assigned only once during rendering");
-        const cellRange = this.host.cursor.onwards(value);
-        if (!equalCellRanges(cellRange, this.appliedCellRange)) {
-            this.driver.applyCellRange(this, cellRange);
-            this.appliedCellRange = cellRange;
-        }
-        this.appliedPlacement = value !== null && value !== void 0 ? value : {};
-    }
-    get widthGrowth() { return this.appliedWidthGrowth; }
-    set widthGrowth(value) {
-        if (value !== this.appliedWidthGrowth) {
-            this.driver.applyWidthGrowth(this, value);
-            this.appliedWidthGrowth = value;
-        }
-    }
-    get minWidth() { return this.appliedMinWidth; }
-    set minWidth(value) {
-        if (value !== this.appliedMinWidth) {
-            this.driver.applyMinWidth(this, value);
-            this.appliedMinWidth = value;
-        }
-    }
-    get maxWidth() { return this.appliedMaxWidth; }
-    set maxWidth(value) {
-        if (value !== this.appliedMaxWidth) {
-            this.driver.applyMaxWidth(this, value);
-            this.appliedMaxWidth = value;
-        }
-    }
-    get heightGrowth() { return this.appliedHeightGrowth; }
-    set heightGrowth(value) {
-        if (value !== this.appliedHeightGrowth) {
-            this.driver.applyHeightGrowth(this, value);
-            this.appliedHeightGrowth = value;
-        }
-    }
-    get minHeight() { return this.appliedMinHeight; }
-    set minHeight(value) {
-        if (value !== this.appliedMinHeight) {
-            this.driver.applyMinHeight(this, value);
-            this.appliedMinHeight = value;
-        }
-    }
-    get maxHeight() { return this.appliedMaxHeight; }
-    set maxHeight(value) {
-        if (value !== this.appliedMaxHeight) {
-            this.driver.applyMaxHeight(this, value);
-            this.appliedMaxHeight = value;
-        }
-    }
-    get contentAlignment() { return this.appliedContentAlignment; }
-    set contentAlignment(value) {
-        if (value !== this.appliedContentAlignment) {
-            this.driver.applyContentAlignment(this, value);
-            this.appliedContentAlignment = value;
-        }
-    }
-    get blockAlignment() { return this.appliedBlockAlignment; }
-    set blockAlignment(value) {
-        if (value !== this.appliedBlockAlignment) {
-            this.driver.applyBlockAlignment(this, value);
-            this.appliedBlockAlignment = value;
-        }
-    }
-    get contentWrapping() { return this.appliedContentWrapping; }
-    set contentWrapping(value) {
-        if (value !== this.appliedContentWrapping) {
-            this.driver.applyContentWrapping(this, value);
-            this.appliedContentWrapping = value;
-        }
-    }
-    get overlayVisible() { return this.appliedOverlayVisible; }
-    set overlayVisible(value) {
-        if (value !== this.appliedOverlayVisible) {
-            this.driver.applyOverlayVisible(this, value);
-            this.appliedOverlayVisible = value;
-        }
-    }
-    style(styleName, enabled) {
-        this.driver.applyStyle(this, this.wasStyleApplied, styleName, enabled);
-        this.wasStyleApplied = true;
-    }
-    configureReactronic(options) {
-        if (this.stamp !== 1 || !isReaction(this.builder))
-            throw new Error("reactronic can be configured only for reacting blocks and only inside initialize");
-        return Rx.getController(this.render).configure(options);
-    }
-    static tryUseContextVariable(variable) {
-        var _a, _b;
-        let b = gCurrent.instance;
-        while (((_a = b.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && b.host !== b)
-            b = b.outer;
-        return (_b = b.context) === null || _b === void 0 ? void 0 : _b.value;
-    }
-    static useContextVariableValue(variable) {
-        var _a;
-        const result = (_a = VBlockImpl.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 block = gCurrent.instance;
-        const host = block.host;
-        const hostCtx = nonreactive(() => { var _a; return (_a = host.context) === null || _a === void 0 ? void 0 : _a.value; });
-        if (value && value !== hostCtx) {
-            if (hostCtx)
-                block.outer = host;
-            else
-                block.outer = host.outer;
-            Transaction.run({ separation: true }, () => {
-                const ctx = block.context;
-                if (ctx) {
-                    ctx.variable = variable;
-                    ctx.value = value;
-                }
-                else
-                    block.context = new VBlockContext(variable, value);
-            });
-        }
-        else if (hostCtx)
-            block.outer = host;
-        else
-            block.outer = host.outer;
-    }
-}
-VBlockImpl.grandCount = 0;
-VBlockImpl.disposableCount = 0;
-VBlockImpl.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)
-], VBlockImpl.prototype, "render", null);
-function runRenderNestedTreesThenDo(error, action) {
-    var _a;
-    const current = gCurrent;
-    const owner = current.instance;
-    const children = owner.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 ownerIsSection = owner.isSection;
-                const sequential = children.isStrict;
-                const cursor = owner.cursor;
-                let p1 = undefined;
-                let p2 = undefined;
-                let redeploy = false;
-                let hostingRow = owner;
-                cursor.reset();
-                for (const item of children.items()) {
-                    if (Transaction.isCanceled)
-                        break;
-                    const block = item.instance;
-                    const isRow = block.driver.isRow;
-                    const host = isRow ? owner : hostingRow;
-                    const p = (_a = block.renderingPriority) !== null && _a !== void 0 ? _a : Priority.Realtime;
-                    redeploy = markToRedeployIfNecessary(redeploy, 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 (ownerIsSection && isRow)
-                        hostingRow = block;
-                }
-                if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
-                    promised = startIncrementalRendering(current, children, p1, p2).then(() => action(error), e => action(e));
-            }
-        }
-        finally {
-            if (!promised)
-                action(error);
-        }
-    }
-}
-function markToRedeployIfNecessary(redeploy, host, item, children, sequential) {
-    const block = item.instance;
-    if (block.native) {
-        if (redeploy || block.host !== host) {
-            children.markAsMoved(item);
-            redeploy = false;
-        }
-    }
-    else if (sequential && children.isMoved(item))
-        redeploy = true;
-    block.host = host;
-    return redeploy;
-}
-function startIncrementalRendering(owner, allChildren, priority1, priority2) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const stamp = owner.instance.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, VBlock.shortFrameDuration / 3)) {
-            let outerPriority = VBlock.currentRenderingPriority;
-            VBlock.currentRenderingPriority = priority;
-            try {
-                if (block.childrenShuffling)
-                    shuffle(items);
-                const frameDurationLimit = priority === Priority.Background ? VBlock.shortFrameDuration : Infinity;
-                let frameDuration = Math.min(frameDurationLimit, Math.max(VBlock.frameDuration / 4, VBlock.shortFrameDuration));
-                for (const child of items) {
-                    triggerRendering(child);
-                    if (Transaction.isFrameOver(1, frameDuration)) {
-                        VBlock.currentRenderingPriority = outerPriority;
-                        yield Transaction.requestNextFrame(0);
-                        outerPriority = VBlock.currentRenderingPriority;
-                        VBlock.currentRenderingPriority = priority;
-                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, VBlock.frameDuration));
-                    }
-                    if (Transaction.isCanceled && Transaction.isFrameOver(1, VBlock.shortFrameDuration / 3))
-                        break;
-                }
-            }
-            finally {
-                VBlock.currentRenderingPriority = outerPriority;
-            }
-        }
-    });
-}
-function triggerRendering(item) {
-    const block = item.instance;
-    if (block.stamp >= 0) {
-        if (isReaction(block.builder)) {
-            if (block.stamp === 0) {
-                Transaction.outside(() => {
-                    if (Rx.isLogging)
-                        Rx.setLoggingHint(block, block.key);
-                    Rx.getController(block.render).configure({
-                        order: block.level,
-                    });
-                });
-            }
-            nonreactive(block.render, block.builder.triggers);
-        }
-        else
-            renderNow(item);
-    }
-}
-function redeployIfNecessary(block) {
-    const driver = block.driver;
-    if (block.stamp === 0) {
-        block.stamp = 1;
-        nonreactive(() => {
-            driver.create(block, block);
-            driver.initialize(block);
-            driver.deploy(block);
-        });
-    }
-    else if (block.isMoved)
-        nonreactive(() => driver.deploy(block));
-}
-function renderNow(item) {
-    const block = item.instance;
-    if (block.stamp >= 0) {
-        let result = undefined;
-        runUnder(item, () => {
-            try {
-                redeployIfNecessary(block);
-                block.stamp++;
-                block.numerator = 0;
-                block.appliedPlacement = undefined;
-                block.wasStyleApplied = false;
-                block.children.beginMerge();
-                const driver = block.driver;
-                result = driver.render(block);
-                if (driver.isRow)
-                    block.host.cursor.rowBreak();
-                else if (block.appliedPlacement === undefined)
-                    block.placement = 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: ${block.key}`);
-                console.log(`${e}`);
-            }
-        });
-    }
-}
-function triggerFinalization(item, isLeader, individual) {
-    const block = item.instance;
-    if (block.stamp >= 0) {
-        const driver = block.driver;
-        if (individual && block.key !== block.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: ${block.key}`);
-        block.stamp = ~block.stamp;
-        const childrenAreLeaders = nonreactive(() => driver.finalize(block, isLeader));
-        block.native = null;
-        block.controller = null;
-        if (isReaction(block.builder)) {
-            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.key})` }, () => {
-                    void runDisposalLoop().then(NOP, error => console.log(error));
-                });
-        }
-        for (const item of block.children.items())
-            triggerFinalization(item, childrenAreLeaders, false);
-        VBlockImpl.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;
-            VBlockImpl.disposableCount--;
-        }
-        gFirstToDispose = gLastToDispose = undefined;
-    });
-}
-function forEachChildRecursively(item, action) {
-    const block = item.instance;
-    const e = block.native;
-    e && action(e);
-    for (const item of block.children.items())
-        forEachChildRecursively(item, action);
-}
-function wrap(func) {
-    const current = gCurrent;
-    const wrappedRunUnder = (...args) => {
-        return runUnder(current, func, ...args);
-    };
-    return wrappedRunUnder;
-}
-function runUnder(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 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 ? wrap(resolve) : defaultResolve;
-    reject = reject ? wrap(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) => { };
-const gSysDriver = new StaticDriver(null, "SYSTEM", false, b => b.childrenLayout = Layout.Group);
-const gSysRoot = Collection.createItem(new VBlockImpl(gSysDriver.name, gSysDriver, { level: 0 }, { reaction: true, render: NOP }));
-gSysRoot.instance.item = gSysRoot;
-Object.defineProperty(gSysRoot.instance, "host", {
-    value: gSysRoot.instance,
-    writable: false,
-    configurable: false,
-    enumerable: true,
-});
-Object.defineProperty(gSysRoot.instance, "senior", {
-    value: gSysRoot.instance,
-    writable: false,
-    configurable: false,
-    enumerable: true,
-});
-let gCurrent = gSysRoot;
-let gFirstToDispose = undefined;
-let gLastToDispose = undefined;