verstak 0.93.25025 → 0.93.25026

package/build/dist/source/components/RealTimeClock.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 { TriggeringObject, atomicBlock, reaction } from "reactronic";
+import { TriggeringObject, atomic, reaction } from "reactronic";
 export class RealTimeClock extends TriggeringObject {
     constructor(interval = 1000) {
         super();
@@ -45,13 +45,13 @@ export class RealTimeClock extends TriggeringObject {
     }
 }
 __decorate([
-    atomicBlock,
+    atomic,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Boolean]),
     __metadata("design:returntype", void 0)
 ], RealTimeClock.prototype, "pause", null);
 __decorate([
-    atomicBlock,
+    atomic,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)

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

@@ -1,4 +1,4 @@
-import { atomicRun, ReactiveNodeVariable, Isolation } from "reactronic";
+import { runAtomically, ReactiveNodeVariable, 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(atomicRun({ isolation: Isolation.disjoinFromOuterTransaction }, () => new Theme()));
+Theme.gCurrent = new ReactiveNodeVariable(runAtomically({ isolation: Isolation.disjoinFromOuterTransaction }, () => new Theme()));

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

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

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

@@ -1,4 +1,4 @@
-import { ReactiveNode, Mode, nonReactiveRun } from "reactronic";
+import { ReactiveNode, Mode, runNonReactively } from "reactronic";
 import { ElKind, Direction } from "./El.js";
 import { clamp } from "./ElUtils.js";
 import { Constants, CursorCommandDriver, ElDriver, ElLayoutInfo, InitialElLayoutInfo } from "./ElDriver.js";
@@ -51,7 +51,7 @@ export function declareSplitter(index, splitViewNode) {
                             for (const item of initialSizesPx) {
                                 clonedSizesPx.push({ node: item.node, sizePx: item.sizePx });
                             }
-                            nonReactiveRun(() => relayoutUsingSplitter(splitViewNode, deltaPx, index, clonedSizesPx));
+                            runNonReactively(() => relayoutUsingSplitter(splitViewNode, deltaPx, index, clonedSizesPx));
                             if (pointer.dropped) {
                                 (_a = model === null || model === void 0 ? void 0 : model.droppedAction) === null || _a === void 0 ? void 0 : _a.call(model, pointer);
                             }
@@ -168,7 +168,7 @@ export class DivisionDriver extends HtmlDriver {
                         const priorities = preferred.length > 0
                             ? getPrioritiesForSizeChanging(isHorizontal, node.children, preferred)
                             : getPrioritiesForEmptySpaceDistribution(isHorizontal, node.children);
-                        nonReactiveRun(() => relayout(node, priorities.resizable, priorities.manuallyResizable, sizesPx));
+                        runNonReactively(() => relayout(node, priorities.resizable, priorities.manuallyResizable, sizesPx));
                     }
                 },
             });

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

@@ -7,9 +7,9 @@ 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, atomicRun } from "reactronic";
+import { cache, runAtomically } from "reactronic";
 export function restyler(restyle) {
-    return atomicRun(() => new TriggeringStyles(restyle));
+    return runAtomically(() => new TriggeringStyles(restyle));
 }
 export class TriggeringStyles {
     constructor(restyle) {

package/build/dist/source/core/sensors/ButtonSensor.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, Reentrance, atomicBlock, Transaction, LoggingLevel } from "reactronic";
+import { options, Reentrance, atomic, Transaction, LoggingLevel } from "reactronic";
 import { extractPointerButton, isPointerButtonDown, PointerButton, BasePointerSensor } from "./BasePointerSensor.js";
 import { findTargetElementData, SymDataForSensor } from "./DataForSensor.js";
 import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor.js";
@@ -164,42 +164,42 @@ export class ButtonSensor extends BasePointerSensor {
     }
 }
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], ButtonSensor.prototype, "press", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ reentrance: Reentrance.cancelPrevious, logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], ButtonSensor.prototype, "selecting", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], ButtonSensor.prototype, "select", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], ButtonSensor.prototype, "release", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], ButtonSensor.prototype, "cancel", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),

package/build/dist/source/core/sensors/FocusSensor.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, atomicBlock, LoggingLevel, Transaction } from "reactronic";
+import { options, atomic, LoggingLevel, Transaction } from "reactronic";
 import { objectHasMember } from "../ElUtils.js";
 import { grabElementDataList, SymDataForSensor } from "./DataForSensor.js";
 import { HtmlElementSensor } from "./HtmlElementSensor.js";
