reactronic 0.24.316 → 0.24.401

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

@@ -6,7 +6,7 @@ export type ScriptAsync<E> = (el: E, basis: () => Promise<void>) => Promise<void
 export type Handler<E = unknown, R = void> = (el: E) => R;
 export declare enum Mode {
     default = 0,
-    independentUpdate = 1,
+    autonomous = 1,
     manualMount = 2
 }
 export declare enum Priority {
@@ -23,7 +23,7 @@ export declare abstract class ReactiveNode<E = unknown> {
     abstract element: E;
     abstract readonly host: ReactiveNode;
     abstract readonly children: MergeListReader<ReactiveNode>;
-    abstract readonly seat: MergedItem<ReactiveNode<E>> | undefined;
+    abstract readonly slot: MergedItem<ReactiveNode<E>> | undefined;
     abstract readonly stamp: number;
     abstract readonly outer: ReactiveNode;
     abstract readonly context: ReactiveNodeContext | undefined;
@@ -36,9 +36,9 @@ export declare abstract class ReactiveNode<E = unknown> {
     static readonly longFrameDuration = 300;
     static currentUpdatePriority: Priority;
     static frameDuration: number;
-    static declare<E = void>(driver: ReactiveNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, creation?: Script<E>, creationAsync?: ScriptAsync<E>, destruction?: Script<E>, triggers?: unknown, basis?: ReactiveNodeDecl<E>): ReactiveNode<E>;
+    static declare<E = void>(driver: ReactiveNodeDriver<E>, content?: Script<E>, contentAsync?: ScriptAsync<E>, key?: string, mode?: Mode, creation?: Script<E>, creationAsync?: ScriptAsync<E>, destruction?: Script<E>, triggers?: unknown, basis?: ReactiveNodeDecl<E>): ReactiveNode<E>;
     static declare<E = void>(driver: ReactiveNodeDriver<E>, declaration?: ReactiveNodeDecl<E>): ReactiveNode<E>;
-    static declare<E = void>(driver: ReactiveNodeDriver<E>, scriptOrDeclaration?: Script<E> | ReactiveNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, creation?: Script<E>, creationAsync?: ScriptAsync<E>, destruction?: Script<E>, triggers?: unknown, basis?: ReactiveNodeDecl<E>): ReactiveNode<E>;
+    static declare<E = void>(driver: ReactiveNodeDriver<E>, contentOrDeclaration?: Script<E> | ReactiveNodeDecl<E>, contentAsync?: ScriptAsync<E>, key?: string, mode?: Mode, creation?: Script<E>, creationAsync?: ScriptAsync<E>, destruction?: Script<E>, triggers?: unknown, basis?: ReactiveNodeDecl<E>): ReactiveNode<E>;
     static withBasis<E = void>(declaration?: ReactiveNodeDecl<E>, basis?: ReactiveNodeDecl<E>): ReactiveNodeDecl<E>;
     static get isFirstUpdate(): boolean;
     static get key(): string;
@@ -59,8 +59,8 @@ export declare abstract class ReactiveNode<E = unknown> {
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
 export type ReactiveNodeDecl<E = unknown> = {
-    script?: Script<E>;
-    scriptAsync?: ScriptAsync<E>;
+    content?: Script<E>;
+    contentAsync?: ScriptAsync<E>;
     key?: string;
     mode?: Mode;
     creation?: Script<E>;

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

@@ -26,7 +26,7 @@ import { ReactiveSystem, options, raw, reactive, unobs } from "../ReactiveSystem
 export var Mode;
 (function (Mode) {
     Mode[Mode["default"] = 0] = "default";
-    Mode[Mode["independentUpdate"] = 1] = "independentUpdate";
+    Mode[Mode["autonomous"] = 1] = "autonomous";
     Mode[Mode["manualMount"] = 2] = "manualMount";
 })(Mode || (Mode = {}));
 export var Priority;
@@ -36,23 +36,23 @@ export var Priority;
     Priority[Priority["background"] = 2] = "background";
 })(Priority || (Priority = {}));
 export class ReactiveNode {
-    static declare(driver, scriptOrDeclaration, scriptAsync, key, mode, creation, creationAsync, destruction, triggers, basis) {
+    static declare(driver, contentOrDeclaration, contentAsync, key, mode, creation, creationAsync, destruction, triggers, basis) {
         let result;
         let declaration;
-        if (scriptOrDeclaration instanceof Function) {
+        if (contentOrDeclaration instanceof Function) {
             declaration = {
-                script: scriptOrDeclaration, scriptAsync, key, mode,
+                content: contentOrDeclaration, contentAsync, key, mode,
                 creation, creationAsync, destruction, triggers, basis,
             };
         }
         else
-            declaration = scriptOrDeclaration !== null && scriptOrDeclaration !== void 0 ? scriptOrDeclaration : {};
+            declaration = contentOrDeclaration !== null && contentOrDeclaration !== void 0 ? contentOrDeclaration : {};
         let effectiveKey = declaration.key;
-        const owner = gOwnSeat === null || gOwnSeat === void 0 ? void 0 : gOwnSeat.instance;
+        const owner = gOwnSlot === null || gOwnSlot === void 0 ? void 0 : gOwnSlot.instance;
         if (owner) {
             let existing = owner.driver.child(owner, driver, declaration, declaration.basis);
             const children = owner.children;
-            existing !== null && existing !== void 0 ? existing : (existing = children.tryMergeAsExisting(effectiveKey = effectiveKey || generateKey(owner), undefined, "nested elements can be declared inside update function only"));
+            existing !== null && existing !== void 0 ? existing : (existing = children.tryMergeAsExisting(effectiveKey = effectiveKey || generateKey(owner), undefined, "nested elements can be declared inside content script only"));
             if (existing) {
                 result = existing.instance;
                 if (result.driver !== driver && driver !== undefined)
@@ -64,13 +64,13 @@ export class ReactiveNode {
             }
             else {
                 result = new ReactiveNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
-                result.seat = children.mergeAsAdded(result);
+                result.slot = children.mergeAsAdded(result);
             }
         }
         else {
             result = new ReactiveNodeImpl(effectiveKey || "", driver, declaration, owner);
-            result.seat = MergeList.createItem(result);
-            triggerUpdateViaSeat(result.seat);
+            result.slot = MergeList.createItem(result);
+            triggerUpdateViaSlot(result.slot);
         }
         return result;
     }
@@ -82,43 +82,43 @@ export class ReactiveNode {
         return declaration;
     }
     static get isFirstUpdate() {
-        return ReactiveNodeImpl.ownSeat.instance.stamp === 1;
+        return ReactiveNodeImpl.ownSlot.instance.stamp === 1;
     }
     static get key() {
-        return ReactiveNodeImpl.ownSeat.instance.key;
+        return ReactiveNodeImpl.ownSlot.instance.key;
     }
     static get stamp() {
-        return ReactiveNodeImpl.ownSeat.instance.stamp;
+        return ReactiveNodeImpl.ownSlot.instance.stamp;
     }
     static get triggers() {
-        return ReactiveNodeImpl.ownSeat.instance.declaration.triggers;
+        return ReactiveNodeImpl.ownSlot.instance.declaration.triggers;
     }
     static get priority() {
-        return ReactiveNodeImpl.ownSeat.instance.priority;
+        return ReactiveNodeImpl.ownSlot.instance.priority;
     }
     static set priority(value) {
-        ReactiveNodeImpl.ownSeat.instance.priority = value;
+        ReactiveNodeImpl.ownSlot.instance.priority = value;
     }
     static get childrenShuffling() {
-        return ReactiveNodeImpl.ownSeat.instance.childrenShuffling;
+        return ReactiveNodeImpl.ownSlot.instance.childrenShuffling;
     }
     static set childrenShuffling(value) {
-        ReactiveNodeImpl.ownSeat.instance.childrenShuffling = value;
+        ReactiveNodeImpl.ownSlot.instance.childrenShuffling = value;
     }
     static triggerUpdate(node, triggers) {
         const impl = node;
         const declaration = impl.declaration;
         if (!triggersAreEqual(triggers, declaration.triggers)) {
             declaration.triggers = triggers;
-            triggerUpdateViaSeat(impl.seat);
+            triggerUpdateViaSlot(impl.slot);
         }
     }
     static triggerDeactivation(node) {
         const impl = node;
-        triggerDeactivation(impl.seat, true, true);
+        triggerDeactivation(impl.slot, true, true);
     }
     static updateNestedNodesThenDo(action) {
-        runUpdateNestedNodesThenDo(ReactiveNodeImpl.ownSeat, undefined, action);
+        runUpdateNestedNodesThenDo(ReactiveNodeImpl.ownSlot, undefined, action);
     }
     static markAsMounted(node, yes) {
         const n = node;
@@ -135,7 +135,7 @@ export class ReactiveNode {
         return p;
     }
     static findMatchingPrevSibling(node, match) {
-        let p = node.seat.prev;
+        let p = node.slot.prev;
         while (p && !match(p.instance))
             p = p.prev;
         return p === null || p === void 0 ? void 0 : p.instance;
@@ -174,7 +174,7 @@ export class BaseDriver {
     mount(node) {
     }
     update(node) {
-        return invokeScriptUsingBasisChain(node.element, node.declaration);
+        return invokeContentUsingBasisChain(node.element, node.declaration);
     }
     child(ownerNode, childDriver, childDeclaration, childBasis) {
         return undefined;
@@ -211,22 +211,19 @@ function getModeUsingBasisChain(declaration) {
     var _a;
     return (_a = declaration === null || declaration === void 0 ? void 0 : declaration.mode) !== null && _a !== void 0 ? _a : ((declaration === null || declaration === void 0 ? void 0 : declaration.basis) ? getModeUsingBasisChain(declaration === null || declaration === void 0 ? void 0 : declaration.basis) : Mode.default);
 }
-function invokeScriptUsingBasisChain(element, declaration) {
+function invokeContentUsingBasisChain(element, declaration) {
     let result = undefined;
     const basis = declaration.basis;
-    const script = declaration.script;
-    const scriptAsync = declaration.scriptAsync;
-    if (script && scriptAsync) {
-        throw misuse("'script' and 'scriptAsync' cannot be defined together");
-    }
-    if (script) {
-        result = script(element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP);
-    }
-    else if (scriptAsync) {
-        result = scriptAsync(element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP_ASYNC);
-    }
+    const content = declaration.content;
+    const contentAsync = declaration.contentAsync;
+    if (content && contentAsync)
+        throw misuse("'content' and 'contentAsync' cannot be defined together");
+    if (content)
+        result = content(element, basis ? () => invokeContentUsingBasisChain(element, basis) : NOP);
+    else if (contentAsync)
+        result = contentAsync(element, basis ? () => invokeContentUsingBasisChain(element, basis) : NOP_ASYNC);
     else if (basis)
-        result = invokeScriptUsingBasisChain(element, basis);
+        result = invokeContentUsingBasisChain(element, basis);
     return result;
 }
 function invokeCreationUsingBasisChain(element, declaration) {
@@ -234,15 +231,12 @@ function invokeCreationUsingBasisChain(element, declaration) {
     const basis = declaration.basis;
     const creation = declaration.creation;
     const creationAsync = declaration.creationAsync;
-    if (creation && creationAsync) {
+    if (creation && creationAsync)
         throw misuse("'creation' and 'creationAsync' cannot be defined together");
-    }
-    if (creation) {
+    if (creation)
         result = creation(element, basis ? () => invokeCreationUsingBasisChain(element, basis) : NOP);
-    }
-    else if (creationAsync) {
+    else if (creationAsync)
         result = creationAsync(element, basis ? () => invokeCreationUsingBasisChain(element, basis) : NOP_ASYNC);
-    }
     else if (basis)
         result = invokeCreationUsingBasisChain(element, basis);
     return result;
@@ -292,40 +286,40 @@ class ReactiveNodeImpl extends ReactiveNode {
         this.element = driver.allocate(this);
         this.host = thisAsUnknown;
         this.children = new MergeList(getNodeKey, true);
-        this.seat = undefined;
+        this.slot = undefined;
         this.stamp = Number.MAX_SAFE_INTEGER;
         this.context = undefined;
         this.numerator = 0;
         this.priority = Priority.realtime;
         this.childrenShuffling = false;
         ReactiveNodeImpl.grandNodeCount++;
-        if (this.has(Mode.independentUpdate))
+        if (this.has(Mode.autonomous))
             ReactiveNodeImpl.disposableNodeCount++;
     }
     get strictOrder() { return this.children.isStrict; }
     set strictOrder(value) { this.children.isStrict = value; }
-    get isMoved() { return this.owner.children.isMoved(this.seat); }
+    get isMoved() { return this.owner.children.isMoved(this.slot); }
     has(mode) {
         return (getModeUsingBasisChain(this.declaration) & mode) === mode;
     }
     update(_triggers) {
-        updateNow(this.seat);
+        updateNow(this.slot);
     }
     configureReactronic(options) {
-        if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.independentUpdate))
-            throw new Error("reactronic can be configured only for elements with independent update mode and only during activation");
+        if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.autonomous))
+            throw new Error("reactronic can be configured only for elements with autonomous mode and only during activation");
         return ReactiveSystem.getOperation(this.update).configure(options);
     }
-    static get ownSeat() {
-        if (!gOwnSeat)
+    static get ownSlot() {
+        if (!gOwnSlot)
             throw new Error("current element is undefined");
-        return gOwnSeat;
+        return gOwnSlot;
     }
     static tryUseNodeVariableValue(variable) {
         var _a, _b;
-        let node = ReactiveNodeImpl.ownSeat.instance;
+        let node = ReactiveNodeImpl.ownSlot.instance;
         while (((_a = node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && node.owner !== node)
-            node = node.outer.seat.instance;
+            node = node.outer.slot.instance;
         return (_b = node.context) === null || _b === void 0 ? void 0 : _b.value;
     }
     static useNodeVariableValue(variable) {
@@ -336,7 +330,7 @@ class ReactiveNodeImpl extends ReactiveNode {
         return result;
     }
     static setNodeVariableValue(variable, value) {
-        const node = ReactiveNodeImpl.ownSeat.instance;
+        const node = ReactiveNodeImpl.ownSlot.instance;
         const owner = node.owner;
         const hostCtx = unobs(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
@@ -378,10 +372,10 @@ __decorate([
 function getNodeKey(node) {
     return node.stamp >= 0 ? node.key : undefined;
 }
-function runUpdateNestedNodesThenDo(ownSeat, error, action) {
-    runInside(ownSeat, () => {
+function runUpdateNestedNodesThenDo(ownSlot, error, action) {
+    runInside(ownSlot, () => {
         var _a;
-        const owner = ownSeat.instance;
+        const owner = ownSlot.instance;
         const children = owner.children;
         if (children.isMergeInProgress) {
             let promised = undefined;
@@ -404,7 +398,7 @@ function runUpdateNestedNodesThenDo(ownSeat, error, action) {
                         mounting = markToMountIfNecessary(mounting, host, child, children, sequential);
                         const p = (_a = childNode.priority) !== null && _a !== void 0 ? _a : Priority.realtime;
                         if (p === Priority.realtime)
-                            triggerUpdateViaSeat(child);
+                            triggerUpdateViaSlot(child);
                         else if (p === Priority.normal)
                             p1 = push(child, p1);
                         else
@@ -413,7 +407,7 @@ function runUpdateNestedNodesThenDo(ownSeat, error, action) {
                             partition = childNode;
                     }
                     if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
-                        promised = startIncrementalUpdate(ownSeat, children, p1, p2).then(() => action(error), e => action(e));
+                        promised = startIncrementalUpdate(ownSlot, children, p1, p2).then(() => action(error), e => action(e));
                 }
             }
             finally {
@@ -423,26 +417,26 @@ function runUpdateNestedNodesThenDo(ownSeat, error, action) {
         }
     });
 }
-function markToMountIfNecessary(mounting, host, seat, children, sequential) {
-    const node = seat.instance;
+function markToMountIfNecessary(mounting, host, slot, children, sequential) {
+    const node = slot.instance;
     if (node.element.native && !node.has(Mode.manualMount)) {
         if (mounting || node.host !== host) {
-            children.markAsMoved(seat);
+            children.markAsMoved(slot);
             mounting = false;
         }
     }
-    else if (sequential && children.isMoved(seat))
+    else if (sequential && children.isMoved(slot))
         mounting = true;
     node.host = host;
     return mounting;
 }
-function startIncrementalUpdate(ownerSeat, allChildren, priority1, priority2) {
+function startIncrementalUpdate(ownerSlot, allChildren, priority1, priority2) {
     return __awaiter(this, void 0, void 0, function* () {
-        const stamp = ownerSeat.instance.stamp;
+        const stamp = ownerSlot.instance.stamp;
         if (priority1)
-            yield updateIncrementally(ownerSeat, stamp, allChildren, priority1, Priority.normal);
+            yield updateIncrementally(ownerSlot, stamp, allChildren, priority1, Priority.normal);
         if (priority2)
-            yield updateIncrementally(ownerSeat, stamp, allChildren, priority2, Priority.background);
+            yield updateIncrementally(ownerSlot, stamp, allChildren, priority2, Priority.background);
     });
 }
 function updateIncrementally(owner, stamp, allChildren, items, priority) {
@@ -458,7 +452,7 @@ function updateIncrementally(owner, stamp, allChildren, items, priority) {
                 const frameDurationLimit = priority === Priority.background ? ReactiveNode.shortFrameDuration : Infinity;
                 let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveNode.frameDuration / 4, ReactiveNode.shortFrameDuration));
                 for (const child of items) {
-                    triggerUpdateViaSeat(child);
+                    triggerUpdateViaSlot(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
                         ReactiveNode.currentUpdatePriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
@@ -476,10 +470,10 @@ function updateIncrementally(owner, stamp, allChildren, items, priority) {
         }
     });
 }
-function triggerUpdateViaSeat(seat) {
-    const node = seat.instance;
+function triggerUpdateViaSlot(slot) {
+    const node = slot.instance;
     if (node.stamp >= 0) {
-        if (node.has(Mode.independentUpdate)) {
+        if (node.has(Mode.autonomous)) {
             if (node.stamp === Number.MAX_SAFE_INTEGER) {
                 Transaction.outside(() => {
                     if (ReactiveSystem.isLogging)
@@ -492,7 +486,7 @@ function triggerUpdateViaSeat(seat) {
             unobs(node.update, node.declaration.triggers);
         }
         else
-            updateNow(seat);
+            updateNow(slot);
     }
 }
 function mountOrRemountIfNecessary(node) {
@@ -511,11 +505,11 @@ function mountOrRemountIfNecessary(node) {
     else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
         unobs(() => driver.mount(node));
 }
-function updateNow(seat) {
-    const node = seat.instance;
+function updateNow(slot) {
+    const node = slot.instance;
     if (node.stamp >= 0) {
         let result = undefined;
-        runInside(seat, () => {
+        runInside(slot, () => {
             mountOrRemountIfNecessary(node);
             if (node.stamp < Number.MAX_SAFE_INTEGER - 1) {
                 try {
@@ -524,10 +518,10 @@ function updateNow(seat) {
                     node.children.beginMerge();
                     const driver = node.driver;
                     result = driver.update(node);
-                    result = proceedSyncOrAsync(result, v => { runUpdateNestedNodesThenDo(seat, undefined, NOP); return v; }, e => { console.log(e); runUpdateNestedNodesThenDo(seat, e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
+                    result = proceedSyncOrAsync(result, v => { runUpdateNestedNodesThenDo(slot, undefined, NOP); return v; }, e => { console.log(e); runUpdateNestedNodesThenDo(slot, e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
                 }
                 catch (e) {
-                    runUpdateNestedNodesThenDo(seat, e, NOP);
+                    runUpdateNestedNodesThenDo(slot, e, NOP);
                     console.log(`Update failed: ${node.key}`);
                     console.log(`${e}`);
                 }
@@ -535,23 +529,23 @@ function updateNow(seat) {
         });
     }
 }
-function triggerDeactivation(seat, isLeader, individual) {
-    const node = seat.instance;
+function triggerDeactivation(slot, isLeader, individual) {
+    const node = slot.instance;
     if (node.stamp >= 0) {
         const driver = node.driver;
         if (individual && node.key !== node.declaration.key && !driver.isPartition)
             console.log(`WARNING: it is recommended to assign explicit key for conditional element in order to avoid unexpected side effects: ${node.key}`);
         node.stamp = ~node.stamp;
         const childrenAreLeaders = unobs(() => driver.destroy(node, isLeader));
-        if (node.has(Mode.independentUpdate)) {
-            seat.aux = undefined;
+        if (node.has(Mode.autonomous)) {
+            slot.aux = undefined;
             const last = gLastToDispose;
             if (last)
-                gLastToDispose = last.aux = seat;
+                gLastToDispose = last.aux = slot;
             else
-                gFirstToDispose = gLastToDispose = seat;
-            if (gFirstToDispose === seat)
-                Transaction.run({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${seat.instance.key})` }, () => {
+                gFirstToDispose = gLastToDispose = slot;
+            if (gFirstToDispose === slot)
+                Transaction.run({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }
@@ -563,12 +557,12 @@ function triggerDeactivation(seat, isLeader, individual) {
 function runDisposalLoop() {
     return __awaiter(this, void 0, void 0, function* () {
         yield Transaction.requestNextFrame();
-        let seat = gFirstToDispose;
-        while (seat !== undefined) {
+        let slot = gFirstToDispose;
+        while (slot !== undefined) {
             if (Transaction.isFrameOver(500, 5))
                 yield Transaction.requestNextFrame();
-            ReactiveSystem.dispose(seat.instance);
-            seat = seat.aux;
+            ReactiveSystem.dispose(slot.instance);
+            slot = slot.aux;
             ReactiveNodeImpl.disposableNodeCount--;
         }
         gFirstToDispose = gLastToDispose = undefined;
@@ -576,7 +570,7 @@ function runDisposalLoop() {
 }
 function wrapToRunInside(func) {
     let wrappedToRunInside;
-    const outer = gOwnSeat;
+    const outer = gOwnSlot;
     if (outer)
         wrappedToRunInside = (...args) => {
             return runInside(outer, func, ...args);
@@ -585,14 +579,14 @@ function wrapToRunInside(func) {
         wrappedToRunInside = func;
     return wrappedToRunInside;
 }
-function runInside(seat, func, ...args) {
-    const outer = gOwnSeat;
+function runInside(slot, func, ...args) {
+    const outer = gOwnSlot;
     try {
-        gOwnSeat = seat;
+        gOwnSlot = slot;
         return func(...args);
     }
     finally {
-        gOwnSeat = outer;
+        gOwnSlot = outer;
     }
 }
 function triggersAreEqual(a1, a2) {
@@ -646,6 +640,6 @@ function defaultReject(error) {
 Promise.prototype.then = reactronicDomHookedThen;
 const NOP = (...args) => { };
 const NOP_ASYNC = (...args) => __awaiter(void 0, void 0, void 0, function* () { });
-let gOwnSeat = undefined;
+let gOwnSlot = undefined;
 let gFirstToDispose = undefined;
 let gLastToDispose = undefined;

package/build/dist/source/util/Utils.js

@@ -101,7 +101,7 @@ export function getCallerInfo(prefix) {
     return result;
 }
 function extractFunctionAndLocation(s) {
-    const match = s.match(/(?:\s*at\s+)?(?:(\S+)\s\()?(?:.*?)([^\/\(\):]+)(?:(:|\d)*\)?)$/);
+    const match = s.match(/(?:\s*at\s+)?(?:(\S+)\s\()?(?:.*?)([^\/\(\)]+)(?:(:|\d)*\)?)$/);
     return {
         func: (match === null || match === void 0 ? void 0 : match[1]) || "",
         file: (match === null || match === void 0 ? void 0 : match[2]) || "",

package/package.json

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