verstak 0.23.109 → 0.23.111

package/build/dist/source/core/Interfaces.d.ts

@@ -13,7 +13,7 @@ export declare enum BlockKind {
     Native = 6
 }
 export interface Block<T = unknown, M = unknown, C = unknown, R = void> {
-    readonly descriptor: BlockDescriptor<T, M, C, R>;
+    readonly node: BlockNode<T, M, C, R>;
     readonly native: T;
     readonly isBand: boolean;
     readonly isTable: boolean;
@@ -31,14 +31,14 @@ export interface Block<T = unknown, M = unknown, C = unknown, R = void> {
     blockAlignment: Align;
     contentWrapping: boolean;
     overlayVisible: boolean | undefined;
-    childrenShuffling: boolean;
     renderingPriority?: Priority;
-    isSequential: boolean;
+    childrenShuffling: boolean;
+    strictOrder: boolean;
     readonly isInitialRendering: boolean;
     useStyle(styleName: string, enabled?: boolean): void;
     configureReactronic(options: Partial<MemberOptions>): MemberOptions;
 }
-export interface BlockDescriptor<T = unknown, M = unknown, C = unknown, R = void> {
+export interface BlockNode<T = unknown, M = unknown, C = unknown, R = void> {
     readonly key: string;
     readonly driver: Driver<T>;
     readonly builder: Readonly<BlockBuilder<T, M, C, R>>;
@@ -46,7 +46,7 @@ export interface BlockDescriptor<T = unknown, M = unknown, C = unknown, R = void
     readonly owner: Block;
     readonly host: Block;
     readonly children: CollectionReader<Block>;
-    readonly item: Item<Block> | undefined;
+    readonly ties: Item<Block> | undefined;
     readonly stamp: number;
     readonly outer: Block;
     readonly context: BlockCtx | undefined;
@@ -106,7 +106,7 @@ export declare const enum Priority {
 export declare enum Mode {
     Default = 0,
     PinpointRefresh = 1,
-    ManualMounting = 2
+    ManualMount = 2
 }
 export declare enum Align {
     Stretch = 0,

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

@@ -18,7 +18,7 @@ export var Mode;
 (function (Mode) {
     Mode[Mode["Default"] = 0] = "Default";
     Mode[Mode["PinpointRefresh"] = 1] = "PinpointRefresh";
-    Mode[Mode["ManualMounting"] = 2] = "ManualMounting";
+    Mode[Mode["ManualMount"] = 2] = "ManualMount";
 })(Mode || (Mode = {}));
 export var Align;
 (function (Align) {

package/build/dist/source/core/Verstak.d.ts

@@ -7,6 +7,7 @@ export declare class Verstak {
     static frameDuration: number;
     static claim<T = undefined, M = unknown, C = unknown, R = void>(driver: Driver<T>, builder?: BlockBuilder<T, M, C, R>, base?: BlockBuilder<T, M, C, R>): Block<T, M, C, R>;
     static get block(): Block;
+    static triggerRendering(block: Block<any, any, any, void>, triggers: unknown): void;
     static renderNestedTreesThenDo(action: (error: unknown) => void): void;
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
@@ -60,7 +61,7 @@ export declare class CursorCommandDriver extends BaseDriver<CursorCommand, void>
         controller?: void;
     }): void;
 }
-export declare class ContextVariable<T extends Object = Object> {
+export declare class SubTreeVariable<T extends Object = Object> {
     readonly defaultValue: T | undefined;
     constructor(defaultValue?: T);
     set value(value: T);

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

@@ -31,32 +31,32 @@ export class Verstak {
         const owner = gCurrent === null || gCurrent === void 0 ? void 0 : gCurrent.instance;
         if (owner) {
             let ex = undefined;
-            const children = owner.descriptor.children;
+            const children = owner.node.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)
+                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.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;
+                const node = result.node;
+                if (node.driver !== driver && driver !== undefined)
+                    throw new Error(`changing block driver is not yet supported: "${result.node.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
+                const exTriggers = node.builder.triggers;
                 if (triggersAreEqual(builder.triggers, exTriggers))
                     builder.triggers = exTriggers;
-                d.builder = builder;
+                node.builder = builder;
             }
             else {
                 result = new BlockImpl(key || generateKey(owner), driver, owner, builder);
-                result.descriptor.item = children.add(result);
+                result.node.ties = children.add(result);
             }
         }
         else {
             result = new BlockImpl(key || "", driver, owner, builder);
-            result.descriptor.item = Collection.createItem(result);
-            triggerRendering(result.descriptor.item);
+            result.node.ties = Collection.createItem(result);
+            triggerRendering(result.node.ties);
         }
         return result;
     }
@@ -65,6 +65,14 @@ export class Verstak {
             throw new Error("current block is undefined");
         return gCurrent.instance;
     }
+    static triggerRendering(block, triggers) {
+        const b = block;
+        const builder = b.node.builder;
+        if (!triggersAreEqual(triggers, builder.triggers)) {
+            builder.triggers = triggers;
+            triggerRendering(b.node.ties);
+        }
+    }
     static renderNestedTreesThenDo(action) {
         runRenderNestedTreesThenDo(undefined, action);
     }
@@ -87,25 +95,25 @@ export class BaseDriver {
     }
     claim(block) {
         const b = block;
-        chainedClaim(b, b.descriptor.builder);
+        chainedClaim(b, b.node.builder);
     }
     create(block, b) {
-        chainedCreate(block, block.descriptor.builder);
+        chainedCreate(block, block.node.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);
+        chainedInitialize(b, b.node.builder);
     }
     mount(block) {
     }
     render(block) {
-        chainedRender(block, block.descriptor.builder);
+        chainedRender(block, block.node.builder);
     }
     finalize(block, isLeader) {
         const b = block;
-        chainedFinalize(b, b.descriptor.builder);
+        chainedFinalize(b, b.node.builder);
         return isLeader;
     }
     applyKind(block, value) { }
@@ -124,7 +132,7 @@ export class BaseDriver {
 }
 BaseDriver.fragment = new BaseDriver("fragment", false, b => b.kind = BlockKind.Group);
 function generateKey(owner) {
-    const n = owner.descriptor.numerator++;
+    const n = owner.node.numerator++;
     const lettered = emitLetters(n);
     let result;
     if (Rx.isLogging)
@@ -197,18 +205,18 @@ export class CursorCommandDriver extends BaseDriver {
         super.create(block, b);
     }
 }
-export class ContextVariable {
+export class SubTreeVariable {
     constructor(defaultValue) {
         this.defaultValue = defaultValue;
     }
     set value(value) {
-        BlockImpl.setContextVariableValue(this, value);
+        BlockImpl.setSubTreeVariableValue(this, value);
     }
     get value() {
-        return BlockImpl.useContextVariableValue(this);
+        return BlockImpl.useSubTreeVariableValue(this);
     }
     get valueOrUndefined() {
-        return BlockImpl.tryUseContextVariable(this);
+        return BlockImpl.tryUseSubTreeVariable(this);
     }
 }
 class CursorPosition {
@@ -243,9 +251,9 @@ __decorate([
 ], BlockCtxImpl.prototype, "next", void 0);
 __decorate([
     raw,
-    __metadata("design:type", ContextVariable)
+    __metadata("design:type", SubTreeVariable)
 ], BlockCtxImpl.prototype, "variable", void 0);
-class BlockDescriptorImpl {
+class BlockNodeImpl {
     constructor(key, driver, builder, self, owner) {
         this.maxColumnCount = 0;
         this.maxRowCount = 0;
@@ -253,10 +261,10 @@ class BlockDescriptorImpl {
         this.driver = driver;
         this.builder = builder;
         if (owner) {
-            const d = owner.descriptor;
-            this.level = d.level + 1;
+            const node = owner.node;
+            this.level = node.level + 1;
             this.owner = owner;
-            this.outer = d.context ? owner : d.outer;
+            this.outer = node.context ? owner : node.outer;
         }
         else {
             this.level = 1;
@@ -265,7 +273,7 @@ class BlockDescriptorImpl {
         }
         this.host = self;
         this.children = new Collection(getBlockKey, true);
-        this.item = undefined;
+        this.ties = undefined;
         this.stamp = 0;
         this.context = undefined;
         this.numerator = 0;
@@ -276,7 +284,7 @@ class BlockDescriptorImpl {
 }
 class BlockImpl {
     constructor(key, driver, owner, builder) {
-        this.descriptor = new BlockDescriptorImpl(key, driver, builder, this, owner);
+        this.node = new BlockNodeImpl(key, driver, builder, this, owner);
         this.native = undefined;
         this.model = undefined;
         this.controller = undefined;
@@ -291,49 +299,49 @@ class BlockImpl {
         this._maxHeight = "";
         this._contentAlignment = Align.Default;
         this._blockAlignment = Align.Default;
-        this._contentWrapping = false;
+        this._contentWrapping = true;
         this._overlayVisible = undefined;
         this._hasStyles = false;
-        this.childrenShuffling = false;
         this.renderingPriority = Priority.Realtime;
-        BlockImpl.grandCount++;
+        this.childrenShuffling = false;
+        BlockImpl.grandBlockCount++;
         if (this.isOn(Mode.PinpointRefresh))
-            BlockImpl.disposableCount++;
+            BlockImpl.disposableBlockCount++;
     }
     render(_triggers) {
-        renderNow(this.descriptor.item);
+        renderNow(this.node.ties);
     }
     prepareForRender() {
         this._area = undefined;
         this._hasStyles = false;
     }
     isOn(mode) {
-        return (chainedMode(this.descriptor.builder) & mode) === mode;
+        return (chainedMode(this.node.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 isInitialRendering() { return this.node.stamp === 2; }
     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 isAutoMountEnabled() { return !this.isOn(Mode.ManualMount) && this.node.host !== this; }
+    get isMoved() { return this.node.owner.node.children.isMoved(this.node.ties); }
+    get strictOrder() { return this.node.children.isStrict; }
+    set strictOrder(value) { this.node.children.isStrict = value; }
     get kind() { return this._kind; }
     set kind(value) {
-        if (value !== this._kind || this.descriptor.stamp < 2) {
-            this.descriptor.driver.applyKind(this, value);
+        if (value !== this._kind || this.node.stamp < 2) {
+            this.node.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;
+        const node = this.node;
+        const driver = node.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 owner = node.owner.node;
+            const cursorPosition = (_b = (_a = node.ties.prev) === null || _a === void 0 ? void 0 : _a.instance.node.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
+            const newCursorPosition = node.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)) {
@@ -348,79 +356,79 @@ class BlockImpl {
     get widthGrowth() { return this._widthGrowth; }
     set widthGrowth(value) {
         if (value !== this._widthGrowth) {
-            this.descriptor.driver.applyWidthGrowth(this, value);
+            this.node.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.node.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.node.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.node.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.node.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.node.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.node.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.node.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.node.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.node.driver.applyOverlayVisible(this, value);
             this._overlayVisible = value;
         }
     }
     useStyle(styleName, enabled) {
-        this.descriptor.driver.applyStyle(this, this._hasStyles, styleName, enabled);
+        this.node.driver.applyStyle(this, this._hasStyles, styleName, enabled);
         this._hasStyles = true;
     }
     configureReactronic(options) {
-        if (this.descriptor.stamp !== 1 || !this.isOn(Mode.PinpointRefresh))
+        if (this.node.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);
     }
@@ -429,56 +437,56 @@ class BlockImpl {
             throw new Error("current block is undefined");
         return gCurrent;
     }
-    static tryUseContextVariable(variable) {
+    static tryUseSubTreeVariable(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;
+        while (((_a = b.node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && b.node.owner !== b)
+            b = b.node.outer;
+        return (_b = b.node.context) === null || _b === void 0 ? void 0 : _b.value;
     }
-    static useContextVariableValue(variable) {
+    static useSubTreeVariableValue(variable) {
         var _a;
-        const result = (_a = BlockImpl.tryUseContextVariable(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
+        const result = (_a = BlockImpl.tryUseSubTreeVariable(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
         if (!result)
             throw new Error("context doesn't exist");
         return result;
     }
-    static setContextVariableValue(variable, value) {
+    static setSubTreeVariableValue(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; });
+        const node = b.node;
+        const owner = node.owner;
+        const hostCtx = nonreactive(() => { var _a; return (_a = owner.node.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
             if (hostCtx)
-                d.outer = owner;
+                node.outer = owner;
             else
-                d.outer = owner.descriptor.outer;
+                node.outer = owner.node.outer;
             Transaction.run({ separation: true }, () => {
-                const ctx = d.context;
+                const ctx = node.context;
                 if (ctx) {
                     ctx.variable = variable;
                     ctx.value = value;
                 }
                 else
-                    d.context = new BlockCtxImpl(variable, value);
+                    node.context = new BlockCtxImpl(variable, value);
             });
         }
         else if (hostCtx)
-            d.outer = owner;
+            node.outer = owner;
         else
-            d.outer = owner.descriptor.outer;
+            node.outer = owner.node.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);
+        const node = this.node;
+        const cursorPosition = (_b = (_a = node.ties.prev) === null || _a === void 0 ? void 0 : _a.instance.node.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
+        const newCursorPosition = this.node.cursorPosition = new CursorPosition(cursorPosition);
         newCursorPosition.x = 1;
         newCursorPosition.y = newCursorPosition.runningMaxY + 1;
     }
 }
-BlockImpl.grandCount = 0;
-BlockImpl.disposableCount = 0;
+BlockImpl.grandBlockCount = 0;
+BlockImpl.disposableBlockCount = 0;
 BlockImpl.logging = undefined;
 __decorate([
     reactive,
@@ -492,8 +500,8 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], BlockImpl.prototype, "render", null);
 function getBlockKey(block) {
-    const d = block.descriptor;
-    return d.stamp >= 0 ? d.key : undefined;
+    const node = block.node;
+    return node.stamp >= 0 ? node.key : undefined;
 }
 function getEffectiveBlockCoords(isRegularBlock, area, maxX, maxY, cursorPosition, newCursorPosition) {
     var _a, _b;
@@ -576,7 +584,7 @@ function runRenderNestedTreesThenDo(error, action) {
     var _a;
     const curr = BlockImpl.curr;
     const owner = curr.instance;
-    const children = owner.descriptor.children;
+    const children = owner.node.children;
     if (children.isMergeInProgress) {
         let promised = undefined;
         try {
@@ -594,7 +602,7 @@ function runRenderNestedTreesThenDo(error, action) {
                     if (Transaction.isCanceled)
                         break;
                     const block = item.instance;
-                    const isRow = block.descriptor.driver.isRow;
+                    const isRow = block.node.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);
@@ -617,23 +625,23 @@ function runRenderNestedTreesThenDo(error, action) {
         }
     }
 }
-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);
+function markToMountIfNecessary(mounting, host, ties, children, sequential) {
+    const b = ties.instance;
+    const node = b.node;
+    if (b.native && !b.isOn(Mode.ManualMount)) {
+        if (mounting || node.host !== host) {
+            children.markAsMoved(ties);
             mounting = false;
         }
     }
-    else if (sequential && children.isMoved(item))
+    else if (sequential && children.isMoved(ties))
         mounting = true;
-    d.host = host;
+    node.host = host;
     return mounting;
 }
 function startIncrementalRendering(owner, allChildren, priority1, priority2) {
     return __awaiter(this, void 0, void 0, function* () {
-        const stamp = owner.instance.descriptor.stamp;
+        const stamp = owner.instance.node.stamp;
         if (priority1)
             yield renderIncrementally(owner, stamp, allChildren, priority1, Priority.Normal);
         if (priority2)
@@ -671,56 +679,56 @@ function renderIncrementally(owner, stamp, allChildren, items, priority) {
         }
     });
 }
-function triggerRendering(item) {
-    const b = item.instance;
-    const d = b.descriptor;
-    if (d.stamp >= 0) {
+function triggerRendering(ties) {
+    const b = ties.instance;
+    const node = b.node;
+    if (node.stamp >= 0) {
         if (b.isOn(Mode.PinpointRefresh)) {
-            if (d.stamp === 0) {
+            if (node.stamp === 0) {
                 Transaction.outside(() => {
                     if (Rx.isLogging)
-                        Rx.setLoggingHint(b, d.key);
+                        Rx.setLoggingHint(b, node.key);
                     Rx.getController(b.render).configure({
-                        order: d.level,
+                        order: node.level,
                     });
                 });
             }
-            nonreactive(b.render, d.builder.triggers);
+            nonreactive(b.render, node.builder.triggers);
         }
         else
-            renderNow(item);
+            renderNow(ties);
     }
 }
 function mountIfNecessary(block) {
-    const d = block.descriptor;
-    const driver = d.driver;
-    if (d.stamp === 0) {
-        d.stamp = 1;
+    const node = block.node;
+    const driver = node.driver;
+    if (node.stamp === 0) {
+        node.stamp = 1;
         nonreactive(() => {
             driver.create(block, block);
             driver.initialize(block);
-            if (block.isAutoMountingEnabled)
+            if (block.isAutoMountEnabled)
                 driver.mount(block);
         });
     }
-    else if (block.isMoved && block.isAutoMountingEnabled)
+    else if (block.isMoved && block.isAutoMountEnabled)
         nonreactive(() => driver.mount(block));
 }
-function renderNow(item) {
-    const b = item.instance;
-    const d = b.descriptor;
-    if (d.stamp >= 0) {
+function renderNow(ties) {
+    const b = ties.instance;
+    const node = b.node;
+    if (node.stamp >= 0) {
         let result = undefined;
-        runInside(item, () => {
+        runInside(ties, () => {
             try {
                 mountIfNecessary(b);
-                d.stamp++;
-                d.numerator = 0;
+                node.stamp++;
+                node.numerator = 0;
                 b.prepareForRender();
-                d.children.beginMerge();
-                const driver = d.driver;
+                node.children.beginMerge();
+                const driver = node.driver;
                 result = driver.render(b);
-                if (b.area === undefined && d.owner.isTable)
+                if (b.area === undefined && node.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); });
@@ -729,38 +737,38 @@ function renderNow(item) {
             }
             catch (e) {
                 runRenderNestedTreesThenDo(e, NOP);
-                console.log(`Rendering failed: ${d.key}`);
+                console.log(`Rendering failed: ${node.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;
+function triggerFinalization(ties, isLeader, individual) {
+    const b = ties.instance;
+    const node = b.node;
+    if (node.stamp >= 0) {
+        const driver = node.driver;
+        if (individual && node.key !== node.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: ${node.key}`);
+        node.stamp = ~node.stamp;
         const childrenAreLeaders = nonreactive(() => driver.finalize(b, isLeader));
         b.native = null;
         b.controller = null;
         if (b.isOn(Mode.PinpointRefresh)) {
-            item.aux = undefined;
+            ties.aux = undefined;
             const last = gLastToDispose;
             if (last)
-                gLastToDispose = last.aux = item;
+                gLastToDispose = last.aux = ties;
             else
-                gFirstToDispose = gLastToDispose = item;
-            if (gFirstToDispose === item)
-                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${item.instance.descriptor.key})` }, () => {
+                gFirstToDispose = gLastToDispose = ties;
+            if (gFirstToDispose === ties)
+                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${ties.instance.node.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }
-        for (const item of d.children.items())
+        for (const item of node.children.items())
             triggerFinalization(item, childrenAreLeaders, false);
-        BlockImpl.grandCount--;
+        BlockImpl.grandBlockCount--;
     }
 }
 function runDisposalLoop() {
@@ -772,7 +780,7 @@ function runDisposalLoop() {
                 yield Transaction.requestNextFrame();
             Rx.dispose(item.instance);
             item = item.aux;
-            BlockImpl.disposableCount--;
+            BlockImpl.disposableBlockCount--;
         }
         gFirstToDispose = gLastToDispose = undefined;
     });
@@ -788,10 +796,10 @@ function wrapToRunInside(func) {
         wrappedToRunInside = func;
     return wrappedToRunInside;
 }
-function runInside(item, func, ...args) {
+function runInside(ties, func, ...args) {
     const outer = gCurrent;
     try {
-        gCurrent = item;
+        gCurrent = ties;
         return func(...args);
     }
     finally {

package/build/dist/source/html/Blocks.js

@@ -78,7 +78,7 @@ export class VerstakHtmlDriver extends HtmlDriver {
         block.native.style.maxWidth = `${value}`;
     }
     applyHeightGrowth(block, value) {
-        const bNode = block.descriptor;
+        const bNode = block.node;
         const driver = bNode.driver;
         if (driver.isRow) {
             const s = block.native.style;
@@ -88,7 +88,7 @@ export class VerstakHtmlDriver extends HtmlDriver {
                 s.flexGrow = "";
         }
         else {
-            const hostDriver = bNode.host.descriptor.driver;
+            const hostDriver = bNode.host.node.driver;
             if (hostDriver.isRow) {
                 driver.applyBlockAlignment(block, Align.Stretch);
                 hostDriver.applyHeightGrowth(bNode.host, value);
@@ -202,14 +202,14 @@ const VerstakDriversByLayout = [
         const s = b.native.style;
         s.display = "flex";
         s.flexDirection = "column";
-        s.alignSelf = b.descriptor.owner.isTable ? "stretch" : "center";
+        s.alignSelf = b.node.owner.isTable ? "stretch" : "center";
         s.textAlign = "initial";
         s.flexShrink = "1";
         s.minWidth = "0";
     },
     b => {
         const s = b.native.style;
-        s.alignSelf = b.descriptor.owner.isTable ? "stretch" : "center";
+        s.alignSelf = b.node.owner.isTable ? "stretch" : "center";
         s.display = "grid";
         s.flexBasis = "0";
         s.gridAutoRows = "minmax(min-content, 1fr)";
@@ -218,12 +218,9 @@ const VerstakDriversByLayout = [
     },
     b => {
         const s = b.native.style;
-        s.alignSelf = b.descriptor.owner.isTable ? "stretch" : "center";
+        s.alignSelf = b.node.owner.isTable ? "stretch" : "center";
         s.display = "inline-grid";
         s.flexShrink = "1";
-        s.overflow = "";
-        s.textOverflow = "";
-        s.whiteSpace = "";
     },
     b => {
         const s = b.native.style;
@@ -231,7 +228,7 @@ const VerstakDriversByLayout = [
     },
     b => {
         const s = b.native.style;
-        s.display = b.descriptor.owner.isTable ? "none" : "flex";
+        s.display = b.node.owner.isTable ? "none" : "flex";
         s.flexDirection = "row";
     },
 ];

package/build/dist/source/html/HtmlBlocks.d.ts

@@ -87,7 +87,7 @@ export declare function Ruby<M = unknown, R = void>(builder?: BlockBuilder<HTMLE
 export declare function S<M = unknown, R = void>(builder?: BlockBuilder<HTMLElement, M, void, R>, base?: BlockBuilder<HTMLElement, M, void, R>): Block<HTMLElement, M, void, R>;
 export declare function Samp<M = unknown, R = void>(builder?: BlockBuilder<HTMLElement, M, void, R>, base?: BlockBuilder<HTMLElement, M, void, R>): Block<HTMLElement, M, void, R>;
 export declare function Script<M = unknown, R = void>(builder?: BlockBuilder<HTMLScriptElement, M, void, R>, base?: BlockBuilder<HTMLScriptElement, M, void, R>): Block<HTMLScriptElement, M, void, R>;
-export declare function Section<M = unknown, R = void>(builder?: BlockBuilder<HTMLElement, M, void, R>, base?: BlockBuilder<HTMLElement, M, void, R>): Block<HTMLElement, M, void, R>;
+export declare function Sctn<M = unknown, R = void>(builder?: BlockBuilder<HTMLElement, M, void, R>, base?: BlockBuilder<HTMLElement, M, void, R>): Block<HTMLElement, M, void, R>;
 export declare function Select<M = unknown, R = void>(builder?: BlockBuilder<HTMLSelectElement, M, void, R>, base?: BlockBuilder<HTMLSelectElement, M, void, R>): Block<HTMLSelectElement, M, void, R>;
 export declare function Small<M = unknown, R = void>(builder?: BlockBuilder<HTMLElement, M, void, R>, base?: BlockBuilder<HTMLElement, M, void, R>): Block<HTMLElement, M, void, R>;
 export declare function Source<M = unknown, R = void>(builder?: BlockBuilder<HTMLSourceElement, M, void, R>, base?: BlockBuilder<HTMLSourceElement, M, void, R>): Block<HTMLSourceElement, M, void, R>;

package/build/dist/source/html/HtmlBlocks.js

@@ -91,7 +91,7 @@ export function Ruby(builder, base) { return Verstak.claim(HtmlTags.ruby, builde
 export function S(builder, base) { return Verstak.claim(HtmlTags.s, builder, base); }
 export function Samp(builder, base) { return Verstak.claim(HtmlTags.samp, builder, base); }
 export function Script(builder, base) { return Verstak.claim(HtmlTags.script, builder, base); }
-export function Section(builder, base) { return Verstak.claim(HtmlTags.section, builder, base); }
+export function Sctn(builder, base) { return Verstak.claim(HtmlTags.section, builder, base); }
 export function Select(builder, base) { return Verstak.claim(HtmlTags.select, builder, base); }
 export function Small(builder, base) { return Verstak.claim(HtmlTags.small, builder, base); }
 export function Source(builder, base) { return Verstak.claim(HtmlTags.source, builder, base); }

package/build/dist/source/html/HtmlDriver.d.ts

@@ -13,7 +13,7 @@ export declare abstract class BaseHtmlDriver<T extends Element, C = unknown> ext
     static get blinkingEffectMarker(): string | undefined;
     static set blinkingEffectMarker(value: string | undefined);
     static findEffectiveHtmlBlockHost(block: Block<any>): Block<HTMLElement | SVGElement>;
-    static findPrevSiblingHtmlBlock(item: Item<Block<any>>): Item<Block<HTMLElement | SVGElement>> | undefined;
+    static findPrevSiblingHtmlBlock(ties: Item<Block<any>>): Item<Block<HTMLElement | SVGElement>> | undefined;
 }
 export declare class HtmlDriver<T extends HTMLElement, C = unknown> extends BaseHtmlDriver<T, C> {
     create(block: Block<T, unknown, C, void>, b: {

package/build/dist/source/html/HtmlDriver.js

@@ -5,8 +5,8 @@ export class BaseHtmlDriver extends BaseDriver {
         super.create(block, b);
     }
     initialize(block) {
-        if (Rx.isLogging && !block.descriptor.driver.isRow)
-            block.native.setAttribute("key", block.descriptor.key);
+        if (Rx.isLogging && !block.node.driver.isRow)
+            block.native.setAttribute("key", block.node.key);
         super.initialize(block);
     }
     finalize(block, isLeader) {
@@ -23,13 +23,13 @@ export class BaseHtmlDriver extends BaseDriver {
     mount(block) {
         const e = block.native;
         if (e) {
-            const bNode = block.descriptor;
-            const sequential = bNode.owner.descriptor.children.isStrict;
+            const node = block.node;
+            const sequential = node.owner.node.children.isStrict;
             const nativeParent = BaseHtmlDriver.findEffectiveHtmlBlockHost(block).native;
             if (nativeParent) {
-                if (sequential && !bNode.driver.isRow) {
-                    const after = BaseHtmlDriver.findPrevSiblingHtmlBlock(block.descriptor.item);
-                    if (after === undefined || after.instance.descriptor.driver.isRow) {
+                if (sequential && !node.driver.isRow) {
+                    const after = BaseHtmlDriver.findPrevSiblingHtmlBlock(block.node.ties);
+                    if (after === undefined || after.instance.node.driver.isRow) {
                         if (nativeParent !== e.parentNode || !e.previousSibling)
                             nativeParent.prepend(e);
                     }
@@ -51,7 +51,7 @@ export class BaseHtmlDriver extends BaseDriver {
     render(block) {
         const result = super.render(block);
         if (gBlinkingEffectMarker)
-            blink(block.native, Verstak.currentRenderingPriority, block.descriptor.stamp);
+            blink(block.native, Verstak.currentRenderingPriority, block.node.stamp);
         return result;
     }
     static get blinkingEffectMarker() {
@@ -61,14 +61,14 @@ export class BaseHtmlDriver extends BaseDriver {
         gBlinkingEffectMarker = value;
     }
     static findEffectiveHtmlBlockHost(block) {
-        let p = block.descriptor.host;
+        let p = block.node.host;
         while (p.native instanceof HTMLElement === false &&
             p.native instanceof SVGElement === false && p !== block)
-            p = p.descriptor.host;
+            p = p.node.host;
         return p;
     }
-    static findPrevSiblingHtmlBlock(item) {
-        let p = item.prev;
+    static findPrevSiblingHtmlBlock(ties) {
+        let p = ties.prev;
         while (p && !(p.instance.native instanceof HTMLElement) && !(p.instance.native instanceof SVGElement))
             p = p.prev;
         return p;
@@ -76,13 +76,13 @@ export class BaseHtmlDriver extends BaseDriver {
 }
 export class HtmlDriver extends BaseHtmlDriver {
     create(block, b) {
-        b.native = document.createElement(block.descriptor.driver.name);
+        b.native = document.createElement(block.node.driver.name);
         super.create(block, b);
     }
 }
 export class SvgDriver extends BaseHtmlDriver {
     create(block, b) {
-        b.native = document.createElementNS("http://www.w3.org/2000/svg", block.descriptor.driver.name);
+        b.native = document.createElementNS("http://www.w3.org/2000/svg", block.node.driver.name);
         super.create(block, b);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verstak",
-  "version": "0.23.109",
+  "version": "0.23.111",
   "description": "Verstak - Front-End Library",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",