@adviser/cement 0.5.0 → 0.5.2

package/ts/cjs/mutable-url.test.js

@@ -1,329 +1,330 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const mutable_url_js_1 = require("./mutable-url.js");
-describe("URLSearchParamsEntries", () => {
-    it("should iterate over URLSearchParams entries", () => {
+const vitest_1 = require("vitest");
+(0, vitest_1.describe)("URLSearchParamsEntries", () => {
+    (0, vitest_1.it)("should iterate over URLSearchParams entries", () => {
         const params = new URLSearchParams();
         params.set("key1", "value1");
         params.set("key2", "value2");
         const entries = Array.from((0, mutable_url_js_1.URLSearchParamsEntries)(params));
-        expect(entries).toEqual([
+        (0, vitest_1.expect)(entries).toEqual([
             ["key1", "value1"],
             ["key2", "value2"],
         ]);
     });
-    it("should handle empty URLSearchParams", () => {
+    (0, vitest_1.it)("should handle empty URLSearchParams", () => {
         const params = new URLSearchParams();
         const entries = Array.from((0, mutable_url_js_1.URLSearchParamsEntries)(params));
-        expect(entries).toEqual([]);
+        (0, vitest_1.expect)(entries).toEqual([]);
     });
-    it("should handle multiple values for same key", () => {
+    (0, vitest_1.it)("should handle multiple values for same key", () => {
         const params = new URLSearchParams();
         params.append("key", "value1");
         params.append("key", "value2");
         const entries = Array.from((0, mutable_url_js_1.URLSearchParamsEntries)(params));
-        expect(entries.length).toBeGreaterThan(0);
-        expect(entries.some(([k, v]) => k === "key" && (v === "value1" || v === "value2"))).toBe(true);
+        (0, vitest_1.expect)(entries.length).toBeGreaterThan(0);
+        (0, vitest_1.expect)(entries.some(([k, v]) => k === "key" && (v === "value1" || v === "value2"))).toBe(true);
     });
 });
-describe("ReadonlyURL", () => {
-    describe("constructor and basic properties", () => {
-        it("should create ReadonlyURL with http protocol", () => {
+(0, vitest_1.describe)("ReadonlyURL", () => {
+    (0, vitest_1.describe)("constructor and basic properties", () => {
+        (0, vitest_1.it)("should create ReadonlyURL with http protocol", () => {
             const url = mutable_url_js_1.ReadonlyURL.fromThrow("http://example.com/path");
-            expect(url.protocol).toBe("http:");
-            expect(url.hostname).toBe("example.com");
-            expect(url.pathname).toBe("/path");
+            (0, vitest_1.expect)(url.protocol).toBe("http:");
+            (0, vitest_1.expect)(url.hostname).toBe("example.com");
+            (0, vitest_1.expect)(url.pathname).toBe("/path");
         });
-        it("should create ReadonlyURL with https protocol", () => {
+        (0, vitest_1.it)("should create ReadonlyURL with https protocol", () => {
             const url = mutable_url_js_1.ReadonlyURL.fromThrow("https://example.com:8080/path");
-            expect(url.protocol).toBe("https:");
-            expect(url.hostname).toBe("example.com");
-            expect(url.port).toBe("8080");
-            expect(url.pathname).toBe("/path");
+            (0, vitest_1.expect)(url.protocol).toBe("https:");
+            (0, vitest_1.expect)(url.hostname).toBe("example.com");
+            (0, vitest_1.expect)(url.port).toBe("8080");
+            (0, vitest_1.expect)(url.pathname).toBe("/path");
         });
-        it("should create ReadonlyURL with custom protocol without host part", () => {
+        (0, vitest_1.it)("should create ReadonlyURL with custom protocol without host part", () => {
             const url = mutable_url_js_1.ReadonlyURL.fromThrow("file://path/to/file");
-            expect(url.protocol).toBe("file:");
-            expect(url.pathname).toBe("path/to/file");
+            (0, vitest_1.expect)(url.protocol).toBe("file:");
+            (0, vitest_1.expect)(url.pathname).toBe("path/to/file");
         });
-        it("should throw error for invalid URL", () => {
-            expect(() => mutable_url_js_1.ReadonlyURL.fromThrow("invalid-url")).toThrow();
+        (0, vitest_1.it)("should throw error for invalid URL", () => {
+            (0, vitest_1.expect)(() => mutable_url_js_1.ReadonlyURL.fromThrow("invalid-url")).toThrow();
         });
     });
-    describe("readonly setters", () => {
+    (0, vitest_1.describe)("readonly setters", () => {
         let url;
-        beforeEach(() => {
+        (0, vitest_1.beforeEach)(() => {
             url = mutable_url_js_1.ReadonlyURL.fromThrow("http://example.com/path");
         });
-        it("should throw error when setting origin", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting origin", () => {
+            (0, vitest_1.expect)(() => {
                 url.origin = "http://other.com";
             }).toThrow("origin is readonly");
         });
-        it("should throw error when setting href", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting href", () => {
+            (0, vitest_1.expect)(() => {
                 url.href = "http://other.com";
             }).toThrow("href is readonly");
         });
-        it("should throw error when setting password", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting password", () => {
+            (0, vitest_1.expect)(() => {
                 url.password = "pass";
             }).toThrow("password is readonly");
         });
-        it("should throw error when setting username", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting username", () => {
+            (0, vitest_1.expect)(() => {
                 url.username = "user";
             }).toThrow("username is readonly");
         });
-        it("should throw error when setting hash", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting hash", () => {
+            (0, vitest_1.expect)(() => {
                 url.hash = "#test";
             }).toThrow("hash is readonly");
         });
-        it("should throw error when setting host", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting host", () => {
+            (0, vitest_1.expect)(() => {
                 url.host = "other.com";
             }).toThrow("host is readonly");
         });
-        it("should throw error when setting hostname", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting hostname", () => {
+            (0, vitest_1.expect)(() => {
                 url.hostname = "other.com";
             }).toThrow("hostname is readonly");
         });
-        it("should throw error when setting pathname", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting pathname", () => {
+            (0, vitest_1.expect)(() => {
                 url.pathname = "/other";
             }).toThrow("pathname is readonly");
         });
-        it("should throw error when setting port", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting port", () => {
+            (0, vitest_1.expect)(() => {
                 url.port = "8080";
             }).toThrow("port is readonly");
         });
-        it("should throw error when setting protocol", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting protocol", () => {
+            (0, vitest_1.expect)(() => {
                 url.protocol = "https:";
             }).toThrow("protocol is readonly");
         });
-        it("should throw error when setting search", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting search", () => {
+            (0, vitest_1.expect)(() => {
                 url.search = "?test=1";
             }).toThrow("search is readonly");
         });
-        it("should throw error when setting searchParams", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting searchParams", () => {
+            (0, vitest_1.expect)(() => {
                 url.searchParams = new URLSearchParams();
             }).toThrow("searchParams is readonly");
         });
     });
-    describe("host-related properties for non-host protocols", () => {
+    (0, vitest_1.describe)("host-related properties for non-host protocols", () => {
         let url;
-        beforeEach(() => {
+        (0, vitest_1.beforeEach)(() => {
             url = mutable_url_js_1.ReadonlyURL.fromThrow("file://path/to/file");
         });
-        it("should throw error when accessing host for non-host protocol", () => {
-            expect(() => url.host).toThrow("you can use hostname only if protocol is");
+        (0, vitest_1.it)("should throw error when accessing host for non-host protocol", () => {
+            (0, vitest_1.expect)(() => url.host).toThrow("you can use hostname only if protocol is");
         });
-        it("should throw error when accessing hostname for non-host protocol", () => {
-            expect(() => url.hostname).toThrow("you can use hostname only if protocol is");
+        (0, vitest_1.it)("should throw error when accessing hostname for non-host protocol", () => {
+            (0, vitest_1.expect)(() => url.hostname).toThrow("you can use hostname only if protocol is");
         });
-        it("should throw error when accessing port for non-host protocol", () => {
-            expect(() => url.port).toThrow("you can use hostname only if protocol is");
+        (0, vitest_1.it)("should throw error when accessing port for non-host protocol", () => {
+            (0, vitest_1.expect)(() => url.port).toThrow("you can use hostname only if protocol is");
         });
     });
-    describe("search and searchParams", () => {
-        it("should handle empty search params", () => {
+    (0, vitest_1.describe)("search and searchParams", () => {
+        (0, vitest_1.it)("should handle empty search params", () => {
             const url = mutable_url_js_1.ReadonlyURL.fromThrow("http://example.com/path");
-            expect(url.search).toBe("");
+            (0, vitest_1.expect)(url.search).toBe("");
         });
-        it("should handle search params", () => {
+        (0, vitest_1.it)("should handle search params", () => {
             const url = mutable_url_js_1.ReadonlyURL.fromThrow("http://example.com/path?b=2&a=1");
-            expect(url.search).toBe("?a=1&b=2");
+            (0, vitest_1.expect)(url.search).toBe("?a=1&b=2");
         });
-        it("should encode search param values", () => {
+        (0, vitest_1.it)("should encode search param values", () => {
             const url = mutable_url_js_1.ReadonlyURL.fromThrow("http://example.com/path");
             url.searchParams.set("key", "value with spaces");
-            expect(url.search).toBe("?key=value%20with%20spaces");
+            (0, vitest_1.expect)(url.search).toBe("?key=value%20with%20spaces");
         });
     });
-    describe("toString", () => {
-        it("should return correct string for host-based URL", () => {
+    (0, vitest_1.describe)("toString", () => {
+        (0, vitest_1.it)("should return correct string for host-based URL", () => {
             const url = mutable_url_js_1.ReadonlyURL.fromThrow("http://example.com:8080/path?a=1#hash");
-            expect(url.toString()).toBe("http://example.com:8080/path?a=1#hash");
+            (0, vitest_1.expect)(url.toString()).toBe("http://example.com:8080/path?a=1#hash");
         });
-        it("should return correct string for non-host URL", () => {
+        (0, vitest_1.it)("should return correct string for non-host URL", () => {
             const url = mutable_url_js_1.ReadonlyURL.fromThrow("file://path/to/file");
-            expect(url.toString()).toBe("file://path/to/file");
+            (0, vitest_1.expect)(url.toString()).toBe("file://path/to/file");
         });
-        it("should handle URL without leading slash in pathname", () => {
+        (0, vitest_1.it)("should handle URL without leading slash in pathname", () => {
             const url = mutable_url_js_1.ReadonlyURL.fromThrow("http://example.com");
-            expect(url.toString()).toContain("http://example.com/");
+            (0, vitest_1.expect)(url.toString()).toContain("http://example.com/");
         });
     });
-    describe("utility methods", () => {
+    (0, vitest_1.describe)("utility methods", () => {
         let url;
-        beforeEach(() => {
+        (0, vitest_1.beforeEach)(() => {
             url = mutable_url_js_1.ReadonlyURL.fromThrow("http://example.com/path");
         });
-        it("test serialization", () => {
+        (0, vitest_1.it)("test serialization", () => {
             const url = mutable_url_js_1.ReadonlyURL.fromThrow("http://example.com/path");
-            expect(JSON.stringify(url)).toBe(`"${url.toString()}"`);
+            (0, vitest_1.expect)(JSON.stringify(url)).toBe(`"${url.toString()}"`);
         });
-        it("should return JSON string", () => {
-            expect(url.toJSON()).toBe(url.toString());
+        (0, vitest_1.it)("should return JSON string", () => {
+            (0, vitest_1.expect)(url.toJSON()).toBe(url.toString());
         });
-        it("should return string for custom inspect", () => {
+        (0, vitest_1.it)("should return string for custom inspect", () => {
             const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
-            expect(url[customInspectSymbol]()).toBe(url.toString());
+            (0, vitest_1.expect)(url[customInspectSymbol]()).toBe(url.toString());
         });
-        it("should clone and return same instance", () => {
+        (0, vitest_1.it)("should clone and return same instance", () => {
             const cloned = url.clone();
-            expect(cloned).toBe(url);
+            (0, vitest_1.expect)(cloned).toBe(url);
         });
     });
 });
-describe("WritableURL", () => {
-    describe("static factory methods", () => {
-        it("should create WritableURL with fromThrow", () => {
+(0, vitest_1.describe)("WritableURL", () => {
+    (0, vitest_1.describe)("static factory methods", () => {
+        (0, vitest_1.it)("should create WritableURL with fromThrow", () => {
             const url = mutable_url_js_1.WritableURL.fromThrow("http://example.com/path");
-            expect(url).toBeInstanceOf(mutable_url_js_1.WritableURL);
-            expect(url.toString()).toBe("http://example.com/path");
+            (0, vitest_1.expect)(url).toBeInstanceOf(mutable_url_js_1.WritableURL);
+            (0, vitest_1.expect)(url.toString()).toBe("http://example.com/path");
         });
-        it("should throw error with fromThrow for invalid URL", () => {
-            expect(() => mutable_url_js_1.WritableURL.fromThrow("invalid-url")).toThrow();
+        (0, vitest_1.it)("should throw error with fromThrow for invalid URL", () => {
+            (0, vitest_1.expect)(() => mutable_url_js_1.WritableURL.fromThrow("invalid-url")).toThrow();
         });
-        it("should create Result.Ok with from for valid URL", () => {
+        (0, vitest_1.it)("should create Result.Ok with from for valid URL", () => {
             const result = mutable_url_js_1.WritableURL.from("http://example.com/path");
-            expect(result.isOk()).toBe(true);
-            expect(result.Ok()).toBeInstanceOf(mutable_url_js_1.WritableURL);
+            (0, vitest_1.expect)(result.isOk()).toBe(true);
+            (0, vitest_1.expect)(result.Ok()).toBeInstanceOf(mutable_url_js_1.WritableURL);
         });
-        it("should create Result.Err with from for invalid URL", () => {
+        (0, vitest_1.it)("should create Result.Err with from for invalid URL", () => {
             const result = mutable_url_js_1.WritableURL.from("invalid-url");
-            expect(result.isErr()).toBe(true);
-            expect(result.Err().message).toContain("Invalid URL");
+            (0, vitest_1.expect)(result.isErr()).toBe(true);
+            (0, vitest_1.expect)(result.Err().message).toContain("Invalid URL");
         });
     });
-    describe("mutable setters", () => {
+    (0, vitest_1.describe)("mutable setters", () => {
         let url;
-        beforeEach(() => {
+        (0, vitest_1.beforeEach)(() => {
             url = mutable_url_js_1.WritableURL.fromThrow("http://example.com/path");
         });
-        it("should throw error when setting origin", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting origin", () => {
+            (0, vitest_1.expect)(() => {
                 url.origin = "http://other.com";
             }).toThrow("don't use origin");
         });
-        it("should set href", () => {
-            expect(() => {
+        (0, vitest_1.it)("should set href", () => {
+            (0, vitest_1.expect)(() => {
                 url.href = "http://other.com/other";
             }).toThrow("don't use href");
         });
-        it("should set password", () => {
+        (0, vitest_1.it)("should set password", () => {
             url.password = "newpass";
-            expect(url.password).toBe("newpass");
+            (0, vitest_1.expect)(url.password).toBe("newpass");
         });
-        it("should set username", () => {
+        (0, vitest_1.it)("should set username", () => {
             url.username = "newuser";
-            expect(url.username).toBe("newuser");
+            (0, vitest_1.expect)(url.username).toBe("newuser");
         });
-        it("should set hash", () => {
+        (0, vitest_1.it)("should set hash", () => {
             url.hash = "#newhash";
-            expect(url.hash).toBe("#newhash");
+            (0, vitest_1.expect)(url.hash).toBe("#newhash");
         });
-        it("should set host", () => {
+        (0, vitest_1.it)("should set host", () => {
             url.host = "other.com:9000";
-            expect(url.host).toBe("other.com:9000");
+            (0, vitest_1.expect)(url.host).toBe("other.com:9000");
         });
-        it("should set hostname", () => {
+        (0, vitest_1.it)("should set hostname", () => {
             url.hostname = "other.com";
-            expect(url.hostname).toBe("other.com");
+            (0, vitest_1.expect)(url.hostname).toBe("other.com");
         });
-        it("should set pathname", () => {
+        (0, vitest_1.it)("should set pathname", () => {
             url.pathname = "/newpath";
-            expect(url.pathname).toBe("/newpath");
+            (0, vitest_1.expect)(url.pathname).toBe("/newpath");
         });
-        it("should set port", () => {
+        (0, vitest_1.it)("should set port", () => {
             url.port = "9000";
-            expect(url.port).toBe("9000");
+            (0, vitest_1.expect)(url.port).toBe("9000");
         });
-        it("should set protocol with colon", () => {
+        (0, vitest_1.it)("should set protocol with colon", () => {
             url.protocol = "https:";
-            expect(url.protocol).toBe("https:");
+            (0, vitest_1.expect)(url.protocol).toBe("https:");
         });
-        it("should set protocol without colon", () => {
+        (0, vitest_1.it)("should set protocol without colon", () => {
             url.protocol = "https";
-            expect(url.protocol).toBe("https:");
+            (0, vitest_1.expect)(url.protocol).toBe("https:");
         });
-        it("should set search", () => {
+        (0, vitest_1.it)("should set search", () => {
             url.search = "?new=param";
-            expect(url.search).toBe("?new=param");
+            (0, vitest_1.expect)(url.search).toBe("?new=param");
         });
-        it("should verify state change when setting username and password", () => {
+        (0, vitest_1.it)("should verify state change when setting username and password", () => {
             url.username = "testuser";
             url.password = "testpass";
-            expect(url.username).toBe("testuser");
-            expect(url.password).toBe("testpass");
-            expect(url.href).toContain("testuser:testpass@");
+            (0, vitest_1.expect)(url.username).toBe("testuser");
+            (0, vitest_1.expect)(url.password).toBe("testpass");
+            (0, vitest_1.expect)(url.href).toContain("testuser:testpass@");
         });
-        it("should verify state change when setting empty values", () => {
+        (0, vitest_1.it)("should verify state change when setting empty values", () => {
             url.hash = "#test";
             url.search = "?test=value";
-            expect(url.hash).toBe("#test");
-            expect(url.search).toBe("?test=value");
+            (0, vitest_1.expect)(url.hash).toBe("#test");
+            (0, vitest_1.expect)(url.search).toBe("?test=value");
             url.hash = "";
             url.search = "";
-            expect(url.hash).toBe("");
-            expect(url.search).toBe("");
+            (0, vitest_1.expect)(url.hash).toBe("");
+            (0, vitest_1.expect)(url.search).toBe("");
         });
     });
-    describe("host-related setters for non-host protocols", () => {
+    (0, vitest_1.describe)("host-related setters for non-host protocols", () => {
         let url;
-        beforeEach(() => {
+        (0, vitest_1.beforeEach)(() => {
             url = mutable_url_js_1.WritableURL.fromThrow("file://path/to/file");
         });
-        it("should throw error when setting hostname for non-host protocol", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting hostname for non-host protocol", () => {
+            (0, vitest_1.expect)(() => {
                 url.hostname = "example.com";
             }).toThrow("you can use hostname only if protocol is");
         });
-        it("should throw error when setting port for non-host protocol", () => {
-            expect(() => {
+        (0, vitest_1.it)("should throw error when setting port for non-host protocol", () => {
+            (0, vitest_1.expect)(() => {
                 url.port = "8080";
             }).toThrow("you can use port only if protocol is");
         });
     });
-    describe("searchParams setter", () => {
+    (0, vitest_1.describe)("searchParams setter", () => {
         let url;
-        beforeEach(() => {
+        (0, vitest_1.beforeEach)(() => {
             url = mutable_url_js_1.WritableURL.fromThrow("http://example.com/path?existing=param");
         });
-        it("should replace searchParams completely", () => {
+        (0, vitest_1.it)("should replace searchParams completely", () => {
             const originalSearch = url.search;
             const newParams = new URLSearchParams();
             newParams.set("new", "value");
             newParams.set("another", "param");
             url.searchParams = newParams;
-            expect(url.searchParams.get("new")).toBe("value");
-            expect(url.searchParams.get("another")).toBe("param");
-            expect(url.searchParams.get("existing")).toBeNull();
-            expect(url.search).not.toBe(originalSearch);
-            expect(url.search).toContain("new=value");
-            expect(url.search).toContain("another=param");
-        });
-        it("should handle empty searchParams", () => {
+            (0, vitest_1.expect)(url.searchParams.get("new")).toBe("value");
+            (0, vitest_1.expect)(url.searchParams.get("another")).toBe("param");
+            (0, vitest_1.expect)(url.searchParams.get("existing")).toBeNull();
+            (0, vitest_1.expect)(url.search).not.toBe(originalSearch);
+            (0, vitest_1.expect)(url.search).toContain("new=value");
+            (0, vitest_1.expect)(url.search).toContain("another=param");
+        });
+        (0, vitest_1.it)("should handle empty searchParams", () => {
             const originalSearch = url.search;
             url.searchParams = new URLSearchParams();
-            expect(url.search).toBe("");
-            expect(url.search).not.toBe(originalSearch);
-            expect(url.searchParams.toString()).toBe("");
+            (0, vitest_1.expect)(url.search).toBe("");
+            (0, vitest_1.expect)(url.search).not.toBe(originalSearch);
+            (0, vitest_1.expect)(url.searchParams.toString()).toBe("");
         });
     });
-    describe("comprehensive state change verification", () => {
+    (0, vitest_1.describe)("comprehensive state change verification", () => {
         let url;
-        beforeEach(() => {
+        (0, vitest_1.beforeEach)(() => {
             url = mutable_url_js_1.WritableURL.fromThrow("http://example.com/path?existing=param");
         });
-        it("should verify all mutable setters change state correctly", () => {
+        (0, vitest_1.it)("should verify all mutable setters change state correctly", () => {
             const originalHash = url.hash;
             const originalHost = url.host;
             const originalHostname = url.hostname;
@@ -340,113 +341,113 @@ describe("WritableURL", () => {
             url.search = "?new=value";
             url.username = "newuser";
             url.password = "newpass";
-            expect(url.hash).toBe("#newHash");
-            expect(url.hash).not.toBe(originalHash);
-            expect(url.host).toBe("newhost.com:8080");
-            expect(url.host).not.toBe(originalHost);
-            expect(url.hostname).toBe("newhost.com");
-            expect(url.hostname).not.toBe(originalHostname);
-            expect(url.pathname).toBe("/newpath");
-            expect(url.pathname).not.toBe(originalPathname);
-            expect(url.port).toBe("8080");
-            expect(url.port).not.toBe(originalPort);
-            expect(url.protocol).toBe("https:");
-            expect(url.protocol).not.toBe(originalProtocol);
-            expect(url.search).toBe("?new=value");
-            expect(url.search).not.toBe(originalSearch);
-            expect(url.username).toBe("newuser");
-            expect(url.username).not.toBe(originalUsername);
-            expect(url.password).toBe("newpass");
-            expect(url.password).not.toBe(originalPassword);
-            expect(url.toString()).toContain("https://");
-            expect(url.toString()).toContain("newuser:newpass@");
-            expect(url.toString()).toContain("newhost.com:8080");
-            expect(url.toString()).toContain("/newpath");
-            expect(url.toString()).toContain("?new=value");
-            expect(url.toString()).toContain("#newHash");
+            (0, vitest_1.expect)(url.hash).toBe("#newHash");
+            (0, vitest_1.expect)(url.hash).not.toBe(originalHash);
+            (0, vitest_1.expect)(url.host).toBe("newhost.com:8080");
+            (0, vitest_1.expect)(url.host).not.toBe(originalHost);
+            (0, vitest_1.expect)(url.hostname).toBe("newhost.com");
+            (0, vitest_1.expect)(url.hostname).not.toBe(originalHostname);
+            (0, vitest_1.expect)(url.pathname).toBe("/newpath");
+            (0, vitest_1.expect)(url.pathname).not.toBe(originalPathname);
+            (0, vitest_1.expect)(url.port).toBe("8080");
+            (0, vitest_1.expect)(url.port).not.toBe(originalPort);
+            (0, vitest_1.expect)(url.protocol).toBe("https:");
+            (0, vitest_1.expect)(url.protocol).not.toBe(originalProtocol);
+            (0, vitest_1.expect)(url.search).toBe("?new=value");
+            (0, vitest_1.expect)(url.search).not.toBe(originalSearch);
+            (0, vitest_1.expect)(url.username).toBe("newuser");
+            (0, vitest_1.expect)(url.username).not.toBe(originalUsername);
+            (0, vitest_1.expect)(url.password).toBe("newpass");
+            (0, vitest_1.expect)(url.password).not.toBe(originalPassword);
+            (0, vitest_1.expect)(url.toString()).toContain("https://");
+            (0, vitest_1.expect)(url.toString()).toContain("newuser:newpass@");
+            (0, vitest_1.expect)(url.toString()).toContain("newhost.com:8080");
+            (0, vitest_1.expect)(url.toString()).toContain("/newpath");
+            (0, vitest_1.expect)(url.toString()).toContain("?new=value");
+            (0, vitest_1.expect)(url.toString()).toContain("#newHash");
         });
     });
-    describe("clone method", () => {
-        it("should create new instance with same URL", () => {
+    (0, vitest_1.describe)("clone method", () => {
+        (0, vitest_1.it)("should create new instance with same URL", () => {
             const url = mutable_url_js_1.WritableURL.fromThrow("http://example.com/path?param=value#hash");
             const cloned = url.clone();
-            expect(cloned).toBeInstanceOf(mutable_url_js_1.WritableURL);
-            expect(cloned).not.toBe(url);
-            expect(cloned.toString()).toBe(url.toString());
+            (0, vitest_1.expect)(cloned).toBeInstanceOf(mutable_url_js_1.WritableURL);
+            (0, vitest_1.expect)(cloned).not.toBe(url);
+            (0, vitest_1.expect)(cloned.toString()).toBe(url.toString());
         });
     });
-    describe("utility methods", () => {
+    (0, vitest_1.describe)("utility methods", () => {
         let url;
-        beforeEach(() => {
+        (0, vitest_1.beforeEach)(() => {
             url = mutable_url_js_1.WritableURL.fromThrow("http://example.com/path");
         });
-        it("test serialization", () => {
+        (0, vitest_1.it)("test serialization", () => {
             const url = mutable_url_js_1.WritableURL.fromThrow("http://example.com/path");
-            expect(JSON.stringify(url)).toBe(`"${url.toString()}"`);
+            (0, vitest_1.expect)(JSON.stringify(url)).toBe(`"${url.toString()}"`);
         });
-        it("should return JSON string", () => {
-            expect(url.toJSON()).toBe(url.toString());
+        (0, vitest_1.it)("should return JSON string", () => {
+            (0, vitest_1.expect)(url.toJSON()).toBe(url.toString());
         });
-        it("should return string for custom inspect", () => {
+        (0, vitest_1.it)("should return string for custom inspect", () => {
             const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
-            expect(url[customInspectSymbol]()).toBe(url.toString());
+            (0, vitest_1.expect)(url[customInspectSymbol]()).toBe(url.toString());
         });
     });
 });
-describe("ReadonlyURL.from", () => {
-    it("should return Ok for valid url with protocol", () => {
+(0, vitest_1.describe)("ReadonlyURL.from", () => {
+    (0, vitest_1.it)("should return Ok for valid url with protocol", () => {
         const result = mutable_url_js_1.ReadonlyURL.from("http://example.com/foo");
-        expect(result.isOk()).toBe(true);
-        expect(result.Ok().toString()).toBe("http://example.com/foo");
+        (0, vitest_1.expect)(result.isOk()).toBe(true);
+        (0, vitest_1.expect)(result.Ok().toString()).toBe("http://example.com/foo");
     });
-    it("should return Err for invalid url", () => {
+    (0, vitest_1.it)("should return Err for invalid url", () => {
         const result = mutable_url_js_1.ReadonlyURL.from("not-a-url");
-        expect(result.isErr()).toBe(true);
+        (0, vitest_1.expect)(result.isErr()).toBe(true);
     });
-    it("should return Err for invalid url 1", () => {
+    (0, vitest_1.it)("should return Err for invalid url 1", () => {
         const result = mutable_url_js_1.ReadonlyURL.from("not-a-url:");
-        expect(result.isErr()).toBe(true);
+        (0, vitest_1.expect)(result.isErr()).toBe(true);
     });
-    it("should return Err for invalid url 2", () => {
+    (0, vitest_1.it)("should return Err for invalid url 2", () => {
         const result = mutable_url_js_1.ReadonlyURL.from("not-a-url:/");
-        expect(result.isErr()).toBe(true);
+        (0, vitest_1.expect)(result.isErr()).toBe(true);
     });
-    it("should return Err for invalid urll 3", () => {
+    (0, vitest_1.it)("should return Err for invalid urll 3", () => {
         const result = mutable_url_js_1.ReadonlyURL.from("not-a-url://kdkkef/df:dkdkfkdk");
-        expect(result.isErr()).toBe(true);
+        (0, vitest_1.expect)(result.isErr()).toBe(true);
     });
-    it("should return Ok for custom protocol", () => {
+    (0, vitest_1.it)("should return Ok for custom protocol", () => {
         const result = mutable_url_js_1.ReadonlyURL.from("b0lix://foo/bar");
-        expect(result.isOk()).toBe(true);
-        expect(result.Ok().toString()).toBe("b0lix://foo/bar");
+        (0, vitest_1.expect)(result.isOk()).toBe(true);
+        (0, vitest_1.expect)(result.Ok().toString()).toBe("b0lix://foo/bar");
     });
 });
-describe("WritableURL.from", () => {
-    it("should return Ok for valid url with protocol", () => {
+(0, vitest_1.describe)("WritableURL.from", () => {
+    (0, vitest_1.it)("should return Ok for valid url with protocol", () => {
         const result = mutable_url_js_1.WritableURL.from("http://example.com/foo");
-        expect(result.isOk()).toBe(true);
-        expect(result.Ok().toString()).toBe("http://example.com/foo");
+        (0, vitest_1.expect)(result.isOk()).toBe(true);
+        (0, vitest_1.expect)(result.Ok().toString()).toBe("http://example.com/foo");
     });
-    it("should return Err for invalid url", () => {
+    (0, vitest_1.it)("should return Err for invalid url", () => {
         const result = mutable_url_js_1.WritableURL.from("not-a-url");
-        expect(result.isErr()).toBe(true);
+        (0, vitest_1.expect)(result.isErr()).toBe(true);
     });
-    it("should return Err for invalid url 1", () => {
+    (0, vitest_1.it)("should return Err for invalid url 1", () => {
         const result = mutable_url_js_1.WritableURL.from("not-a-url:");
-        expect(result.isErr()).toBe(true);
+        (0, vitest_1.expect)(result.isErr()).toBe(true);
     });
-    it("should return Err for invalid url 2", () => {
+    (0, vitest_1.it)("should return Err for invalid url 2", () => {
         const result = mutable_url_js_1.WritableURL.from("not-a-url:/");
-        expect(result.isErr()).toBe(true);
+        (0, vitest_1.expect)(result.isErr()).toBe(true);
     });
-    it("should return Err for invalid urll 3", () => {
+    (0, vitest_1.it)("should return Err for invalid urll 3", () => {
         const result = mutable_url_js_1.WritableURL.from("not-a-url://kdkkef/df:dkdkfkdk");
-        expect(result.isErr()).toBe(true);
+        (0, vitest_1.expect)(result.isErr()).toBe(true);
     });
-    it("should return Ok for custom protocol", () => {
+    (0, vitest_1.it)("should return Ok for custom protocol", () => {
         const result = mutable_url_js_1.WritableURL.from("b0lix://foo/bar");
-        expect(result.isOk()).toBe(true);
-        expect(result.Ok().toString()).toBe("b0lix://foo/bar");
+        (0, vitest_1.expect)(result.isOk()).toBe(true);
+        (0, vitest_1.expect)(result.Ok().toString()).toBe("b0lix://foo/bar");
     });
 });
 //# sourceMappingURL=mutable-url.test.js.map