verstak 0.93.25026 → 0.94.25029

package/build/dist/source/components/Button.v.d.ts

@@ -1,8 +1,8 @@
-import { ReactiveNodeDecl, ReactiveNode } from "reactronic";
+import { ReactiveTreeNode, ReactiveTreeNodeDecl } from "reactronic";
 import { El } from "verstak";
 export type ButtonModel = {
     icon?: string;
     label?: string;
     action?(): void;
 };
-export declare function Button(declaration?: ReactiveNodeDecl<El<HTMLElement, ButtonModel>>): ReactiveNode<El<HTMLElement, ButtonModel>>;
+export declare function Button(declaration?: ReactiveTreeNodeDecl<El<HTMLElement, ButtonModel>>): ReactiveTreeNode<El<HTMLElement, ButtonModel>>;

package/build/dist/source/components/Button.v.js

@@ -1,16 +1,16 @@
-import { Mode, ReactiveNode } from "reactronic";
+import { ReactiveTree, ReactiveTreeNode, Mode } from "reactronic";
 import { Division, JustText, OnClick } from "verstak";
 import { triggeringModel } from "./common/Utils.js";
 import { Theme } from "./Theme.js";
 import { Icon } from "./Icon.v.js";
 export function Button(declaration) {
-    return (Division(ReactiveNode.withBasis(declaration, {
+    return (Division(ReactiveTree.withBasis(declaration, {
         mode: Mode.autonomous,
         preparation: el => {
             var _a;
             (_a = el.model) !== null && _a !== void 0 ? _a : (el.model = triggeringModel({
                 icon: "fa-solid fa-square",
-                label: ReactiveNode.key,
+                label: ReactiveTreeNode.key,
             }));
         },
         script: el => {

package/build/dist/source/components/Icon.v.d.ts

@@ -1,3 +1,3 @@
-import { ReactiveNodeDecl, ReactiveNode } from "reactronic";
+import { ReactiveTreeNodeDecl } from "reactronic";
 import { El } from "verstak";
-export declare function Icon(name: string, declaration?: ReactiveNodeDecl<El<HTMLElement, void>>): ReactiveNode<El<HTMLElement, void>>;
+export declare function Icon(name: string, declaration?: ReactiveTreeNodeDecl<El<HTMLElement, void>>): import("reactronic").ReactiveTreeNode<El<HTMLElement, void>>;

package/build/dist/source/components/Icon.v.js

@@ -1,8 +1,8 @@
-import { Mode, ReactiveNode } from "reactronic";
+import { ReactiveTree, Mode } from "reactronic";
 import { Division } from "verstak";
 import { Theme } from "./Theme.js";
 export function Icon(name, declaration) {
-    return (Division(ReactiveNode.withBasis(declaration, {
+    return (Division(ReactiveTree.withBasis(declaration, {
         mode: Mode.autonomous,
         triggers: { name },
         script: el => {

package/build/dist/source/components/Image.v.d.ts

@@ -1,6 +1,6 @@
-import { ReactiveNodeDecl, ReactiveNode } from "reactronic";
+import { ReactiveTreeNodeDecl } from "reactronic";
 import { El } from "verstak";
 export type ImageModel = {
     source?: string;
 };
-export declare function Image(declaration?: ReactiveNodeDecl<El<HTMLElement, ImageModel>>): ReactiveNode<El<HTMLElement, ImageModel>>;
+export declare function Image(declaration?: ReactiveTreeNodeDecl<El<HTMLElement, ImageModel>>): import("reactronic").ReactiveTreeNode<El<HTMLElement, ImageModel>>;

package/build/dist/source/components/Image.v.js

@@ -1,8 +1,8 @@
-import { Mode, ReactiveNode } from "reactronic";
+import { ReactiveTree, Mode } from "reactronic";
 import { Division } from "verstak";
 import { triggeringModel } from "./common/Utils.js";
 export function Image(declaration) {
-    return (Division(ReactiveNode.withBasis(declaration, {
+    return (Division(ReactiveTree.withBasis(declaration, {
         mode: Mode.autonomous,
         preparation: el => {
             var _a;

package/build/dist/source/components/Input.v.d.ts

@@ -1,4 +1,4 @@
-import { ReactiveNodeDecl, ReactiveNode } from "reactronic";
+import { ReactiveTreeNodeDecl } from "reactronic";
 import { FocusModel, El } from "verstak";
 import { ValuesOrRefs } from "./common/Utils.js";
 export type InputModel<T = string> = FocusModel & {
@@ -12,5 +12,5 @@ export type InputModel<T = string> = FocusModel & {
     isHotText: boolean;
     inputStyle: string;
 };
-export declare function Input(declaration?: ReactiveNodeDecl<El<HTMLElement, InputModel>>): ReactiveNode<El<HTMLElement, InputModel<string>>>;
+export declare function Input(declaration?: ReactiveTreeNodeDecl<El<HTMLElement, InputModel>>): import("reactronic").ReactiveTreeNode<El<HTMLElement, InputModel<string>>>;
 export declare function composeInputModel<T>(props?: Partial<ValuesOrRefs<InputModel<T>>>): InputModel<T>;

package/build/dist/source/components/Input.v.js

@@ -1,10 +1,10 @@
-import { Mode, ReactiveNode } from "reactronic";
+import { ReactiveTree, Mode } from "reactronic";
 import { Division, JustText, OnFocus, rowBreak, Fragment, KeyboardModifiers, Horizontal, Vertical } from "verstak";
 import { triggeringModel } from "./common/Utils.js";
 import { Theme } from "./Theme.js";
 import { Icon } from "./Icon.v.js";
 export function Input(declaration) {
-    return (Division(ReactiveNode.withBasis(declaration, {
+    return (Division(ReactiveTree.withBasis(declaration, {
         mode: Mode.autonomous,
         preparation: el => {
             var _a;

package/build/dist/source/components/Markdown.v.d.ts

@@ -1 +1 @@
-export declare function Markdown(content: string): import("reactronic").ReactiveNode<import("verstak").El<HTMLElement, void>>;
+export declare function Markdown(content: string): import("reactronic").ReactiveTreeNode<import("verstak").El<HTMLElement, void>>;

package/build/dist/source/components/RealTimeClock.d.ts

@@ -1,5 +1,5 @@
-import { TriggeringObject } from "reactronic";
-export declare class RealTimeClock extends TriggeringObject {
+import { ObservableObject } from "reactronic";
+export declare class RealTimeClock extends ObservableObject {
     hour: number;
     minute: number;
     second: number;

package/build/dist/source/components/RealTimeClock.js

@@ -7,8 +7,8 @@ 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 { TriggeringObject, atomic, reaction } from "reactronic";
-export class RealTimeClock extends TriggeringObject {
+import { ObservableObject, atomic, reactive } from "reactronic";
+export class RealTimeClock extends ObservableObject {
     constructor(interval = 1000) {
         super();
         this.hour = 0;
@@ -57,7 +57,7 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], RealTimeClock.prototype, "tick", null);
 __decorate([
-    reaction,
+    reactive,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)

package/build/dist/source/components/Spinner.v.d.ts

@@ -1,9 +1,9 @@
-import { ReactiveNodeDecl, ReactiveNode } from "reactronic";
+import { ReactiveTreeNodeDecl } from "reactronic";
 import { El } from "verstak";
 import { ValuesOrRefs } from "./common/Utils.js";
 export type SpinnerModel = {
     active: boolean;
     color: string;
 };
-export declare function Spinner(declaration?: ReactiveNodeDecl<El<HTMLElement, SpinnerModel>>): ReactiveNode<El<HTMLElement, SpinnerModel>>;
+export declare function Spinner(declaration?: ReactiveTreeNodeDecl<El<HTMLElement, SpinnerModel>>): import("reactronic").ReactiveTreeNode<El<HTMLElement, SpinnerModel>>;
 export declare function composeSpinnerModel<T>(props?: Partial<ValuesOrRefs<SpinnerModel>>): SpinnerModel;

package/build/dist/source/components/Spinner.v.js

@@ -1,8 +1,8 @@
-import { Mode, ReactiveNode } from "reactronic";
+import { ReactiveTree, Mode } from "reactronic";
 import { Division, JustText } from "verstak";
 import { triggeringModel } from "./common/Utils.js";
 export function Spinner(declaration) {
-    return (Division(ReactiveNode.withBasis(declaration, {
+    return (Division(ReactiveTree.withBasis(declaration, {
         mode: Mode.autonomous,
         preparation: el => {
             var _a;

package/build/dist/source/components/Theme.js

@@ -1,4 +1,4 @@
-import { runAtomically, ReactiveNodeVariable, Isolation } from "reactronic";
+import { runAtomically, ReactiveTreeVariable, Isolation } from "reactronic";
 import { DefaultButtonStyling } from "./theme/Button.s.js";
 import { DefaultInputStyling } from "./theme/Input.s.js";
 import { DefaultIconStyling } from "./theme/Icon.s.js";
@@ -27,4 +27,4 @@ export class Theme {
         Theme.gCurrent.value = value;
     }
 }
-Theme.gCurrent = new ReactiveNodeVariable(runAtomically({ isolation: Isolation.disjoinFromOuterTransaction }, () => new Theme()));
+Theme.gCurrent = new ReactiveTreeVariable(runAtomically({ isolation: Isolation.disjoinFromOuterTransaction }, () => new Theme()));

package/build/dist/source/components/Toggle.v.d.ts

@@ -1,8 +1,8 @@
-import { ReactiveNodeDecl, ReactiveNode } from "reactronic";
+import { ReactiveTreeNode, ReactiveTreeNodeDecl } from "reactronic";
 import { El } from "verstak";
 export type ToggleModel = {
     label?: string;
     checked?: boolean;
     color?: string;
 };
-export declare function Toggle(declaration?: ReactiveNodeDecl<El<HTMLElement, ToggleModel>>): ReactiveNode<El<HTMLElement, ToggleModel>>;
+export declare function Toggle(declaration?: ReactiveTreeNodeDecl<El<HTMLElement, ToggleModel>>): ReactiveTreeNode<El<HTMLElement, ToggleModel>>;

package/build/dist/source/components/Toggle.v.js

@@ -1,15 +1,15 @@
-import { Mode, ReactiveNode } from "reactronic";
+import { ReactiveTree, ReactiveTreeNode, Mode } from "reactronic";
 import { Division, JustText, OnClick } from "verstak";
 import { triggeringModel } from "./common/Utils.js";
 import { Theme } from "./Theme.js";
 import { Icon } from "./Icon.v.js";
 export function Toggle(declaration) {
-    return (Division(ReactiveNode.withBasis(declaration, {
+    return (Division(ReactiveTree.withBasis(declaration, {
         mode: Mode.autonomous,
         preparation: el => {
             var _a;
             (_a = el.model) !== null && _a !== void 0 ? _a : (el.model = triggeringModel({
-                label: ReactiveNode.key,
+                label: ReactiveTreeNode.key,
                 checked: true,
                 color: "green"
             }));

package/build/dist/source/components/common/Utils.js

@@ -1,8 +1,8 @@
-import { TriggeringObject, Ref, runAtomically, Isolation } from "reactronic";
+import { ObservableObject, Ref, runAtomically, Isolation } from "reactronic";
 export function triggeringModel(modelProps) {
     return runAtomically({ isolation: Isolation.disjoinFromOuterTransaction }, () => new TriggeringComposition(modelProps));
 }
-class TriggeringComposition extends TriggeringObject {
+class TriggeringComposition extends ObservableObject {
     constructor(composition) {
         super();
         convertValuesToFieldsAndRefsToGetSet(this, composition);

package/build/dist/source/components/theme/Button.s.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 { cache } from "reactronic";
+import { cached } from "reactronic";
 import { css } from "@emotion/css";
 import { Styling } from "./Styling.js";
 export class DefaultButtonStyling extends Styling {
@@ -33,17 +33,17 @@ export class DefaultButtonStyling extends Styling {
     }
 }
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", String),
     __metadata("design:paramtypes", [])
 ], DefaultButtonStyling.prototype, "main", null);
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", String),
     __metadata("design:paramtypes", [])
 ], DefaultButtonStyling.prototype, "icon", null);
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", String),
     __metadata("design:paramtypes", [])
 ], DefaultButtonStyling.prototype, "label", null);

package/build/dist/source/components/theme/Icon.s.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 { cache } from "reactronic";
+import { cached } from "reactronic";
 import { css } from "@emotion/css";
 import { Styling } from "./Styling.js";
 export class DefaultIconStyling extends Styling {
@@ -20,7 +20,7 @@ export class DefaultIconStyling extends Styling {
     }
 }
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", String),
     __metadata("design:paramtypes", [])
 ], DefaultIconStyling.prototype, "main", null);

package/build/dist/source/components/theme/Input.s.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 { cache } from "reactronic";
+import { cached } from "reactronic";
 import { css } from "@emotion/css";
 import { Styling } from "./Styling.js";
 export class DefaultInputStyling extends Styling {
@@ -47,22 +47,22 @@ export class DefaultInputStyling extends Styling {
     }
 }
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", String),
     __metadata("design:paramtypes", [])
 ], DefaultInputStyling.prototype, "main", null);
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", String),
     __metadata("design:paramtypes", [])
 ], DefaultInputStyling.prototype, "icon", null);
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", String),
     __metadata("design:paramtypes", [])
 ], DefaultInputStyling.prototype, "field", null);
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", String),
     __metadata("design:paramtypes", [])
 ], DefaultInputStyling.prototype, "popup", null);

package/build/dist/source/components/theme/Styling.d.ts

@@ -1,4 +1,4 @@
-import { TriggeringObject } from "reactronic";
+import { ObservableObject } from "reactronic";
 export type BasicAbstractTheme = {
     fillColor: string;
     textColor: string;
@@ -10,7 +10,7 @@ export type BasicAbstractTheme = {
     outlinePadding: string;
     shadow: string;
 };
-export declare class Styling extends TriggeringObject {
+export declare class Styling extends ObservableObject {
     protected readonly $: BasicAbstractTheme;
     constructor($: BasicAbstractTheme);
 }

package/build/dist/source/components/theme/Styling.js

@@ -7,14 +7,14 @@ 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 { TriggeringObject, trigger } from "reactronic";
-export class Styling extends TriggeringObject {
+import { ObservableObject, observable } from "reactronic";
+export class Styling extends ObservableObject {
     constructor($) {
         super();
         this.$ = $;
     }
 }
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Object)
 ], Styling.prototype, "$", void 0);

package/build/dist/source/components/theme/Toggle.s.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 { cache } from "reactronic";
+import { cached } from "reactronic";
 import { css } from "@emotion/css";
 import { Styling } from "./Styling.js";
 export class DefaultToggleStyling extends Styling {
@@ -32,17 +32,17 @@ export class DefaultToggleStyling extends Styling {
     }
 }
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", String),
     __metadata("design:paramtypes", [])
 ], DefaultToggleStyling.prototype, "main", null);
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", String),
     __metadata("design:paramtypes", [])
 ], DefaultToggleStyling.prototype, "icon", null);
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", String),
     __metadata("design:paramtypes", [])
 ], DefaultToggleStyling.prototype, "label", null);

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

@@ -1,6 +1,6 @@
-import { ReactiveNode } from "reactronic";
+import { ReactiveTreeNode } from "reactronic";
 export type El<T = any, M = any> = {
-    readonly node: ReactiveNode<El<T, M>>;
+    readonly node: ReactiveTreeNode<El<T, M>>;
     readonly index: number;
     native: T;
     model: M;

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

@@ -1,10 +1,10 @@
-import { ReactiveNode, BaseDriver } from "reactronic";
+import { ReactiveTreeNode, BaseDriver } from "reactronic";
 import { El, ElKind, Horizontal, Vertical, Range, ElPlace, Direction } from "./El.js";
 export declare class ElDriver<T extends Element, M = unknown> extends BaseDriver<El<T, M>> {
-    create(node: ReactiveNode<El<T, M>>): El<T, M>;
+    create(node: ReactiveTreeNode<El<T, M>>): El<T, M>;
 }
 export declare class ElImpl<T extends Element = any, M = any> implements El<T, M> {
-    readonly node: ReactiveNode<El<T, M>>;
+    readonly node: ReactiveTreeNode<El<T, M>>;
     maxColumnCount: number;
     maxRowCount: number;
     layoutInfo?: ElLayoutInfo;
@@ -26,7 +26,7 @@ export declare class ElImpl<T extends Element = any, M = any> implements El<T, M
     private _sealed;
     private _splitView;
     private _hasStylingPresets;
-    constructor(node: ReactiveNode<El<T, M>>);
+    constructor(node: ReactiveTreeNode<El<T, M>>);
     prepareForUpdate(): void;
     get index(): number;
     get isDivision(): boolean;
@@ -80,7 +80,7 @@ export declare class ElImpl<T extends Element = any, M = any> implements El<T, M
     get style(): CSSStyleDeclaration;
     useStylingPreset(stylingPresetName: string, enabled?: boolean): void;
     protected children(onlyAfter?: ElImpl): Generator<ElImpl>;
-    static childrenOf(node: ReactiveNode<El>, onlyAfter?: El): Generator<ElImpl>;
+    static childrenOf(node: ReactiveTreeNode<El>, onlyAfter?: El): Generator<ElImpl>;
     private rowBreak;
     private static applyKind;
     private static applyCoords;

package/build/dist/source/core/ElDriver.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 { ReactiveNode, BaseDriver, Transaction, trigger, TriggeringObject } from "reactronic";
+import { ReactiveTree, BaseDriver, Transaction, observable, ObservableObject } from "reactronic";
 import { ElKind, Horizontal, Vertical, Direction } from "./El.js";
 import { equalElCoords, parseElCoords } from "./ElUtils.js";
 export class ElDriver extends BaseDriver {
@@ -482,7 +482,7 @@ export class ElImpl {
     }
     static applyOverlayVisible(element, value) {
         const s = element.style;
-        const host = ReactiveNode.findMatchingHost(element.node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
+        const host = ReactiveTree.findMatchingHost(element.node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
         const nativeHost = host === null || host === void 0 ? void 0 : host.element.native;
         if (value === true) {
             const doc = document.body;
@@ -535,7 +535,7 @@ export class ElImpl {
             native.className = enabled ? styleName : "";
     }
 }
-class Size extends TriggeringObject {
+class Size extends ObservableObject {
     constructor() {
         super();
         this.raw = { min: "", max: "" };
@@ -561,27 +561,27 @@ export class ElLayoutInfo {
     }
 }
 __decorate([
-    trigger,
+    observable,
     __metadata("design:type", Number)
 ], ElLayoutInfo.prototype, "effectiveSizePx", void 0);
 __decorate([
-    trigger,
+    observable,
     __metadata("design:type", Number)
 ], ElLayoutInfo.prototype, "contentSizeXpx", void 0);
 __decorate([
-    trigger,
+    observable,
     __metadata("design:type", Number)
 ], ElLayoutInfo.prototype, "contentSizeYpx", void 0);
 __decorate([
-    trigger,
+    observable,
     __metadata("design:type", Number)
 ], ElLayoutInfo.prototype, "borderSizeYpx", void 0);
 __decorate([
-    trigger,
+    observable,
     __metadata("design:type", Number)
 ], ElLayoutInfo.prototype, "borderSizeXpx", void 0);
 __decorate([
-    trigger,
+    observable,
     __metadata("design:type", Boolean)
 ], ElLayoutInfo.prototype, "isUpdateFinished", void 0);
 var ElLayoutInfoFlags;

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

@@ -1,33 +1,33 @@
-import { ReactiveNodeDecl, ReactiveNodeDriver, ReactiveNode, Script, Mode, MergedItem, ScriptAsync } from "reactronic";
+import { ReactiveTreeNode, ReactiveTreeNodeDecl, ReactiveTreeNodeDriver, Script, Mode, MergedItem, ScriptAsync } from "reactronic";
 import { El, ElPlace } from "./El.js";
 import { CursorCommandDriver } from "./ElDriver.js";
 import { HtmlDriver } from "./WebDriver.js";
-export declare function Window(script?: Script<El<HTMLBodyElement>>, scriptAsync?: ScriptAsync<El<HTMLBodyElement>>, key?: string, mode?: Mode, preparation?: Script<El<HTMLBodyElement>>, preparationAsync?: ScriptAsync<El<HTMLBodyElement>>, finalization?: Script<El<HTMLBodyElement>>, triggers?: unknown, basis?: ReactiveNodeDecl<El<HTMLBodyElement>>): ReactiveNode<El<HTMLBodyElement>>;
-export declare function Window(declaration?: ReactiveNodeDecl<El<HTMLBodyElement>>): ReactiveNode<El<HTMLBodyElement>>;
-export declare function Division<M = unknown>(script?: Script<El<HTMLElement, M>>, scriptAsync?: ScriptAsync<El<HTMLElement, M>>, key?: string, mode?: Mode, preparation?: Script<El<HTMLElement, M>>, preparationAsync?: ScriptAsync<El<HTMLElement, M>>, finalization?: Script<El<HTMLElement, M>>, triggers?: unknown, basis?: ReactiveNodeDecl<El<HTMLElement, M>>): ReactiveNode<El<HTMLElement, M>>;
-export declare function Division<M = unknown>(declaration?: ReactiveNodeDecl<El<HTMLElement, M>>): ReactiveNode<El<HTMLElement, M>>;
-export declare function Table<M = unknown>(script?: Script<El<HTMLElement, M>>, scriptAsync?: ScriptAsync<El<HTMLElement, M>>, key?: string, mode?: Mode, preparation?: Script<El<HTMLElement, M>>, preparationAsync?: ScriptAsync<El<HTMLElement, M>>, finalization?: Script<El<HTMLElement, M>>, triggers?: unknown, basis?: ReactiveNodeDecl<El<HTMLElement, M>>): ReactiveNode<El<HTMLElement, M>>;
-export declare function Table<M = unknown>(declaration?: ReactiveNodeDecl<El<HTMLElement, M>>): ReactiveNode<El<HTMLElement, M>>;
+export declare function Window(script?: Script<El<HTMLBodyElement>>, scriptAsync?: ScriptAsync<El<HTMLBodyElement>>, key?: string, mode?: Mode, preparation?: Script<El<HTMLBodyElement>>, preparationAsync?: ScriptAsync<El<HTMLBodyElement>>, finalization?: Script<El<HTMLBodyElement>>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<El<HTMLBodyElement>>): ReactiveTreeNode<El<HTMLBodyElement>>;
+export declare function Window(declaration?: ReactiveTreeNodeDecl<El<HTMLBodyElement>>): ReactiveTreeNode<El<HTMLBodyElement>>;
+export declare function Division<M = unknown>(script?: Script<El<HTMLElement, M>>, scriptAsync?: ScriptAsync<El<HTMLElement, M>>, key?: string, mode?: Mode, preparation?: Script<El<HTMLElement, M>>, preparationAsync?: ScriptAsync<El<HTMLElement, M>>, finalization?: Script<El<HTMLElement, M>>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<El<HTMLElement, M>>): ReactiveTreeNode<El<HTMLElement, M>>;
+export declare function Division<M = unknown>(declaration?: ReactiveTreeNodeDecl<El<HTMLElement, M>>): ReactiveTreeNode<El<HTMLElement, M>>;
+export declare function Table<M = unknown>(script?: Script<El<HTMLElement, M>>, scriptAsync?: ScriptAsync<El<HTMLElement, M>>, key?: string, mode?: Mode, preparation?: Script<El<HTMLElement, M>>, preparationAsync?: ScriptAsync<El<HTMLElement, M>>, finalization?: Script<El<HTMLElement, M>>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<El<HTMLElement, M>>): ReactiveTreeNode<El<HTMLElement, M>>;
+export declare function Table<M = unknown>(declaration?: ReactiveTreeNodeDecl<El<HTMLElement, M>>): ReactiveTreeNode<El<HTMLElement, M>>;
 export declare function row<T = void>(builder?: (element: void) => T, shiftCursorDown?: number): void;
-export declare function Splitter<M = unknown>(script?: Script<El<HTMLElement, M>>, scriptAsync?: ScriptAsync<El<HTMLElement, M>>, key?: string, mode?: Mode, preparation?: Script<El<HTMLElement, M>>, preparationAsync?: ScriptAsync<El<HTMLElement, M>>, finalization?: Script<El<HTMLElement, M>>, triggers?: unknown, basis?: ReactiveNodeDecl<El<HTMLElement, M>>): ReactiveNode<El<HTMLElement, M>>;
-export declare function Splitter<M = unknown>(declaration?: ReactiveNodeDecl<El<HTMLElement, M>>): ReactiveNode<El<HTMLElement, M>>;
+export declare function Splitter<M = unknown>(script?: Script<El<HTMLElement, M>>, scriptAsync?: ScriptAsync<El<HTMLElement, M>>, key?: string, mode?: Mode, preparation?: Script<El<HTMLElement, M>>, preparationAsync?: ScriptAsync<El<HTMLElement, M>>, finalization?: Script<El<HTMLElement, M>>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<El<HTMLElement, M>>): ReactiveTreeNode<El<HTMLElement, M>>;
+export declare function Splitter<M = unknown>(declaration?: ReactiveTreeNodeDecl<El<HTMLElement, M>>): ReactiveTreeNode<El<HTMLElement, M>>;
 export declare function rowBreak(shiftCursorDown?: number): void;
-export declare function declareSplitter<T>(index: number, splitViewNode: ReactiveNode<El<T>>): ReactiveNode<El<HTMLElement>>;
+export declare function declareSplitter<T>(index: number, splitViewNode: ReactiveTreeNode<El<T>>): ReactiveTreeNode<El<HTMLElement>>;
 export declare function cursor(place: ElPlace): void;
-export declare function JustText(content: string, formatted?: boolean, declaration?: ReactiveNodeDecl<El<HTMLElement, void>>): ReactiveNode<El<HTMLElement, void>>;
-export declare function Group<M = unknown>(script?: Script<El<HTMLElement, M>>, scriptAsync?: ScriptAsync<El<HTMLElement, M>>, key?: string, mode?: Mode, preparation?: Script<El<HTMLElement, M>>, preparationAsync?: ScriptAsync<El<HTMLElement, M>>, finalization?: Script<El<HTMLElement, M>>, triggers?: unknown, basis?: ReactiveNodeDecl<El<HTMLElement, M>>): ReactiveNode<El<HTMLElement, M>>;
-export declare function Group<M = unknown>(declaration?: ReactiveNodeDecl<El<HTMLElement, M>>): ReactiveNode<El<HTMLElement, M>>;
-export declare function Fragment<M = unknown>(script: Script<El<void, M>>): ReactiveNode<El<void, M>>;
-export declare function PseudoElement<M = unknown>(script?: Script<El<void, M>>, scriptAsync?: ScriptAsync<El<void, M>>, key?: string, mode?: Mode, preparation?: Script<El<void, M>>, preparationAsync?: ScriptAsync<El<void, M>>, finalization?: Script<El<void, M>>, triggers?: unknown, basis?: ReactiveNodeDecl<El<void, M>>): ReactiveNode<El<void, M>>;
-export declare function PseudoElement<M = unknown>(declaration?: ReactiveNodeDecl<El<void, M>>): ReactiveNode<El<void, M>>;
+export declare function JustText(content: string, formatted?: boolean, declaration?: ReactiveTreeNodeDecl<El<HTMLElement, void>>): ReactiveTreeNode<El<HTMLElement, void>>;
+export declare function Group<M = unknown>(script?: Script<El<HTMLElement, M>>, scriptAsync?: ScriptAsync<El<HTMLElement, M>>, key?: string, mode?: Mode, preparation?: Script<El<HTMLElement, M>>, preparationAsync?: ScriptAsync<El<HTMLElement, M>>, finalization?: Script<El<HTMLElement, M>>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<El<HTMLElement, M>>): ReactiveTreeNode<El<HTMLElement, M>>;
+export declare function Group<M = unknown>(declaration?: ReactiveTreeNodeDecl<El<HTMLElement, M>>): ReactiveTreeNode<El<HTMLElement, M>>;
+export declare function Fragment<M = unknown>(script: Script<El<void, M>>): ReactiveTreeNode<El<void, M>>;
+export declare function PseudoElement<M = unknown>(script?: Script<El<void, M>>, scriptAsync?: ScriptAsync<El<void, M>>, key?: string, mode?: Mode, preparation?: Script<El<void, M>>, preparationAsync?: ScriptAsync<El<void, M>>, finalization?: Script<El<void, M>>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<El<void, M>>): ReactiveTreeNode<El<void, M>>;
+export declare function PseudoElement<M = unknown>(declaration?: ReactiveTreeNodeDecl<El<void, M>>): ReactiveTreeNode<El<void, M>>;
 export declare class DivisionDriver<T extends HTMLElement> extends HtmlDriver<T> {
-    runScript(node: ReactiveNode<El<T>>): void | Promise<void>;
-    declareChild(ownerNode: ReactiveNode<El<T, any>>, childDriver: ReactiveNodeDriver<any>, childDeclaration?: ReactiveNodeDecl<any> | undefined, childBasis?: ReactiveNodeDecl<any> | undefined): MergedItem<ReactiveNode> | undefined;
+    runScript(node: ReactiveTreeNode<El<T>>): void | Promise<void>;
+    declareChild(ownerNode: ReactiveTreeNode<El<T, any>>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any> | undefined, childBasis?: ReactiveTreeNodeDecl<any> | undefined): MergedItem<ReactiveTreeNode> | undefined;
 }
-export declare function isSplitViewPartition(childDriver: ReactiveNodeDriver): boolean;
+export declare function isSplitViewPartition(childDriver: ReactiveTreeNodeDriver): boolean;
 export declare class PartitionDriver<T extends HTMLElement> extends HtmlDriver<T> {
-    runScript(node: ReactiveNode<El<T>>): void | Promise<void>;
-    provideHost(node: ReactiveNode<El<T, any>>): ReactiveNode<El<T, any>>;
+    runScript(node: ReactiveTreeNode<El<T>>): void | Promise<void>;
+    provideHost(node: ReactiveTreeNode<El<T, any>>): ReactiveTreeNode<El<T, any>>;
 }
 export declare const Drivers: {
     division: DivisionDriver<HTMLElement>;
@@ -38,5 +38,5 @@ export declare const Drivers: {
     wrapper: HtmlDriver<HTMLElement, any>;
     splitter: HtmlDriver<HTMLElement, any>;
     cursor: CursorCommandDriver;
-    pseudo: ReactiveNodeDriver<El<void, any>>;
+    pseudo: ReactiveTreeNodeDriver<El<void, any>>;
 };