@ng-org/alien-deepsignals 0.1.2-alpha.10 → 0.1.2-alpha.12

package/dist/test/lib/index.test.js

@@ -1,4 +1,3 @@
-"use strict";
 // Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
 // All rights reserved.
 // Licensed under the Apache License, Version 2.0
@@ -8,48 +7,47 @@
 // notice may not be copied, modified, or distributed except
 // according to those terms.
 // SPDX-License-Identifier: Apache-2.0 OR MIT
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("../../index");
-const vitest_1 = require("vitest");
-const __1 = require("../..");
-(0, vitest_1.describe)("deepsignal/core", () => {
+import { deepSignal, shallow } from "../../index.js";
+import { describe, it, expect, beforeEach } from "vitest";
+import { effect } from "../../index.js";
+describe("deepsignal/core", () => {
     let nested = { b: 2 };
     let array = [3, nested];
     let state = { a: 1, nested, array };
-    let store = (0, index_1.deepSignal)(state);
+    let store = deepSignal(state);
     const window = globalThis;
-    (0, vitest_1.beforeEach)(() => {
+    beforeEach(() => {
         nested = { b: 2 };
         array = [3, nested];
         state = { a: 1, nested, array };
-        store = (0, index_1.deepSignal)(state);
+        store = deepSignal(state);
     });
-    (0, vitest_1.describe)("get - plain", () => {
-        (0, vitest_1.it)("should return plain objects/arrays", () => {
-            (0, vitest_1.expect)(store.nested).to.deep.equal({ b: 2 });
-            (0, vitest_1.expect)(store.array).to.deep.equal([3, { b: 2 }]);
-            (0, vitest_1.expect)(store.array[1]).to.deep.equal({ b: 2 });
-        });
-        (0, vitest_1.it)("should return plain primitives", () => {
-            (0, vitest_1.expect)(store.a).to.equal(1);
-            (0, vitest_1.expect)(store.nested.b).to.equal(2);
-            (0, vitest_1.expect)(store.array[0]).to.equal(3);
-            (0, vitest_1.expect)(typeof store.array[1] === "object" && store.array[1].b).to.equal(2);
-            (0, vitest_1.expect)(store.array.length).to.equal(2);
-        });
-        (0, vitest_1.it)("should support reading from getters", () => {
-            const store = (0, index_1.deepSignal)({
+    describe("get - plain", () => {
+        it("should return plain objects/arrays", () => {
+            expect(store.nested).to.deep.equal({ b: 2 });
+            expect(store.array).to.deep.equal([3, { b: 2 }]);
+            expect(store.array[1]).to.deep.equal({ b: 2 });
+        });
+        it("should return plain primitives", () => {
+            expect(store.a).to.equal(1);
+            expect(store.nested.b).to.equal(2);
+            expect(store.array[0]).to.equal(3);
+            expect(typeof store.array[1] === "object" && store.array[1].b).to.equal(2);
+            expect(store.array.length).to.equal(2);
+        });
+        it("should support reading from getters", () => {
+            const store = deepSignal({
                 counter: 1,
                 get double() {
                     return store.counter * 2;
                 },
             });
-            (0, vitest_1.expect)(store.double).to.equal(2);
+            expect(store.double).to.equal(2);
             store.counter = 2;
-            (0, vitest_1.expect)(store.double).to.equal(4);
+            expect(store.double).to.equal(4);
         });
-        (0, vitest_1.it)("should support getters returning other parts of the state", () => {
-            const store = (0, index_1.deepSignal)({
+        it("should support getters returning other parts of the state", () => {
+            const store = deepSignal({
                 switch: "a",
                 a: { data: "a" },
                 b: { data: "b" },
@@ -57,12 +55,12 @@ const __1 = require("../..");
                     return store.switch === "a" ? store.a : store.b;
                 },
             });
-            (0, vitest_1.expect)(store.aOrB.data).to.equal("a");
+            expect(store.aOrB.data).to.equal("a");
             store.switch = "b";
-            (0, vitest_1.expect)(store.aOrB.data).to.equal("b");
+            expect(store.aOrB.data).to.equal("b");
         });
-        (0, vitest_1.it)("should support getters using ownKeys traps", () => {
-            const state = (0, index_1.deepSignal)({
+        it("should support getters using ownKeys traps", () => {
+            const state = deepSignal({
                 x: {
                     a: 1,
                     b: 2,
@@ -71,10 +69,10 @@ const __1 = require("../..");
                     return Object.values(state.x);
                 },
             });
-            (0, vitest_1.expect)(state.y).to.deep.equal([1, 2]);
+            expect(state.y).to.deep.equal([1, 2]);
         });
-        (0, vitest_1.it)("should work with normal functions", () => {
-            const store = (0, index_1.deepSignal)({
+        it("should work with normal functions", () => {
+            const store = deepSignal({
                 value: 1,
                 isBigger: (newValue) => store.value < newValue,
                 sum(newValue) {
@@ -84,25 +82,25 @@ const __1 = require("../..");
                     store.value = newValue;
                 },
             });
-            (0, vitest_1.expect)(store.isBigger(2)).to.equal(true);
-            (0, vitest_1.expect)(store.sum(2)).to.equal(3);
-            (0, vitest_1.expect)(store.value).to.equal(1);
+            expect(store.isBigger(2)).to.equal(true);
+            expect(store.sum(2)).to.equal(3);
+            expect(store.value).to.equal(1);
             store.replace(2);
-            (0, vitest_1.expect)(store.value).to.equal(2);
+            expect(store.value).to.equal(2);
         });
     });
-    (0, vitest_1.describe)("set", () => {
-        (0, vitest_1.it)("should update like plain objects/arrays", () => {
-            (0, vitest_1.expect)(store.a).to.equal(1);
-            (0, vitest_1.expect)(store.nested.b).to.equal(2);
+    describe("set", () => {
+        it("should update like plain objects/arrays", () => {
+            expect(store.a).to.equal(1);
+            expect(store.nested.b).to.equal(2);
             store.a = 2;
             store.nested.b = 3;
-            (0, vitest_1.expect)(store.a).to.equal(2);
-            (0, vitest_1.expect)(store.nested.b).to.equal(3);
+            expect(store.a).to.equal(2);
+            expect(store.nested.b).to.equal(3);
         });
         // TODO: Remove the .value access semantics.
-        (0, vitest_1.it)("should support setting values with setters", () => {
-            const store = (0, index_1.deepSignal)({
+        it("should support setting values with setters", () => {
+            const store = deepSignal({
                 counter: 1,
                 get double() {
                     return store.counter * 2;
@@ -111,26 +109,26 @@ const __1 = require("../..");
                     store.counter = val / 2;
                 },
             });
-            (0, vitest_1.expect)(store.counter).to.equal(1);
+            expect(store.counter).to.equal(1);
             store.double = 4;
-            (0, vitest_1.expect)(store.counter).to.equal(2);
+            expect(store.counter).to.equal(2);
         });
-        (0, vitest_1.it)("should update array length", () => {
+        it("should update array length", () => {
             let state = { a: 1, nested, array };
-            let store = (0, index_1.deepSignal)(state);
-            (0, vitest_1.expect)(store.array.length).to.equal(2);
+            let store = deepSignal(state);
+            expect(store.array.length).to.equal(2);
             store.array.push(4);
-            (0, vitest_1.expect)(store.array.length).to.equal(3);
+            expect(store.array.length).to.equal(3);
             store.array.splice(1, 2);
-            (0, vitest_1.expect)(store.array.length).to.equal(1);
+            expect(store.array.length).to.equal(1);
         });
-        (0, vitest_1.it)("should update when mutations happen", () => {
-            (0, vitest_1.expect)(store.a).to.equal(1);
+        it("should update when mutations happen", () => {
+            expect(store.a).to.equal(1);
             store.a = 11;
-            (0, vitest_1.expect)(store.a).to.equal(11);
+            expect(store.a).to.equal(11);
         });
-        (0, vitest_1.it)("should support setting getters on the fly", () => {
-            const store = (0, index_1.deepSignal)({
+        it("should support setting getters on the fly", () => {
+            const store = deepSignal({
                 counter: 1,
             });
             Object.defineProperty(store, "double", {
@@ -138,112 +136,112 @@ const __1 = require("../..");
                     return store.counter * 2;
                 },
             });
-            (0, vitest_1.expect)(store.double).to.equal(2);
+            expect(store.double).to.equal(2);
             store.counter = 2;
-            (0, vitest_1.expect)(store.double).to.equal(4);
+            expect(store.double).to.equal(4);
         });
-        (0, vitest_1.it)("should copy object like plain JavaScript", () => {
-            const store = (0, index_1.deepSignal)({
+        it("should copy object like plain JavaScript", () => {
+            const store = deepSignal({
                 b: { id: 1, nested: { id: 1 } },
             });
             store.a = store.b;
-            (0, vitest_1.expect)(store.a.id).to.equal(1);
-            (0, vitest_1.expect)(store.b.id).to.equal(1);
-            (0, vitest_1.expect)(store.a.nested.id).to.equal(1);
-            (0, vitest_1.expect)(store.b.nested.id).to.equal(1);
+            expect(store.a.id).to.equal(1);
+            expect(store.b.id).to.equal(1);
+            expect(store.a.nested.id).to.equal(1);
+            expect(store.b.nested.id).to.equal(1);
             store.a.id = 2;
             store.a.nested.id = 2;
-            (0, vitest_1.expect)(store.a.id).to.equal(2);
-            (0, vitest_1.expect)(store.b.id).to.equal(2);
-            (0, vitest_1.expect)(store.a.nested.id).to.equal(2);
-            (0, vitest_1.expect)(store.b.nested.id).to.equal(2);
+            expect(store.a.id).to.equal(2);
+            expect(store.b.id).to.equal(2);
+            expect(store.a.nested.id).to.equal(2);
+            expect(store.b.nested.id).to.equal(2);
             store.b.id = 3;
             store.b.nested.id = 3;
-            (0, vitest_1.expect)(store.b.id).to.equal(3);
-            (0, vitest_1.expect)(store.a.id).to.equal(3);
-            (0, vitest_1.expect)(store.a.nested.id).to.equal(3);
-            (0, vitest_1.expect)(store.b.nested.id).to.equal(3);
+            expect(store.b.id).to.equal(3);
+            expect(store.a.id).to.equal(3);
+            expect(store.a.nested.id).to.equal(3);
+            expect(store.b.nested.id).to.equal(3);
             store.a.id = 4;
             store.a.nested.id = 4;
-            (0, vitest_1.expect)(store.a.id).to.equal(4);
-            (0, vitest_1.expect)(store.b.id).to.equal(4);
-            (0, vitest_1.expect)(store.a.nested.id).to.equal(4);
-            (0, vitest_1.expect)(store.b.nested.id).to.equal(4);
+            expect(store.a.id).to.equal(4);
+            expect(store.b.id).to.equal(4);
+            expect(store.a.nested.id).to.equal(4);
+            expect(store.b.nested.id).to.equal(4);
         });
-        (0, vitest_1.it)("should be able to reset values with Object.assign", () => {
+        it("should be able to reset values with Object.assign", () => {
             const initialNested = { ...nested };
             const initialState = { ...state, nested: initialNested };
             store.a = 2;
             store.nested.b = 3;
             Object.assign(store, initialState);
-            (0, vitest_1.expect)(store.a).to.equal(1);
-            (0, vitest_1.expect)(store.nested.b).to.equal(2);
+            expect(store.a).to.equal(1);
+            expect(store.nested.b).to.equal(2);
         });
     });
-    (0, vitest_1.describe)("delete", () => {
-        (0, vitest_1.it)("should delete properties before they are accessed", () => {
+    describe("delete", () => {
+        it("should delete properties before they are accessed", () => {
             delete store.a;
-            (0, vitest_1.expect)(store.a).to.equal(undefined);
+            expect(store.a).to.equal(undefined);
         });
-        (0, vitest_1.it)("should delete properties after they are accessed", () => {
-            (0, vitest_1.expect)(store.a).to.equal(1);
+        it("should delete properties after they are accessed", () => {
+            expect(store.a).to.equal(1);
             delete store.a;
-            (0, vitest_1.expect)(store.a).to.equal(undefined);
+            expect(store.a).to.equal(undefined);
         });
-        (0, vitest_1.it)("should delete nested properties before they are accessed", () => {
+        it("should delete nested properties before they are accessed", () => {
             delete store.nested.b;
-            (0, vitest_1.expect)(store.nested.b).to.equal(undefined);
+            expect(store.nested.b).to.equal(undefined);
         });
-        (0, vitest_1.it)("should delete nested properties after they are accessed", () => {
-            (0, vitest_1.expect)(store.nested.b).to.equal(2);
+        it("should delete nested properties after they are accessed", () => {
+            expect(store.nested.b).to.equal(2);
             delete store.nested.b;
-            (0, vitest_1.expect)(store.nested.b).to.equal(undefined);
+            expect(store.nested.b).to.equal(undefined);
         });
-        (0, vitest_1.it)("should delete properties in arrays before they are accessed", () => {
+        it("should delete properties in arrays before they are accessed", () => {
             delete store.array[0];
-            (0, vitest_1.expect)(store.array[0]).to.equal(undefined);
+            expect(store.array[0]).to.equal(undefined);
         });
-        (0, vitest_1.it)("should delete properties in arrays after they are accessed", () => {
-            (0, vitest_1.expect)(store.array[0]).to.equal(3);
+        it("should delete properties in arrays after they are accessed", () => {
+            expect(store.array[0]).to.equal(3);
             delete store.array[0];
-            (0, vitest_1.expect)(store.array[0]).to.equal(undefined);
+            expect(store.array[0]).to.equal(undefined);
         });
     });
-    (0, vitest_1.describe)("ownKeys", () => {
-        (0, vitest_1.it)("should return own properties in objects", () => {
+    describe("ownKeys", () => {
+        it("should return own properties in objects", () => {
             const state = { a: 1, b: 2 };
-            const store = (0, index_1.deepSignal)(state);
+            const store = deepSignal(state);
             let sum = 0;
             for (const property in store) {
                 sum += store[property];
             }
-            (0, vitest_1.expect)(sum).to.equal(3);
+            expect(sum).to.equal(3);
         });
-        (0, vitest_1.it)("should return own properties in arrays", () => {
+        it("should return own properties in arrays", () => {
             const state = [1, 2];
-            const store = (0, index_1.deepSignal)(state);
+            const store = deepSignal(state);
             let sum = 0;
             for (const property of store) {
                 sum += property;
             }
-            (0, vitest_1.expect)(sum).to.equal(3);
+            expect(sum).to.equal(3);
         });
-        (0, vitest_1.it)("should spread objects correctly", () => {
+        it("should spread objects correctly", () => {
             const store2 = { ...store };
-            (0, vitest_1.expect)(store2.a).to.equal(1);
-            (0, vitest_1.expect)(store2.nested.b).to.equal(2);
-            (0, vitest_1.expect)(store2.array[0]).to.equal(3);
-            (0, vitest_1.expect)(typeof store2.array[1] === "object" && store2.array[1].b).to.equal(2);
+            expect(store2.a).to.equal(1);
+            expect(store2.nested.b).to.equal(2);
+            expect(store2.array[0]).to.equal(3);
+            expect(typeof store2.array[1] === "object" && store2.array[1].b).to.equal(2);
         });
-        (0, vitest_1.it)("should spread arrays correctly", () => {
+        it("should spread arrays correctly", () => {
             const array2 = [...store.array];
-            (0, vitest_1.expect)(array2[0]).to.equal(3);
-            (0, vitest_1.expect)(typeof array2[1] === "object" && array2[1].b).to.equal(2);
+            expect(array2[0]).to.equal(3);
+            expect(typeof array2[1] === "object" && array2[1].b).to.equal(2);
         });
     });
-    (0, vitest_1.describe)("computations", () => {
-        (0, vitest_1.it)("should subscribe to values mutated with setters", () => {
-            const store = (0, index_1.deepSignal)({
+    describe("computations", () => {
+        it("should subscribe to values mutated with setters", () => {
+            const store = deepSignal({
                 counter: 1,
                 get double() {
                     return store.counter * 2;
@@ -254,59 +252,59 @@ const __1 = require("../..");
             });
             let counter = 0;
             let double = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 counter = store.counter;
                 double = store.double;
             });
-            (0, vitest_1.expect)(counter).to.equal(1);
-            (0, vitest_1.expect)(double).to.equal(2);
+            expect(counter).to.equal(1);
+            expect(double).to.equal(2);
             store.double = 4;
-            (0, vitest_1.expect)(counter).to.equal(2);
-            (0, vitest_1.expect)(double).to.equal(4);
+            expect(counter).to.equal(2);
+            expect(double).to.equal(4);
         });
-        (0, vitest_1.it)("should subscribe to changes when an item is removed from the array", () => {
-            const store = (0, index_1.deepSignal)([0, 0, 0]);
+        it("should subscribe to changes when an item is removed from the array", () => {
+            const store = deepSignal([0, 0, 0]);
             let sum = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 sum = 0;
                 sum = store.reduce((sum) => sum + 1, 0);
             });
-            (0, vitest_1.expect)(sum).to.equal(3);
+            expect(sum).to.equal(3);
             store.splice(2, 1);
-            (0, vitest_1.expect)(sum).to.equal(2);
+            expect(sum).to.equal(2);
         });
-        (0, vitest_1.it)("should subscribe to changes to for..in loops", () => {
+        it("should subscribe to changes to for..in loops", () => {
             const state = { a: 0, b: 0 };
-            const store = (0, index_1.deepSignal)(state);
+            const store = deepSignal(state);
             let sum = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 sum = 0;
                 for (const _ in store) {
                     sum += 1;
                 }
             });
-            (0, vitest_1.expect)(sum).to.equal(2);
+            expect(sum).to.equal(2);
             store.c = 0;
-            (0, vitest_1.expect)(sum).to.equal(3);
+            expect(sum).to.equal(3);
             delete store.c;
-            (0, vitest_1.expect)(sum).to.equal(2);
+            expect(sum).to.equal(2);
         });
-        (0, vitest_1.it)("should not retrigger effects when unrelated object branches change", () => {
-            const store = (0, index_1.deepSignal)({
+        it("should not retrigger effects when unrelated object branches change", () => {
+            const store = deepSignal({
                 alpha: { value: 1 },
                 beta: { value: 2 },
             });
             let runs = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 runs += 1;
                 store.alpha.value;
             });
-            (0, vitest_1.expect)(runs).to.equal(1);
+            expect(runs).to.equal(1);
             store.beta.value = 3;
-            (0, vitest_1.expect)(runs).to.equal(1);
+            expect(runs).to.equal(1);
         });
-        (0, vitest_1.it)("should not retrigger effects for untouched Set entries", () => {
-            const store = (0, index_1.deepSignal)({
+        it("should not retrigger effects for untouched Set entries", () => {
+            const store = deepSignal({
                 set: new Set([
                     { id: "a", data: { value: 1 } },
                     { id: "b", data: { value: 2 } },
@@ -317,201 +315,201 @@ const __1 = require("../..");
             });
             const [entryA, entryB] = Array.from(store.set);
             let runs = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 runs += 1;
                 entryA.data.value;
             });
-            (0, vitest_1.expect)(runs).to.equal(1);
+            expect(runs).to.equal(1);
             entryB.data.value = 5;
-            (0, vitest_1.expect)(runs).to.equal(1);
+            expect(runs).to.equal(1);
         });
-        (0, vitest_1.it)("should subscribe to array iteration via Symbol.iterator", () => {
-            const store = (0, index_1.deepSignal)([1, 2]);
+        it("should subscribe to array iteration via Symbol.iterator", () => {
+            const store = deepSignal([1, 2]);
             let total = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 total = 0;
                 for (const value of store) {
                     total += value;
                 }
             });
-            (0, vitest_1.expect)(total).to.equal(3);
+            expect(total).to.equal(3);
             store.push(3);
-            (0, vitest_1.expect)(total).to.equal(6);
+            expect(total).to.equal(6);
         });
-        (0, vitest_1.it)("should subscribe to Set iteration via Symbol.iterator", () => {
-            const store = (0, index_1.deepSignal)({ set: new Set([1, 2]) });
+        it("should subscribe to Set iteration via Symbol.iterator", () => {
+            const store = deepSignal({ set: new Set([1, 2]) });
             let total = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 total = 0;
                 for (const value of store.set) {
                     total += value;
                 }
             });
-            (0, vitest_1.expect)(total).to.equal(3);
+            expect(total).to.equal(3);
             store.set.add(3);
-            (0, vitest_1.expect)(total).to.equal(6);
+            expect(total).to.equal(6);
             store.set.delete(1);
-            (0, vitest_1.expect)(total).to.equal(5);
+            expect(total).to.equal(5);
         });
-        (0, vitest_1.it)("should subscribe when using Set iterator helper chains", () => {
-            const store = (0, index_1.deepSignal)({ set: new Set([1]) });
+        it("should subscribe when using Set iterator helper chains", () => {
+            const store = deepSignal({ set: new Set([1]) });
             let reduced = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 reduced = store.set
                     .map((value) => value)
                     .reduce((acc, value) => acc + value, 0);
             });
-            (0, vitest_1.expect)(reduced).to.equal(1);
+            expect(reduced).to.equal(1);
             store.set.add(2);
-            (0, vitest_1.expect)(reduced).to.equal(3);
+            expect(reduced).to.equal(3);
             store.set.delete(1);
-            (0, vitest_1.expect)(reduced).to.equal(2);
+            expect(reduced).to.equal(2);
         });
-        (0, vitest_1.it)("should subscribe to changes for Object.getOwnPropertyNames()", () => {
+        it("should subscribe to changes for Object.getOwnPropertyNames()", () => {
             const state = { a: 1, b: 2 };
-            const store = (0, index_1.deepSignal)(state);
+            const store = deepSignal(state);
             let sum = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 sum = 0;
                 const keys = Object.getOwnPropertyNames(store);
                 for (const _ of keys) {
                     sum += 1;
                 }
             });
-            (0, vitest_1.expect)(sum).to.equal(2);
+            expect(sum).to.equal(2);
             store.c = 0;
-            (0, vitest_1.expect)(sum).to.equal(3);
+            expect(sum).to.equal(3);
             delete store.a;
-            (0, vitest_1.expect)(sum).to.equal(2);
+            expect(sum).to.equal(2);
         });
-        (0, vitest_1.it)("should subscribe to changes to Object.keys/values/entries()", () => {
+        it("should subscribe to changes to Object.keys/values/entries()", () => {
             const state = { a: 1, b: 2 };
-            const store = (0, index_1.deepSignal)(state);
+            const store = deepSignal(state);
             let keys = 0;
             let values = 0;
             let entries = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 keys = 0;
                 Object.keys(store).forEach(() => (keys += 1));
             });
-            (0, __1.effect)(() => {
+            effect(() => {
                 values = 0;
                 Object.values(store).forEach(() => (values += 1));
             });
-            (0, __1.effect)(() => {
+            effect(() => {
                 entries = 0;
                 Object.entries(store).forEach(() => (entries += 1));
             });
-            (0, vitest_1.expect)(keys).to.equal(2);
-            (0, vitest_1.expect)(values).to.equal(2);
-            (0, vitest_1.expect)(entries).to.equal(2);
+            expect(keys).to.equal(2);
+            expect(values).to.equal(2);
+            expect(entries).to.equal(2);
             store.c = 0;
-            (0, vitest_1.expect)(keys).to.equal(3);
-            (0, vitest_1.expect)(values).to.equal(3);
-            (0, vitest_1.expect)(entries).to.equal(3);
+            expect(keys).to.equal(3);
+            expect(values).to.equal(3);
+            expect(entries).to.equal(3);
             delete store.a;
-            (0, vitest_1.expect)(keys).to.equal(2);
-            (0, vitest_1.expect)(values).to.equal(2);
-            (0, vitest_1.expect)(entries).to.equal(2);
+            expect(keys).to.equal(2);
+            expect(values).to.equal(2);
+            expect(entries).to.equal(2);
         });
-        (0, vitest_1.it)("should subscribe to changes to for..of loops", () => {
-            const store = (0, index_1.deepSignal)([0, 0]);
+        it("should subscribe to changes to for..of loops", () => {
+            const store = deepSignal([0, 0]);
             let sum = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 sum = 0;
                 for (const _ of store) {
                     sum += 1;
                 }
             });
-            (0, vitest_1.expect)(sum).to.equal(2);
+            expect(sum).to.equal(2);
             store.push(0);
-            (0, vitest_1.expect)(sum).to.equal(3);
+            expect(sum).to.equal(3);
             store.splice(0, 1);
-            (0, vitest_1.expect)(sum).to.equal(2);
+            expect(sum).to.equal(2);
         });
-        (0, vitest_1.it)("should subscribe to implicit changes in array items", () => {
-            const store = (0, index_1.deepSignal)(["foo", "bar"]);
+        it("should subscribe to implicit changes in array items", () => {
+            const store = deepSignal(["foo", "bar"]);
             let x = "";
-            (0, __1.effect)(() => {
+            effect(() => {
                 x = store.join(" ");
             });
-            (0, vitest_1.expect)(x).to.equal("foo bar");
+            expect(x).to.equal("foo bar");
             store.push("baz");
-            (0, vitest_1.expect)(x).to.equal("foo bar baz");
+            expect(x).to.equal("foo bar baz");
             store.splice(0, 1);
-            (0, vitest_1.expect)(x).to.equal("bar baz");
+            expect(x).to.equal("bar baz");
             store.splice(1, 1, "bam");
-            (0, vitest_1.expect)(x).to.equal("bar bam");
+            expect(x).to.equal("bar bam");
         });
-        (0, vitest_1.it)("should subscribe to changes when deleting properties", () => {
+        it("should subscribe to changes when deleting properties", () => {
             let x, y;
-            (0, __1.effect)(() => {
+            effect(() => {
                 x = store.a;
             });
-            (0, __1.effect)(() => {
+            effect(() => {
                 y = store.nested.b;
             });
-            (0, vitest_1.expect)(x).to.equal(1);
+            expect(x).to.equal(1);
             delete store.a;
-            (0, vitest_1.expect)(x).to.equal(undefined);
-            (0, vitest_1.expect)(y).to.equal(2);
+            expect(x).to.equal(undefined);
+            expect(y).to.equal(2);
             delete store.nested.b;
-            (0, vitest_1.expect)(y).to.equal(undefined);
+            expect(y).to.equal(undefined);
         });
-        (0, vitest_1.it)("should subscribe to changes when mutating objects", () => {
+        it("should subscribe to changes when mutating objects", () => {
             let x, y;
-            const store = (0, index_1.deepSignal)({
+            const store = deepSignal({
                 b: [
                     { id: 1, nested: { id: 1 } },
                     { id: 2, nested: { id: 2 } },
                 ],
             });
-            (0, __1.effect)(() => {
+            effect(() => {
                 x = store.a?.id;
             });
-            (0, __1.effect)(() => {
+            effect(() => {
                 y = store.a?.nested.id;
             });
-            (0, vitest_1.expect)(x).to.equal(undefined);
-            (0, vitest_1.expect)(y).to.equal(undefined);
+            expect(x).to.equal(undefined);
+            expect(y).to.equal(undefined);
             store.a = store.b[0];
-            (0, vitest_1.expect)(x).to.equal(1);
-            (0, vitest_1.expect)(y).to.equal(1);
+            expect(x).to.equal(1);
+            expect(y).to.equal(1);
             store.a = store.b[1];
-            (0, vitest_1.expect)(x).to.equal(2);
-            (0, vitest_1.expect)(y).to.equal(2);
+            expect(x).to.equal(2);
+            expect(y).to.equal(2);
             store.a = undefined;
-            (0, vitest_1.expect)(x).to.equal(undefined);
-            (0, vitest_1.expect)(y).to.equal(undefined);
+            expect(x).to.equal(undefined);
+            expect(y).to.equal(undefined);
             store.a = store.b[1];
-            (0, vitest_1.expect)(x).to.equal(2);
-            (0, vitest_1.expect)(y).to.equal(2);
+            expect(x).to.equal(2);
+            expect(y).to.equal(2);
         });
-        (0, vitest_1.it)("should trigger effects after mutations happen", () => {
+        it("should trigger effects after mutations happen", () => {
             let x;
-            (0, __1.effect)(() => {
+            effect(() => {
                 x = store.a;
             });
-            (0, vitest_1.expect)(x).to.equal(1);
+            expect(x).to.equal(1);
             store.a = 11;
-            (0, vitest_1.expect)(x).to.equal(11);
+            expect(x).to.equal(11);
         });
-        (0, vitest_1.it)("should subscribe corretcly from getters", () => {
+        it("should subscribe corretcly from getters", () => {
             let x;
-            const store = (0, index_1.deepSignal)({
+            const store = deepSignal({
                 counter: 1,
                 get double() {
                     return store.counter * 2;
                 },
             });
-            (0, __1.effect)(() => (x = store.double));
-            (0, vitest_1.expect)(x).to.equal(2);
+            effect(() => (x = store.double));
+            expect(x).to.equal(2);
             store.counter = 2;
-            (0, vitest_1.expect)(x).to.equal(4);
+            expect(x).to.equal(4);
         });
-        (0, vitest_1.it)("should subscribe corretcly from getters returning other parts of the store", () => {
+        it("should subscribe corretcly from getters returning other parts of the store", () => {
             let data;
-            const store = (0, index_1.deepSignal)({
+            const store = deepSignal({
                 switch: "a",
                 a: { data: "a" },
                 b: { data: "b" },
@@ -519,33 +517,33 @@ const __1 = require("../..");
                     return store.switch === "a" ? store.a : store.b;
                 },
             });
-            (0, __1.effect)(() => (data = store.aOrB.data));
-            (0, vitest_1.expect)(data).to.equal("a");
+            effect(() => (data = store.aOrB.data));
+            expect(data).to.equal("a");
             store.switch = "b";
-            (0, vitest_1.expect)(data).to.equal("b");
+            expect(data).to.equal("b");
         });
-        (0, vitest_1.it)("should be able to reset values with Object.assign and still react to changes", () => {
+        it("should be able to reset values with Object.assign and still react to changes", () => {
             const initialNested = { ...nested };
             const initialState = { ...state, nested: initialNested };
             let a, b;
-            (0, __1.effect)(() => {
+            effect(() => {
                 a = store.a;
             });
-            (0, __1.effect)(() => {
+            effect(() => {
                 b = store.nested.b;
             });
             store.a = 2;
             store.nested.b = 3;
-            (0, vitest_1.expect)(a).to.equal(2);
-            (0, vitest_1.expect)(b).to.equal(3);
+            expect(a).to.equal(2);
+            expect(b).to.equal(3);
             Object.assign(store, initialState);
-            (0, vitest_1.expect)(a).to.equal(1);
-            (0, vitest_1.expect)(b).to.equal(2);
+            expect(a).to.equal(1);
+            expect(b).to.equal(2);
         });
     });
-    (0, vitest_1.describe)("refs", () => {
-        (0, vitest_1.it)("should change if children changed when replaceProxiesInBranchOnChange", async () => {
-            const signalObj = (0, index_1.deepSignal)({
+    describe("refs", () => {
+        it("should change if children changed when replaceProxiesInBranchOnChange", async () => {
+            const signalObj = deepSignal({
                 primitive: 1,
                 nestedObject: { primitive: 2 },
                 nestedSetOfPrimitives: new Set([1, 2, "three"]),
@@ -570,251 +568,251 @@ const __1 = require("../..");
             let [naoo1, naoo2] = signalObj.nestedArrayOfObjects;
             // Mutate root primitive - should not affect nested proxies
             signalObj.primitive = 2;
-            (0, vitest_1.expect)(signalObj.nestedObject).toBe(no);
-            (0, vitest_1.expect)(signalObj.nestedObject.primitive).toBe(nop);
-            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).toBe(nsop);
-            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).toBe(nsoo);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).toBe(naop);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).toBe(naoo);
+            expect(signalObj.nestedObject).toBe(no);
+            expect(signalObj.nestedObject.primitive).toBe(nop);
+            expect(signalObj.nestedSetOfPrimitives).toBe(nsop);
+            expect(signalObj.nestedSetOfObjects).toBe(nsoo);
+            expect(signalObj.nestedArrayOfPrimitives).toBe(naop);
+            expect(signalObj.nestedArrayOfObjects).toBe(naoo);
             // Mutate nested object primitive - should replace nestedObject proxy
             signalObj.nestedObject.primitive = 3;
-            (0, vitest_1.expect)(signalObj.nestedObject.primitive).toBe(3);
-            (0, vitest_1.expect)(signalObj.nestedObject).not.toBe(no);
+            expect(signalObj.nestedObject.primitive).toBe(3);
+            expect(signalObj.nestedObject).not.toBe(no);
             no = signalObj.nestedObject;
             // Unrelated proxies should remain the same
-            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).toBe(nsop);
-            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).toBe(nsoo);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).toBe(naop);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).toBe(naoo);
+            expect(signalObj.nestedSetOfPrimitives).toBe(nsop);
+            expect(signalObj.nestedSetOfObjects).toBe(nsoo);
+            expect(signalObj.nestedArrayOfPrimitives).toBe(naop);
+            expect(signalObj.nestedArrayOfObjects).toBe(naoo);
             // Mutate Set of primitives - should replace the Set proxy
             signalObj.nestedSetOfPrimitives.add(4);
-            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).not.toBe(nsop);
+            expect(signalObj.nestedSetOfPrimitives).not.toBe(nsop);
             nsop = signalObj.nestedSetOfPrimitives;
-            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives.has(4)).toBe(true);
+            expect(signalObj.nestedSetOfPrimitives.has(4)).toBe(true);
             // Unrelated proxies should remain the same
-            (0, vitest_1.expect)(signalObj.nestedObject).toBe(no);
-            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).toBe(nsoo);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).toBe(naop);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).toBe(naoo);
+            expect(signalObj.nestedObject).toBe(no);
+            expect(signalObj.nestedSetOfObjects).toBe(nsoo);
+            expect(signalObj.nestedArrayOfPrimitives).toBe(naop);
+            expect(signalObj.nestedArrayOfObjects).toBe(naoo);
             // Mutate object inside Set - should replace Set proxy and the object proxy
             nsoo1.primitive = false;
-            (0, vitest_1.expect)([...signalObj.nestedSetOfObjects][1]).toBe(nsoo2);
-            (0, vitest_1.expect)([...signalObj.nestedSetOfObjects][0]).not.toBe(nsoo1);
-            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).not.toBe(nsoo);
+            expect([...signalObj.nestedSetOfObjects][1]).toBe(nsoo2);
+            expect([...signalObj.nestedSetOfObjects][0]).not.toBe(nsoo1);
+            expect(signalObj.nestedSetOfObjects).not.toBe(nsoo);
             nsoo = signalObj.nestedSetOfObjects;
             [nsoo1, nsoo2] = [...signalObj.nestedSetOfObjects];
             // Unrelated proxies should remain the same
-            (0, vitest_1.expect)(signalObj.nestedObject).toBe(no);
-            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).toBe(nsop);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).toBe(naop);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).toBe(naoo);
+            expect(signalObj.nestedObject).toBe(no);
+            expect(signalObj.nestedSetOfPrimitives).toBe(nsop);
+            expect(signalObj.nestedArrayOfPrimitives).toBe(naop);
+            expect(signalObj.nestedArrayOfObjects).toBe(naoo);
             // Mutate array of primitives - should replace the array proxy
             signalObj.nestedArrayOfPrimitives.push(4);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).not.toBe(naop);
+            expect(signalObj.nestedArrayOfPrimitives).not.toBe(naop);
             naop = signalObj.nestedArrayOfPrimitives;
-            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives.length).toBe(4);
+            expect(signalObj.nestedArrayOfPrimitives.length).toBe(4);
             // Unrelated proxies should remain the same
-            (0, vitest_1.expect)(signalObj.nestedObject).toBe(no);
-            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).toBe(nsop);
-            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).toBe(nsoo);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).toBe(naoo);
+            expect(signalObj.nestedObject).toBe(no);
+            expect(signalObj.nestedSetOfPrimitives).toBe(nsop);
+            expect(signalObj.nestedSetOfObjects).toBe(nsoo);
+            expect(signalObj.nestedArrayOfObjects).toBe(naoo);
             // Mutate object inside array - should replace array proxy and the object proxy
             naoo1.primitive = false;
-            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects[0]).not.toBe(naoo1);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects[1]).toBe(naoo2);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).not.toBe(naoo);
+            expect(signalObj.nestedArrayOfObjects[0]).not.toBe(naoo1);
+            expect(signalObj.nestedArrayOfObjects[1]).toBe(naoo2);
+            expect(signalObj.nestedArrayOfObjects).not.toBe(naoo);
             naoo = signalObj.nestedArrayOfObjects;
             [naoo1, naoo2] = signalObj.nestedArrayOfObjects;
             // Unrelated proxies should remain the same
-            (0, vitest_1.expect)(signalObj.nestedObject).toBe(no);
-            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).toBe(nsop);
-            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).toBe(nsoo);
-            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).toBe(naop);
+            expect(signalObj.nestedObject).toBe(no);
+            expect(signalObj.nestedSetOfPrimitives).toBe(nsop);
+            expect(signalObj.nestedSetOfObjects).toBe(nsoo);
+            expect(signalObj.nestedArrayOfPrimitives).toBe(naop);
         });
-        (0, vitest_1.it)("should return the same proxy if initialized more than once", () => {
+        it("should return the same proxy if initialized more than once", () => {
             const state = {};
-            const store1 = (0, index_1.deepSignal)(state);
-            const store2 = (0, index_1.deepSignal)(state);
-            (0, vitest_1.expect)(store1).to.equal(store2);
+            const store1 = deepSignal(state);
+            const store2 = deepSignal(state);
+            expect(store1).to.equal(store2);
         });
     });
-    (0, vitest_1.describe)("unsupported data structures", () => {
-        (0, vitest_1.it)("should throw when trying to deepsignal a class instance", () => {
+    describe("unsupported data structures", () => {
+        it("should throw when trying to deepsignal a class instance", () => {
             class MyClass {
             }
             const obj = new MyClass();
-            (0, vitest_1.expect)(() => (0, index_1.deepSignal)(obj)).to.throw();
+            expect(() => deepSignal(obj)).to.throw();
         });
-        (0, vitest_1.it)("should not wrap a class instance", () => {
+        it("should not wrap a class instance", () => {
             class MyClass {
             }
             const obj = new MyClass();
-            const store = (0, index_1.deepSignal)({ obj });
-            (0, vitest_1.expect)(store.obj).to.equal(obj);
+            const store = deepSignal({ obj });
+            expect(store.obj).to.equal(obj);
         });
-        (0, vitest_1.it)("should not wrap built-ins in proxies", () => {
+        it("should not wrap built-ins in proxies", () => {
             window.MyClass = class MyClass {
             };
             const obj = new window.MyClass();
-            const store = (0, index_1.deepSignal)({ obj });
-            (0, vitest_1.expect)(store.obj).to.equal(obj);
+            const store = deepSignal({ obj });
+            expect(store.obj).to.equal(obj);
         });
         // it("should not wrap elements in proxies", () => {
         // 	const el = window.document.createElement("div");
         // 	const store = deepSignal({ el });
         // 	expect(store.el).to.equal(el);
         // });
-        (0, vitest_1.it)("should wrap global objects", () => {
+        it("should wrap global objects", () => {
             window.obj = { b: 2 };
-            const store = (0, index_1.deepSignal)(window.obj);
-            (0, vitest_1.expect)(store).to.not.equal(window.obj);
-            (0, vitest_1.expect)(store).to.deep.equal({ b: 2 });
-            (0, vitest_1.expect)(store.b).to.equal(2);
+            const store = deepSignal(window.obj);
+            expect(store).to.not.equal(window.obj);
+            expect(store).to.deep.equal({ b: 2 });
+            expect(store.b).to.equal(2);
         });
-        (0, vitest_1.it)("should not wrap dates", () => {
+        it("should not wrap dates", () => {
             const date = new Date();
-            const store = (0, index_1.deepSignal)({ date });
-            (0, vitest_1.expect)(store.date).to.equal(date);
+            const store = deepSignal({ date });
+            expect(store.date).to.equal(date);
         });
-        (0, vitest_1.it)("should not wrap regular expressions", () => {
+        it("should not wrap regular expressions", () => {
             const regex = new RegExp("");
-            const store = (0, index_1.deepSignal)({ regex });
-            (0, vitest_1.expect)(store.regex).to.equal(regex);
+            const store = deepSignal({ regex });
+            expect(store.regex).to.equal(regex);
         });
-        (0, vitest_1.it)("should not wrap Map", () => {
+        it("should not wrap Map", () => {
             const map = new Map();
-            const store = (0, index_1.deepSignal)({ map });
-            (0, vitest_1.expect)(store.map).to.equal(map);
+            const store = deepSignal({ map });
+            expect(store.map).to.equal(map);
         });
-        (0, vitest_1.it)("should wrap Set and emit patches on structural changes", () => {
+        it("should wrap Set and emit patches on structural changes", () => {
             const set = new Set([1]);
-            const store = (0, index_1.deepSignal)({ set });
+            const store = deepSignal({ set });
             // The Set itself should be proxied (different reference)
-            (0, vitest_1.expect)(store.set).to.not.equal(set);
+            expect(store.set).to.not.equal(set);
             // Size observable via manual mutation + patch emission (indirectly validated in watchPatches Set test)
             store.set.add(2);
             store.set.delete(1);
-            (0, vitest_1.expect)(store.set.has(2)).to.equal(true);
+            expect(store.set.has(2)).to.equal(true);
         });
-        (0, vitest_1.it)("should expose reactive Set size without throwing", () => {
-            const store = (0, index_1.deepSignal)({ set: new Set([1, 2]) });
+        it("should expose reactive Set size without throwing", () => {
+            const store = deepSignal({ set: new Set([1, 2]) });
             let size = 0;
-            (0, __1.effect)(() => {
+            effect(() => {
                 size = store.set.size;
             });
-            (0, vitest_1.expect)(store.set.size).to.equal(2);
-            (0, vitest_1.expect)(size).to.equal(2);
+            expect(store.set.size).to.equal(2);
+            expect(size).to.equal(2);
             store.set.add(3);
-            (0, vitest_1.expect)(store.set.size).to.equal(3);
-            (0, vitest_1.expect)(size).to.equal(3);
+            expect(store.set.size).to.equal(3);
+            expect(size).to.equal(3);
             store.set.delete(1);
-            (0, vitest_1.expect)(store.set.size).to.equal(2);
-            (0, vitest_1.expect)(size).to.equal(2);
+            expect(store.set.size).to.equal(2);
+            expect(size).to.equal(2);
         });
     });
-    (0, vitest_1.describe)("symbols", () => {
-        (0, vitest_1.it)("should observe symbols", () => {
+    describe("symbols", () => {
+        it("should observe symbols", () => {
             const key = Symbol("key");
             let x;
-            const store = (0, index_1.deepSignal)({});
-            (0, __1.effect)(() => (x = store[key]));
-            (0, vitest_1.expect)(store[key]).to.equal(undefined);
-            (0, vitest_1.expect)(x).to.equal(undefined);
+            const store = deepSignal({});
+            effect(() => (x = store[key]));
+            expect(store[key]).to.equal(undefined);
+            expect(x).to.equal(undefined);
             store[key] = true;
-            (0, vitest_1.expect)(store[key]).to.equal(true);
-            (0, vitest_1.expect)(x).to.equal(true);
+            expect(store[key]).to.equal(true);
+            expect(x).to.equal(true);
         });
-        (0, vitest_1.it)("should not observe well-known symbols", () => {
+        it("should not observe well-known symbols", () => {
             const key = Symbol.isConcatSpreadable;
             let x;
-            const state = (0, index_1.deepSignal)({});
-            (0, __1.effect)(() => (x = state[key]));
-            (0, vitest_1.expect)(state[key]).to.equal(undefined);
-            (0, vitest_1.expect)(x).to.equal(undefined);
+            const state = deepSignal({});
+            effect(() => (x = state[key]));
+            expect(state[key]).to.equal(undefined);
+            expect(x).to.equal(undefined);
             state[key] = true;
-            (0, vitest_1.expect)(state[key]).to.equal(true);
-            (0, vitest_1.expect)(x).to.equal(undefined);
+            expect(state[key]).to.equal(true);
+            expect(x).to.equal(undefined);
         });
-        (0, vitest_1.it)("access well-known symbol property returns raw value and not a signal", () => {
+        it("access well-known symbol property returns raw value and not a signal", () => {
             const tag = Symbol.toStringTag;
-            const ds = (0, index_1.deepSignal)({ [tag]: "Custom", x: 1 });
+            const ds = deepSignal({ [tag]: "Custom", x: 1 });
             const val = ds[tag];
-            (0, vitest_1.expect)(val).toBe("Custom");
+            expect(val).toBe("Custom");
         });
-        (0, vitest_1.it)("access Set Symbol.iterator.toString() key path (skip branch)", () => {
-            const ds = (0, index_1.deepSignal)({ set: new Set([1]) });
+        it("access Set Symbol.iterator.toString() key path (skip branch)", () => {
+            const ds = deepSignal({ set: new Set([1]) });
             const iterKey = Symbol.iterator.toString(); // 'Symbol(Symbol.iterator)'
             // Accessing this string property triggers skip branch (no special handling needed)
             const maybe = ds.set[iterKey];
             // underlying Set likely has undefined for that string key
-            (0, vitest_1.expect)(maybe).toBeUndefined();
+            expect(maybe).toBeUndefined();
         });
     });
-    (0, vitest_1.describe)("shallow", () => {
-        (0, vitest_1.it)("should not proxy shallow objects", () => {
+    describe("shallow", () => {
+        it("should not proxy shallow objects", () => {
             const shallowObj1 = { a: 1 };
             let shallowObj2 = { b: 2 };
             const deepObj = { c: 3 };
-            shallowObj2 = (0, index_1.shallow)(shallowObj2);
-            const store = (0, index_1.deepSignal)({
-                shallowObj1: (0, index_1.shallow)(shallowObj1),
+            shallowObj2 = shallow(shallowObj2);
+            const store = deepSignal({
+                shallowObj1: shallow(shallowObj1),
                 shallowObj2,
                 deepObj,
             });
-            (0, vitest_1.expect)(store.shallowObj1.a).to.equal(1);
-            (0, vitest_1.expect)(store.shallowObj2.b).to.equal(2);
-            (0, vitest_1.expect)(store.deepObj.c).to.equal(3);
-            (0, vitest_1.expect)(store.shallowObj1).to.equal(shallowObj1);
-            (0, vitest_1.expect)(store.shallowObj2).to.equal(shallowObj2);
-            (0, vitest_1.expect)(store.deepObj).to.not.equal(deepObj);
+            expect(store.shallowObj1.a).to.equal(1);
+            expect(store.shallowObj2.b).to.equal(2);
+            expect(store.deepObj.c).to.equal(3);
+            expect(store.shallowObj1).to.equal(shallowObj1);
+            expect(store.shallowObj2).to.equal(shallowObj2);
+            expect(store.deepObj).to.not.equal(deepObj);
         });
-        (0, vitest_1.it)("should not proxy shallow objects if shallow is called on the reference before accessing the property", () => {
+        it("should not proxy shallow objects if shallow is called on the reference before accessing the property", () => {
             const shallowObj = { a: 1 };
             const deepObj = { c: 3 };
-            const store = (0, index_1.deepSignal)({ shallowObj, deepObj });
-            (0, index_1.shallow)(shallowObj);
-            (0, vitest_1.expect)(store.shallowObj.a).to.equal(1);
-            (0, vitest_1.expect)(store.deepObj.c).to.equal(3);
-            (0, vitest_1.expect)(store.shallowObj).to.equal(shallowObj);
-            (0, vitest_1.expect)(store.deepObj).to.not.equal(deepObj);
-        });
-        (0, vitest_1.it)("should observe changes in the shallow object if the reference changes", () => {
+            const store = deepSignal({ shallowObj, deepObj });
+            shallow(shallowObj);
+            expect(store.shallowObj.a).to.equal(1);
+            expect(store.deepObj.c).to.equal(3);
+            expect(store.shallowObj).to.equal(shallowObj);
+            expect(store.deepObj).to.not.equal(deepObj);
+        });
+        it("should observe changes in the shallow object if the reference changes", () => {
             const obj = { a: 1 };
-            const shallowObj = (0, index_1.shallow)(obj);
-            const store = (0, index_1.deepSignal)({ shallowObj });
+            const shallowObj = shallow(obj);
+            const store = deepSignal({ shallowObj });
             let x;
-            (0, __1.effect)(() => {
+            effect(() => {
                 x = store.shallowObj.a;
             });
-            (0, vitest_1.expect)(x).to.equal(1);
-            store.shallowObj = (0, index_1.shallow)({ a: 2 });
-            (0, vitest_1.expect)(x).to.equal(2);
+            expect(x).to.equal(1);
+            store.shallowObj = shallow({ a: 2 });
+            expect(x).to.equal(2);
         });
-        (0, vitest_1.it)("should stop observing changes in the shallow object if the reference changes and it's not shallow anymore", () => {
+        it("should stop observing changes in the shallow object if the reference changes and it's not shallow anymore", () => {
             const obj = { a: 1 };
-            const shallowObj = (0, index_1.shallow)(obj);
-            const store = (0, index_1.deepSignal)({ obj: shallowObj });
+            const shallowObj = shallow(obj);
+            const store = deepSignal({ obj: shallowObj });
             let x;
-            (0, __1.effect)(() => {
+            effect(() => {
                 x = store.obj.a;
             });
-            (0, vitest_1.expect)(x).to.equal(1);
+            expect(x).to.equal(1);
             store.obj = { a: 2 };
-            (0, vitest_1.expect)(x).to.equal(2);
+            expect(x).to.equal(2);
             store.obj.a = 3;
-            (0, vitest_1.expect)(x).to.equal(3);
+            expect(x).to.equal(3);
         });
-        (0, vitest_1.it)("should not observe changes in the props of the shallow object", () => {
+        it("should not observe changes in the props of the shallow object", () => {
             const obj = { a: 1 };
-            const shallowObj = (0, index_1.shallow)(obj);
-            const store = (0, index_1.deepSignal)({ shallowObj });
+            const shallowObj = shallow(obj);
+            const store = deepSignal({ shallowObj });
             let x;
-            (0, __1.effect)(() => {
+            effect(() => {
                 x = store.shallowObj.a;
             });
-            (0, vitest_1.expect)(x).to.equal(1);
+            expect(x).to.equal(1);
             store.shallowObj.a = 2;
-            (0, vitest_1.expect)(x).to.equal(1);
+            expect(x).to.equal(1);
         });
     });
 });