@@ -132,32 +132,32 @@ export class FocusSensor extends HtmlElementSensor {
     }
 }
 __decorate([
-    atomicBlock,
+    atomic,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, String]),
     __metadata("design:returntype", void 0)
 ], FocusSensor.prototype, "setActiveData", null);
 __decorate([
-    atomicBlock,
+    atomic,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Boolean]),
     __metadata("design:returntype", void 0)
 ], FocusSensor.prototype, "listen", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [FocusEvent]),
     __metadata("design:returntype", void 0)
 ], FocusSensor.prototype, "doFocusIn", null);
 __decorate([
-    atomicBlock,
+    atomic,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [FocusEvent]),
     __metadata("design:returntype", void 0)
 ], FocusSensor.prototype, "doFocusOut", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [MouseEvent]),

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

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Mode, ToggleRef, nonReactiveRun } from "reactronic";
+import { Mode, ToggleRef, runNonReactively } from "reactronic";
 import { PseudoElement } from "../Elements.js";
 export function OnClick(target, action, key) {
     if (action !== undefined) {
@@ -19,10 +19,10 @@ export function OnClick(target, action, key) {
                 const pointer = target.sensors.pointer;
                 if (target.dataForSensor.click !== undefined && pointer.clicked === target.dataForSensor.click || target.dataForSensor.click === undefined && pointer.clicked) {
                     if (action instanceof Function) {
-                        nonReactiveRun(() => action(pointer));
+                        runNonReactively(() => action(pointer));
                     }
                     else if (action instanceof ToggleRef) {
-                        nonReactiveRun(() => action.toggle());
+                        runNonReactively(() => action.toggle());
                     }
                 }
             },
@@ -39,10 +39,10 @@ export function OnClickAsync(target, action, key) {
                 const pointer = target.sensors.pointer;
                 if (target.dataForSensor.click !== undefined && pointer.clicked === target.dataForSensor.click || target.dataForSensor.click === undefined && pointer.clicked) {
                     if (action instanceof Function) {
-                        yield nonReactiveRun(() => action(pointer));
+                        yield runNonReactively(() => action(pointer));
                     }
                     else if (action instanceof ToggleRef) {
-                        nonReactiveRun(() => action.toggle());
+                        runNonReactively(() => action.toggle());
                     }
                 }
             }),
@@ -94,8 +94,8 @@ export function prepareResizeHandler(action) {
     return (element) => {
         const size = element.borderBoxSize[0];
         if (action instanceof Function)
-            nonReactiveRun(() => action(size.inlineSize, size.blockSize));
+            runNonReactively(() => action(size.inlineSize, size.blockSize));
         else if (action instanceof ResizeData && action.handler !== undefined)
-            nonReactiveRun(() => action.handler(size.inlineSize, size.blockSize));
+            runNonReactively(() => action.handler(size.inlineSize, size.blockSize));
     };
 }

package/build/dist/source/core/sensors/HoverSensor.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, atomicBlock, LoggingLevel, Transaction } from "reactronic";
+import { options, atomic, LoggingLevel, Transaction } from "reactronic";
 import { SymDataForSensor, findTargetElementData } from "./DataForSensor.js";
 import { BasePointerSensor } from "./BasePointerSensor.js";
 import { KeyboardModifiers, extractModifierKeys } from "./KeyboardSensor.js";
@@ -90,35 +90,35 @@ export class HoverSensor extends BasePointerSensor {
     }
 }
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], HoverSensor.prototype, "doPointerEnter", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], HoverSensor.prototype, "doPointerOver", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], HoverSensor.prototype, "doPointerMove", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], HoverSensor.prototype, "doPointerLeave", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),

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, atomicBlock, trigger, Transaction, LoggingLevel } from "reactronic";
+import { options, reaction, atomic, trigger, Transaction, LoggingLevel } from "reactronic";
 import { findTargetElementData, SymDataForSensor } from "./DataForSensor.js";
 import { HtmlElementSensor } from "./HtmlElementSensor.js";
 import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor.js";
@@ -294,70 +294,70 @@ __decorate([
     __metadata("design:type", Boolean)
 ], HtmlDragSensor.prototype, "dropAllowed", void 0);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [DragEvent]),
     __metadata("design:returntype", void 0)
 ], HtmlDragSensor.prototype, "startDragging", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [DragEvent]),
     __metadata("design:returntype", void 0)
 ], HtmlDragSensor.prototype, "dragging", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [DragEvent]),
     __metadata("design:returntype", void 0)
 ], HtmlDragSensor.prototype, "finishDragging", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [DragEvent]),
     __metadata("design:returntype", void 0)
 ], HtmlDragSensor.prototype, "enterTarget", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [DragEvent]),
     __metadata("design:returntype", void 0)
 ], HtmlDragSensor.prototype, "leaveTarget", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [DragEvent]),
     __metadata("design:returntype", void 0)
 ], HtmlDragSensor.prototype, "dragOver", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [DragEvent]),
     __metadata("design:returntype", void 0)
 ], HtmlDragSensor.prototype, "drop", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [DragEvent]),
     __metadata("design:returntype", void 0)
 ], HtmlDragSensor.prototype, "updateEventOnDragStart", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [DragEvent]),
     __metadata("design:returntype", void 0)
 ], HtmlDragSensor.prototype, "updateEventOnDropAllowed", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),

