verstak 0.22.500 → 0.22.503

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

@@ -0,0 +1,504 @@
+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 } from "reactronic";
+import { Allocator, To } from "./Allocator";
+export var Priority;
+(function (Priority) {
+    Priority[Priority["SyncP0"] = 0] = "SyncP0";
+    Priority[Priority["AsyncP1"] = 1] = "AsyncP1";
+    Priority[Priority["AsyncP2"] = 2] = "AsyncP2";
+})(Priority || (Priority = {}));
+export class VBlock {
+    baseRender() {
+        return callRenderFunctions(this);
+    }
+    get isInitialRendering() {
+        return this.stamp === 2;
+    }
+    static root(render) {
+        gSysRoot.instance.args.render = render;
+        prepareAndRunRender(gSysRoot, false, false);
+    }
+    static get current() {
+        return gContext.instance;
+    }
+    static renderNestedTreesThenDo(action) {
+        runRenderNestedTreesThenDo(undefined, action);
+    }
+    static runForAllBlocks(action) {
+        forEachChildRecursively(gSysRoot, action);
+    }
+    static claim(name, args, driver) {
+        var _a, _b;
+        let result;
+        const owner = gContext.instance;
+        const children = owner.children;
+        let existing = undefined;
+        driver !== null && driver !== void 0 ? driver : (driver = AbstractDriver.group);
+        name || (name = `${++owner.numerator}`);
+        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)
+                existing = last;
+        }
+        existing !== null && existing !== void 0 ? existing : (existing = children.claim(name));
+        if (existing) {
+            result = existing.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 = (_b = result.args) === null || _b === void 0 ? void 0 : _b.triggers;
+            if (triggersAreEqual(args.triggers, exTriggers))
+                args.triggers = exTriggers;
+            result.args = args;
+        }
+        else {
+            result = new VBlockImpl(name, driver, owner, args);
+            result.item = children.add(result);
+            VBlockImpl.grandCount++;
+            if (args.reacting)
+                VBlockImpl.disposableCount++;
+        }
+        return result;
+    }
+    static getDefaultLoggingOptions() {
+        return VBlockImpl.logging;
+    }
+    static setDefaultLoggingOptions(logging) {
+        VBlockImpl.logging = logging;
+    }
+}
+VBlock.shortFrameDuration = 16;
+VBlock.longFrameDuration = 300;
+VBlock.currentRenderingPriority = Priority.SyncP0;
+VBlock.frameDuration = VBlock.longFrameDuration;
+export var LayoutKind;
+(function (LayoutKind) {
+    LayoutKind[LayoutKind["Block"] = 0] = "Block";
+    LayoutKind[LayoutKind["Grid"] = 1] = "Grid";
+    LayoutKind[LayoutKind["Line"] = 2] = "Line";
+    LayoutKind[LayoutKind["Group"] = 3] = "Group";
+    LayoutKind[LayoutKind["Text"] = 4] = "Text";
+})(LayoutKind || (LayoutKind = {}));
+const createDefaultAllocator = () => new Allocator();
+export class AbstractDriver {
+    constructor(name, layout, createAllocator) {
+        this.name = name;
+        this.layout = layout;
+        this.createAllocator = createAllocator !== null && createAllocator !== void 0 ? createAllocator : createDefaultAllocator;
+    }
+    get isSequential() { return (this.layout & 1) === 0; }
+    get isAuxiliary() { return (this.layout & 2) === 2; }
+    get isBlock() { return this.layout === LayoutKind.Block; }
+    get isGrid() { return this.layout === LayoutKind.Grid; }
+    get isLine() { return this.layout === LayoutKind.Line; }
+    initialize(block, native) {
+        const b = block;
+        b.native = native;
+    }
+    finalize(block, isLeader) {
+        const b = block;
+        b.native = undefined;
+        return isLeader;
+    }
+    deploy(block, sequential) {
+    }
+    arrange(block, place, heightGrab) {
+        var _a, _b, _c;
+        const b = block;
+        if (heightGrab === undefined) {
+            b.place = place;
+            const host = b.host;
+            if (host.driver.isLine) {
+                const grab = (_a = place === null || place === void 0 ? void 0 : place.heightGrab) !== null && _a !== void 0 ? _a : 0;
+                if (grab > 0 && ((_c = (_b = host.place) === null || _b === void 0 ? void 0 : _b.heightGrab) !== null && _c !== void 0 ? _c : 0) < grab)
+                    host.driver.arrange(host, undefined, grab);
+            }
+        }
+        else if (heightGrab > 0) {
+            if (b.place === undefined)
+                b.place = {
+                    exact: undefined,
+                    widthMin: "", widthMax: "", widthGrab: 0,
+                    heightMin: "", heightMax: "", heightGrab,
+                    align: To.Default,
+                    dock: To.Default,
+                };
+            else
+                b.place.heightGrab = heightGrab;
+        }
+    }
+    render(block) {
+        var _a;
+        let result;
+        const wrapper = (_a = block.args) === null || _a === void 0 ? void 0 : _a.wrapper;
+        if (wrapper)
+            result = wrapper(block.native, block);
+        else
+            result = callRenderFunctions(block);
+        return result;
+    }
+}
+AbstractDriver.group = new AbstractDriver("group", LayoutKind.Group);
+function callRenderFunctions(block) {
+    var _a;
+    const uses = (_a = block.args) === null || _a === void 0 ? void 0 : _a.mixins;
+    if (uses)
+        for (const use of uses)
+            use(block.native, block);
+    return block.args.render(block.native, block);
+}
+export class StaticDriver extends AbstractDriver {
+    constructor(element, name, layout, createAllocator) {
+        super(name, layout, createAllocator);
+        this.element = element;
+    }
+    initialize(block, element) {
+        super.initialize(block, this.element);
+    }
+}
+function getBlockName(block) {
+    return block.stamp >= 0 ? block.name : undefined;
+}
+class VBlockImpl extends VBlock {
+    constructor(name, driver, owner, options) {
+        super();
+        this.name = name;
+        this.driver = driver;
+        this.args = options;
+        this.model = undefined;
+        this.level = owner.level + 1;
+        this.host = owner;
+        this.children = new Collection(driver.isSequential, getBlockName);
+        this.numerator = 0;
+        this.item = undefined;
+        this.stamp = 0;
+        this.native = undefined;
+        this.place = undefined;
+        this.allocator = driver.createAllocator();
+    }
+    rerender(_triggers) {
+        runRender(this.item);
+    }
+}
+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, "rerender", null);
+function runRenderNestedTreesThenDo(error, action) {
+    var _a;
+    const context = gContext;
+    const owner = context.instance;
+    const children = owner.children;
+    if (children.isMergeInProgress) {
+        let promised = undefined;
+        try {
+            children.endMerge(error);
+            for (const item of children.removedItems(true))
+                runFinalize(item, true);
+            if (!error) {
+                const isBlockOwner = owner.driver.isBlock;
+                const sequential = children.strict;
+                const allocator = owner.allocator;
+                allocator.reset();
+                let p1 = undefined;
+                let p2 = undefined;
+                let redeploy = false;
+                let lineHost = owner;
+                for (const item of children.items()) {
+                    if (Transaction.isCanceled)
+                        break;
+                    const block = item.instance;
+                    const driver = block.driver;
+                    const opt = block.args;
+                    if (!driver.isLine) {
+                        const place = allocator.allocate(opt);
+                        driver.arrange(block, place, undefined);
+                    }
+                    else
+                        allocator.lineFeed();
+                    const host = driver.isLine ? owner : lineHost;
+                    redeploy = markToRedeployIfNecessary(redeploy, host, item, children, sequential);
+                    const priority = (_a = opt === null || opt === void 0 ? void 0 : opt.priority) !== null && _a !== void 0 ? _a : Priority.SyncP0;
+                    if (priority === Priority.SyncP0)
+                        prepareAndRunRender(item, children.isMoved(item), sequential);
+                    else if (priority === Priority.AsyncP1)
+                        p1 = push(item, p1);
+                    else
+                        p2 = push(item, p2);
+                    if (isBlockOwner && driver.isLine)
+                        lineHost = block;
+                }
+                if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
+                    promised = startIncrementalRendering(context, 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.AsyncP1);
+        if (priority2)
+            yield renderIncrementally(owner, stamp, allChildren, priority2, Priority.AsyncP2);
+    });
+}
+function renderIncrementally(owner, stamp, allChildren, items, priority) {
+    var _a;
+    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 {
+                const sequential = block.children.strict;
+                if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.shuffle)
+                    shuffle(items);
+                const frameDurationLimit = priority === Priority.AsyncP2 ? VBlock.shortFrameDuration : Infinity;
+                let frameDuration = Math.min(frameDurationLimit, Math.max(VBlock.frameDuration / 4, VBlock.shortFrameDuration));
+                for (const child of items) {
+                    prepareAndRunRender(child, allChildren.isMoved(child), sequential);
+                    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 prepareAndRunRender(item, redeploy, sequential) {
+    var _a, _b;
+    const block = item.instance;
+    if (block.stamp >= 0) {
+        prepareRender(item, redeploy, sequential);
+        if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.reacting)
+            nonreactive(block.rerender, (_b = block.args) === null || _b === void 0 ? void 0 : _b.triggers);
+        else
+            runRender(item);
+    }
+}
+function prepareRender(item, redeploy, sequential) {
+    var _a;
+    const block = item.instance;
+    const driver = block.driver;
+    if (block.stamp === 0) {
+        block.stamp = 1;
+        if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.reacting) {
+            Transaction.outside(() => {
+                var _a, _b, _c;
+                if (Rx.isLogging)
+                    Rx.setLoggingHint(block, block.name);
+                Rx.getController(block.rerender).configure({
+                    order: block.level,
+                    monitor: (_a = block.args) === null || _a === void 0 ? void 0 : _a.monitor,
+                    throttling: (_b = block.args) === null || _b === void 0 ? void 0 : _b.throttling,
+                    logging: (_c = block.args) === null || _c === void 0 ? void 0 : _c.logging,
+                });
+            });
+        }
+        driver.initialize(block, undefined);
+        driver.deploy(block, sequential);
+        driver.arrange(block, block.place, undefined);
+    }
+    else if (redeploy)
+        driver.deploy(block, sequential);
+}
+function runRender(item) {
+    const block = item.instance;
+    if (block.stamp >= 0) {
+        runUnder(item, () => {
+            let result = undefined;
+            try {
+                block.stamp++;
+                block.numerator = 0;
+                block.children.beginMerge();
+                result = block.driver.render(block);
+                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.name}`);
+                console.log(`${e}`);
+            }
+        });
+    }
+}
+function runFinalize(item, isLeader) {
+    var _a;
+    const block = item.instance;
+    if (block.stamp >= 0) {
+        block.stamp = ~block.stamp;
+        const childrenAreLeaders = block.driver.finalize(block, isLeader);
+        if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.reacting) {
+            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.name})` }, () => {
+                    void runDisposalLoop().then(NOP, error => console.log(error));
+                });
+        }
+        for (const item of block.children.items())
+            runFinalize(item, childrenAreLeaders);
+        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 native = block.native;
+    native && action(native);
+    for (const item of block.children.items())
+        forEachChildRecursively(item, action);
+}
+function wrap(func) {
+    const ctx = gContext;
+    const wrappedRunUnder = (...args) => {
+        return runUnder(ctx, func, ...args);
+    };
+    return wrappedRunUnder;
+}
+function runUnder(item, func, ...args) {
+    const outer = gContext;
+    try {
+        gContext = item;
+        return func(...args);
+    }
+    finally {
+        gContext = 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 = () => { };
+const gSysDriver = new StaticDriver(null, "SYSTEM", LayoutKind.Group);
+const gSysRoot = Collection.createItem(new VBlockImpl("SYSTEM", gSysDriver, { level: 0 }, { reacting: true, render: NOP }));
+gSysRoot.instance.item = gSysRoot;
+Object.defineProperty(gSysRoot.instance, "host", {
+    value: gSysRoot.instance,
+    writable: false,
+    configurable: false,
+    enumerable: true,
+});
+let gContext = gSysRoot;
+let gFirstToDispose = undefined;
+let gLastToDispose = undefined;

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

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { cached, Transaction } from 'reactronic';
+import { cached, Transaction } from "reactronic";
 export function restyler(restyle) {
     return Transaction.run(null, () => new ObservablesStyles(restyle));
 }

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

@@ -1,5 +1,5 @@
-export * from './Utils';
-export * from './Layout';
-export * from './Block';
-export * from './Elements';
-export * from './Restyler';
+export * from "./Utils";
+export * from "./CellRange";
+export * from "./Allocator";
+export * from "./Kernel";
+export * from "./Restyler";

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

@@ -1,5 +1,5 @@
-export * from './Utils';
-export * from './Layout';
-export * from './Block';
-export * from './Elements';
-export * from './Restyler';
+export * from "./Utils";
+export * from "./CellRange";
+export * from "./Allocator";
+export * from "./Kernel";
+export * from "./Restyler";

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

@@ -0,0 +1,14 @@
+import { VBlock, Place, BlockArgs } from "../core/api";
+import { HtmlDriver } from "./HtmlDriver";
+export declare function Block<M = unknown, R = void>(name: string, args: BlockArgs<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function PlainText(content: string): VBlock<HTMLElement, void, void>;
+export declare function MdText(content: string): VBlock<HTMLElement, void, void>;
+export declare function HtmlText(content: string): VBlock<HTMLElement, void, void>;
+export declare function Grid<M = unknown, R = void>(name: string, args: BlockArgs<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function Line<T = void>(claim: (x: void) => T): VBlock<HTMLElement>;
+export declare function lineFeed(args?: BlockArgs<HTMLElement, void, void>, noCoalescing?: boolean): VBlock<HTMLElement>;
+export declare function Group<M = unknown, R = void>(name: string, args: BlockArgs<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare class VerstakDriver<T extends HTMLElement> extends HtmlDriver<T> {
+    arrange(block: VBlock<T>, place: Place | undefined, heightGrab: number | undefined): void;
+    render(block: VBlock<T>): void | Promise<void>;
+}

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

@@ -0,0 +1,124 @@
+import { VBlock, LayoutKind, To, GridBasedAllocator } from "../core/api";
+import { HtmlDriver } from "./HtmlDriver";
+export function Block(name, args) {
+    return VBlock.claim(name, args, VerstakTags.block);
+}
+export function PlainText(content) {
+    return VBlock.claim("", { render(e) { e.innerText = content; } }, VerstakTags.text);
+}
+export function MdText(content) {
+    return VBlock.claim("", { render(e) { e.innerHTML = content; } }, VerstakTags.text);
+}
+export function HtmlText(content) {
+    return VBlock.claim("", { render(e) { e.innerHTML = content; } }, VerstakTags.text);
+}
+export function Grid(name, args) {
+    return VBlock.claim(name, args, VerstakTags.grid);
+}
+export function Line(claim) {
+    const result = VBlock.claim("", EMPTY_RENDER, VerstakTags.line);
+    claim();
+    VBlock.claim("", EMPTY_RENDER, VerstakTags.line);
+    return result;
+}
+export function lineFeed(args, noCoalescing) {
+    return VBlock.claim("", args !== null && args !== void 0 ? args : EMPTY_RENDER, VerstakTags.line);
+}
+export function Group(name, args) {
+    return VBlock.claim(name, args, VerstakTags.group);
+}
+export class VerstakDriver extends HtmlDriver {
+    arrange(block, place, heightGrab) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        if (block.native) {
+            if (heightGrab === undefined) {
+                const existing = block.stamp > 1 ? block.place : undefined;
+                if (place !== existing) {
+                    const css = block.native.style;
+                    const exact = place === null || place === void 0 ? void 0 : place.exact;
+                    if (exact !== (existing === null || existing === void 0 ? void 0 : existing.exact)) {
+                        if (exact) {
+                            const x1 = exact.x1 || 1;
+                            const y1 = exact.y1 || 1;
+                            const x2 = exact.x2 || x1;
+                            const y2 = exact.y2 || y1;
+                            css.gridArea = `${y1} / ${x1} / span ${y2 - y1 + 1} / span ${x2 - x1 + 1}`;
+                        }
+                        else
+                            css.gridArea = "";
+                    }
+                    const widthGrab = (_a = place === null || place === void 0 ? void 0 : place.widthGrab) !== null && _a !== void 0 ? _a : 0;
+                    if (widthGrab !== ((_b = existing === null || existing === void 0 ? void 0 : existing.widthGrab) !== null && _b !== void 0 ? _b : 0)) {
+                        if (widthGrab > 0)
+                            css.flexGrow = `${widthGrab}`;
+                        else
+                            css.flexGrow = "";
+                    }
+                    const widthMin = (_c = place === null || place === void 0 ? void 0 : place.widthMin) !== null && _c !== void 0 ? _c : "";
+                    if (widthMin !== ((_d = existing === null || existing === void 0 ? void 0 : existing.widthMin) !== null && _d !== void 0 ? _d : ""))
+                        css.minWidth = `${widthMin}`;
+                    const widthMax = (_e = place === null || place === void 0 ? void 0 : place.widthMax) !== null && _e !== void 0 ? _e : "";
+                    if (widthMax !== ((_f = existing === null || existing === void 0 ? void 0 : existing.widthMax) !== null && _f !== void 0 ? _f : ""))
+                        css.maxWidth = `${widthMax}`;
+                    const heightMin = (_g = place === null || place === void 0 ? void 0 : place.heightMin) !== null && _g !== void 0 ? _g : "";
+                    if (heightMin !== ((_h = existing === null || existing === void 0 ? void 0 : existing.heightMin) !== null && _h !== void 0 ? _h : ""))
+                        css.minHeight = `${heightMin}`;
+                    const heightMax = (_j = place === null || place === void 0 ? void 0 : place.heightMax) !== null && _j !== void 0 ? _j : "";
+                    if (heightMax !== ((_k = existing === null || existing === void 0 ? void 0 : existing.heightMax) !== null && _k !== void 0 ? _k : ""))
+                        css.maxHeight = `${heightMax}`;
+                    const align = (_l = place === null || place === void 0 ? void 0 : place.align) !== null && _l !== void 0 ? _l : To.Default;
+                    if (align !== ((_m = existing === null || existing === void 0 ? void 0 : existing.align) !== null && _m !== void 0 ? _m : To.Default)) {
+                        if ((align & To.Default) === 0) {
+                            const v = AlignCss[(align >> 2) & 0b11];
+                            const h = AlignCss[align & 0b11];
+                            const t = TextAlignCss[align & 0b11];
+                            css.justifyContent = v;
+                            css.alignItems = h;
+                            css.textAlign = t;
+                        }
+                        else
+                            css.justifyContent = css.alignItems = css.textAlign = "";
+                    }
+                    const heightGrab = (_o = place === null || place === void 0 ? void 0 : place.heightGrab) !== null && _o !== void 0 ? _o : 0;
+                    const dock = (_p = place === null || place === void 0 ? void 0 : place.dock) !== null && _p !== void 0 ? _p : To.Default;
+                    if (dock !== ((_q = existing === null || existing === void 0 ? void 0 : existing.dock) !== null && _q !== void 0 ? _q : To.Default) ||
+                        heightGrab !== ((_r = existing === null || existing === void 0 ? void 0 : existing.heightGrab) !== null && _r !== void 0 ? _r : 0)) {
+                        if ((dock & To.Default) === 0) {
+                            const v = AlignCss[(dock >> 2) & 0b11];
+                            const h = AlignCss[dock & 0b11];
+                            css.alignSelf = v;
+                            css.justifySelf = h;
+                        }
+                        else if (heightGrab > 0) {
+                            css.alignSelf = AlignCss[To.Fit];
+                        }
+                        else
+                            css.alignSelf = css.justifySelf = "";
+                    }
+                }
+            }
+            else {
+                if (heightGrab > 0)
+                    block.native.style.flexGrow = `${heightGrab}`;
+                else
+                    block.native.style.flexGrow = "";
+            }
+        }
+        super.arrange(block, place, heightGrab);
+    }
+    render(block) {
+        if (!block.driver.isLine)
+            VBlock.claim("", EMPTY_RENDER, VerstakTags.line);
+        return super.render(block);
+    }
+}
+const VerstakTags = {
+    block: new VerstakDriver("v-block", LayoutKind.Block),
+    text: new VerstakDriver("v-text", LayoutKind.Text),
+    grid: new VerstakDriver("v-grid", LayoutKind.Grid, () => new GridBasedAllocator()),
+    line: new VerstakDriver("v-line", LayoutKind.Line),
+    group: new VerstakDriver("v-group", LayoutKind.Group),
+};
+const EMPTY_RENDER = { render() { } };
+const AlignCss = ["stretch", "start", "center", "end"];
+const TextAlignCss = ["justify", "left", "center", "right"];

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

@@ -1,4 +1,4 @@
-import { DataForSensor } from './sensors/DataForSensor';
+import { DataForSensor } from "./sensors/DataForSensor";
 declare global {
     interface Element {
         dataForSensor: DataForSensor;