@stackframe/stack-shared 2.7.19 → 2.7.21

package/dist/utils/compile-time.js

@@ -6,3 +6,20 @@
 export function scrambleDuringCompileTime(t) {
     return t;
 }
+import.meta.vitest?.test("scrambleDuringCompileTime", ({ expect }) => {
+    // Test with primitive values
+    expect(scrambleDuringCompileTime(42)).toBe(42);
+    expect(scrambleDuringCompileTime("hello")).toBe("hello");
+    expect(scrambleDuringCompileTime(true)).toBe(true);
+    expect(scrambleDuringCompileTime(null)).toBe(null);
+    expect(scrambleDuringCompileTime(undefined)).toBe(undefined);
+    // Test with objects (reference equality)
+    const obj = { a: 1 };
+    expect(scrambleDuringCompileTime(obj)).toBe(obj);
+    // Test with arrays (reference equality)
+    const arr = [1, 2, 3];
+    expect(scrambleDuringCompileTime(arr)).toBe(arr);
+    // Test with functions (reference equality)
+    const fn = () => "test";
+    expect(scrambleDuringCompileTime(fn)).toBe(fn);
+});

package/dist/utils/dates.js

@@ -2,6 +2,16 @@ import { remainder } from "./math";
 export function isWeekend(date) {
     return date.getDay() === 0 || date.getDay() === 6;
 }
