verstak 0.23.122 → 0.23.123

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

@@ -20,43 +20,43 @@ import { reactive, unobs, Transaction, options, Reentrance, Rx, MergeList, Obser
 import { ElKind, Priority, Mode, Align } from "./Interfaces.js";
 import { emitLetters, equalElCoords, parseElCoords, getCallerInfo } from "./Utils.js";
 export class Verstak {
-    static claim(driver, builder, base) {
+    static specify(driver, spec, base) {
         var _a;
         let result;
-        if (builder)
-            builder.base = base;
+        if (spec)
+            spec.base = base;
         else
-            builder = base !== null && base !== void 0 ? base : {};
-        let key = builder.key;
+            spec = base !== null && base !== void 0 ? base : {};
+        let key = spec.key;
         const owner = gCurrent === null || gCurrent === void 0 ? void 0 : gCurrent.instance;
         if (owner) {
             let ex = undefined;
             const children = owner.node.children;
-            if (driver.isRow) {
-                const last = children.lastClaimedItem();
+            if (driver.isSeparator) {
+                const last = children.lastSpecifiedItem();
                 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 elements can be declared inside update function only"));
+            ex !== null && ex !== void 0 ? ex : (ex = children.specify(key = key || generateKey(owner), undefined, "nested elements can be declared inside update function only"));
             if (ex) {
                 result = ex.instance;
                 const node = result.node;
                 if (node.driver !== driver && driver !== undefined)
                     throw new Error(`changing element 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;
-                node.builder = builder;
+                const exTriggers = node.spec.triggers;
+                if (triggersAreEqual(spec.triggers, exTriggers))
+                    spec.triggers = exTriggers;
+                node.spec = spec;
             }
             else {
-                result = new ElImpl(key || generateKey(owner), driver, owner, builder);
-                result.node.ties = children.add(result);
+                result = new ElImpl(key || generateKey(owner), driver, owner, spec);
+                result.node.slot = children.add(result);
             }
         }
         else {
-            result = new ElImpl(key || "", driver, owner, builder);
-            result.node.ties = MergeList.createItem(result);
-            triggerUpdate(result.node.ties);
+            result = new ElImpl(key || "", driver, owner, spec);
+            result.node.slot = MergeList.createItem(result);
+            triggerUpdate(result.node.slot);
         }
         return result;
     }
@@ -67,10 +67,10 @@ export class Verstak {
     }
     static triggerUpdate(element, triggers) {
         const el = element;
-        const builder = el.node.builder;
-        if (!triggersAreEqual(triggers, builder.triggers)) {
-            builder.triggers = triggers;
-            triggerUpdate(el.node.ties);
+        const spec = el.node.spec;
+        if (!triggersAreEqual(triggers, spec.triggers)) {
+            spec.triggers = triggers;
+            triggerUpdate(el.node.slot);
         }
     }
     static updateNestedTreesThenDo(action) {
@@ -88,32 +88,29 @@ Verstak.longFrameDuration = 300;
 Verstak.currentUpdatePriority = Priority.Realtime;
 Verstak.frameDuration = Verstak.longFrameDuration;
 export class BaseDriver {
-    constructor(name, isRow, preset) {
+    constructor(name, isSeparator, preset) {
         this.name = name;
-        this.isRow = isRow;
+        this.isSeparator = isSeparator;
         this.preset = preset;
     }
-    claim(element) {
-        const el = element;
-        chainedClaim(el, el.node.builder);
+    specify(element) {
+        chainedSpecify(element, element.node.spec);
     }
-    create(element, result) {
-        chainedCreate(element, element.node.builder);
+    create(element) {
+        chainedCreate(element, element.node.spec);
     }
     initialize(element) {
         var _a;
-        const el = element;
-        (_a = this.preset) === null || _a === void 0 ? void 0 : _a.call(this, el);
-        chainedInitialize(el, el.node.builder);
+        (_a = this.preset) === null || _a === void 0 ? void 0 : _a.call(this, element);
+        chainedInitialize(element, element.node.spec);
     }
-    mount(element, nativeHost) {
+    mount(element) {
     }
     update(element) {
-        chainedUpdated(element, element.node.builder);
+        chainedUpdated(element, element.node.spec);
     }
     finalize(element, isLeader) {
-        const el = element;
-        chainedFinalize(el, el.node.builder);
+        chainedFinalize(element, element.node.spec);
         return isLeader;
     }
     applyKind(element, value) { }
@@ -145,13 +142,13 @@ function chainedMode(bb) {
     var _a;
     return (_a = bb === null || bb === void 0 ? void 0 : bb.mode) !== null && _a !== void 0 ? _a : ((bb === null || bb === void 0 ? void 0 : bb.base) ? chainedMode(bb === null || bb === void 0 ? void 0 : bb.base) : Mode.Default);
 }
-function chainedClaim(element, elb) {
-    const claim = elb.claim;
+function chainedSpecify(element, elb) {
+    const specify = elb.specify;
     const base = elb.base;
-    if (claim)
-        claim(element, base ? () => chainedClaim(element, base) : NOP);
+    if (specify)
+        specify(element, base ? () => chainedSpecify(element, base) : NOP);
     else if (base)
-        chainedClaim(element, base);
+        chainedSpecify(element, base);
 }
 function chainedCreate(element, elb) {
     const create = elb.create;
@@ -190,8 +187,8 @@ export class StaticDriver extends BaseDriver {
         super(name, isRow, preset);
         this.native = native;
     }
-    create(element, result) {
-        result.native = this.native;
+    create(element) {
+        element.native = this.native;
     }
 }
 export class CursorCommand {
@@ -200,9 +197,9 @@ export class CursorCommandDriver extends BaseDriver {
     constructor() {
         super("cursor", false, el => el.kind = ElKind.Cursor);
     }
-    create(element, result) {
-        result.native = new CursorCommand();
-        super.create(element, result);
+    create(element) {
+        element.native = new CursorCommand();
+        super.create(element);
     }
 }
 export class SubTreeVariable {
@@ -237,7 +234,7 @@ var CursorFlags;
 })(CursorFlags || (CursorFlags = {}));
 const UndefinedElCoords = Object.freeze({ x1: 0, y1: 0, x2: 0, y2: 0 });
 const InitialCursorPosition = Object.freeze(new CursorPosition({ x: 1, y: 1, runningMaxX: 0, runningMaxY: 0, flags: CursorFlags.None }));
-class ElCtxImpl extends ObservableObject {
+class RxNodeCtxImpl extends ObservableObject {
     constructor(variable, value) {
         super();
         this.next = undefined;
@@ -248,43 +245,69 @@ class ElCtxImpl extends ObservableObject {
 __decorate([
     raw,
     __metadata("design:type", Object)
-], ElCtxImpl.prototype, "next", void 0);
+], RxNodeCtxImpl.prototype, "next", void 0);
 __decorate([
     raw,
     __metadata("design:type", SubTreeVariable)
-], ElCtxImpl.prototype, "variable", void 0);
-class ElNodeImpl {
-    constructor(key, driver, builder, self, owner) {
-        this.maxColumnCount = 0;
-        this.maxRowCount = 0;
+], RxNodeCtxImpl.prototype, "variable", void 0);
+class RxNodeImpl {
+    constructor(key, driver, spec, element, owner) {
         this.key = key;
         this.driver = driver;
-        this.builder = builder;
+        this.spec = spec;
         if (owner) {
-            const node = owner.node;
+            const node = owner;
             this.level = node.level + 1;
             this.owner = owner;
             this.outer = node.context ? owner : node.outer;
         }
         else {
             this.level = 1;
-            this.owner = owner = self;
-            this.outer = self;
+            this.owner = owner = this;
+            this.outer = this;
         }
-        this.host = self;
-        this.children = new MergeList(getElNodeKey, true);
-        this.ties = undefined;
+        this.host = this;
+        this.children = new MergeList(getNodeKey, true);
+        this.slot = undefined;
         this.stamp = Number.MAX_SAFE_INTEGER;
         this.context = undefined;
         this.numerator = 0;
-        this.maxColumnCount = 0;
-        this.maxRowCount = 0;
-        this.cursorPosition = undefined;
+        this.priority = Priority.Realtime;
+        this.childrenShuffling = false;
+        RxNodeImpl.grandNodeCount++;
+        if (this.has(Mode.PinpointUpdate))
+            RxNodeImpl.disposableNodeCount++;
+    }
+    get isInitialUpdate() { return this.stamp === 1; }
+    get strictOrder() { return this.children.isStrict; }
+    set strictOrder(value) { this.children.isStrict = value; }
+    get isMoved() { return this.owner.children.isMoved(this.slot); }
+    has(mode) {
+        return (chainedMode(this.spec) & mode) === mode;
+    }
+    update(_triggers) {
+        updateNow(this.slot);
     }
 }
+RxNodeImpl.grandNodeCount = 0;
+RxNodeImpl.disposableNodeCount = 0;
+__decorate([
+    reactive,
+    options({
+        reentrance: Reentrance.CancelPrevious,
+        triggeringArgs: true,
+        noSideEffects: false,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], RxNodeImpl.prototype, "update", null);
 class ElImpl {
-    constructor(key, driver, owner, builder) {
-        this.node = new ElNodeImpl(key, driver, builder, this, owner);
+    constructor(key, driver, owner, spec) {
+        this.node = new RxNodeImpl(key, driver, spec, this, owner === null || owner === void 0 ? void 0 : owner.node);
+        this.maxColumnCount = 0;
+        this.maxRowCount = 0;
+        this.cursorPosition = undefined;
         this.native = undefined;
         this.model = undefined;
         this.controller = undefined;
@@ -302,29 +325,14 @@ class ElImpl {
         this._contentWrapping = true;
         this._overlayVisible = undefined;
         this._hasStyles = false;
-        this.updatePriority = Priority.Realtime;
-        this.childrenShuffling = false;
-        ElImpl.grandElementCount++;
-        if (this.hasMode(Mode.PinpointUpdate))
-            ElImpl.disposableElementCount++;
-    }
-    update(_triggers) {
-        updateNow(this.node.ties);
     }
     prepareForUpdate() {
         this._area = undefined;
         this._hasStyles = false;
     }
-    hasMode(mode) {
-        return (chainedMode(this.node.builder) & mode) === mode;
-    }
-    get isInitialUpdate() { return this.node.stamp === 1; }
     get isAuxiliary() { return this.kind > ElKind.Note; }
     get isSection() { return this.kind === ElKind.Section; }
     get isTable() { return this.kind === ElKind.Table; }
-    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.node.stamp >= Number.MAX_SAFE_INTEGER - 1) {
@@ -337,12 +345,13 @@ class ElImpl {
         var _a, _b;
         const node = this.node;
         const driver = node.driver;
-        if (!driver.isRow) {
-            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;
+        if (!driver.isSeparator) {
+            const owner = node.owner;
+            const ownerEl = owner.slot.instance;
+            const cursorPosition = (_b = (_a = node.slot.prev) === null || _a === void 0 ? void 0 : _a.instance.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
+            const newCursorPosition = this.cursorPosition = owner.children.isStrict ? new CursorPosition(cursorPosition) : undefined;
             const isCursorElement = driver instanceof CursorCommandDriver;
-            const coords = getEffectiveElCoords(!isCursorElement, value, owner.maxColumnCount, owner.maxRowCount, cursorPosition, newCursorPosition);
+            const coords = getEffectiveElCoords(!isCursorElement, value, ownerEl.maxColumnCount, ownerEl.maxRowCount, cursorPosition, newCursorPosition);
             if (!equalElCoords(coords, this._coords)) {
                 driver.applyCoords(this, coords);
                 this._coords = coords;
@@ -427,9 +436,10 @@ class ElImpl {
         this._hasStyles = true;
     }
     configureReactronic(options) {
-        if (this.node.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.hasMode(Mode.PinpointUpdate))
+        const node = this.node;
+        if (node.stamp < Number.MAX_SAFE_INTEGER - 1 || !node.has(Mode.PinpointUpdate))
             throw new Error("reactronic can be configured only for elements with pinpoint update mode and only inside initialize");
-        return Rx.getReaction(this.update).configure(options);
+        return Rx.getReaction(node.update).configure(options);
     }
     static get curr() {
         if (!gCurrent)
@@ -439,8 +449,8 @@ class ElImpl {
     static tryUseSubTreeVariable(variable) {
         var _a, _b;
         let el = ElImpl.curr.instance;
-        while (((_a = el.node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && el.node.owner !== el)
-            el = el.node.outer;
+        while (((_a = el.node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && el.node.owner !== el.node)
+            el = el.node.outer.slot.instance;
         return (_b = el.node.context) === null || _b === void 0 ? void 0 : _b.value;
     }
     static useSubTreeVariableValue(variable) {
@@ -454,12 +464,12 @@ class ElImpl {
         const el = ElImpl.curr.instance;
         const node = el.node;
         const owner = node.owner;
-        const hostCtx = unobs(() => { var _a; return (_a = owner.node.context) === null || _a === void 0 ? void 0 : _a.value; });
+        const hostCtx = unobs(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
             if (hostCtx)
                 node.outer = owner;
             else
-                node.outer = owner.node.outer;
+                node.outer = owner.outer;
             Transaction.run({ separation: true }, () => {
                 const ctx = node.context;
                 if (ctx) {
@@ -467,38 +477,25 @@ class ElImpl {
                     ctx.value = value;
                 }
                 else
-                    node.context = new ElCtxImpl(variable, value);
+                    node.context = new RxNodeCtxImpl(variable, value);
             });
         }
         else if (hostCtx)
             node.outer = owner;
         else
-            node.outer = owner.node.outer;
+            node.outer = owner.outer;
     }
     rowBreak() {
         var _a, _b;
         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);
+        const cursorPosition = (_b = (_a = node.slot.prev) === null || _a === void 0 ? void 0 : _a.instance.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
+        const newCursorPosition = this.cursorPosition = new CursorPosition(cursorPosition);
         newCursorPosition.x = 1;
         newCursorPosition.y = newCursorPosition.runningMaxY + 1;
     }
 }
-ElImpl.grandElementCount = 0;
-ElImpl.disposableElementCount = 0;
 ElImpl.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)
-], ElImpl.prototype, "update", null);
-function getElNodeKey(element) {
+function getNodeKey(element) {
     const node = element.node;
     return node.stamp >= 0 ? node.key : undefined;
 }
@@ -588,8 +585,8 @@ function runUpdateNestedTreesThenDo(error, action) {
         let promised = undefined;
         try {
             children.endMerge(error);
-            for (const item of children.removedItems(true))
-                triggerFinalization(item, true, true);
+            for (const slot of children.removedItems(true))
+                triggerFinalization(slot, true, true);
             if (!error) {
                 const ownerIsSection = owner.isSection;
                 const sequential = children.isStrict;
@@ -597,21 +594,21 @@ function runUpdateNestedTreesThenDo(error, action) {
                 let p2 = undefined;
                 let mounting = false;
                 let hostingRow = owner;
-                for (const item of children.items()) {
+                for (const slot of children.items()) {
                     if (Transaction.isCanceled)
                         break;
-                    const el = item.instance;
-                    const isRow = el.node.driver.isRow;
-                    const host = isRow ? owner : hostingRow;
-                    const p = (_a = el.updatePriority) !== null && _a !== void 0 ? _a : Priority.Realtime;
-                    mounting = markToMountIfNecessary(mounting, host, item, children, sequential);
+                    const el = slot.instance;
+                    const isSeparator = el.node.driver.isSeparator;
+                    const host = isSeparator ? owner : hostingRow;
+                    const p = (_a = el.node.priority) !== null && _a !== void 0 ? _a : Priority.Realtime;
+                    mounting = markToMountIfNecessary(mounting, host, slot, children, sequential);
                     if (p === Priority.Realtime)
-                        triggerUpdate(item);
+                        triggerUpdate(slot);
                     else if (p === Priority.Normal)
-                        p1 = push(item, p1);
+                        p1 = push(slot, p1);
                     else
-                        p2 = push(item, p2);
-                    if (ownerIsSection && isRow)
+                        p2 = push(slot, p2);
+                    if (ownerIsSection && isSeparator)
                         hostingRow = el;
                 }
                 if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
@@ -624,18 +621,18 @@ function runUpdateNestedTreesThenDo(error, action) {
         }
     }
 }
-function markToMountIfNecessary(mounting, host, ties, children, sequential) {
-    const el = ties.instance;
+function markToMountIfNecessary(mounting, host, slot, children, sequential) {
+    const el = slot.instance;
     const node = el.node;
-    if (el.native && !el.hasMode(Mode.ManualMount)) {
-        if (mounting || node.host !== host) {
-            children.markAsMoved(ties);
+    if (el.native && !node.has(Mode.ManualMount)) {
+        if (mounting || node.host !== host.node) {
+            children.markAsMoved(slot);
             mounting = false;
         }
     }
-    else if (sequential && children.isMoved(ties))
+    else if (sequential && children.isMoved(slot))
         mounting = true;
-    node.host = host;
+    node.host = host.node;
     return mounting;
 }
 function startIncrementalUpdate(owner, allChildren, priority1, priority2) {
@@ -655,7 +652,7 @@ function updateIncrementally(owner, stamp, allChildren, items, priority) {
             let outerPriority = Verstak.currentUpdatePriority;
             Verstak.currentUpdatePriority = priority;
             try {
-                if (el.childrenShuffling)
+                if (el.node.childrenShuffling)
                     shuffle(items);
                 const frameDurationLimit = priority === Priority.Background ? Verstak.shortFrameDuration : Infinity;
                 let frameDuration = Math.min(frameDurationLimit, Math.max(Verstak.frameDuration / 4, Verstak.shortFrameDuration));
@@ -678,24 +675,24 @@ function updateIncrementally(owner, stamp, allChildren, items, priority) {
         }
     });
 }
-function triggerUpdate(ties) {
-    const el = ties.instance;
+function triggerUpdate(slot) {
+    const el = slot.instance;
     const node = el.node;
     if (node.stamp >= 0) {
-        if (el.hasMode(Mode.PinpointUpdate)) {
+        if (node.has(Mode.PinpointUpdate)) {
             if (node.stamp === Number.MAX_SAFE_INTEGER) {
                 Transaction.outside(() => {
                     if (Rx.isLogging)
                         Rx.setLoggingHint(el, node.key);
-                    Rx.getReaction(el.update).configure({
+                    Rx.getReaction(node.update).configure({
                         order: node.level,
                     });
                 });
             }
-            unobs(el.update, node.builder.triggers);
+            unobs(node.update, node.spec.triggers);
         }
         else
-            updateNow(ties);
+            updateNow(slot);
     }
 }
 function mountOrRemountIfNecessary(element) {
@@ -704,24 +701,25 @@ function mountOrRemountIfNecessary(element) {
     if (node.stamp === Number.MAX_SAFE_INTEGER) {
         node.stamp = Number.MAX_SAFE_INTEGER - 1;
         unobs(() => {
-            driver.create(element, element);
+            driver.create(element);
             driver.initialize(element);
-            if (!element.hasMode(Mode.ManualMount)) {
+            if (!node.has(Mode.ManualMount)) {
                 node.stamp = 0;
-                if (element.node.host !== element)
+                if (element.node.host !== element.node)
                     driver.mount(element);
             }
+            node.stamp = 0;
         });
     }
-    else if (element.isMoved && !element.hasMode(Mode.ManualMount) && element.node.host !== element)
+    else if (node.isMoved && !node.has(Mode.ManualMount) && element.node.host !== element.node)
         unobs(() => driver.mount(element));
 }
-function updateNow(ties) {
-    const el = ties.instance;
+function updateNow(slot) {
+    const el = slot.instance;
     const node = el.node;
     if (node.stamp >= 0) {
         let result = undefined;
-        runInside(ties, () => {
+        runInside(slot, () => {
             mountOrRemountIfNecessary(el);
             if (node.stamp < Number.MAX_SAFE_INTEGER - 1) {
                 try {
@@ -731,7 +729,7 @@ function updateNow(ties) {
                     node.children.beginMerge();
                     const driver = node.driver;
                     result = driver.update(el);
-                    if (el.area === undefined && node.owner.isTable)
+                    if (el.area === undefined && node.owner.slot.instance.isTable)
                         el.area = undefined;
                     if (result instanceof Promise)
                         result.then(v => { runUpdateNestedTreesThenDo(undefined, NOP); return v; }, e => { console.log(e); runUpdateNestedTreesThenDo(e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
@@ -747,44 +745,44 @@ function updateNow(ties) {
         });
     }
 }
-function triggerFinalization(ties, isLeader, individual) {
-    const el = ties.instance;
+function triggerFinalization(slot, isLeader, individual) {
+    const el = slot.instance;
     const node = el.node;
     if (node.stamp >= 0) {
         const driver = node.driver;
-        if (individual && node.key !== node.builder.key && !driver.isRow)
+        if (individual && node.key !== node.spec.key && !driver.isSeparator)
             console.log(`WARNING: it is recommended to assign explicit key for conditional element in order to avoid unexpected side effects: ${node.key}`);
         node.stamp = ~node.stamp;
         const childrenAreLeaders = unobs(() => driver.finalize(el, isLeader));
         el.native = null;
         el.controller = null;
-        if (el.hasMode(Mode.PinpointUpdate)) {
-            ties.aux = undefined;
+        if (node.has(Mode.PinpointUpdate)) {
+            slot.aux = undefined;
             const last = gLastToDispose;
             if (last)
-                gLastToDispose = last.aux = ties;
+                gLastToDispose = last.aux = slot;
             else
-                gFirstToDispose = gLastToDispose = ties;
-            if (gFirstToDispose === ties)
-                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${ties.instance.node.key})` }, () => {
+                gFirstToDispose = gLastToDispose = slot;
+            if (gFirstToDispose === slot)
+                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${slot.instance.node.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }
-        for (const item of node.children.items())
-            triggerFinalization(item, childrenAreLeaders, false);
-        ElImpl.grandElementCount--;
+        for (const slot of node.children.items())
+            triggerFinalization(slot, childrenAreLeaders, false);
+        RxNodeImpl.grandNodeCount--;
     }
 }
 function runDisposalLoop() {
     return __awaiter(this, void 0, void 0, function* () {
         yield Transaction.requestNextFrame();
-        let item = gFirstToDispose;
-        while (item !== undefined) {
+        let slot = gFirstToDispose;
+        while (slot !== undefined) {
             if (Transaction.isFrameOver(500, 5))
                 yield Transaction.requestNextFrame();
-            Rx.dispose(item.instance);
-            item = item.aux;
-            ElImpl.disposableElementCount--;
+            Rx.dispose(slot.instance);
+            slot = slot.aux;
+            RxNodeImpl.disposableNodeCount--;
         }
         gFirstToDispose = gLastToDispose = undefined;
     });
@@ -800,10 +798,10 @@ function wrapToRunInside(func) {
         wrappedToRunInside = func;
     return wrappedToRunInside;
 }
-function runInside(ties, func, ...args) {
+function runInside(slot, func, ...args) {
     const outer = gCurrent;
     try {
-        gCurrent = ties;
+        gCurrent = slot;
         return func(...args);
     }
     finally {

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

@@ -1,14 +1,14 @@
-import { El, ElKind, ElBuilder, Align, ElCoords, ElArea } from "../core/api.js";
+import { El, ElKind, RxNodeSpec, Align, ElCoords, ElArea } from "../core/api.js";
 import { HtmlDriver } from "./HtmlDriver.js";
-export declare function Section<M = unknown, R = void>(builder?: ElBuilder<HTMLElement, M, R>, base?: ElBuilder<HTMLElement, M, R>): El<HTMLElement, M, R>;
-export declare function Table<M = unknown, R = void>(builder?: ElBuilder<HTMLElement, M, R>, base?: ElBuilder<HTMLElement, M, R>): El<HTMLElement, M, R>;
+export declare function Section<M = unknown, R = void>(spec?: RxNodeSpec<El<HTMLElement, M, R>>, base?: RxNodeSpec<El<HTMLElement, M, R>>): El<HTMLElement, M, R>;
+export declare function Table<M = unknown, R = void>(spec?: RxNodeSpec<El<HTMLElement, M, R>>, base?: RxNodeSpec<El<HTMLElement, M, R>>): El<HTMLElement, M, R>;
 export declare function row<T = void>(builder?: (element: void) => T, shiftCursorDown?: number): void;
 export declare function startNewRow(shiftCursorDown?: number): void;
 export declare function cursor(areaParams: ElArea): void;
-export declare function Note(content: string, builder?: ElBuilder<HTMLElement, void, void>): El<HTMLElement, void, void>;
-export declare function HtmlNote(content: string, builder?: ElBuilder<HTMLElement, void, void>): El<HTMLElement, void, void>;
-export declare function Group<M = unknown, R = void>(builder?: ElBuilder<HTMLElement, M, R>, base?: ElBuilder<HTMLElement, M, R>): El<HTMLElement, M, R>;
-export declare function Fragment<M = unknown, R = void>(builder?: ElBuilder<void, M, R>, base?: ElBuilder<void, M, R>): El<void, M, R>;
+export declare function Note(content: string, spec?: RxNodeSpec<El<HTMLElement, void, void>>): El<HTMLElement, void, void>;
+export declare function HtmlNote(content: string, spec?: RxNodeSpec<El<HTMLElement, void, void>>): El<HTMLElement, void, void>;
+export declare function Group<M = unknown, R = void>(spec?: RxNodeSpec<El<HTMLElement, M, R>>, base?: RxNodeSpec<El<HTMLElement, M, R>>): El<HTMLElement, M, R>;
+export declare function Fragment<M = unknown, R = void>(spec?: RxNodeSpec<El<void, M, R>>, base?: RxNodeSpec<El<void, M, R>>): El<void, M, R>;
 export declare class VerstakHtmlDriver<T extends HTMLElement> extends HtmlDriver<T> {
     applyKind(element: El<T, any, any>, value: ElKind): void;
     applyCoords(element: El<T>, value: ElCoords | undefined): void;