verstak 0.22.500 → 0.22.504

package/build/dist/source/html/sensors/ButtonSensor.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, Transaction, LoggingLevel } from 'reactronic';
-import { extractPointerButton, isPointerButtonDown, PointerButton, BasePointerSensor } from './BasePointerSensor';
-import { findTargetElementData, SymDataForSensor } from './DataForSensor';
-import { extractModifierKeys, KeyboardModifiers } from './KeyboardSensor';
+import { options, Reentrance, transactional, Transaction, LoggingLevel } from "reactronic";
+import { extractPointerButton, isPointerButtonDown, PointerButton, BasePointerSensor } from "./BasePointerSensor";
+import { findTargetElementData, SymDataForSensor } from "./DataForSensor";
+import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor";
 export var ButtonState;
 (function (ButtonState) {
     ButtonState[ButtonState["Pressed"] = 0] = "Pressed";
@@ -33,19 +33,19 @@ export class ButtonSensor 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 });
             }
         }
     }
@@ -89,7 +89,7 @@ export class ButtonSensor extends BasePointerSensor {
         }
     }
     onKeyDown(e) {
-        if (e.key === 'Escape' && this.state !== ButtonState.Released) {
+        if (e.key === "Escape" && this.state !== ButtonState.Released) {
             this.cancel();
             this.reset();
         }
@@ -99,7 +99,7 @@ export class ButtonSensor extends BasePointerSensor {
         this.stopPropagation = false;
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
-        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['button']);
+        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["button"]);
         const originData = data === null || data === void 0 ? void 0 : data.button;
         if (originData) {
             this.state = ButtonState.Pressed;
@@ -112,7 +112,7 @@ export class ButtonSensor extends BasePointerSensor {
         }
         Transaction.separate(() => {
             var _a;
-            (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(window, 'button');
+            (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(window, "button");
         });
     }
     selecting(e) {

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

@@ -1,5 +1,5 @@
-export const SymDataForSensor = Symbol('DataForSensor');
-export const SymResizeObserver = Symbol('ResizeObserver');
+export const SymDataForSensor = Symbol("DataForSensor");
+export const SymResizeObserver = Symbol("ResizeObserver");
 export const EmptyDataArray = [];
 export function findTargetElementData(targetPath, underPointer, sym, anyOfPayloadKeys, ignoreWindow = false) {
     let result = undefined;
@@ -11,8 +11,8 @@ export function findTargetElementData(targetPath, underPointer, sym, anyOfPayloa
         if (candidateData !== undefined) {
             if (!ignoreWindow) {
                 if (window === undefined)
-                    window = candidateData['window'];
-                else if (window !== candidateData['window'])
+                    window = candidateData["window"];
+                else if (window !== candidateData["window"])
                     break;
             }
             if (result === undefined) {
@@ -42,8 +42,8 @@ export function grabElementDataList(targetPath, sym, payloadKey, existing, ignor
         if (candidateData !== undefined) {
             if (!ignoreWindow) {
                 if (window === undefined)
-                    window = candidateData['window'];
-                else if (window !== candidateData['window'])
+                    window = candidateData["window"];
+                else if (window !== candidateData["window"])
                     break;
             }
             payload = candidateData[payloadKey];

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

@@ -1,6 +1,6 @@
-import { ToggleRef } from 'reactronic';
-import { HtmlElementSensor } from './HtmlElementSensor';
-import { WindowSensor } from './WindowSensor';
+import { ToggleRef } from "reactronic";
+import { HtmlElementSensor } from "./HtmlElementSensor";
+import { WindowSensor } from "./WindowSensor";
 export interface FocusModel {
     isEditMode: boolean;
     onFocusIn?: (focus: FocusSensor) => void;

package/build/dist/source/html/sensors/FocusSensor.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, transactional, LoggingLevel } from 'reactronic';
-import { objectHasMember } from '../../core/Utils';
-import { grabElementDataList, SymDataForSensor } from './DataForSensor';
-import { HtmlElementSensor } from './HtmlElementSensor';
+import { options, transactional, LoggingLevel } from "reactronic";
+import { objectHasMember } from "../../core/Utils";
+import { grabElementDataList, SymDataForSensor } from "./DataForSensor";
+import { HtmlElementSensor } from "./HtmlElementSensor";
 export class FocusSensor extends HtmlElementSensor {
     constructor(windowSensor) {
         super(undefined, windowSensor);
@@ -18,16 +18,16 @@ export class FocusSensor extends HtmlElementSensor {
         this.oldActiveData = undefined;
         this.contextElementDataList = [];
     }
-    setActiveData(data, debugHint = '') {
+    setActiveData(data, debugHint = "") {
         var _a, _b;
         if (data !== this.activeData) {
             const activeData = this.activeData;
-            if (activeData !== undefined && objectHasMember(activeData, 'isEditMode')) {
+            if (activeData !== undefined && objectHasMember(activeData, "isEditMode")) {
                 activeData.isEditMode = false;
                 (_a = activeData.onFocusOut) === null || _a === void 0 ? void 0 : _a.call(activeData, this);
             }
             if (data !== undefined) {
-                if (objectHasMember(data, 'isEditMode')) {
+                if (objectHasMember(data, "isEditMode")) {
                     data.isEditMode = true;
                     (_b = data.onFocusIn) === null || _b === void 0 ? void 0 : _b.call(data, this);
                 }
@@ -40,15 +40,15 @@ export class FocusSensor extends HtmlElementSensor {
         const existing = this.sourceElement;
         if (element !== existing) {
             if (existing) {
-                existing.removeEventListener('focusin', this.onFocusIn.bind(this), { capture: true });
-                existing.removeEventListener('focusout', this.onFocusOut.bind(this), { capture: true });
-                existing.removeEventListener('mousedown', this.onMouseDown.bind(this), { capture: true });
+                existing.removeEventListener("focusin", this.onFocusIn.bind(this), { capture: true });
+                existing.removeEventListener("focusout", this.onFocusOut.bind(this), { capture: true });
+                existing.removeEventListener("mousedown", this.onMouseDown.bind(this), { capture: true });
             }
             this.sourceElement = element;
             if (element && enabled) {
-                element.addEventListener('focusin', this.onFocusIn.bind(this), { capture: true });
-                element.addEventListener('focusout', this.onFocusOut.bind(this), { capture: true });
-                element.addEventListener('mousedown', this.onMouseDown.bind(this), { capture: true });
+                element.addEventListener("focusin", this.onFocusIn.bind(this), { capture: true });
+                element.addEventListener("focusout", this.onFocusOut.bind(this), { capture: true });
+                element.addEventListener("mousedown", this.onMouseDown.bind(this), { capture: true });
             }
         }
     }
@@ -71,11 +71,11 @@ export class FocusSensor extends HtmlElementSensor {
     doFocusIn(e) {
         var _a;
         const path = e.composedPath();
-        const { dataList: focusDataList, activeData: focusActiveData, window } = grabElementDataList(path, SymDataForSensor, 'focus', this.elementDataList, false, e => document.activeElement === e);
+        const { dataList: focusDataList, activeData: focusActiveData, window } = grabElementDataList(path, SymDataForSensor, "focus", this.elementDataList, false, e => document.activeElement === e);
         this.elementDataList = focusDataList;
         this.setActiveData(focusActiveData);
         (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(window);
-        const { dataList: contextDataList } = grabElementDataList(path, SymDataForSensor, 'context', this.contextElementDataList, true);
+        const { dataList: contextDataList } = grabElementDataList(path, SymDataForSensor, "context", this.contextElementDataList, true);
         this.contextElementDataList = toggleContextRefs(this, this.contextElementDataList, contextDataList);
         this.reset();
     }
@@ -84,16 +84,16 @@ export class FocusSensor extends HtmlElementSensor {
         const isLosingFocus = e.relatedTarget === null;
         if (isLosingFocus) {
             const path = e.composedPath();
-            const { dataList } = grabElementDataList(path, SymDataForSensor, 'focus', this.elementDataList, true);
+            const { dataList } = grabElementDataList(path, SymDataForSensor, "focus", this.elementDataList, true);
             this.elementDataList = dataList;
             const filteredElementDataList = dataList.filter(x => x !== this.activeData);
             if (filteredElementDataList.length > 0) {
-                this.trySetEditMode(filteredElementDataList[0], '  └─');
+                this.trySetEditMode(filteredElementDataList[0], "  └─");
             }
             else {
                 const defaultData = this.getDefaultSensorData();
                 if ((defaultData === null || defaultData === void 0 ? void 0 : defaultData.focus) !== undefined) {
-                    this.trySetEditMode(defaultData.focus, '    └─');
+                    this.trySetEditMode(defaultData.focus, "    └─");
                 }
                 else {
                     this.setActiveData(undefined);
@@ -110,21 +110,21 @@ export class FocusSensor extends HtmlElementSensor {
         const path = e.composedPath();
         const isClickInsideTabIndexedElement = path.find(el => el !== document.body && el.tabIndex >= 0) !== undefined;
         if (path.length > 0 && !isClickInsideTabIndexedElement) {
-            const { dataList } = grabElementDataList(path, SymDataForSensor, 'focus', this.elementDataList, true);
+            const { dataList } = grabElementDataList(path, SymDataForSensor, "focus", this.elementDataList, true);
             this.elementDataList = dataList;
             if (dataList.length > 0) {
-                this.trySetEditMode(dataList[0], '└─');
+                this.trySetEditMode(dataList[0], "└─");
                 e.preventDefault();
             }
-            const { dataList: contextDataList } = grabElementDataList(path, SymDataForSensor, 'context', this.contextElementDataList, true);
+            const { dataList: contextDataList } = grabElementDataList(path, SymDataForSensor, "context", this.contextElementDataList, true);
             this.contextElementDataList = toggleContextRefs(this, this.contextElementDataList, contextDataList);
             this.reset();
         }
         else {
         }
     }
-    trySetEditMode(candidateData, indent = '') {
-        if (candidateData !== undefined && objectHasMember(candidateData, 'isEditMode')) {
+    trySetEditMode(candidateData, indent = "") {
+        if (candidateData !== undefined && objectHasMember(candidateData, "isEditMode")) {
             candidateData.isEditMode = true;
         }
     }
@@ -165,16 +165,16 @@ function toggleContextRefs(focusSensor, existing, updated) {
     if (updated !== existing) {
         existing.forEach(x => {
             var _a;
-            if (objectHasMember(x, 'contextToggle') && x.contextToggle && x.contextToggle.valueOn !== x.contextToggle.valueOff)
+            if (objectHasMember(x, "contextToggle") && x.contextToggle && x.contextToggle.valueOn !== x.contextToggle.valueOff)
                 x.contextToggle.variable = x.contextToggle.valueOff;
-            if (objectHasMember(x, 'onContextOut'))
+            if (objectHasMember(x, "onContextOut"))
                 (_a = x.onContextOut) === null || _a === void 0 ? void 0 : _a.call(x, focusSensor);
         });
         updated.forEach(x => {
             var _a;
-            if (objectHasMember(x, 'contextToggle') && x.contextToggle)
+            if (objectHasMember(x, "contextToggle") && x.contextToggle)
                 x.contextToggle.variable = x.contextToggle.valueOn;
-            if (objectHasMember(x, 'onContextIn'))
+            if (objectHasMember(x, "onContextIn"))
                 (_a = x.onContextIn) === null || _a === void 0 ? void 0 : _a.call(x, focusSensor);
         });
     }

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

@@ -1,4 +1,4 @@
-import { BasePointerSensor } from './BasePointerSensor';
+import { BasePointerSensor } from "./BasePointerSensor";
 export declare class HoverSensor extends BasePointerSensor {
     target: unknown;
     constructor();

package/build/dist/source/html/sensors/HoverSensor.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, transactional, LoggingLevel } from 'reactronic';
-import { findTargetElementData, SymDataForSensor } from './DataForSensor';
-import { extractModifierKeys, KeyboardModifiers } from './KeyboardSensor';
-import { BasePointerSensor } from './BasePointerSensor';
+import { options, transactional, LoggingLevel } from "reactronic";
+import { findTargetElementData, SymDataForSensor } from "./DataForSensor";
+import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor";
+import { BasePointerSensor } from "./BasePointerSensor";
 export class HoverSensor extends BasePointerSensor {
     constructor() {
         super();
@@ -21,13 +21,13 @@ export class HoverSensor extends BasePointerSensor {
         const existing = this.sourceElement;
         if (element !== existing) {
             if (existing) {
-                existing.removeEventListener('pointerover', this.onPointerOver.bind(this), { capture: true });
-                existing.removeEventListener('pointerout', this.onPointerOut.bind(this), { capture: true });
+                existing.removeEventListener("pointerover", this.onPointerOver.bind(this), { capture: true });
+                existing.removeEventListener("pointerout", this.onPointerOut.bind(this), { capture: true });
             }
             this.sourceElement = element;
             if (element && enabled) {
-                element.addEventListener('pointerover', this.onPointerOver.bind(this), { capture: true });
-                element.addEventListener('pointerout', this.onPointerOut.bind(this), { capture: true });
+                element.addEventListener("pointerover", this.onPointerOver.bind(this), { capture: true });
+                element.addEventListener("pointerout", this.onPointerOut.bind(this), { capture: true });
             }
         }
     }
@@ -43,7 +43,7 @@ export class HoverSensor extends BasePointerSensor {
         this.stopPropagation = false;
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
-        this.target = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['hover']).data) === null || _a === void 0 ? void 0 : _a.hover;
+        this.target = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["hover"]).data) === null || _a === void 0 ? void 0 : _a.hover;
         this.modifiers = extractModifierKeys(e);
         this.positionX = e.clientX;
         this.positionY = e.clientY;

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

@@ -1,9 +1,9 @@
-import { FocusSensor } from './FocusSensor';
-import { HtmlElementSensor } from './HtmlElementSensor';
-import { KeyboardModifiers } from './KeyboardSensor';
-import { WindowSensor } from './WindowSensor';
-export declare type DragEffectAllowed = 'none' | 'copy' | 'copyLink' | 'copyMove' | 'link' | 'linkMove' | 'move' | 'all' | 'uninitialized';
-export declare type DropEffect = 'none' | 'copy' | 'link' | 'move';
+import { FocusSensor } from "./FocusSensor";
+import { HtmlElementSensor } from "./HtmlElementSensor";
+import { KeyboardModifiers } from "./KeyboardSensor";
+import { WindowSensor } from "./WindowSensor";
+export declare type DragEffectAllowed = "none" | "copy" | "copyLink" | "copyMove" | "link" | "linkMove" | "move" | "all" | "uninitialized";
+export declare type DropEffect = "none" | "copy" | "link" | "move";
 export declare class HtmlDragSensor extends HtmlElementSensor {
     draggable: unknown;
     dragSource: unknown;

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;
     }