+import.meta.vitest?.test("isWeekend", ({ expect }) => {
+    // Sunday (day 0)
+    expect(isWeekend(new Date(2023, 0, 1))).toBe(true);
+    // Saturday (day 6)
+    expect(isWeekend(new Date(2023, 0, 7))).toBe(true);
+    // Monday (day 1)
+    expect(isWeekend(new Date(2023, 0, 2))).toBe(false);
+    // Friday (day 5)
+    expect(isWeekend(new Date(2023, 0, 6))).toBe(false);
+});
 const agoUnits = [
     [60, 'second'],
     [60, 'minute'],
@@ -12,6 +22,29 @@ const agoUnits = [
 export function fromNow(date) {
     return fromNowDetailed(date).result;
 }
+import.meta.vitest?.test("fromNow", ({ expect }) => {
+    // Set a fixed date for testing
+    const fixedDate = new Date("2023-01-15T12:00:00.000Z");
+    // Use Vitest's fake timers
+    import.meta.vitest?.vi.useFakeTimers();
+    import.meta.vitest?.vi.setSystemTime(fixedDate);
+    // Test past times
+    expect(fromNow(new Date("2023-01-15T11:59:50.000Z"))).toBe("just now");
+    expect(fromNow(new Date("2023-01-15T11:59:00.000Z"))).toBe("1 minute ago");
+    expect(fromNow(new Date("2023-01-15T11:00:00.000Z"))).toBe("1 hour ago");
+    expect(fromNow(new Date("2023-01-14T12:00:00.000Z"))).toBe("1 day ago");
+    expect(fromNow(new Date("2023-01-08T12:00:00.000Z"))).toBe("1 week ago");
+    // Test future times
+    expect(fromNow(new Date("2023-01-15T12:00:10.000Z"))).toBe("just now");
+    expect(fromNow(new Date("2023-01-15T12:01:00.000Z"))).toBe("in 1 minute");
+    expect(fromNow(new Date("2023-01-15T13:00:00.000Z"))).toBe("in 1 hour");
+    expect(fromNow(new Date("2023-01-16T12:00:00.000Z"))).toBe("in 1 day");
+    expect(fromNow(new Date("2023-01-22T12:00:00.000Z"))).toBe("in 1 week");
+    // Test very old dates (should use date format)
+    expect(fromNow(new Date("2022-01-15T12:00:00.000Z"))).toMatch(/Jan 15, 2022/);
+    // Restore real timers
+    import.meta.vitest?.vi.useRealTimers();
+});
 export function fromNowDetailed(date) {
     if (!(date instanceof Date)) {
         throw new Error(`fromNow only accepts Date objects (received: ${date})`);
@@ -58,3 +91,24 @@ export function getInputDatetimeLocalString(date) {
     date.setMinutes(date.getMinutes() - date.getTimezoneOffset());
     return date.toISOString().slice(0, 19);
 }
+import.meta.vitest?.test("getInputDatetimeLocalString", ({ expect }) => {
+    // Use Vitest's fake timers to ensure consistent timezone behavior
+    import.meta.vitest?.vi.useFakeTimers();
+    // Test with a specific date
+    const mockDate = new Date("2023-01-15T12:30:45.000Z");
+    const result = getInputDatetimeLocalString(mockDate);
+    // The result should be in the format YYYY-MM-DDTHH:MM:SS
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/);
+    // Test with different dates
+    const dates = [
+        new Date("2023-01-01T00:00:00.000Z"),
+        new Date("2023-06-15T23:59:59.000Z"),
+        new Date("2023-12-31T12:34:56.000Z"),
+    ];
+    for (const date of dates) {
+        const result = getInputDatetimeLocalString(date);
+        expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/);
+    }
+    // Restore real timers
+    import.meta.vitest?.vi.useRealTimers();
+});

package/dist/utils/functions.js

@@ -1,6 +1,21 @@
 export function identity(t) {
     return t;
 }
+import.meta.vitest?.test("identity", ({ expect }) => {
+    expect(identity(1)).toBe(1);
+    expect(identity("test")).toBe("test");
+    expect(identity(null)).toBe(null);
+    expect(identity(undefined)).toBe(undefined);
+    const obj = { a: 1 };
+    expect(identity(obj)).toBe(obj);
+});
 export function identityArgs(...args) {
     return args;
 }
+import.meta.vitest?.test("identityArgs", ({ expect }) => {
+    expect(identityArgs()).toEqual([]);
+    expect(identityArgs(1)).toEqual([1]);
+    expect(identityArgs(1, 2, 3)).toEqual([1, 2, 3]);
+    expect(identityArgs("a", "b", "c")).toEqual(["a", "b", "c"]);
+    expect(identityArgs(null, undefined)).toEqual([null, undefined]);
+});

package/dist/utils/html.js

@@ -7,6 +7,34 @@ export function escapeHtml(unsafe) {
         .replace(/"/g, """)
         .replace(/'/g, "'");
 }
+import.meta.vitest?.test("escapeHtml", ({ expect }) => {
+    // Test with empty string
+    expect(escapeHtml("")).toBe("");
+    // Test with string without special characters
+    expect(escapeHtml("hello world")).toBe("hello world");
+    // Test with special characters
+    expect(escapeHtml("<div>")).toBe("&lt;div&gt;");
+    expect(escapeHtml("a & b")).toBe("a &amp; b");
+    expect(escapeHtml('a "quoted" string')).toBe("a &quot;quoted&quot; string");
+    expect(escapeHtml("it's a test")).toBe("it&#039;s a test");
+    // Test with multiple special characters
+    expect(escapeHtml("<a href=\"test\">It's a link</a>")).toBe("&lt;a href=&quot;test&quot;&gt;It&#039;s a link&lt;/a&gt;");
+});
 export function html(strings, ...values) {
     return templateIdentity(strings, ...values.map(v => escapeHtml(`${v}`)));
 }
+import.meta.vitest?.test("html", ({ expect }) => {
+    // Test with no interpolation
+    expect(html `simple string`).toBe("simple string");
+    // Test with string interpolation
+    expect(html `Hello, ${"world"}!`).toBe("Hello, world!");
+    // Test with number interpolation
+    expect(html `Count: ${42}`).toBe("Count: 42");
+    // Test with HTML special characters in interpolated values
+    expect(html `<div>${"<script>"}</div>`).toBe("<div>&lt;script&gt;</div>");
+    // Test with multiple interpolations
+    expect(html `${1} + ${2} = ${"<3"}`).toBe("1 + 2 = &lt;3");
+    // Test with object interpolation
+    const obj = { toString: () => "<object>" };
+    expect(html `Object: ${obj}`).toBe("Object: &lt;object&gt;");
+});

package/dist/utils/http.js

@@ -51,8 +51,37 @@ export function decodeBasicAuthorizationHeader(value) {
     const split = decoded.split(':');
     return [split[0], split.slice(1).join(':')];
 }
+import.meta.vitest?.test("decodeBasicAuthorizationHeader", ({ expect }) => {
+    // Test with valid Basic Authorization header
+    const username = "user";
+    const password = "pass";
+    const encoded = encodeBasicAuthorizationHeader(username, password);
+    expect(decodeBasicAuthorizationHeader(encoded)).toEqual([username, password]);
+    // Test with password containing colons
+    const complexPassword = "pass:with:colons";
+    const encodedComplex = encodeBasicAuthorizationHeader(username, complexPassword);
+    expect(decodeBasicAuthorizationHeader(encodedComplex)).toEqual([username, complexPassword]);
+    // Test with invalid headers
+    expect(decodeBasicAuthorizationHeader("NotBasic dXNlcjpwYXNz")).toBe(null); // Wrong type
+    expect(decodeBasicAuthorizationHeader("Basic")).toBe(null); // Missing encoded part
+    expect(decodeBasicAuthorizationHeader("Basic not-base64")).toBe(null); // Not base64
+    expect(decodeBasicAuthorizationHeader("Basic dXNlcjpwYXNz extra")).toBe(null); // Extra parts
+});
 export function encodeBasicAuthorizationHeader(id, password) {
     if (id.includes(':'))
         throw new Error("Basic authorization header id cannot contain ':'");
     return `Basic ${encodeBase64(new TextEncoder().encode(`${id}:${password}`))}`;
 }
+import.meta.vitest?.test("encodeBasicAuthorizationHeader", ({ expect }) => {
+    // Test with simple username and password
+    const encoded = encodeBasicAuthorizationHeader("user", "pass");
+    expect(encoded).toMatch(/^Basic [A-Za-z0-9+/=]+$/); // Should start with "Basic " followed by base64
+    // Test with empty password
+    const encodedEmptyPass = encodeBasicAuthorizationHeader("user", "");
+    expect(encodedEmptyPass).toMatch(/^Basic [A-Za-z0-9+/=]+$/);
+    // Test with password containing special characters
+    const encodedSpecialChars = encodeBasicAuthorizationHeader("user", "p@ss!w0rd");
+    expect(encodedSpecialChars).toMatch(/^Basic [A-Za-z0-9+/=]+$/);
+    // Test with username containing colon should throw
+    expect(() => encodeBasicAuthorizationHeader("user:name", "pass")).toThrow();
+});

package/dist/utils/ips.js

@@ -2,8 +2,37 @@ import ipRegex from "ip-regex";
 export function isIpAddress(ip) {
     return ipRegex({ exact: true }).test(ip);
 }
+import.meta.vitest?.test("isIpAddress", ({ expect }) => {
+    // Test valid IPv4 addresses
+    expect(isIpAddress("192.168.1.1")).toBe(true);
+    expect(isIpAddress("127.0.0.1")).toBe(true);
+    expect(isIpAddress("0.0.0.0")).toBe(true);
+    expect(isIpAddress("255.255.255.255")).toBe(true);
+    // Test valid IPv6 addresses
+    expect(isIpAddress("::1")).toBe(true);
+    expect(isIpAddress("2001:db8::")).toBe(true);
+    expect(isIpAddress("2001:db8:85a3:8d3:1319:8a2e:370:7348")).toBe(true);
+    // Test invalid IP addresses
+    expect(isIpAddress("")).toBe(false);
+    expect(isIpAddress("not an ip")).toBe(false);
+    expect(isIpAddress("256.256.256.256")).toBe(false);
+    expect(isIpAddress("192.168.1")).toBe(false);
+    expect(isIpAddress("192.168.1.1.1")).toBe(false);
+    expect(isIpAddress("2001:db8::xyz")).toBe(false);
+});
 export function assertIpAddress(ip) {
     if (!isIpAddress(ip)) {
         throw new Error(`Invalid IP address: ${ip}`);
     }
 }
+import.meta.vitest?.test("assertIpAddress", ({ expect }) => {
+    // Test with valid IPv4 address
+    expect(() => assertIpAddress("192.168.1.1")).not.toThrow();
+    // Test with valid IPv6 address
+    expect(() => assertIpAddress("::1")).not.toThrow();
+    // Test with invalid IP addresses
+    expect(() => assertIpAddress("")).toThrow("Invalid IP address: ");
+    expect(() => assertIpAddress("not an ip")).toThrow("Invalid IP address: not an ip");
+    expect(() => assertIpAddress("256.256.256.256")).toThrow("Invalid IP address: 256.256.256.256");
+    expect(() => assertIpAddress("192.168.1")).toThrow("Invalid IP address: 192.168.1");
+});

package/dist/utils/json.js

@@ -18,9 +18,144 @@ export function isJson(value) {
         }
     }
 }
+import.meta.vitest?.test("isJson", ({ expect }) => {
+    // Test primitive values
+    expect(isJson(null)).toBe(true);
+    expect(isJson(true)).toBe(true);
+    expect(isJson(false)).toBe(true);
+    expect(isJson(123)).toBe(true);
+    expect(isJson("string")).toBe(true);
+    // Test arrays
+    expect(isJson([])).toBe(true);
+    expect(isJson([1, 2, 3])).toBe(true);
+    expect(isJson(["a", "b", "c"])).toBe(true);
+    expect(isJson([1, "a", true, null])).toBe(true);
+    expect(isJson([1, [2, 3], { a: "b" }])).toBe(true);
+    // Test objects
+    expect(isJson({})).toBe(true);
+    expect(isJson({ a: 1, b: 2 })).toBe(true);
+    expect(isJson({ a: "string", b: true, c: null })).toBe(true);
+    expect(isJson({ a: [1, 2, 3], b: { c: "d" } })).toBe(true);
+    // Test invalid JSON values
+    expect(isJson(undefined)).toBe(false);
+    expect(isJson(() => { })).toBe(false);
+    expect(isJson(Symbol())).toBe(false);
+    expect(isJson(BigInt(123))).toBe(false);
+    // Test arrays with invalid JSON values
+    expect(isJson([1, undefined, 3])).toBe(false);
+    expect(isJson([1, () => { }, 3])).toBe(false);
+    // Test objects with invalid JSON values
+    expect(isJson({ a: 1, b: undefined })).toBe(false);
+    expect(isJson({ a: 1, b: () => { } })).toBe(false);
+});
 export function parseJson(json) {
     return Result.fromThrowing(() => JSON.parse(json));
 }
+import.meta.vitest?.test("parseJson", ({ expect }) => {
+    // Test valid JSON strings
+    const nullResult = parseJson("null");
+    expect(nullResult.status).toBe("ok");
+    if (nullResult.status === "ok") {
+        expect(nullResult.data).toBe(null);
+    }
+    const trueResult = parseJson("true");
+    expect(trueResult.status).toBe("ok");
+    if (trueResult.status === "ok") {
+        expect(trueResult.data).toBe(true);
+    }
+    const numberResult = parseJson("123");
+    expect(numberResult.status).toBe("ok");
+    if (numberResult.status === "ok") {
+        expect(numberResult.data).toBe(123);
+    }
+    const stringResult = parseJson('"string"');
+    expect(stringResult.status).toBe("ok");
+    if (stringResult.status === "ok") {
+        expect(stringResult.data).toBe("string");
+    }
+    const emptyArrayResult = parseJson("[]");
+    expect(emptyArrayResult.status).toBe("ok");
+    if (emptyArrayResult.status === "ok") {
+        expect(emptyArrayResult.data).toEqual([]);
+    }
+    const arrayResult = parseJson("[1,2,3]");
+    expect(arrayResult.status).toBe("ok");
+    if (arrayResult.status === "ok") {
+        expect(arrayResult.data).toEqual([1, 2, 3]);
+    }
+    const emptyObjectResult = parseJson("{}");
+    expect(emptyObjectResult.status).toBe("ok");
+    if (emptyObjectResult.status === "ok") {
+        expect(emptyObjectResult.data).toEqual({});
+    }
+    const objectResult = parseJson('{"a":1,"b":"string"}');
+    expect(objectResult.status).toBe("ok");
+    if (objectResult.status === "ok") {
+        expect(objectResult.data).toEqual({ a: 1, b: "string" });
+    }
+    // Test invalid JSON strings
+    expect(parseJson("").status).toBe("error");
+    expect(parseJson("undefined").status).toBe("error");
+    expect(parseJson("{").status).toBe("error");
+    expect(parseJson('{"a":1,}').status).toBe("error");
+    expect(parseJson("function(){}").status).toBe("error");
+});
 export function stringifyJson(json) {
     return Result.fromThrowing(() => JSON.stringify(json));
 }
+import.meta.vitest?.test("stringifyJson", ({ expect }) => {
+    // Test primitive values
+    const nullResult = stringifyJson(null);
+    expect(nullResult.status).toBe("ok");
+    if (nullResult.status === "ok") {
+        expect(nullResult.data).toBe("null");
+    }
+    const trueResult = stringifyJson(true);
+    expect(trueResult.status).toBe("ok");
+    if (trueResult.status === "ok") {
+        expect(trueResult.data).toBe("true");
+    }
+    const numberResult = stringifyJson(123);
+    expect(numberResult.status).toBe("ok");
+    if (numberResult.status === "ok") {
+        expect(numberResult.data).toBe("123");
+    }
+    const stringResult = stringifyJson("string");
+    expect(stringResult.status).toBe("ok");
+    if (stringResult.status === "ok") {
+        expect(stringResult.data).toBe('"string"');
+    }
+    // Test arrays
+    const emptyArrayResult = stringifyJson([]);
+    expect(emptyArrayResult.status).toBe("ok");
+    if (emptyArrayResult.status === "ok") {
+        expect(emptyArrayResult.data).toBe("[]");
+    }
+    const arrayResult = stringifyJson([1, 2, 3]);
+    expect(arrayResult.status).toBe("ok");
+    if (arrayResult.status === "ok") {
+        expect(arrayResult.data).toBe("[1,2,3]");
+    }
+    // Test objects
+    const emptyObjectResult = stringifyJson({});
+    expect(emptyObjectResult.status).toBe("ok");
+    if (emptyObjectResult.status === "ok") {
+        expect(emptyObjectResult.data).toBe("{}");
+    }
+    const objectResult = stringifyJson({ a: 1, b: "string" });
+    expect(objectResult.status).toBe("ok");
+    if (objectResult.status === "ok") {
+        expect(objectResult.data).toBe('{"a":1,"b":"string"}');
+    }
+    // Test nested structures
+    const nested = { a: [1, 2, 3], b: { c: "d" } };
+    const nestedResult = stringifyJson(nested);
+    expect(nestedResult.status).toBe("ok");
+    if (nestedResult.status === "ok") {
+        expect(nestedResult.data).toBe('{"a":[1,2,3],"b":{"c":"d"}}');
+    }
+    // Test circular references (should error)
+    const circular = { a: 1 };
+    circular.self = circular;
+    expect(stringifyJson(circular).status).toBe("error");
+});

package/dist/utils/maps.js

@@ -13,6 +13,20 @@ export class WeakRefIfAvailable {
         return this._ref.deref();
     }
 }
