verstak 0.22.500 → 0.22.503

package/build/dist/source/html/sensors/HtmlDragSensor.js

@@ -7,10 +7,10 @@ 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, reactive, transactional, raw, Transaction, LoggingLevel } from 'reactronic';
-import { findTargetElementData, SymDataForSensor } from './DataForSensor';
-import { HtmlElementSensor } from './HtmlElementSensor';
-import { extractModifierKeys, KeyboardModifiers } from './KeyboardSensor';
+import { options, reactive, transactional, raw, Transaction, LoggingLevel } from "reactronic";
+import { findTargetElementData, SymDataForSensor } from "./DataForSensor";
+import { HtmlElementSensor } from "./HtmlElementSensor";
+import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor";
 export class HtmlDragSensor extends HtmlElementSensor {
     constructor(focusSensor, windowSensor) {
         super(focusSensor, windowSensor);
@@ -27,9 +27,9 @@ export class HtmlDragSensor extends HtmlElementSensor {
         this.draggingImage = undefined;
         this.draggingImageX = Infinity;
         this.draggingImageY = Infinity;
-        this.dropEffect = 'none';
+        this.dropEffect = "none";
         this.dataTypesAllowed = [];
-        this.effectAllowed = 'uninitialized';
+        this.effectAllowed = "uninitialized";
         this.dropAllowed = false;
         this.draggingOver = false;
         this.draggingDataTypes = [];
@@ -64,23 +64,23 @@ export class HtmlDragSensor extends HtmlElementSensor {
         const existing = this.sourceElement;
         if (element !== existing) {
             if (existing) {
-                existing.removeEventListener('dragstart', this.onDragStart.bind(this), { capture: true });
-                existing.removeEventListener('drag', this.onDrag.bind(this), { capture: true });
-                existing.removeEventListener('dragenter', this.onDragEnter.bind(this), { capture: false });
-                existing.removeEventListener('dragleave', this.onDragLeave.bind(this), { capture: false });
-                existing.removeEventListener('dragover', this.onDragOver.bind(this), { capture: true });
-                existing.removeEventListener('drop', this.onDrop.bind(this), { capture: true });
-                existing.removeEventListener('dragend', this.onDragEnd.bind(this), { capture: true });
+                existing.removeEventListener("dragstart", this.onDragStart.bind(this), { capture: true });
+                existing.removeEventListener("drag", this.onDrag.bind(this), { capture: true });
+                existing.removeEventListener("dragenter", this.onDragEnter.bind(this), { capture: false });
+                existing.removeEventListener("dragleave", this.onDragLeave.bind(this), { capture: false });
+                existing.removeEventListener("dragover", this.onDragOver.bind(this), { capture: true });
+                existing.removeEventListener("drop", this.onDrop.bind(this), { capture: true });
+                existing.removeEventListener("dragend", this.onDragEnd.bind(this), { capture: true });
             }
             this.sourceElement = element;
             if (element && enabled) {
-                element.addEventListener('dragstart', this.onDragStart.bind(this), { capture: true });
-                element.addEventListener('drag', this.onDrag.bind(this), { capture: true });
-                element.addEventListener('dragenter', this.onDragEnter.bind(this), { capture: false });
-                element.addEventListener('dragleave', this.onDragLeave.bind(this), { capture: false });
-                element.addEventListener('dragover', this.onDragOver.bind(this), { capture: true });
-                element.addEventListener('drop', this.onDrop.bind(this), { capture: true });
-                element.addEventListener('dragend', this.onDragEnd.bind(this), { capture: true });
+                element.addEventListener("dragstart", this.onDragStart.bind(this), { capture: true });
+                element.addEventListener("drag", this.onDrag.bind(this), { capture: true });
+                element.addEventListener("dragenter", this.onDragEnter.bind(this), { capture: false });
+                element.addEventListener("dragleave", this.onDragLeave.bind(this), { capture: false });
+                element.addEventListener("dragover", this.onDragOver.bind(this), { capture: true });
+                element.addEventListener("drop", this.onDrop.bind(this), { capture: true });
+                element.addEventListener("dragend", this.onDragEnd.bind(this), { capture: true });
             }
         }
     }
@@ -115,9 +115,9 @@ export class HtmlDragSensor extends HtmlElementSensor {
         this.stopPropagation = false;
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
-        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['htmlDraggable']);
+        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["htmlDraggable"]);
         this.draggable = data === null || data === void 0 ? void 0 : data.htmlDraggable;
-        this.dragSource = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['htmlDrag'], true).data) === null || _a === void 0 ? void 0 : _a.htmlDrag;
+        this.dragSource = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["htmlDrag"], true).data) === null || _a === void 0 ? void 0 : _a.htmlDrag;
         this.dragStarted = true;
         this.dragFinished = false;
         this.startX = e.clientX;