package/build/dist/source/core/sensors/KeyboardSensor.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, sensitiveRun, atomicBlock, LoggingLevel, Transaction } from "reactronic";
+import { options, runSensitively, atomic, LoggingLevel, Transaction } from "reactronic";
 import { grabElementDataList, SymDataForSensor } from "./DataForSensor.js";
 import { HtmlElementSensor } from "./HtmlElementSensor.js";
 export var KeyboardModifiers;
@@ -74,12 +74,12 @@ export class KeyboardSensor extends HtmlElementSensor {
     keyDown(e) {
         this.updateSensorData(e);
         this.up = "";
-        sensitiveRun(true, () => this.down = e.key);
+        runSensitively(true, () => this.down = e.key);
     }
     keyUp(e) {
         this.updateSensorData(e);
         this.down = "";
-        sensitiveRun(true, () => this.up = e.key);
+        runSensitively(true, () => this.up = e.key);
     }
     updateSensorData(e) {
         this.preventDefault = false;
@@ -103,20 +103,20 @@ export class KeyboardSensor extends HtmlElementSensor {
     }
 }
 __decorate([
-    atomicBlock,
+    atomic,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], KeyboardSensor.prototype, "reset", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [KeyboardEvent]),
     __metadata("design:returntype", void 0)
 ], KeyboardSensor.prototype, "keyDown", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [KeyboardEvent]),

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, atomicBlock, reaction, Reentrance, Transaction, LoggingLevel } from "reactronic";
+import { options, trigger, atomic, reaction, 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";
@@ -308,70 +308,70 @@ __decorate([
     __metadata("design:type", Boolean)
 ], PointerSensor.prototype, "dropAllowed", void 0);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], PointerSensor.prototype, "moveOver", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], PointerSensor.prototype, "tryClickingOrDragging", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ reentrance: Reentrance.cancelPrevious, logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], PointerSensor.prototype, "clickingOver", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], PointerSensor.prototype, "click", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], PointerSensor.prototype, "startDragging", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], PointerSensor.prototype, "dragOver", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], PointerSensor.prototype, "drop", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], PointerSensor.prototype, "finishDragging", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], PointerSensor.prototype, "cancelDragging", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),

package/build/dist/source/core/sensors/ResizeSensor.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, atomicBlock, LoggingLevel } from "reactronic";
+import { options, atomic, LoggingLevel } from "reactronic";
 import { Sensor } from "./Sensor.js";
 export class ResizeSensor extends Sensor {
     constructor() {
@@ -58,13 +58,13 @@ export class ResizeSensor extends Sensor {
     }
 }
 __decorate([
-    atomicBlock,
+    atomic,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], ResizeSensor.prototype, "reset", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array]),

package/build/dist/source/core/sensors/ScrollSensor.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, Reentrance, atomicBlock, LoggingLevel, Transaction } from "reactronic";
+import { options, Reentrance, atomic, LoggingLevel, Transaction } from "reactronic";
 import { HtmlElementSensor } from "./HtmlElementSensor.js";
 export class ScrollSensor extends HtmlElementSensor {
     constructor(element) {
@@ -53,13 +53,13 @@ export class ScrollSensor extends HtmlElementSensor {
     }
 }
 __decorate([
-    atomicBlock,
+    atomic,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], ScrollSensor.prototype, "reset", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ reentrance: Reentrance.cancelPrevious, logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Event]),

package/build/dist/source/core/sensors/WheelSensor.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, Reentrance, atomicBlock, LoggingLevel, Transaction } from "reactronic";
+import { options, Reentrance, atomic, LoggingLevel, Transaction } from "reactronic";
 import { findTargetElementData, SymDataForSensor } from "./DataForSensor.js";
 import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor.js";
 import { BasePointerSensor } from "./BasePointerSensor.js";
@@ -68,13 +68,13 @@ export class WheelSensor extends BasePointerSensor {
     }
 }
 __decorate([
-    atomicBlock,
+    atomic,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], WheelSensor.prototype, "reset", null);
 __decorate([
-    atomicBlock,
+    atomic,
     options({ reentrance: Reentrance.cancelPrevious, logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [WheelEvent]),

package/build/dist/source/core/sensors/WindowSensor.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 { ToggleRef, atomicBlock } from "reactronic";
+import { ToggleRef, atomic } from "reactronic";
 import { objectHasMember } from "../ElUtils.js";
 import { Sensor } from "./Sensor.js";
 export class WindowSensor extends Sensor {
@@ -31,7 +31,7 @@ export class WindowSensor extends Sensor {
     }
 }
 __decorate([
-    atomicBlock,
+    atomic,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, String]),
     __metadata("design:returntype", void 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verstak",
-  "version": "0.93.25025",
+  "version": "0.93.25026",
   "description": "Verstak - Front-End Library",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
@@ -42,7 +42,7 @@
     "markdown-it": "^14.1.0",
     "markdown-it-prism": "^2.3.0",
     "prismjs": "^1.29.0",
-    "reactronic": "^0.93.25025"
+    "reactronic": "^0.93.25026"
   },
   "devDependencies": {
     "@types/markdown-it": "14.1.2",