+import.meta.vitest?.test("WeakRefIfAvailable", ({ expect }) => {
+    // Test with an object
+    const obj = { id: 1, name: "test" };
+    const weakRef = new WeakRefIfAvailable(obj);
+    // Test deref returns the original object
+    expect(weakRef.deref()).toBe(obj);
+    // Test with a different object
+    const obj2 = { id: 2, name: "test2" };
+    const weakRef2 = new WeakRefIfAvailable(obj2);
+    expect(weakRef2.deref()).toBe(obj2);
+    expect(weakRef2.deref()).not.toBe(obj);
+    // We can't easily test garbage collection in this environment,
+    // but we can verify the basic functionality works
+});
 /**
  * A WeakMap-like object that can be iterated over.
  *
@@ -62,6 +76,56 @@ export class IterableWeakMap {
     }
 }
 _a = Symbol.toStringTag;
+import.meta.vitest?.test("IterableWeakMap", ({ expect }) => {
+    // Test basic functionality
+    const map = new IterableWeakMap();
+    // Create object keys
+    const obj1 = { id: 1 };
+    const obj2 = { id: 2 };
+    // Test set and get
+    map.set(obj1, "value1");
+    expect(map.get(obj1)).toBe("value1");
+    // Test has
+    expect(map.has(obj1)).toBe(true);
+    expect(map.has(obj2)).toBe(false);
+    expect(map.has({ id: 1 })).toBe(false); // Different object with same content
+    // Test with multiple keys
+    map.set(obj2, "value2");
+    expect(map.get(obj2)).toBe("value2");
+    expect(map.get(obj1)).toBe("value1"); // Original still exists
+    // Test delete
+    expect(map.delete(obj1)).toBe(true);
+    expect(map.has(obj1)).toBe(false);
+    expect(map.get(obj1)).toBeUndefined();
+    expect(map.has(obj2)).toBe(true); // Other key still exists
+    // Test delete non-existent key
+    expect(map.delete({ id: 3 })).toBe(false);
+    // Test iteration
+    const iterMap = new IterableWeakMap();
+    const iterObj1 = { id: 1 };
+    const iterObj2 = { id: 2 };
+    const iterObj3 = { id: 3 };
+    iterMap.set(iterObj1, 1);
+    iterMap.set(iterObj2, 2);
+    iterMap.set(iterObj3, 3);
+    const entries = Array.from(iterMap);
+    expect(entries.length).toBe(3);
+    // Find entries by their values since we can't directly compare objects in the array
+    const values = entries.map(entry => entry[1]);
+    expect(values).toContain(1);
+    expect(values).toContain(2);
+    expect(values).toContain(3);
+    // Test constructor with entries
+    const initialEntries = [
+        [{ id: 4 }, "initial1"],
+        [{ id: 5 }, "initial2"]
+    ];
+    const mapWithEntries = new IterableWeakMap(initialEntries);
+    // We can't directly access the initial entries since they're different object references
+    // But we can verify the map has the correct number of entries
+    const entriesFromConstructor = Array.from(mapWithEntries);
+    expect(entriesFromConstructor.length).toBe(2);
+});
 /**
  * A map that is a IterableWeakMap for object keys and a regular Map for primitive keys. Also provides iteration over both
  * object and primitive keys.
@@ -117,6 +181,45 @@ export class MaybeWeakMap {
     }
 }
 _b = Symbol.toStringTag;
+import.meta.vitest?.test("MaybeWeakMap", ({ expect }) => {
+    // Test with primitive keys
+    const map = new MaybeWeakMap();
+    // Test with string keys
+    map.set("key1", 1);
+    map.set("key2", 2);
+    expect(map.get("key1")).toBe(1);
+    expect(map.get("key2")).toBe(2);
+    expect(map.has("key1")).toBe(true);
+    expect(map.has("nonexistent")).toBe(false);
+    // Test with object keys
+    const obj1 = { id: 1 };
+    const obj2 = { id: 2 };
+    map.set(obj1, 3);
+    map.set(obj2, 4);
+    expect(map.get(obj1)).toBe(3);
+    expect(map.get(obj2)).toBe(4);
+    expect(map.has(obj1)).toBe(true);
+    // Test delete with primitive key
+    expect(map.delete("key1")).toBe(true);
+    expect(map.has("key1")).toBe(false);
+    expect(map.delete("nonexistent")).toBe(false);
+    // Test delete with object key
+    expect(map.delete(obj1)).toBe(true);
+    expect(map.has(obj1)).toBe(false);
+    // Test iteration
+    const entries = Array.from(map);
+    expect(entries.length).toBe(2);
+    expect(entries).toContainEqual(["key2", 2]);
+    expect(entries).toContainEqual([obj2, 4]);
+    // Test constructor with entries
+    const initialEntries = [
+        ["initial1", 10],
+        [{ id: 3 }, 20]
+    ];
+    const mapWithEntries = new MaybeWeakMap(initialEntries);
+    expect(mapWithEntries.get("initial1")).toBe(10);
+    expect(mapWithEntries.get(initialEntries[1][0])).toBe(20);
+});
 /**
  * A map that stores values indexed by an array of keys. If the keys are objects and the environment supports WeakRefs,
  * they are stored in a WeakMap.
@@ -198,3 +301,45 @@ export class DependenciesMap {
     }
 }
 _c = Symbol.toStringTag;
+import.meta.vitest?.test("DependenciesMap", ({ expect }) => {
+    // Test basic functionality
+    const map = new DependenciesMap();
+    // Test set and get
+    map.set(["key", 1], "value1");
+    expect(map.get(["key", 1])).toBe("value1");
+    // Test has
+    expect(map.has(["key", 1])).toBe(true);
+    expect(map.has(["key", 2])).toBe(false);
+    // Test with different dependencies
+    map.set(["key", 2], "value2");
+    expect(map.get(["key", 2])).toBe("value2");
+    expect(map.get(["key", 1])).toBe("value1"); // Original still exists
+    // Test delete
+    expect(map.delete(["key", 1])).toBe(true);
+    expect(map.has(["key", 1])).toBe(false);
+    expect(map.get(["key", 1])).toBeUndefined();
+    expect(map.has(["key", 2])).toBe(true); // Other key still exists
+    // Test delete non-existent key
+    expect(map.delete(["nonexistent", 1])).toBe(false);
+    // Test clear
+    map.clear();
+    expect(map.has(["key", 2])).toBe(false);
+    // Test with object keys
+    const objMap = new DependenciesMap();
+    const obj1 = { id: 1 };
+    const obj2 = { id: 2 };
+    objMap.set([obj1, 1], "object1");
+    objMap.set([obj2, 2], "object2");
+    expect(objMap.get([obj1, 1])).toBe("object1");
+    expect(objMap.get([obj2, 2])).toBe("object2");
+    // Test iteration
+    const iterMap = new DependenciesMap();
+    iterMap.set(["a"], 1);
+    iterMap.set(["b"], 2);
+    iterMap.set(["c"], 3);
+    const entries = Array.from(iterMap);
+    expect(entries.length).toBe(3);
+    expect(entries).toContainEqual([["a"], 1]);
+    expect(entries).toContainEqual([["b"], 2]);
+    expect(entries).toContainEqual([["c"], 3]);
+});

package/dist/utils/math.js

@@ -4,3 +4,15 @@
 export function remainder(n, d) {
     return ((n % d) + Math.abs(d)) % d;
 }
+import.meta.vitest?.test("remainder", ({ expect }) => {
+    expect(remainder(10, 3)).toBe(1);
+    expect(remainder(10, 5)).toBe(0);
+    expect(remainder(10, 7)).toBe(3);
+    // Test with negative numbers
+    expect(remainder(-10, 3)).toBe(2);
+    expect(remainder(-5, 2)).toBe(1);
+    expect(remainder(-7, 4)).toBe(1);
+    // Test with decimal numbers
+    expect(remainder(10.5, 3)).toBeCloseTo(1.5);
+    expect(remainder(-10.5, 3)).toBeCloseTo(1.5);
+});

package/dist/utils/numbers.js

@@ -21,9 +21,52 @@ export function prettyPrintWithMagnitudes(num) {
     }
     return toFixedMax(num, 1); // Handle numbers less than 1,000 without suffix.
 }
+import.meta.vitest?.test("prettyPrintWithMagnitudes", ({ expect }) => {
+    // Test different magnitudes
+    expect(prettyPrintWithMagnitudes(1000)).toBe("1k");
+    expect(prettyPrintWithMagnitudes(1500)).toBe("1.5k");
+    expect(prettyPrintWithMagnitudes(1000000)).toBe("1M");
+    expect(prettyPrintWithMagnitudes(1500000)).toBe("1.5M");
+    expect(prettyPrintWithMagnitudes(1000000000)).toBe("1bn");
+    expect(prettyPrintWithMagnitudes(1500000000)).toBe("1.5bn");
+    expect(prettyPrintWithMagnitudes(1000000000000)).toBe("1bln");
+    expect(prettyPrintWithMagnitudes(1500000000000)).toBe("1.5bln");
+    expect(prettyPrintWithMagnitudes(1000000000000000)).toBe("1trln");
+    expect(prettyPrintWithMagnitudes(1500000000000000)).toBe("1.5trln");
+    // Test small numbers
+    expect(prettyPrintWithMagnitudes(100)).toBe("100");
+    expect(prettyPrintWithMagnitudes(0)).toBe("0");
+    expect(prettyPrintWithMagnitudes(0.5)).toBe("0.5");
+    // Test negative numbers
+    expect(prettyPrintWithMagnitudes(-1000)).toBe("-1k");
+    expect(prettyPrintWithMagnitudes(-1500000)).toBe("-1.5M");
+    // Test special cases
+    expect(prettyPrintWithMagnitudes(NaN)).toBe("NaN");
+    expect(prettyPrintWithMagnitudes(Infinity)).toBe("∞");
+    expect(prettyPrintWithMagnitudes(-Infinity)).toBe("-∞");
+});
 export function toFixedMax(num, maxDecimals) {
     return num.toFixed(maxDecimals).replace(/\.?0+$/, "");
 }
+import.meta.vitest?.test("toFixedMax", ({ expect }) => {
+    expect(toFixedMax(1, 2)).toBe("1");
+    expect(toFixedMax(1.2, 2)).toBe("1.2");
+    expect(toFixedMax(1.23, 2)).toBe("1.23");
+    expect(toFixedMax(1.234, 2)).toBe("1.23");
+    expect(toFixedMax(1.0, 2)).toBe("1");
+    expect(toFixedMax(1.20, 2)).toBe("1.2");
+    expect(toFixedMax(0, 2)).toBe("0");
+});
 export function numberCompare(a, b) {
     return Math.sign(a - b);
 }
+import.meta.vitest?.test("numberCompare", ({ expect }) => {
+    expect(numberCompare(1, 2)).toBe(-1);
+    expect(numberCompare(2, 1)).toBe(1);
+    expect(numberCompare(1, 1)).toBe(0);
+    expect(numberCompare(0, 0)).toBe(0);
+    expect(numberCompare(-1, -2)).toBe(1);
+    expect(numberCompare(-2, -1)).toBe(-1);
+    expect(numberCompare(-1, 1)).toBe(-1);
+    expect(numberCompare(1, -1)).toBe(1);
+});