verstak 0.22.514 → 0.22.516

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

@@ -6,4 +6,6 @@ export interface CellRange {
 }
 export declare function parseCellRange(text: string, result: CellRange): CellRange;
 export declare function emitCellRange(value: CellRange): string;
+export declare function emitLetters(n: number): string;
+export declare function emitCellPosition(x: number, y: number): string;
 export declare function equalCellRanges(a: CellRange, b: CellRange): boolean;

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

@@ -134,22 +134,7 @@ export function emitCellRange(value) {
     const p2 = emitCellPosition(value.x2, value.y2);
     return `${p1}${p2 !== "" ? `:${p2}` : ""}`;
 }
-export function equalCellRanges(a, b) {
-    return a.x1 === b.x1 && a.y1 === b.y1 && a.x2 === b.x2 && a.y1 === b.y2;
-}
-function isWhitespace(char) {
-    return char === 32 || (char >= 9 && char <= 13) || char === 133 || char === 160;
-}
-function isDigit(input, index) {
-    return 48 <= input && input <= 57;
-}
-function isCapitalLetter(ch) {
-    return 65 <= ch && ch <= 90;
-}
-function isLowercaseLetter(ch) {
-    return 97 <= ch && ch <= 122;
-}
-function emitLetters(n) {
+export function emitLetters(n) {
     if (n < 0)
         throw new Error(`emitLetters: argument (${n}) should not be negative or zero`);
     let result = "";
@@ -160,7 +145,7 @@ function emitLetters(n) {
     }
     return result;
 }
-function emitCellPosition(x, y) {
+export function emitCellPosition(x, y) {
     let result = "";
     if (x > 0 && y > 0)
         result = `${emitLetters(x - 1)}${y}`;
@@ -174,3 +159,18 @@ function emitCellPosition(x, y) {
         result = "";
     return result;
 }
+export function equalCellRanges(a, b) {
+    return a.x1 === b.x1 && a.y1 === b.y1 && a.x2 === b.x2 && a.y1 === b.y2;
+}
+function isWhitespace(char) {
+    return char === 32 || (char >= 9 && char <= 13) || char === 133 || char === 160;
+}
+function isDigit(input, index) {
+    return 48 <= input && input <= 57;
+}
+function isCapitalLetter(ch) {
+    return 65 <= ch && ch <= 90;
+}
+function isLowercaseLetter(ch) {
+    return 97 <= ch && ch <= 122;
+}

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

@@ -1 +1,2 @@
 export declare function objectHasMember<T>(obj: any, member: string): obj is T;
+export declare function getCallerInfo(prefix: string): string;

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

@@ -1,3 +1,35 @@
 export function objectHasMember(obj, member) {
     return obj === Object(obj) && !Array.isArray(obj) && member in obj;
 }
+export function getCallerInfo(prefix) {
+    const restore = Error.stackTraceLimit = 20;
+    const error = new Error();
+    const stack = error.stack || "";
+    Error.stackTraceLimit = restore;
+    const lines = stack.split("\n");
+    let i = lines.findIndex(x => x.indexOf(".claim") >= 0);
+    i = i >= 0 ? i + 2 : 5;
+    let caller = extractFunctionAndLocation(lines[i]);
+    let location = caller;
+    if (caller.func === "VerstakDriver.render" || caller.func === "render") {
+        i = i - 1;
+        caller = extractFunctionAndLocation(lines[i]);
+        location = extractFunctionAndLocation(lines[i + 1]);
+    }
+    else {
+        while (!caller.func) {
+            i = i - 1;
+            caller = extractFunctionAndLocation(lines[i]);
+        }
+        location = extractFunctionAndLocation(lines[i + 1]);
+    }
+    const result = `${prefix}:${caller.func}@${location.file}`;
+    return result;
+}
+function extractFunctionAndLocation(s) {
+    const match = s.match(/(?:\s*at\s+)?(?:(\S+)\s\()?(?:.*?)([^\/\(\):]+)(?:(:|\d)*\)?)$/);
+    return {
+        func: (match === null || match === void 0 ? void 0 : match[1]) || "",
+        file: (match === null || match === void 0 ? void 0 : match[2]) || "",
+    };
+}

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

@@ -12,6 +12,7 @@ export declare const enum Priority {
 export declare type Type<T> = new (...args: any[]) => T;
 export declare type BlockBody<T = unknown, M = unknown, R = void> = Render<T, M, R> | BlockVmt<T, M, R>;
 export interface BlockVmt<T = unknown, M = unknown, R = void> {
+    key?: string;
     reacting?: boolean;
     triggers?: unknown;
     initialize?: Render<T, M, R>;
@@ -19,15 +20,15 @@ export interface BlockVmt<T = unknown, M = unknown, R = void> {
     render?: Render<T, M, R>;
     finalize?: Render<T, M, R>;
 }
-export declare function baseFor<T, M, R>(outer: BlockBody<T, M, R> | undefined, base: BlockBody<T, M, R>): BlockVmt<T, M, R>;
-export declare function defineSubTreeContext<T extends Object>(type: Type<T>, context: T): void;
-export declare function use<T extends Object>(type: Type<T>): T;
+export declare function asBaseFor<T, M, R>(outer: BlockBody<T, M, R> | undefined, base: BlockBody<T, M, R>): BlockVmt<T, M, R>;
+export declare function nestedContext<T extends Object>(type: Type<T>, context: T): void;
+export declare function useContext<T extends Object>(type: Type<T>): T;
 export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
     static currentRenderingPriority: Priority;
     static frameDuration: number;
-    abstract readonly name: string;
+    abstract readonly key: string;
     abstract readonly driver: AbstractDriver<T>;
     abstract readonly body: Readonly<BlockVmt<T, M, R>>;
     abstract model: M;
@@ -56,14 +57,15 @@ export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     static get current(): VBlock;
     static renderNestedTreesThenDo(action: (error: unknown) => void): void;
     static runForAllBlocks<T>(action: (e: T) => void): void;
-    static claim<T = undefined, M = unknown, R = void>(name: string, driver: AbstractDriver<T> | undefined, body: BlockBody<T, M, R>): VBlock<T, M, R>;
+    static claim<T = undefined, M = unknown, R = void>(driver: AbstractDriver<T> | undefined, body: BlockBody<T, M, R>): VBlock<T, M, R>;
+    private static generateKey;
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
 export declare enum LayoutKind {
     Block = 0,
     Grid = 1,
-    Row = 2,
+    Line = 2,
     Group = 3,
     Text = 4
 }
@@ -76,7 +78,7 @@ export declare class AbstractDriver<T> {
     get isAuxiliary(): boolean;
     get isBlock(): boolean;
     get isGrid(): boolean;
-    get isRow(): boolean;
+    get isLine(): boolean;
     constructor(name: string, layout: LayoutKind, createCursor?: () => Cursor);
     initialize(block: VBlock<T>, native: T): void;
     finalize(block: VBlock<T>, isLeader: boolean): boolean;

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

@@ -17,7 +17,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { reactive, nonreactive, Transaction, options, Reentrance, Rx, Collection, ObservableObject, raw } from "reactronic";
-import { equalCellRanges } from "./CellRange";
+import { getCallerInfo } from "./Utils";
+import { emitLetters, equalCellRanges } from "./CellRange";
 import { Cursor, Align } from "./Cursor";
 export var Priority;
 (function (Priority) {
@@ -25,7 +26,7 @@ export var Priority;
     Priority[Priority["AsyncP1"] = 1] = "AsyncP1";
     Priority[Priority["AsyncP2"] = 2] = "AsyncP2";
 })(Priority || (Priority = {}));
-export function baseFor(outer, base) {
+export function asBaseFor(outer, base) {
     if (outer instanceof Function)
         outer = { render: outer };
     if (base instanceof Function)
@@ -37,10 +38,10 @@ function via(outer, base) {
     const inherited = base !== null && base !== void 0 ? base : NOP;
     return outer ? b => outer(b, () => inherited(b)) : inherited;
 }
-export function defineSubTreeContext(type, context) {
-    return VBlockImpl.defineSubTreeContext(type, context);
+export function nestedContext(type, context) {
+    return VBlockImpl.setContext(type, context);
 }
-export function use(type) {
+export function useContext(type) {
     return VBlockImpl.use(type);
 }
 export class VBlock {
@@ -60,22 +61,22 @@ export class VBlock {
     static runForAllBlocks(action) {
         forEachChildRecursively(gSysRoot, action);
     }
-    static claim(name, driver, body) {
+    static claim(driver, body) {
         var _a, _b;
-        if (body instanceof Function)
-            body = { render: body };
         let result;
         const owner = gCurrent.instance;
         const children = owner.children;
         let ex = undefined;
         driver !== null && driver !== void 0 ? driver : (driver = AbstractDriver.group);
-        name || (name = `${++owner.numerator}`);
-        if (driver.isRow) {
+        if (body instanceof Function)
+            body = { render: body };
+        let key = body.key;
+        if (driver.isLine) {
             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(name, undefined, "nested blocks can be declared inside render function only"));
+        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)
@@ -86,7 +87,7 @@ export class VBlock {
             result.body = body;
         }
         else {
-            result = new VBlockImpl(name, driver, owner, body);
+            result = new VBlockImpl(key || VBlock.generateKey(owner), driver, owner, body);
             result.item = children.add(result);
             VBlockImpl.grandCount++;
             if (body.reacting)
@@ -94,6 +95,16 @@ export class VBlock {
         }
         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;
     }
@@ -109,7 +120,7 @@ export var LayoutKind;
 (function (LayoutKind) {
     LayoutKind[LayoutKind["Block"] = 0] = "Block";
     LayoutKind[LayoutKind["Grid"] = 1] = "Grid";
-    LayoutKind[LayoutKind["Row"] = 2] = "Row";
+    LayoutKind[LayoutKind["Line"] = 2] = "Line";
     LayoutKind[LayoutKind["Group"] = 3] = "Group";
     LayoutKind[LayoutKind["Text"] = 4] = "Text";
 })(LayoutKind || (LayoutKind = {}));
@@ -124,7 +135,7 @@ export class AbstractDriver {
     get isAuxiliary() { return (this.layout & 2) === 2; }
     get isBlock() { return this.layout === LayoutKind.Block; }
     get isGrid() { return this.layout === LayoutKind.Grid; }
-    get isRow() { return this.layout === LayoutKind.Row; }
+    get isLine() { return this.layout === LayoutKind.Line; }
     initialize(block, native) {
         var _a, _b;
         const b = block;
@@ -188,8 +199,8 @@ export class StaticDriver extends AbstractDriver {
         super.initialize(block, this.element);
     }
 }
-function getBlockName(block) {
-    return block.stamp >= 0 ? block.name : undefined;
+function getBlockKey(block) {
+    return block.stamp >= 0 ? block.key : undefined;
 }
 class VBlockContext extends ObservableObject {
     constructor(type, instance) {
@@ -203,9 +214,9 @@ __decorate([
     __metadata("design:type", Object)
 ], VBlockContext.prototype, "type", void 0);
 class VBlockImpl extends VBlock {
-    constructor(name, driver, owner, body) {
+    constructor(key, driver, owner, body) {
         super();
-        this.name = name;
+        this.key = key;
         this.driver = driver;
         this.body = body;
         this.model = undefined;
@@ -225,7 +236,7 @@ class VBlockImpl extends VBlock {
         this.renderingPriority = Priority.SyncP0;
         this.level = owner.level + 1;
         this.host = owner;
-        this.children = new Collection(driver.isSequential, getBlockName);
+        this.children = new Collection(driver.isSequential, getBlockKey);
         this.numerator = 0;
         this.item = undefined;
         this.stamp = 0;
@@ -278,16 +289,16 @@ class VBlockImpl extends VBlock {
     }
     get minHeight() { return this.appliedMinHeight; }
     set minHeight(value) {
-        if (value !== this.appliedMinWidth) {
-            this.driver.applyMinWidth(this, value);
-            this.appliedMinWidth = value;
+        if (value !== this.appliedMinHeight) {
+            this.driver.applyMinHeight(this, value);
+            this.appliedMinHeight = value;
         }
     }
     get maxHeight() { return this.appliedMaxHeight; }
     set maxHeight(value) {
-        if (value !== this.appliedMaxWidth) {
-            this.driver.applyMaxWidth(this, value);
-            this.appliedMaxWidth = value;
+        if (value !== this.appliedMaxHeight) {
+            this.driver.applyMaxHeight(this, value);
+            this.appliedMaxHeight = value;
         }
     }
     get contentAlignment() { return this.appliedContentAlignment; }
@@ -332,7 +343,7 @@ class VBlockImpl extends VBlock {
             throw new Error(`${type.name} context doesn't exist`);
         return (_b = b.context) === null || _b === void 0 ? void 0 : _b.instance;
     }
-    static defineSubTreeContext(type, context) {
+    static setContext(type, context) {
         const block = gCurrent.instance;
         const host = block.host;
         const hostCtx = nonreactive(() => { var _a; return (_a = host.context) === null || _a === void 0 ? void 0 : _a.instance; });
@@ -380,8 +391,9 @@ function runRenderNestedTreesThenDo(error, action) {
         let promised = undefined;
         try {
             children.endMerge(error);
-            for (const item of children.removedItems(true))
-                runFinalize(item, true);
+            for (const item of children.removedItems(true)) {
+                runFinalize(item, true, true);
+            }
             if (!error) {
                 const ownerIsBlock = owner.driver.isBlock;
                 const sequential = children.strict;
@@ -396,7 +408,7 @@ function runRenderNestedTreesThenDo(error, action) {
                         break;
                     const block = item.instance;
                     const driver = block.driver;
-                    const host = driver.isRow ? owner : partHost;
+                    const host = driver.isLine ? owner : partHost;
                     const p = (_a = block.renderingPriority) !== null && _a !== void 0 ? _a : Priority.SyncP0;
                     redeploy = markToRedeployIfNecessary(redeploy, host, item, children, sequential);
                     if (p === Priority.SyncP0)
@@ -405,7 +417,7 @@ function runRenderNestedTreesThenDo(error, action) {
                         p1 = push(item, p1);
                     else
                         p2 = push(item, p2);
-                    if (ownerIsBlock && driver.isRow)
+                    if (ownerIsBlock && driver.isLine)
                         partHost = block;
                 }
                 if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
@@ -493,7 +505,7 @@ function prepareRender(item, redeploy, sequential) {
             if ((_a = block.body) === null || _a === void 0 ? void 0 : _a.reacting) {
                 Transaction.outside(() => {
                     if (Rx.isLogging)
-                        Rx.setLoggingHint(block, block.name);
+                        Rx.setLoggingHint(block, block.key);
                     Rx.getController(block.rerender).configure({
                         order: block.level,
                     });
@@ -519,7 +531,7 @@ function runRender(item) {
                 block.assignedCells = undefined;
                 block.children.beginMerge();
                 result = block.driver.render(block);
-                if (block.driver.isRow)
+                if (block.driver.isLine)
                     block.host.cursor.lineFeed();
                 else if (block.assignedCells === undefined)
                     block.cells = undefined;
@@ -530,16 +542,18 @@ function runRender(item) {
             }
             catch (e) {
                 runRenderNestedTreesThenDo(e, NOP);
-                console.log(`Rendering failed: ${block.name}`);
+                console.log(`Rendering failed: ${block.key}`);
                 console.log(`${e}`);
             }
         });
     }
 }
-function runFinalize(item, isLeader) {
+function runFinalize(item, isLeader, individual) {
     var _a;
     const block = item.instance;
     if (block.stamp >= 0) {
+        if (individual && block.key !== block.body.key && !block.driver.isLine)
+            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 = block.driver.finalize(block, isLeader);
         if ((_a = block.body) === null || _a === void 0 ? void 0 : _a.reacting) {
@@ -550,12 +564,12 @@ function runFinalize(item, isLeader) {
             else
                 gFirstToDispose = gLastToDispose = item;
             if (gFirstToDispose === item)
-                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${item.instance.name})` }, () => {
+                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())
-            runFinalize(item, childrenAreLeaders);
+            runFinalize(item, childrenAreLeaders, false);
         VBlockImpl.grandCount--;
     }
 }
@@ -648,7 +662,7 @@ function defaultReject(error) {
 Promise.prototype.then = reactronicDomHookedThen;
 const NOP = (...args) => { };
 const gSysDriver = new StaticDriver(null, "SYSTEM", LayoutKind.Group);
-const gSysRoot = Collection.createItem(new VBlockImpl("SYSTEM", gSysDriver, { level: 0 }, { reacting: true, render: NOP }));
+const gSysRoot = Collection.createItem(new VBlockImpl(gSysDriver.name, gSysDriver, { level: 0 }, { reacting: true, render: NOP }));
 gSysRoot.instance.item = gSysRoot;
 Object.defineProperty(gSysRoot.instance, "host", {
     value: gSysRoot.instance,

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

@@ -1,12 +1,12 @@
 import { VBlock, BlockBody, Align, CellRange } from "../core/api";
 import { HtmlDriver } from "./HtmlDriver";
-export declare function Block<M = unknown, R = void>(name: string, body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
-export declare function PlainText(content: string, name?: string, body?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
-export declare function HtmlText(content: string, name?: string, body?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
-export declare function Grid<M = unknown, R = void>(name: string, body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
-export declare function Line<T = void>(claim: (x: void) => T): VBlock<HTMLElement>;
-export declare function lineFeed(body?: BlockBody<HTMLElement, void, void>, noCoalescing?: boolean): VBlock<HTMLElement>;
-export declare function Group<M = unknown, R = void>(name: string, body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function Block<M = unknown, R = void>(body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function PlainText(content: string, body?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
+export declare function HtmlText(content: string, body?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
+export declare function Grid<M = unknown, R = void>(body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function line<T = void>(body: (block: void) => T): void;
+export declare function lineFeed(noCoalescing?: boolean, key?: string): VBlock<HTMLElement>;
+export declare function Group<M = unknown, R = void>(body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
 export declare class VerstakDriver<T extends HTMLElement> extends HtmlDriver<T> {
     applyCellRange(block: VBlock<T>, cellRange: CellRange | undefined): void;
     applyWidthGrowth(block: VBlock<T>, widthGrowth: number): void;

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

@@ -1,36 +1,34 @@
-import { VBlock, LayoutKind, Align, GridCursor, baseFor } from "../core/api";
+import { VBlock, LayoutKind, Align, GridCursor, asBaseFor } from "../core/api";
 import { HtmlDriver } from "./HtmlDriver";
-export function Block(name, body) {
-    return VBlock.claim(name, VerstakTags.block, body);
+export function Block(body) {
+    return VBlock.claim(VerstakTags.block, body);
 }
-export function PlainText(content, name, body) {
-    return VBlock.claim(name !== null && name !== void 0 ? name : "", VerstakTags.text, baseFor(body, {
+export function PlainText(content, body) {
+    return VBlock.claim(VerstakTags.text, asBaseFor(body, {
         render(b) {
             b.native.innerText = content;
         },
     }));
 }
-export function HtmlText(content, name, body) {
-    return VBlock.claim(name !== null && name !== void 0 ? name : "", VerstakTags.text, baseFor(body, {
+export function HtmlText(content, body) {
+    return VBlock.claim(VerstakTags.text, asBaseFor(body, {
         render(b) {
             b.native.innerHTML = content;
         },
     }));
 }
-export function Grid(name, body) {
-    return VBlock.claim(name, VerstakTags.grid, body);
+export function Grid(body) {
+    return VBlock.claim(VerstakTags.grid, body);
 }
-export function Line(claim) {
-    const result = VBlock.claim("", VerstakTags.row, EMPTY_BLOCK_BODY);
-    claim();
-    VBlock.claim("", VerstakTags.row, EMPTY_BLOCK_BODY);
-    return result;
+export function line(body) {
+    lineFeed();
+    body();
 }
-export function lineFeed(body, noCoalescing) {
-    return VBlock.claim("", VerstakTags.row, body !== null && body !== void 0 ? body : EMPTY_BLOCK_BODY);
+export function lineFeed(noCoalescing, key) {
+    return VBlock.claim(VerstakTags.line, { key });
 }
-export function Group(name, body) {
-    return VBlock.claim(name, VerstakTags.group, body);
+export function Group(body) {
+    return VBlock.claim(VerstakTags.group, body);
 }
 export class VerstakDriver extends HtmlDriver {
     applyCellRange(block, cellRange) {
@@ -64,14 +62,14 @@ export class VerstakDriver extends HtmlDriver {
         block.native.style.maxWidth = `${maxWidth}`;
     }
     applyHeightGrowth(block, heightGrowth) {
-        if (block.driver.isRow) {
+        if (block.driver.isLine) {
             const css = block.native.style;
             if (heightGrowth > 0)
                 css.flexGrow = `${heightGrowth}`;
             else
                 css.flexGrow = "";
         }
-        else if (block.host.driver.isRow) {
+        else if (block.host.driver.isLine) {
             block.driver.applyFrameAlignment(block, Align.Stretch);
             block.host.driver.applyHeightGrowth(block.host, heightGrowth);
         }
@@ -119,8 +117,8 @@ export class VerstakDriver extends HtmlDriver {
             block.native.removeAttribute("floating");
     }
     render(block) {
-        if (block.driver.layout < LayoutKind.Row)
-            VBlock.claim("", VerstakTags.row, EMPTY_BLOCK_BODY);
+        if (block.driver.layout < LayoutKind.Line)
+            lineFeed();
         return super.render(block);
     }
 }
@@ -128,9 +126,8 @@ const VerstakTags = {
     block: new VerstakDriver("v-block", LayoutKind.Block),
     text: new VerstakDriver("v-text", LayoutKind.Text),
     grid: new VerstakDriver("v-grid", LayoutKind.Grid, () => new GridCursor()),
-    row: new VerstakDriver("v-row", LayoutKind.Row),
+    line: new VerstakDriver("v-line", LayoutKind.Line),
     group: new VerstakDriver("v-group", LayoutKind.Group),
 };
-const EMPTY_BLOCK_BODY = { render() { } };
 const AlignToCss = ["stretch", "start", "center", "end"];
 const TextAlignCss = ["justify", "left", "center", "right"];