@@ -132,7 +132,7 @@ export class HtmlDragSensor extends HtmlElementSensor {
         this.revision++;
         Transaction.separate(() => {
             var _a;
-            (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(window, 'htmlDrag');
+            (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(window, "htmlDrag");
         });
     }
     dragging(e) {
@@ -168,7 +168,7 @@ export class HtmlDragSensor extends HtmlElementSensor {
             dt.types.forEach(type => {
                 if (!dataByFormat.has(type)) {
                     const data = dt.getData(type);
-                    if (data !== '') {
+                    if (data !== "") {
                         this.dataByFormat = dataByFormat = dataByFormat.toMutable();
                         dataByFormat.set(type, data);
                     }
@@ -183,7 +183,7 @@ export class HtmlDragSensor extends HtmlElementSensor {
             dt.dropEffect = this.dropEffect;
             dt.effectAllowed = this.effectAllowed;
             this.dataByFormat.forEach((data, format) => {
-                if (typeof data === 'string')
+                if (typeof data === "string")
                     dt.setData(format, data);
             });
             if (this.draggingImage) {
@@ -209,9 +209,9 @@ export class HtmlDragSensor extends HtmlElementSensor {
         this.draggingImage = undefined;
         this.draggingImageX = Infinity;
         this.draggingImageY = Infinity;
-        this.dropEffect = 'none';
+        this.dropEffect = "none";
         this.dataTypesAllowed = [];
-        this.effectAllowed = 'uninitialized';
+        this.effectAllowed = "uninitialized";
         this.dropAllowed = false;
         this.draggingOver = false;
         this.draggingDataTypes = [];
@@ -230,7 +230,7 @@ export class HtmlDragSensor extends HtmlElementSensor {
         var _a;
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
-        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['htmlDrag']);
+        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["htmlDrag"]);
         const dragTarget = data === null || data === void 0 ? void 0 : data.htmlDrag;
         if (dragTarget !== this.dragTarget) {
             this.previousDragTarget = this.dragTarget;

package/build/dist/source/html/sensors/HtmlElementSensor.d.ts

@@ -1,6 +1,6 @@
-import { DataForSensor } from './DataForSensor';
-import { Sensor } from './Sensor';
-import { WindowSensor } from './WindowSensor';
+import { DataForSensor } from "./DataForSensor";
+import { Sensor } from "./Sensor";
+import { WindowSensor } from "./WindowSensor";
 export declare class HtmlElementSensor extends Sensor {
     readonly focusSensor?: any;
     readonly windowSensor?: WindowSensor;

package/build/dist/source/html/sensors/HtmlElementSensor.js

@@ -7,10 +7,10 @@ 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 { raw } from 'reactronic';
-import { SymDataForSensor } from './DataForSensor';
-import { Sensor } from './Sensor';
-import { WindowSensor } from './WindowSensor';
+import { raw } from "reactronic";
+import { SymDataForSensor } from "./DataForSensor";
+import { Sensor } from "./Sensor";
+import { WindowSensor } from "./WindowSensor";
 export class HtmlElementSensor extends Sensor {
     constructor(focusSensor, windowSensor) {
         super();

package/build/dist/source/html/sensors/HtmlSensors.d.ts

@@ -1,12 +1,12 @@
-import { FocusSensor } from './FocusSensor';
-import { HoverSensor } from './HoverSensor';
-import { HtmlDragSensor } from './HtmlDragSensor';
-import { KeyboardSensor } from './KeyboardSensor';
-import { ButtonSensor } from './ButtonSensor';
-import { ResizeSensor } from './ResizeSensor';
-import { WheelSensor } from './WheelSensor';
-import { WindowSensor } from './WindowSensor';
-import { PointerSensor } from './PointerSensor';
+import { FocusSensor } from "./FocusSensor";
+import { HoverSensor } from "./HoverSensor";
+import { HtmlDragSensor } from "./HtmlDragSensor";
+import { KeyboardSensor } from "./KeyboardSensor";
+import { ButtonSensor } from "./ButtonSensor";
+import { ResizeSensor } from "./ResizeSensor";
+import { WheelSensor } from "./WheelSensor";
+import { WindowSensor } from "./WindowSensor";
+import { PointerSensor } from "./PointerSensor";
 export declare class HtmlSensors {
     readonly window: WindowSensor;
     readonly focus: FocusSensor;

package/build/dist/source/html/sensors/HtmlSensors.js

@@ -7,16 +7,16 @@ 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 { transactional } from 'reactronic';
-import { FocusSensor } from './FocusSensor';
-import { HoverSensor } from './HoverSensor';
-import { HtmlDragSensor } from './HtmlDragSensor';
-import { KeyboardSensor } from './KeyboardSensor';
-import { ButtonSensor } from './ButtonSensor';
-import { ResizeSensor } from './ResizeSensor';
-import { WheelSensor } from './WheelSensor';
-import { WindowSensor } from './WindowSensor';
-import { PointerSensor } from './PointerSensor';
+import { transactional } from "reactronic";
+import { FocusSensor } from "./FocusSensor";
+import { HoverSensor } from "./HoverSensor";
+import { HtmlDragSensor } from "./HtmlDragSensor";
+import { KeyboardSensor } from "./KeyboardSensor";
+import { ButtonSensor } from "./ButtonSensor";
+import { ResizeSensor } from "./ResizeSensor";
+import { WheelSensor } from "./WheelSensor";
+import { WindowSensor } from "./WindowSensor";
+import { PointerSensor } from "./PointerSensor";
 export class HtmlSensors {
     constructor() {
         this.window = new WindowSensor();

package/build/dist/source/html/sensors/KeyboardSensor.d.ts

@@ -1,4 +1,4 @@
-import { HtmlElementSensor } from './HtmlElementSensor';
+import { HtmlElementSensor } from "./HtmlElementSensor";
 export declare enum KeyboardModifiers {
     None = 0,
     Ctrl = 1,

package/build/dist/source/html/sensors/KeyboardSensor.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 { options, sensitive, transactional, LoggingLevel } from 'reactronic';
-import { grabElementDataList, SymDataForSensor } from './DataForSensor';
-import { HtmlElementSensor } from './HtmlElementSensor';
+import { options, sensitive, transactional, LoggingLevel } from "reactronic";
+import { grabElementDataList, SymDataForSensor } from "./DataForSensor";
+import { HtmlElementSensor } from "./HtmlElementSensor";
 export var KeyboardModifiers;
 (function (KeyboardModifiers) {
     KeyboardModifiers[KeyboardModifiers["None"] = 0] = "None";
@@ -31,29 +31,29 @@ export var KeyboardModifiers;
 export class KeyboardSensor extends HtmlElementSensor {
     constructor() {
         super();
-        this.down = '';
-        this.up = '';
+        this.down = "";
+        this.up = "";
         this.modifiers = KeyboardModifiers.None;
     }
     listen(element, enabled = true) {
         const existing = this.sourceElement;
         if (element !== existing) {
             if (existing) {
-                existing.removeEventListener('keydown', this.onKeyDown.bind(this), { capture: true });
-                existing.removeEventListener('keyup', this.onKeyUp.bind(this), { capture: true });
+                existing.removeEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
+                existing.removeEventListener("keyup", this.onKeyUp.bind(this), { capture: true });
             }
             this.sourceElement = element;
             if (element && enabled) {
-                element.addEventListener('keydown', this.onKeyDown.bind(this), { capture: true });
-                element.addEventListener('keyup', this.onKeyUp.bind(this), { capture: true });
+                element.addEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
+                element.addEventListener("keyup", this.onKeyUp.bind(this), { capture: true });
             }
         }
     }
     reset() {
         this.preventDefault = false;
         this.stopPropagation = false;
-        this.down = '';
-        this.up = '';
+        this.down = "";
+        this.up = "";
         this.modifiers = KeyboardModifiers.None;
     }
     onKeyDown(e) {
@@ -66,31 +66,31 @@ export class KeyboardSensor extends HtmlElementSensor {
     }
     keyDown(e) {
         this.updateSensorData(e);
-        this.up = '';
+        this.up = "";
         sensitive(true, () => this.down = e.key);
     }
     keyUp(e) {
         this.updateSensorData(e);
-        this.down = '';
+        this.down = "";
         sensitive(true, () => this.up = e.key);
     }
     updateSensorData(e) {
         this.preventDefault = false;
         this.stopPropagation = false;
         const path = e.composedPath();
-        this.elementDataList = grabElementDataList(path, SymDataForSensor, 'keyboard', this.elementDataList).dataList;
+        this.elementDataList = grabElementDataList(path, SymDataForSensor, "keyboard", this.elementDataList).dataList;
         this.modifiers = extractModifierKeys(e);
         this.revision++;
     }
     static getKeyAsModifierIfAny(key) {
         let modifier = KeyboardModifiers.None;
-        if (key === 'Control')
+        if (key === "Control")
             modifier = KeyboardModifiers.Ctrl;
-        else if (key === 'Shift')
+        else if (key === "Shift")
             modifier = KeyboardModifiers.Shift;
-        else if (key === 'Alt')
+        else if (key === "Alt")
             modifier = KeyboardModifiers.Alt;
-        else if (key === 'Meta')
+        else if (key === "Meta")
             modifier = KeyboardModifiers.Meta;
         return modifier;
     }

package/build/dist/source/html/sensors/PointerSensor.d.ts

@@ -1,7 +1,7 @@
-import { PointerButton, BasePointerSensor } from './BasePointerSensor';
-import { FocusSensor } from './FocusSensor';
-import { KeyboardModifiers } from './KeyboardSensor';
-import { WindowSensor } from './WindowSensor';
+import { PointerButton, BasePointerSensor } from "./BasePointerSensor";
+import { FocusSensor } from "./FocusSensor";
+import { KeyboardModifiers } from "./KeyboardSensor";
+import { WindowSensor } from "./WindowSensor";
 export declare class PointerSensor extends BasePointerSensor {
     pointerButton: PointerButton;
     private clickable;

package/build/dist/source/html/sensors/PointerSensor.js

@@ -7,10 +7,10 @@ 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, reactive, Reentrance, transactional, raw, Transaction, LoggingLevel } from 'reactronic';
-import { extractPointerButton, isPointerButtonDown, PointerButton, BasePointerSensor } from './BasePointerSensor';
-import { findTargetElementData, SymDataForSensor } from './DataForSensor';
-import { extractModifierKeys, KeyboardModifiers } from './KeyboardSensor';
+import { options, reactive, Reentrance, transactional, raw, Transaction, LoggingLevel } from "reactronic";
+import { extractPointerButton, isPointerButtonDown, PointerButton, BasePointerSensor } from "./BasePointerSensor";
+import { findTargetElementData, SymDataForSensor } from "./DataForSensor";
+import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor";
 export class PointerSensor extends BasePointerSensor {
     constructor(focusSensor, windowSensor) {
         super(focusSensor, windowSensor);
@@ -55,19 +55,19 @@ export class PointerSensor extends BasePointerSensor {
         const existing = this.sourceElement;
         if (element !== existing) {
             if (existing) {
-                existing.removeEventListener('pointerdown', this.onPointerDown.bind(this), { capture: true });
-                existing.removeEventListener('pointermove', this.onPointerMove.bind(this), { capture: true });
-                existing.removeEventListener('pointerup', this.onPointerUp.bind(this), { capture: true });
-                existing.removeEventListener('lostpointercapture', this.onLostPointerCapture.bind(this), { capture: true });
-                existing.removeEventListener('keydown', this.onKeyDown.bind(this), { capture: true });
+                existing.removeEventListener("pointerdown", this.onPointerDown.bind(this), { capture: true });
+                existing.removeEventListener("pointermove", this.onPointerMove.bind(this), { capture: true });
+                existing.removeEventListener("pointerup", this.onPointerUp.bind(this), { capture: true });
+                existing.removeEventListener("lostpointercapture", this.onLostPointerCapture.bind(this), { capture: true });
+                existing.removeEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
             }
             this.sourceElement = element;
             if (element && enabled) {
-                element.addEventListener('pointerdown', this.onPointerDown.bind(this), { capture: true });
-                element.addEventListener('pointermove', this.onPointerMove.bind(this), { capture: true });
-                element.addEventListener('pointerup', this.onPointerUp.bind(this), { capture: true });
-                element.addEventListener('lostpointercapture', this.onLostPointerCapture.bind(this), { capture: true });
-                element.addEventListener('keydown', this.onKeyDown.bind(this), { capture: true });
+                element.addEventListener("pointerdown", this.onPointerDown.bind(this), { capture: true });
+                element.addEventListener("pointermove", this.onPointerMove.bind(this), { capture: true });
+                element.addEventListener("pointerup", this.onPointerUp.bind(this), { capture: true });
+                element.addEventListener("lostpointercapture", this.onLostPointerCapture.bind(this), { capture: true });
+                element.addEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
             }
         }
     }
@@ -124,7 +124,7 @@ export class PointerSensor extends BasePointerSensor {
         }
     }
     onKeyDown(e) {
-        if (e.key === 'Escape' && (this.dragStarted || this.clickable)) {
+        if (e.key === "Escape" && (this.dragStarted || this.clickable)) {
             this.cancelDragging();
             this.reset();
         }
@@ -139,7 +139,7 @@ export class PointerSensor extends BasePointerSensor {
         this.stopPropagation = false;
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
-        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['click', 'draggable']);
+        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["click", "draggable"]);
         const clickable = data === null || data === void 0 ? void 0 : data.click;
         const draggable = data === null || data === void 0 ? void 0 : data.draggable;
         if (clickable || draggable) {
@@ -147,7 +147,7 @@ export class PointerSensor extends BasePointerSensor {
             this.clicking = clickable;
             this.draggableData = draggable;
             this.tryingDragging = draggable !== undefined;
-            this.dragSource = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['drag'], true).data) === null || _a === void 0 ? void 0 : _a.drag;
+            this.dragSource = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["drag"], true).data) === null || _a === void 0 ? void 0 : _a.drag;
             this.pointerButton = extractPointerButton(e);
             this.startX = e.clientX;
             this.startY = e.clientY;
@@ -160,7 +160,7 @@ export class PointerSensor extends BasePointerSensor {
             this.previousDragTarget = undefined;
             Transaction.separate(() => {
                 var _a;
-                (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(window, 'pointer');
+                (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(window, "pointer");
             });
         }
         this.revision++;
@@ -248,7 +248,7 @@ export class PointerSensor extends BasePointerSensor {
         var _a;
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
-        const clickable = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['click']).data) === null || _a === void 0 ? void 0 : _a.click;
+        const clickable = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["click"]).data) === null || _a === void 0 ? void 0 : _a.click;
         const isSameClickable = this.clickable === clickable;
         if (isSameClickable)
             this.clicking = clickable;
@@ -260,7 +260,7 @@ export class PointerSensor extends BasePointerSensor {
     updateDragTarget(e) {
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
-        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['drag']);
+        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["drag"]);
         const dragTarget = data === null || data === void 0 ? void 0 : data.drag;
         if (dragTarget !== this.dragTarget) {
             this.previousDragTarget = this.dragTarget;

package/build/dist/source/html/sensors/ResizeSensor.d.ts

@@ -1,5 +1,5 @@
-import { Block } from '../../core/api';
-import { Sensor } from './Sensor';
+import { VBlock } from "../../core/api";
+import { Sensor } from "./Sensor";
 export interface ResizedElement {
     readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;
     readonly contentBoxSize: ReadonlyArray<ResizeObserverSize>;
@@ -11,7 +11,7 @@ export declare class ResizeSensor extends Sensor {
     resizedElements: Array<ResizedElement>;
     constructor();
     reset(): void;
-    observeResizing(block: Block<any, any, any>, value: boolean, boxSizing?: ResizeObserverBoxOptions): void;
+    observeResizing(block: VBlock<any, any, any>, value: boolean, boxSizing?: ResizeObserverBoxOptions): void;
     protected onResize(entries: Array<ResizeObserverEntry>): void;
     protected resize(entries: Array<ResizeObserverEntry>): void;
     protected doReset(): void;

package/build/dist/source/html/sensors/ResizeSensor.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 { options, transactional, LoggingLevel } from 'reactronic';
-import { Sensor } from './Sensor';
+import { options, transactional, LoggingLevel } from "reactronic";
+import { Sensor } from "./Sensor";
 export class ResizeSensor extends Sensor {
     constructor() {
         super();
@@ -18,24 +18,24 @@ export class ResizeSensor extends Sensor {
     reset() {
         this.doReset();
     }
-    observeResizing(block, value, boxSizing = 'content-box') {
-        const impl = block.impl;
-        if (impl instanceof Element) {
+    observeResizing(block, value, boxSizing = "content-box") {
+        const native = block.native;
+        if (native instanceof Element) {
             if (value) {
-                if (impl.resizeObserver !== undefined && impl.resizeObserver !== this.observer)
-                    impl.resizeObserver.unobserve(impl);
-                impl.resizeObserver = this.observer;
-                this.observer.observe(impl, { box: boxSizing });
+                if (native.resizeObserver !== undefined && native.resizeObserver !== this.observer)
+                    native.resizeObserver.unobserve(native);
+                native.resizeObserver = this.observer;
+                this.observer.observe(native, { box: boxSizing });
             }
             else {
-                if (impl.resizeObserver === this.observer) {
-                    this.observer.unobserve(impl);
-                    impl.resizeObserver = undefined;
+                if (native.resizeObserver === this.observer) {
+                    this.observer.unobserve(native);
+                    native.resizeObserver = undefined;
                 }
             }
         }
         else
-            throw new Error('cannot observe resizing of non-HTML block');
+            throw new Error("cannot observe resizing of non-HTML block");
     }
     onResize(entries) {
         this.resize(entries);

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

@@ -1,4 +1,4 @@
-import { ObservableObject } from 'reactronic';
+import { ObservableObject } from "reactronic";
 export declare class Sensor extends ObservableObject {
     revision: number;
     elementDataList: unknown[];

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

@@ -1,4 +1,4 @@
-import { ObservableObject } from 'reactronic';
+import { ObservableObject } from "reactronic";
 export class Sensor extends ObservableObject {
     constructor() {
         super(...arguments);

package/build/dist/source/html/sensors/WheelSensor.d.ts

@@ -1,4 +1,4 @@
-import { BasePointerSensor } from './BasePointerSensor';
+import { BasePointerSensor } from "./BasePointerSensor";
 export declare class WheelSensor extends BasePointerSensor {
     target: unknown;
     deltaX: number;

package/build/dist/source/html/sensors/WheelSensor.js

@@ -7,10 +7,10 @@ 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, transactional, LoggingLevel } from 'reactronic';
-import { findTargetElementData, SymDataForSensor } from './DataForSensor';
-import { extractModifierKeys, KeyboardModifiers } from './KeyboardSensor';
-import { BasePointerSensor } from './BasePointerSensor';
+import { options, Reentrance, transactional, LoggingLevel } from "reactronic";
+import { findTargetElementData, SymDataForSensor } from "./DataForSensor";
+import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor";
+import { BasePointerSensor } from "./BasePointerSensor";
 export class WheelSensor extends BasePointerSensor {
     constructor() {
         super();
@@ -23,11 +23,11 @@ export class WheelSensor extends BasePointerSensor {
         const existing = this.sourceElement;
         if (element !== existing) {
             if (existing) {
-                existing.removeEventListener('wheel', this.onWheel.bind(this), { capture: true });
+                existing.removeEventListener("wheel", this.onWheel.bind(this), { capture: true });
             }
             this.sourceElement = element;
             if (element && enabled) {
-                element.addEventListener('wheel', this.onWheel.bind(this), { capture: true, passive: true });
+                element.addEventListener("wheel", this.onWheel.bind(this), { capture: true, passive: true });
             }
         }
     }
@@ -56,7 +56,7 @@ export class WheelSensor extends BasePointerSensor {
         this.stopPropagation = false;
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
-        this.target = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['wheel']).data) === null || _a === void 0 ? void 0 : _a.wheel;
+        this.target = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["wheel"]).data) === null || _a === void 0 ? void 0 : _a.wheel;
         this.modifiers = extractModifierKeys(e);
         this.positionX = e.clientX;
         this.positionY = e.clientY;

package/build/dist/source/html/sensors/WindowSensor.d.ts

@@ -1,5 +1,5 @@
-import { ToggleRef } from 'reactronic';
-import { Sensor } from './Sensor';
+import { ToggleRef } from "reactronic";
+import { Sensor } from "./Sensor";
 export interface WindowModel {
     popupToggle?: ToggleRef;
 }

package/build/dist/source/html/sensors/WindowSensor.js

@@ -7,19 +7,19 @@ 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, transactional } from 'reactronic';
-import { objectHasMember } from '../../core/Utils';
-import { Sensor } from './Sensor';
+import { ToggleRef, transactional } from "reactronic";
+import { objectHasMember } from "../../core/Utils";
+import { Sensor } from "./Sensor";
 export class WindowSensor extends Sensor {
     constructor() {
         super(...arguments);
         this.activeData = undefined;
         this.previousActiveData = undefined;
     }
-    setActiveWindow(window, debugHint = '') {
+    setActiveWindow(window, debugHint = "") {
         if (window !== this.activeData) {
             const activeData = this.activeData;
-            if (activeData && objectHasMember(activeData, 'popupToggle')) {
+            if (activeData && objectHasMember(activeData, "popupToggle")) {
                 const popupToggle = activeData.popupToggle;
                 if (popupToggle instanceof ToggleRef) {
                     popupToggle.variable = popupToggle.valueOff;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "verstak",
-  "version": "0.22.500",
-  "description": "Verstak - Transactional Reactive Front-End Development Framework",
+  "version": "0.22.503",
+  "description": "Verstak - Front-End Library",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
   "type": "module",
@@ -31,7 +31,7 @@
   },
   "homepage": "https://github.com/nezaboodka/verstak/blob/master/README.md#readme",
   "dependencies": {
-    "reactronic": "^0.22.411"
+    "reactronic": "^0.22.503"
   },
   "devDependencies": {
     "@types/node": "18.11.7",