reactronic 0.94.25028 → 0.94.25030

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

@@ -21,5 +21,4 @@ export { runAtomically, runNonReactively, runSensitively, runContextually, manag
 export { ReactiveSystem, observable, atomic, reactive, cached, options } from "./System.js";
 export { ReactiveOperationEx } from "./OperationEx.js";
 export { ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
-export { ReactiveTree } from "./core/Tree.js";
 export type { Script, ScriptAsync, Handler, ReactiveTreeNodeDecl, ReactiveTreeNodeDriver, ReactiveTreeNodeContext } from "./core/TreeNode.js";

package/build/dist/source/api.js

@@ -17,4 +17,3 @@ export { runAtomically, runNonReactively, runSensitively, runContextually, manag
 export { ReactiveSystem, observable, atomic, reactive, cached, options } from "./System.js";
 export { ReactiveOperationEx } from "./OperationEx.js";
 export { ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
-export { ReactiveTree } from "./core/Tree.js";

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

@@ -7,6 +7,10 @@ export type Script<E> = (el: E, basis: () => void) => void;
 export type ScriptAsync<E> = (el: E, basis: () => Promise<void>) => Promise<void>;
 export type Handler<E = unknown, R = void> = (el: E) => R;
 export declare abstract class ReactiveTreeNode<E = unknown> {
+    static readonly shortFrameDuration = 16;
+    static readonly longFrameDuration = 300;
+    static frameDuration: number;
+    static currentScriptPriority: Priority;
     abstract readonly key: string;
     abstract readonly driver: ReactiveTreeNodeDriver<E>;
     abstract readonly declaration: Readonly<ReactiveTreeNodeDecl<E>>;
@@ -23,14 +27,22 @@ export declare abstract class ReactiveTreeNode<E = unknown> {
     abstract childrenShuffling: boolean;
     abstract strictOrder: boolean;
     abstract has(mode: Mode): boolean;
-    abstract configureReactronic(options: Partial<ReactivityOptions>): ReactivityOptions;
-    static get key(): string;
-    static get stamp(): number;
-    static get triggers(): unknown;
-    static get priority(): Priority;
-    static set priority(value: Priority);
-    static get childrenShuffling(): boolean;
-    static set childrenShuffling(value: boolean);
+    abstract configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
+    static get current(): ReactiveTreeNode;
+    static get isFirstScriptRun(): boolean;
+    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, declaration?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, scriptOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+    static withBasis<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
+    static triggerScriptRun(node: ReactiveTreeNode<any>, triggers: unknown): void;
+    static triggerFinalization(node: ReactiveTreeNode<any>): void;
+    static runNestedNodeScriptsThenDo(action: (error: unknown) => void): void;
+    static markAsMounted(node: ReactiveTreeNode<any>, yes: boolean): void;
+    static findMatchingHost<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
+    static findMatchingPrevSibling<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
+    static forEachChildRecursively<E = unknown>(node: ReactiveTreeNode<E>, action: Handler<ReactiveTreeNode<E>>): void;
+    static getDefaultLoggingOptions(): LoggingOptions | undefined;
+    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
 export type ReactiveTreeNodeDecl<E = unknown> = {
     script?: Script<E>;
@@ -79,6 +91,7 @@ export declare class ReactiveTreeVariable<T extends Object = Object> {
     get valueOrUndefined(): T | undefined;
 }
 export declare function generateKey(owner: ReactiveTreeNodeImpl): string;
+export declare function getModeUsingBasisChain(declaration?: ReactiveTreeNodeDecl<any>): Mode;
 declare class ReactiveTreeNodeContextImpl<T extends Object = Object> extends ObservableObject implements ReactiveTreeNodeContext<T> {
     next: ReactiveTreeNodeContextImpl<object> | undefined;
     variable: ReactiveTreeVariable<T>;
@@ -89,10 +102,6 @@ declare class ReactiveTreeNodeImpl<E = unknown> extends ReactiveTreeNode<E> {
     static logging: LoggingOptions | undefined;
     static grandNodeCount: number;
     static disposableNodeCount: number;
-    static readonly shortFrameDuration = 16;
-    static readonly longFrameDuration = 300;
-    static currentScriptPriority: Priority;
-    static frameDuration: number;
     readonly key: string;
     readonly driver: ReactiveTreeNodeDriver<E>;
     declaration: ReactiveTreeNodeDecl<E>;
@@ -114,11 +123,11 @@ declare class ReactiveTreeNodeImpl<E = unknown> extends ReactiveTreeNode<E> {
     get isMoved(): boolean;
     has(mode: Mode): boolean;
     script(_triggers: unknown): void;
-    configureReactronic(options: Partial<ReactivityOptions>): ReactivityOptions;
+    configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
     static get nodeSlot(): MergedItem<ReactiveTreeNodeImpl>;
-    static tryUseNodeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T | undefined;
-    static useNodeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T;
-    static setNodeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>, value: T | undefined): void;
+    static tryUseTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T | undefined;
+    static useTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T;
+    static setTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>, value: T | undefined): void;
 }
 export declare function observablesAreEqual(a1: any, a2: any): boolean;
 export {};

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

@@ -24,28 +24,108 @@ import { ObservableObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
 import { ReactiveSystem, options, observable, reactive, runAtomically, runNonReactively, manageReactiveOperation, disposeObservableObject } from "../System.js";
 export class ReactiveTreeNode {
-    static get key() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.key;
-    }
-    static get stamp() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.stamp;
-    }
-    static get triggers() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.declaration.triggers;
+    static get current() {
+        return ReactiveTreeNodeImpl.nodeSlot.instance;
+    }
+    static get isFirstScriptRun() {
+        return ReactiveTreeNode.current.stamp === 1;
+    }
+    static declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
+        let result;
+        let declaration;
+        if (scriptOrDeclaration instanceof Function) {
+            declaration = {
+                script: scriptOrDeclaration, scriptAsync, key, mode,
+                preparation, preparationAsync, finalization, triggers, basis,
+            };
+        }
+        else
+            declaration = scriptOrDeclaration !== null && scriptOrDeclaration !== void 0 ? scriptOrDeclaration : {};
+        let effectiveKey = declaration.key;
+        const owner = (getModeUsingBasisChain(declaration) & Mode.rootNode) !== Mode.rootNode ? gNodeSlot === null || gNodeSlot === void 0 ? void 0 : gNodeSlot.instance : undefined;
+        if (owner) {
+            let existing = owner.driver.declareChild(owner, driver, declaration, declaration.basis);
+            const children = owner.children;
+            existing !== null && existing !== void 0 ? existing : (existing = children.tryMergeAsExisting(effectiveKey = effectiveKey || generateKey(owner), undefined, "nested elements can be declared inside 'script' only"));
+            if (existing) {
+                result = existing.instance;
+                if (result.driver !== driver && driver !== undefined)
+                    throw new Error(`changing element driver is not yet supported: "${result.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
+                const exTriggers = result.declaration.triggers;
+                if (observablesAreEqual(declaration.triggers, exTriggers))
+                    declaration.triggers = exTriggers;
+                result.declaration = declaration;
+            }
+            else {
+                result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
+                result.slot = children.mergeAsAdded(result);
+            }
+        }
+        else {
+            result = new ReactiveTreeNodeImpl(effectiveKey || "", driver, declaration, owner);
+            result.slot = MergeList.createItem(result);
+            triggerScriptRunViaSlot(result.slot);
+        }
+        return result;
     }
-    static get priority() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.priority;
+    static withBasis(declaration, basis) {
+        if (declaration)
+            declaration.basis = basis;
+        else
+            declaration = basis !== null && basis !== void 0 ? basis : {};
+        return declaration;
+    }
+    static triggerScriptRun(node, triggers) {
+        const impl = node;
+        const declaration = impl.declaration;
+        if (!observablesAreEqual(triggers, declaration.triggers)) {
+            declaration.triggers = triggers;
+            triggerScriptRunViaSlot(impl.slot);
+        }
     }
-    static set priority(value) {
-        ReactiveTreeNodeImpl.nodeSlot.instance.priority = value;
+    static triggerFinalization(node) {
+        const impl = node;
+        triggerFinalization(impl.slot, true, true);
+    }
+    static runNestedNodeScriptsThenDo(action) {
+        runNestedNodeScriptsThenDoImpl(ReactiveTreeNodeImpl.nodeSlot, undefined, action);
+    }
+    static markAsMounted(node, yes) {
+        const n = node;
+        if (n.stamp < 0)
+            throw new Error("deactivated node cannot be mounted or unmounted");
+        if (n.stamp >= Number.MAX_SAFE_INTEGER)
+            throw new Error("node must be activated before mounting");
+        n.stamp = yes ? 0 : Number.MAX_SAFE_INTEGER - 1;
+    }
+    static findMatchingHost(node, match) {
+        let p = node.host;
+        while (p !== p.host && !match(p))
+            p = p.host;
+        return p;
+    }
+    static findMatchingPrevSibling(node, match) {
+        let p = node.slot.prev;
+        while (p && !match(p.instance))
+            p = p.prev;
+        return p === null || p === void 0 ? void 0 : p.instance;
+    }
+    static forEachChildRecursively(node, action) {
+        action(node);
+        for (const child of node.children.items())
+            ReactiveTreeNode.forEachChildRecursively(child.instance, action);
     }
-    static get childrenShuffling() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.childrenShuffling;
+    static getDefaultLoggingOptions() {
+        return ReactiveTreeNodeImpl.logging;
     }
-    static set childrenShuffling(value) {
-        ReactiveTreeNodeImpl.nodeSlot.instance.childrenShuffling = value;
+    static setDefaultLoggingOptions(logging) {
+        ReactiveTreeNodeImpl.logging = logging;
     }
 }
+ReactiveTreeNode.shortFrameDuration = 16;
+ReactiveTreeNode.longFrameDuration = 300;
+ReactiveTreeNode.frameDuration = ReactiveTreeNode.longFrameDuration;
+ReactiveTreeNode.currentScriptPriority = Priority.realtime;
 export class BaseDriver {
     constructor(name, isPartition, initialize) {
         this.name = name;
@@ -78,13 +158,13 @@ export class ReactiveTreeVariable {
         this.defaultValue = defaultValue;
     }
     set value(value) {
-        ReactiveTreeNodeImpl.setNodeVariableValue(this, value);
+        ReactiveTreeNodeImpl.setTreeVariableValue(this, value);
     }
     get value() {
-        return ReactiveTreeNodeImpl.useNodeVariableValue(this);
+        return ReactiveTreeNodeImpl.useTreeVariableValue(this);
     }
     get valueOrUndefined() {
-        return ReactiveTreeNodeImpl.tryUseNodeVariableValue(this);
+        return ReactiveTreeNodeImpl.tryUseTreeVariableValue(this);
     }
 }
 export function generateKey(owner) {
@@ -97,7 +177,7 @@ export function generateKey(owner) {
         result = `·${lettered}`;
     return result;
 }
-function getModeUsingBasisChain(declaration) {
+export function getModeUsingBasisChain(declaration) {
     var _a;
     return (_a = declaration === null || declaration === void 0 ? void 0 : declaration.mode) !== null && _a !== void 0 ? _a : ((declaration === null || declaration === void 0 ? void 0 : declaration.basis) ? getModeUsingBasisChain(declaration === null || declaration === void 0 ? void 0 : declaration.basis) : Mode.default);
 }
@@ -186,18 +266,24 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
         if (this.has(Mode.autonomous))
             ReactiveTreeNodeImpl.disposableNodeCount++;
     }
-    get strictOrder() { return this.children.isStrict; }
-    set strictOrder(value) { this.children.isStrict = value; }
-    get isMoved() { return this.owner.children.isMoved(this.slot); }
+    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 (getModeUsingBasisChain(this.declaration) & mode) === mode;
     }
     script(_triggers) {
         runScriptNow(this.slot);
     }
-    configureReactronic(options) {
+    configureReactivity(options) {
         if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.autonomous))
-            throw new Error("reactronic can be configured only for elements with autonomous mode and only during activation");
+            throw new Error("reactronic can be configured only for elements with autonomous mode and only during preparation");
         return manageReactiveOperation(this.script).configure(options);
     }
     static get nodeSlot() {
@@ -205,21 +291,21 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
             throw new Error("current element is undefined");
         return gNodeSlot;
     }
-    static tryUseNodeVariableValue(variable) {
+    static tryUseTreeVariableValue(variable) {
         var _a, _b;
         let node = ReactiveTreeNodeImpl.nodeSlot.instance;
         while (((_a = node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && node.owner !== node)
             node = node.outer.slot.instance;
         return (_b = node.context) === null || _b === void 0 ? void 0 : _b.value;
     }
-    static useNodeVariableValue(variable) {
+    static useTreeVariableValue(variable) {
         var _a;
-        const result = (_a = ReactiveTreeNodeImpl.tryUseNodeVariableValue(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
+        const result = (_a = ReactiveTreeNodeImpl.tryUseTreeVariableValue(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
         if (!result)
             throw new Error("unknown node variable");
         return result;
     }
-    static setNodeVariableValue(variable, value) {
+    static setTreeVariableValue(variable, value) {
         const node = ReactiveTreeNodeImpl.nodeSlot.instance;
         const owner = node.owner;
         const hostCtx = runNonReactively(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
@@ -247,10 +333,6 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
 ReactiveTreeNodeImpl.logging = undefined;
 ReactiveTreeNodeImpl.grandNodeCount = 0;
 ReactiveTreeNodeImpl.disposableNodeCount = 0;
-ReactiveTreeNodeImpl.shortFrameDuration = 16;
-ReactiveTreeNodeImpl.longFrameDuration = 300;
-ReactiveTreeNodeImpl.currentScriptPriority = Priority.realtime;
-ReactiveTreeNodeImpl.frameDuration = ReactiveTreeNodeImpl.longFrameDuration;
 __decorate([
     reactive,
     options({
@@ -343,8 +425,8 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
             try {
                 if (node.childrenShuffling)
                     shuffle(items);
-                const frameDurationLimit = priority === Priority.background ? ReactiveTreeNodeImpl.shortFrameDuration : Infinity;
-                let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveTreeNodeImpl.frameDuration / 4, ReactiveTreeNodeImpl.shortFrameDuration));
+                const frameDurationLimit = priority === Priority.background ? ReactiveTreeNode.shortFrameDuration : Infinity;
+                let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveTreeNode.frameDuration / 4, ReactiveTreeNode.shortFrameDuration));
                 for (const child of items) {
                     triggerScriptRunViaSlot(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
@@ -352,9 +434,9 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
                         yield Transaction.requestNextFrame(0);
                         outerPriority = ReactiveTreeNodeImpl.currentScriptPriority;
                         ReactiveTreeNodeImpl.currentScriptPriority = priority;
-                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, ReactiveTreeNodeImpl.frameDuration));
+                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, ReactiveTreeNode.frameDuration));
                     }
-                    if (Transaction.isCanceled && Transaction.isFrameOver(1, ReactiveTreeNodeImpl.shortFrameDuration / 3))
+                    if (Transaction.isCanceled && Transaction.isFrameOver(1, ReactiveTreeNode.shortFrameDuration / 3))
                         break;
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.94.25028",
+  "version": "0.94.25030",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",

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

@@ -1,19 +0,0 @@
-import { Mode } from "../Enums.js";
-import { ReactiveTreeNodeDriver, ReactiveTreeNodeDecl, Script, ScriptAsync, Handler, ReactiveTreeNode } from "./TreeNode.js";
-import { LoggingOptions } from "../Logging.js";
-export declare class ReactiveTree {
-    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
-    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, declaration?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
-    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, scriptOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
-    static withBasis<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
-    static get isFirstScriptRun(): boolean;
-    static triggerScriptRun(node: ReactiveTreeNode<any>, triggers: unknown): void;
-    static triggerFinalization(node: ReactiveTreeNode<any>): void;
-    static runNestedNodeScriptsThenDo(action: (error: unknown) => void): void;
-    static markAsMounted(node: ReactiveTreeNode<any>, yes: boolean): void;
-    static findMatchingHost<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
-    static findMatchingPrevSibling<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
-    static forEachChildRecursively<E = unknown>(node: ReactiveTreeNode<E>, action: Handler<ReactiveTreeNode<E>>): void;
-    static getDefaultLoggingOptions(): LoggingOptions | undefined;
-    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
-}

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

@@ -1,99 +0,0 @@
-import { Mode } from "../Enums.js";
-import { generateKey, observablesAreEqual } from "./TreeNode.js";
-import { MergeList } from "../util/MergeList.js";
-export class ReactiveTree {
-    static declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-        let result;
-        let declaration;
-        if (scriptOrDeclaration instanceof Function) {
-            declaration = {
-                script: scriptOrDeclaration, scriptAsync, key, mode,
-                preparation, preparationAsync, finalization, triggers, basis,
-            };
-        }
-        else
-            declaration = scriptOrDeclaration !== null && scriptOrDeclaration !== void 0 ? scriptOrDeclaration : {};
-        let effectiveKey = declaration.key;
-        const owner = (getModeUsingBasisChain(declaration) & Mode.rootNode) !== Mode.rootNode ? gNodeSlot === null || gNodeSlot === void 0 ? void 0 : gNodeSlot.instance : undefined;
-        if (owner) {
-            let existing = owner.driver.declareChild(owner, driver, declaration, declaration.basis);
-            const children = owner.children;
-            existing !== null && existing !== void 0 ? existing : (existing = children.tryMergeAsExisting(effectiveKey = effectiveKey || generateKey(owner), undefined, "nested elements can be declared inside 'script' only"));
-            if (existing) {
-                result = existing.instance;
-                if (result.driver !== driver && driver !== undefined)
-                    throw new Error(`changing element driver is not yet supported: "${result.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
-                const exTriggers = result.declaration.triggers;
-                if (observablesAreEqual(declaration.triggers, exTriggers))
-                    declaration.triggers = exTriggers;
-                result.declaration = declaration;
-            }
-            else {
-                result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
-                result.slot = children.mergeAsAdded(result);
-            }
-        }
-        else {
-            result = new ReactiveTreeNodeImpl(effectiveKey || "", driver, declaration, owner);
-            result.slot = MergeList.createItem(result);
-            triggerScriptRunViaSlot(result.slot);
-        }
-        return result;
-    }
-    static withBasis(declaration, basis) {
-        if (declaration)
-            declaration.basis = basis;
-        else
-            declaration = basis !== null && basis !== void 0 ? basis : {};
-        return declaration;
-    }
-    static get isFirstScriptRun() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.stamp === 1;
-    }
-    static triggerScriptRun(node, triggers) {
-        const impl = node;
-        const declaration = impl.declaration;
-        if (!observablesAreEqual(triggers, declaration.triggers)) {
-            declaration.triggers = triggers;
-            triggerScriptRunViaSlot(impl.slot);
-        }
-    }
-    static triggerFinalization(node) {
-        const impl = node;
-        triggerFinalization(impl.slot, true, true);
-    }
-    static runNestedNodeScriptsThenDo(action) {
-        runNestedNodeScriptsThenDoImpl(ReactiveTreeNodeImpl.nodeSlot, undefined, action);
-    }
-    static markAsMounted(node, yes) {
-        const n = node;
-        if (n.stamp < 0)
-            throw new Error("deactivated node cannot be mounted or unmounted");
-        if (n.stamp >= Number.MAX_SAFE_INTEGER)
-            throw new Error("node must be activated before mounting");
-        n.stamp = yes ? 0 : Number.MAX_SAFE_INTEGER - 1;
-    }
-    static findMatchingHost(node, match) {
-        let p = node.host;
-        while (p !== p.host && !match(p))
-            p = p.host;
-        return p;
-    }
-    static findMatchingPrevSibling(node, match) {
-        let p = node.slot.prev;
-        while (p && !match(p.instance))
-            p = p.prev;
-        return p === null || p === void 0 ? void 0 : p.instance;
-    }
-    static forEachChildRecursively(node, action) {
-        action(node);
-        for (const child of node.children.items())
-            ReactiveTree.forEachChildRecursively(child.instance, action);
-    }
-    static getDefaultLoggingOptions() {
-        return ReactiveTreeNodeImpl.logging;
-    }
-    static setDefaultLoggingOptions(logging) {
-        ReactiveTreeNodeImpl.logging = logging;
-    }
-}