verstak 0.93.25026 → 0.94.25029

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

@@ -1,4 +1,4 @@
-import { ReactiveNode, Mode, runNonReactively } from "reactronic";
+import { ReactiveTree, Mode, runNonReactively } from "reactronic";
 import { ElKind, Direction } from "./El.js";
 import { clamp } from "./ElUtils.js";
 import { Constants, CursorCommandDriver, ElDriver, ElLayoutInfo, InitialElLayoutInfo } from "./ElDriver.js";
@@ -7,23 +7,23 @@ import { Axis, BodyFontSize, Dimension, toPx } from "./Sizes.js";
 import { HtmlDriver, StaticDriver } from "./WebDriver.js";
 export function Window(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
     const driver = new StaticDriver(global.document.body, "Page", false, el => el.kind = ElKind.division);
-    return ReactiveNode.declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+    return ReactiveTree.declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
 export function Division(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-    return ReactiveNode.declare(Drivers.division, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+    return ReactiveTree.declare(Drivers.division, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
 export function Table(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-    return ReactiveNode.declare(Drivers.table, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+    return ReactiveTree.declare(Drivers.table, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
 export function row(builder, shiftCursorDown) {
     rowBreak(shiftCursorDown);
     builder === null || builder === void 0 ? void 0 : builder();
 }
 export function Splitter(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-    return ReactiveNode.declare(Drivers.splitter, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+    return ReactiveTree.declare(Drivers.splitter, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
 export function rowBreak(shiftCursorDown) {
-    ReactiveNode.declare(Drivers.partition);
+    ReactiveTree.declare(Drivers.partition);
 }
 export function declareSplitter(index, splitViewNode) {
     const key = `splitter-${index}`;
@@ -79,14 +79,14 @@ export function declareSplitter(index, splitViewNode) {
     }));
 }
 export function cursor(place) {
-    ReactiveNode.declare(Drivers.cursor, {
+    ReactiveTree.declare(Drivers.cursor, {
         script: el => {
             el.place = place;
         },
     });
 }
 export function JustText(content, formatted, declaration) {
-    return ReactiveNode.declare(Drivers.text, ReactiveNode.withBasis(declaration, {
+    return ReactiveTree.declare(Drivers.text, ReactiveTree.withBasis(declaration, {
         script: el => {
             if (formatted)
                 el.native.innerHTML = content;
@@ -96,13 +96,13 @@ export function JustText(content, formatted, declaration) {
     }));
 }
 export function Group(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-    return ReactiveNode.declare(Drivers.group, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+    return ReactiveTree.declare(Drivers.group, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
 export function Fragment(script) {
     return PseudoElement({ mode: Mode.autonomous, script });
 }
 export function PseudoElement(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-    return ReactiveNode.declare(Drivers.pseudo, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+    return ReactiveTree.declare(Drivers.pseudo, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
 export class DivisionDriver extends HtmlDriver {
     runScript(node) {
@@ -172,9 +172,9 @@ export class DivisionDriver extends HtmlDriver {
                     }
                 },
             });
-            ReactiveNode.runNestedNodeScriptsThenDo(() => {
+            ReactiveTree.runNestedNodeScriptsThenDo(() => {
                 layoutInfo.isUpdateFinished = true;
-                ReactiveNode.triggerScriptRun(relayoutEl, { stamp: node.stamp });
+                ReactiveTree.triggerScriptRun(relayoutEl, { stamp: node.stamp });
             });
         }
         return result;
@@ -231,7 +231,7 @@ export class PartitionDriver extends HtmlDriver {
         const ownerEl = node.owner.element;
         if (ownerEl.sealed !== undefined) {
             node.element.style.flexGrow = "1";
-            ReactiveNode.declare(Drivers.wrapper, {
+            ReactiveTree.declare(Drivers.wrapper, {
                 script: el => {
                     const ownerEl = el.node.owner.owner.element;
                     if (ownerEl.splitView !== 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 { cache, runAtomically } from "reactronic";
+import { cached, runAtomically } from "reactronic";
 export function restyler(restyle) {
     return runAtomically(() => new TriggeringStyles(restyle));
 }
@@ -23,7 +23,7 @@ export class TriggeringStyles {
     }
 }
 __decorate([
-    cache,
+    cached,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)

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

@@ -1,4 +1,4 @@
-import { ReactiveNodeVariable } from "reactronic";
+import { ReactiveTreeVariable } from "reactronic";
 export declare enum Axis {
     X = 0,
     Y = 1
@@ -13,11 +13,11 @@ export declare class Dimension<T = NoUnit> {
     equalsTo(another: Dimension<T>): boolean;
     static parse<T>(text: string): Dimension<T>;
     static emit<T>(value: Dimension<T>): string;
-    static readonly gFontSizePx: ReactiveNodeVariable<number>;
+    static readonly gFontSizePx: ReactiveTreeVariable<number>;
     private static readonly gLineSizePx;
     static get lineSizePx(): number;
     static set lineSizePx(value: number);
-    static getLineSizePx(): ReactiveNodeVariable<number>;
+    static getLineSizePx(): ReactiveTreeVariable<number>;
 }
 export declare function dim<T = NoUnit>(num: number, unit?: T): Dimension<T>;
 export type SizeConverterOptions = {

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

@@ -1,4 +1,4 @@
-import { ReactiveNodeVariable } from "reactronic";
+import { ReactiveTreeVariable } from "reactronic";
 export var Axis;
 (function (Axis) {
     Axis[Axis["X"] = 0] = "X";
@@ -36,8 +36,8 @@ export class Dimension {
         return Dimension.gLineSizePx;
     }
 }
-Dimension.gFontSizePx = new ReactiveNodeVariable();
-Dimension.gLineSizePx = new ReactiveNodeVariable();
+Dimension.gFontSizePx = new ReactiveTreeVariable();
+Dimension.gLineSizePx = new ReactiveTreeVariable();
 export function dim(num, unit) {
     return new Dimension(num, unit);
 }

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

@@ -1,27 +1,27 @@
-import { MergeList, ReactiveNode } from "reactronic";
+import { ReactiveTreeNode, MergeList } from "reactronic";
 import { ElImpl } from "./ElDriver.js";
 export declare function equal(a: number, b: number): boolean;
 export declare function less(a: number, b: number): boolean;
 export declare function greater(a: number, b: number): boolean;
-export declare function relayoutUsingSplitter(splitViewNode: ReactiveNode<ElImpl>, deltaPx: number, index: number, initialSizesPx: Array<{
-    node: ReactiveNode<ElImpl>;
+export declare function relayoutUsingSplitter(splitViewNode: ReactiveTreeNode<ElImpl>, deltaPx: number, index: number, initialSizesPx: Array<{
+    node: ReactiveTreeNode<ElImpl>;
     sizePx: number;
 }>, priorities?: ReadonlyArray<number>): void;
-export declare function relayout(splitViewNode: ReactiveNode<ElImpl>, priorities: ReadonlyArray<number>, manuallyResizablePriorities: ReadonlyArray<number>, sizesPx: Array<{
-    node: ReactiveNode<ElImpl>;
+export declare function relayout(splitViewNode: ReactiveTreeNode<ElImpl>, priorities: ReadonlyArray<number>, manuallyResizablePriorities: ReadonlyArray<number>, sizesPx: Array<{
+    node: ReactiveTreeNode<ElImpl>;
     sizePx: number;
 }>): void;
-export declare function resizeUsingDelta(splitViewNode: ReactiveNode<ElImpl>, deltaPx: number, index: number, priorities: ReadonlyArray<number>, sizesPx: Array<{
-    node: ReactiveNode<ElImpl>;
+export declare function resizeUsingDelta(splitViewNode: ReactiveTreeNode<ElImpl>, deltaPx: number, index: number, priorities: ReadonlyArray<number>, sizesPx: Array<{
+    node: ReactiveTreeNode<ElImpl>;
     sizePx: number;
 }>, force?: boolean): number;
-export declare function layout(splitViewNode: ReactiveNode<ElImpl>): void;
+export declare function layout(splitViewNode: ReactiveTreeNode<ElImpl>): void;
 export declare function getPrioritiesForSplitter(index: number, size: number): ReadonlyArray<number>;
-export declare function getPrioritiesForSizeChanging(isHorizontal: boolean, children: MergeList<ReactiveNode>, indexes: Array<number>): {
+export declare function getPrioritiesForSizeChanging(isHorizontal: boolean, children: MergeList<ReactiveTreeNode>, indexes: Array<number>): {
     resizable: ReadonlyArray<number>;
     manuallyResizable: ReadonlyArray<number>;
 };
-export declare function getPrioritiesForEmptySpaceDistribution(isHorizontal: boolean, children: MergeList<ReactiveNode>): {
+export declare function getPrioritiesForEmptySpaceDistribution(isHorizontal: boolean, children: MergeList<ReactiveTreeNode>): {
     resizable: ReadonlyArray<number>;
     manuallyResizable: ReadonlyArray<number>;
 };

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

@@ -1,25 +1,25 @@
-import { ReactiveNode, Handler } from "reactronic";
+import { ReactiveTreeNode, Handler } from "reactronic";
 import { El } from "./El.js";
 import { ElDriver } from "./ElDriver.js";
 export declare class WebDriver<T extends Element, M = unknown> extends ElDriver<T, M> {
-    setNativeElement(node: ReactiveNode<El<T, M>>): void;
-    runPreparation(node: ReactiveNode<El<T, M>>): void | Promise<void>;
-    runFinalization(node: ReactiveNode<El<T, M>>, isLeader: boolean): boolean;
-    runMount(node: ReactiveNode<El<T, M>>): void;
-    runScript(node: ReactiveNode<El<T, M>>): void | Promise<void>;
-    static findBrotherlyHost<T, R>(node: ReactiveNode<El<T>>): ReactiveNode<El<R>> | undefined;
-    static findBrotherlyPrevSibling<T, R>(node: ReactiveNode<El<T>>): ReactiveNode<El<R>> | undefined;
+    setNativeElement(node: ReactiveTreeNode<El<T, M>>): void;
+    runPreparation(node: ReactiveTreeNode<El<T, M>>): void | Promise<void>;
+    runFinalization(node: ReactiveTreeNode<El<T, M>>, isLeader: boolean): boolean;
+    runMount(node: ReactiveTreeNode<El<T, M>>): void;
+    runScript(node: ReactiveTreeNode<El<T, M>>): void | Promise<void>;
+    static findBrotherlyHost<T, R>(node: ReactiveTreeNode<El<T>>): ReactiveTreeNode<El<R>> | undefined;
+    static findBrotherlyPrevSibling<T, R>(node: ReactiveTreeNode<El<T>>): ReactiveTreeNode<El<R>> | undefined;
     static get blinkingEffectMarker(): string | undefined;
     static set blinkingEffectMarker(value: string | undefined);
 }
 export declare class StaticDriver<T extends HTMLElement> extends WebDriver<T> {
     readonly native: T;
     constructor(native: T, name: string, isRow: boolean, initialize?: Handler<El<T>>);
-    setNativeElement(node: ReactiveNode<El<T>>): void;
+    setNativeElement(node: ReactiveTreeNode<El<T>>): void;
 }
 export declare class HtmlDriver<T extends HTMLElement, M = any> extends WebDriver<T, M> {
-    setNativeElement(node: ReactiveNode<El<T, M>>): void;
+    setNativeElement(node: ReactiveTreeNode<El<T, M>>): void;
 }
 export declare class SvgDriver<T extends SVGElement, M = any> extends WebDriver<T, M> {
-    setNativeElement(node: ReactiveNode<El<T, M>>): void;
+    setNativeElement(node: ReactiveTreeNode<El<T, M>>): void;
 }

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

@@ -1,4 +1,4 @@
-import { ReactiveSystem, ReactiveNode, proceedSyncOrAsync } from "reactronic";
+import { ReactiveTree, ReactiveTreeNode, ReactiveSystem, proceedSyncOrAsync } from "reactronic";
 import { Constants, ElDriver, ElImpl } from "./ElDriver.js";
 export class WebDriver extends ElDriver {
     setNativeElement(node) {
@@ -31,13 +31,13 @@ export class WebDriver extends ElDriver {
         const native = element.native;
         if (native) {
             const sequential = node.owner.children.isStrict;
-            const automaticHost = ReactiveNode.findMatchingHost(node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
+            const automaticHost = ReactiveTree.findMatchingHost(node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
             const automaticNativeHost = automaticHost !== node.owner
                 ? automaticHost === null || automaticHost === void 0 ? void 0 : automaticHost.driver.provideHost(automaticHost).element.native
                 : automaticHost === null || automaticHost === void 0 ? void 0 : automaticHost.element.native;
             if (automaticNativeHost) {
                 if (sequential && !node.driver.isPartition) {
-                    const after = ReactiveNode.findMatchingPrevSibling(node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
+                    const after = ReactiveTree.findMatchingPrevSibling(node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
                     if (after === undefined || after.driver.isPartition) {
                         if (automaticNativeHost !== native.parentNode || !native.previousSibling)
                             automaticNativeHost.prepend(native);
@@ -67,16 +67,16 @@ export class WebDriver extends ElDriver {
                     element.place = undefined;
             }
             if (gBlinkingEffectMarker)
-                blink(element.native, ReactiveNode.currentScriptPriority, node.stamp);
+                blink(element.native, ReactiveTreeNode.effectiveScriptPriority, node.stamp);
         }, e => {
         });
         return result;
     }
     static findBrotherlyHost(node) {
-        return ReactiveNode.findMatchingHost(node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
+        return ReactiveTree.findMatchingHost(node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
     }
     static findBrotherlyPrevSibling(node) {
-        return ReactiveNode.findMatchingPrevSibling(node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
+        return ReactiveTree.findMatchingPrevSibling(node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
     }
     static get blinkingEffectMarker() {
         return gBlinkingEffectMarker;

package/build/dist/source/core/sensors/HtmlDragSensor.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 { options, reaction, atomic, trigger, Transaction, LoggingLevel } from "reactronic";
+import { options, reactive, atomic, observable, Transaction, LoggingLevel } from "reactronic";
 import { findTargetElementData, SymDataForSensor } from "./DataForSensor.js";
 import { HtmlElementSensor } from "./HtmlElementSensor.js";
 import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor.js";
@@ -262,35 +262,35 @@ export class HtmlDragSensor extends HtmlElementSensor {
     }
 }
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Map)
 ], HtmlDragSensor.prototype, "dataByFormat", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Object)
 ], HtmlDragSensor.prototype, "draggingImage", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Number)
 ], HtmlDragSensor.prototype, "draggingImageX", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Number)
 ], HtmlDragSensor.prototype, "draggingImageY", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", String)
 ], HtmlDragSensor.prototype, "dropEffect", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Array)
 ], HtmlDragSensor.prototype, "dataTypesAllowed", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", String)
 ], HtmlDragSensor.prototype, "effectAllowed", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Boolean)
 ], HtmlDragSensor.prototype, "dropAllowed", void 0);
 __decorate([
@@ -364,7 +364,7 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], HtmlDragSensor.prototype, "reset", null);
 __decorate([
-    reaction,
+    reactive,
     options({ throttling: 0 }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),

package/build/dist/source/core/sensors/HtmlElementSensor.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 { trigger } from "reactronic";
+import { observable } from "reactronic";
 import { SymDataForSensor } from "./DataForSensor.js";
 import { Sensor } from "./Sensor.js";
 import { WindowSensor } from "./WindowSensor.js";
@@ -34,18 +34,18 @@ export class HtmlElementSensor extends Sensor {
     }
 }
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Object)
 ], HtmlElementSensor.prototype, "sourceElement", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", WindowSensor)
 ], HtmlElementSensor.prototype, "windowSensor", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Boolean)
 ], HtmlElementSensor.prototype, "preventDefault", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Boolean)
 ], HtmlElementSensor.prototype, "stopPropagation", void 0);

package/build/dist/source/core/sensors/PointerSensor.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 { options, trigger, atomic, reaction, Reentrance, Transaction, LoggingLevel } from "reactronic";
+import { options, observable, atomic, reactive, Reentrance, Transaction, LoggingLevel } from "reactronic";
 import { extractPointerButton, isPointerButtonDown, PointerButton, BasePointerSensor } from "./BasePointerSensor.js";
 import { findTargetElementData, SymDataForSensor } from "./DataForSensor.js";
 import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor.js";
@@ -292,19 +292,19 @@ export class PointerSensor extends BasePointerSensor {
 }
 PointerSensor.DraggingThreshold = 4;
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Object)
 ], PointerSensor.prototype, "clickable", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Boolean)
 ], PointerSensor.prototype, "tryingDragging", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Object)
 ], PointerSensor.prototype, "draggingData", void 0);
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Boolean)
 ], PointerSensor.prototype, "dropAllowed", void 0);
 __decorate([
@@ -378,14 +378,14 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], PointerSensor.prototype, "reset", null);
 __decorate([
-    reaction,
+    reactive,
     options({ throttling: 0 }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], PointerSensor.prototype, "whenClickingOrDragging", null);
 __decorate([
-    reaction,
+    reactive,
     options({ throttling: 0 }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),

package/build/dist/source/core/sensors/Sensor.d.ts

@@ -1,5 +1,5 @@
-import { TriggeringObject } from "reactronic";
-export declare class Sensor extends TriggeringObject {
+import { ObservableObject } from "reactronic";
+export declare class Sensor extends ObservableObject {
     revision: number;
     elementDataList: unknown[];
     get topElementData(): unknown;

package/build/dist/source/core/sensors/Sensor.js

@@ -1,5 +1,5 @@
-import { TriggeringObject } from "reactronic";
-export class Sensor extends TriggeringObject {
+import { ObservableObject } from "reactronic";
+export class Sensor extends ObservableObject {
     constructor() {
         super(...arguments);
         this.revision = 0;

package/build/dist/source/html/DraggableArea.view.d.ts

@@ -1,4 +1,4 @@
-import { ReactiveNodeDecl, ReactiveNode } from "reactronic";
+import { ReactiveTreeNode, ReactiveTreeNodeDecl } from "reactronic";
 import { El } from "../core/El.js";
 import { PointerSensor } from "../core/sensors/PointerSensor.js";
 export type DragAndDropHandler = (pointer: PointerSensor) => void;
@@ -8,4 +8,4 @@ export interface DraggableAreaModel {
     droppedAction?: DragAndDropHandler;
     dragFinishedAction?: DragAndDropHandler;
 }
-export declare function DraggableArea(draggingId: string, builder: ReactiveNodeDecl<El<HTMLDivElement, DraggableAreaModel>>): ReactiveNode<El<HTMLDivElement>>;
+export declare function DraggableArea(draggingId: string, builder: ReactiveTreeNodeDecl<El<HTMLDivElement, DraggableAreaModel>>): ReactiveTreeNode<El<HTMLDivElement>>;

package/build/dist/source/html/DraggableArea.view.js

@@ -1,8 +1,8 @@
-import { Mode, ReactiveNode } from "reactronic";
+import { ReactiveTree, Mode } from "reactronic";
 import { Div } from "./HtmlElements.js";
 import { Fragment } from "../core/Elements.js";
 export function DraggableArea(draggingId, builder) {
-    return (Div(ReactiveNode.withBasis(builder, {
+    return (Div(ReactiveTree.withBasis(builder, {
         mode: Mode.autonomous,
         script: b => {
             const e = b.native;