@adviser/cement 0.4.7 → 0.4.9

package/ts/src/uri.test.js

@@ -1,606 +0,0 @@
-import { BuildURI, MutableURL, URI, isCoerceURI, param } from "@adviser/cement";
-describe("BuildURI", () => {
-    let uri;
-    beforeEach(() => {
-        uri = BuildURI.from(new MutableURL("http://example.com"));
-        uri.hostname("example");
-        uri.setParam("key", "value");
-    });
-    it("toString", () => {
-        expect(uri.toString()).toBe("http://example/?key=value");
-    });
-    it("build", () => {
-        expect(uri.URI().toString()).toBe("http://example/?key=value");
-    });
-    it("defParam", () => {
-        uri.defParam("key", "value2");
-        uri.defParam("key2", "value2");
-        expect(uri.toString()).toBe("http://example/?key=value&key2=value2");
-    });
-    it("searchParams sorted in toString", () => {
-        uri.setParam("z", "value");
-        uri.setParam("a", "value");
-        uri.setParam("m", "value");
-        expect(uri.toString()).toBe("http://example/?a=value&key=value&m=value&z=value");
-    });
-});
-describe("URI", () => {
-    it("from str with default", () => {
-        const uri = URI.from("/example/wurst");
-        expect(uri.toString()).toBe("file:///example/wurst");
-    });
-    it("from URL str", () => {
-        expect(URI.from("bla://example/com?key=value").toString()).toBe("bla://example/com?key=value");
-    });
-    it("from URL", () => {
-        expect(URI.from(new MutableURL("blix://example.com?key=value")).toString()).toBe("blix://example.com?key=value");
-    });
-    it("from URI", () => {
-        expect(URI.from(URI.from("blix://example.com?key=value")).toString()).toBe("blix://example.com?key=value");
-    });
-    it("from undef", () => {
-        expect(URI.from(null).toString()).toBe("file:///");
-    });
-    it("build", () => {
-        expect(URI.from("blix://example.com?key=value").build().toString()).toBe("blix://example.com?key=value");
-    });
-    it("clone", () => {
-        expect(URI.from("blix://example.com?key=value").clone().toString()).toBe("blix://example.com?key=value");
-    });
-    it("asURL", () => {
-        expect(URI.from("blix://example.com?key=value").asURL().toString()).toBe("blix://example.com?key=value");
-    });
-    it("toString", () => {
-        expect(URI.from("blix://example.com?key=value").toString()).toBe("blix://example.com?key=value");
-    });
-    it("searchParams sorted in toString", () => {
-        expect(URI.from("blix://example.com?z=value&a=value&m=value").toString()).toBe("blix://example.com?a=value&m=value&z=value");
-    });
-    it("searchParams sorted in asURL", () => {
-        expect(URI.from("blix://example.com?z=value&a=value&m=value").asURL().toString()).toBe("blix://example.com?a=value&m=value&z=value");
-    });
-    it("merge", () => {
-        expect(URI.merge("blix://example.com?key=value&into=4", "murk://bla/com?key=from&z=value").toString()).toBe("murk://bla/com?into=4&key=from&z=value");
-    });
-    it("merge empty", () => {
-        expect(URI.merge("blix://example/com?key=value&into=4", "murk://?key=from&z=value").toString()).toBe("murk://example/com?into=4&key=from&z=value");
-    });
-    it("firefox file relative into", () => {
-        expect(URI.from("file://./dist/tests/key.bag").toString()).toBe("file://./dist/tests/key.bag");
-    });
-    it("from empty", () => {
-        expect(URI.merge(`file://./dist/tests/key.bag`, "").toString()).toBe("file://./dist/tests/key.bag");
-    });
-    it("merge thing about", () => {
-        const result = URI.merge("./dist/what?byKey=4444", "murk://bla.com?key=from&z=value");
-        expect(result.toString()).toBe("murk://bla.com?byKey=4444&key=from&z=value");
-    });
-    it("isURI real", () => {
-        expect(URI.is(URI.from())).toBe(true);
-    });
-    it("isURI fake", () => {
-        expect(URI.is({
-            asURL: () => new URL("http://example.com"),
-            hasParam: () => false,
-            getParam: () => "",
-        })).toBe(true);
-    });
-    it("safari has a different pathname behavior", () => {
-        const uri = URI.from("indexdb://fp/?name=test&store=meta");
-        expect(uri.pathname).toBe("fp/");
-    });
-    it("passing URL to fetch", async () => {
-        const uri = URI.from("https://jsonplaceholder.typicode.com/todos/1");
-        const res = await fetch(uri.asURL());
-        expect(res.status).toBeGreaterThan(199);
-    });
-    it("MutableURL is instance of URL", () => {
-        expect(new MutableURL("http://example.com") instanceof URL).toBe(true);
-    });
-    it("file url", () => {
-        const uri = URI.from("file://fp?storagekey=zTvTPEPQRWij8rfb3FrFqBm");
-        expect(uri.pathname).toBe("fp");
-    });
-    it("unregistered protocol with hostPart", () => {
-        const withoutHostpart = URI.from("indexdb://fp:bla/test/?name=test&store=meta");
-        expect(() => withoutHostpart.hostname).toThrowError('you can use hostname only if protocol is ["http","https","ws","wss"]');
-    });
-    it("register protocol with hostPart", () => {
-        const unreg = URI.protocolHasHostpart("indexdb:");
-        const withHostpart = URI.from("indexdb://fp1:88/test/wurst?name=test&store=meta");
-        expect(withHostpart.host).toBe("fp1:88");
-        expect(withHostpart.pathname).toBe("/test/wurst");
-        const withHostpartNoPath = URI.from("indexdb://fp2:88?name=test&store=meta");
-        expect(withHostpartNoPath.host).toBe("fp2:88");
-        expect(withHostpartNoPath.pathname).toBe("/");
-        unreg();
-    });
-    it("host uri as json with omit", () => {
-        const uri = URI.from("http://example.com:8000/bla/blub?name=test&store=meta&key=%40bla");
-        expect(uri.asObj()).toEqual({
-            style: "host",
-            protocol: "http:",
-            hostname: "example.com",
-            port: "8000",
-            pathname: "/bla/blub",
-            searchParams: {
-                store: "meta",
-                name: "test",
-                key: "@bla",
-            },
-        });
-    });
-    it("path uri as json with omit", () => {
-        const uri = URI.from("blix://bla/blub?name=test&store=meta&key=%40bla");
-        expect(uri.asObj()).toEqual({
-            style: "path",
-            protocol: "blix:",
-            pathname: "bla/blub",
-            searchParams: {
-                store: "meta",
-                name: "test",
-                key: "@bla",
-            },
-        });
-    });
-    it("URI getParamResult", () => {
-        const uri = URI.from("blix://bla/blub?name=test&store=meta&key=%40bla");
-        expect(uri.getParamResult("key").Ok()).toBe("@bla");
-        expect(uri.getParamResult("key2", (k) => `${k} not found`).Err().message).toBe("key2 not found");
-        expect(uri.getParamResult("key2").Err().message).toBe("missing parameter: key2");
-    });
-    it("BuildURI getParamResult", () => {
-        const uri = BuildURI.from("blix://bla/blub?name=test&store=meta&key=%40bla");
-        expect(uri.getParamResult("key").Ok()).toBe("@bla");
-        expect(uri.getParamResult("key2", (k) => `${k} not found`).Err().message).toBe("key2 not found");
-        expect(uri.getParamResult("key2").Err().message).toBe("missing parameter: key2");
-    });
-    it("URI append Params Path", () => {
-        const uri = BuildURI.from("blix://bla/blub?name=test&store=meta&key=%40bla").appendRelative("/murks/blub?name=append&work=hard");
-        expect(uri.asObj()).toEqual({
-            pathname: "bla/blub/murks/blub",
-            protocol: "blix:",
-            searchParams: {
-                key: "@bla",
-                name: "append",
-                store: "meta",
-                work: "hard",
-            },
-            style: "path",
-        });
-    });
-    it("URI append Params Host", () => {
-        const uri = BuildURI.from("http://host/bla/blub?name=test&store=meta&key=%40bla").appendRelative("/murks/blub?name=append&work=hard");
-        expect(uri.asObj()).toEqual({
-            pathname: "/bla/blub/murks/blub",
-            hostname: "host",
-            port: "",
-            protocol: "http:",
-            searchParams: {
-                key: "@bla",
-                name: "append",
-                store: "meta",
-                work: "hard",
-            },
-            style: "host",
-        });
-    });
-    it("URI append Params Host Flat", () => {
-        const uri = BuildURI.from("https://fp1-uploads-201698179963.s3.us-east-2.amazonaws.com/").appendRelative(`/data/name/key.car`);
-        expect(uri.asObj()).toEqual({
-            pathname: "/data/name/key.car",
-            hostname: "fp1-uploads-201698179963.s3.us-east-2.amazonaws.com",
-            port: "",
-            protocol: "https:",
-            searchParams: {},
-            style: "host",
-        });
-    });
-    it("URI getParamsResult ok", () => {
-        const rParams = BuildURI.from("http://host/bla/blub?name=test&store=meta&key=%40bla").getParamsResult("key", "name", "store");
-        expect(rParams.Ok()).toEqual({
-            key: "@bla",
-            name: "test",
-            store: "meta",
-        });
-    });
-    it("BuildURI getParamsResult fail", () => {
-        const url = BuildURI.from("http://host/bla/blub?name=test&store=meta&key=%40bla");
-        const rParams = url.getParamsResult("key", "name", "store", "key2", "name2");
-        expect(rParams.Err().message).toEqual(`missing parameters: key2,name2`);
-        const rParams2 = url.getParamsResult("key", "name", "store", "key2", "name2", (...keys) => `keys not found: ${keys.join(",")}`);
-        expect(rParams2.Err().message).toEqual(`keys not found: key2,name2`);
-    });
-    describe("URI appendRelative", () => {
-        const cases = [
-            ["", "", "", "/"],
-            ["/", "", "", "/"],
-            ["", "/", "/"],
-            ["/", "/", "/"],
-            ["ab", "", "ab", "/ab"],
-            ["ab", "/", "/ab"],
-            ["cd", "/ab", "/ab/cd"],
-            ["cd", "/ab", "/ab/cd"],
-            ["/cd", "/ab", "/ab/cd"],
-            ["/cd", "/ab", "/ab/cd"],
-            ["/cd", "/ab/", "/ab/cd"],
-            ["/cd/", "/ab/", "/ab/cd/"],
-        ];
-        for (const [relative, path, result, httpResult] of cases) {
-            it(`[${path}] [${relative}] -> ${result}`, () => {
-                const noHost = BuildURI.from(`file://${path}`).appendRelative(relative).URI();
-                expect(noHost.pathname).toBe(result);
-                const host = BuildURI.from(`https://wurst`).pathname(path).appendRelative(relative).URI();
-                expect(host.pathname).toBe(httpResult || result);
-            });
-        }
-    });
-    it("URI getParamsResult fail", () => {
-        const url = URI.from("http://host/bla/blub?name=test&store=meta&key=%40bla");
-        const rParams = url.getParamsResult("key", "name", "store", "key2", {
-            name2: undefined,
-        });
-        expect(rParams.Err().message).toEqual(`missing parameters: key2,name2`);
-        const rParams2 = url.getParamsResult("key", "name", "store", "key2", "name2", (...keys) => `keys not found: ${keys.join(",")}`);
-        expect(rParams2.Err().message).toEqual(`keys not found: key2,name2`);
-    });
-    for (const url of [
-        URI.from("http://host/bla/blub?name=test&store=meta&key=%40bla"),
-        BuildURI.from("http://host/bla/blub?name=test&store=meta&key=%40bla"),
-    ]) {
-        it(`getParam default ${url.constructor.name}`, () => {
-            const rstring = url.getParam("key2", "default");
-            expectTypeOf(rstring).toEqualTypeOf();
-            const xstring = url.getParam("key2");
-            expectTypeOf(xstring).toEqualTypeOf();
-            expect(url.getParam("key2", "default")).toBe("default");
-            expect(url.getParam("key2")).toBeFalsy();
-            expect(url.getParam("key")).toBe("@bla");
-            expect(url.getParam("key", "default")).toBe("@bla");
-            expect(url.getParam({ key: "default" })).toBe("@bla");
-            expect(url.getParam({ key2: "default" })).toBe("default");
-            expect(() => url.getParam({})).toThrowError("Invalid key: {}");
-            expect(() => url.getParam({ key: "x", key2: "y" })).toThrowError('Invalid key: {"key":"x","key2":"y"}');
-        });
-    }
-    it("dashed getParamsResult", () => {
-        const url = URI.from("http://host/bla/blub?name=test&email=a@b.de&clock-id=123&server-id=456");
-        const res = url.getParamsResult("name", "email", "clock-id", {
-            "server-id": "defServer",
-            bla: "defBla",
-        });
-        expect(res.isOk()).toBe(true);
-        expect(res.Ok()).toEqual({
-            bla: "defBla",
-            name: "test",
-            email: "a@b.de",
-            "clock-id": "123",
-            "server-id": "456",
-        });
-    });
-    it("recorded getParamsResult", () => {
-        const url = URI.from("http://host/bla/blub?name=test&email=a@b.de&clock-id=123&server-id=456");
-        const res = url.getParamsResult({
-            name: "defName",
-            email: "defEmail",
-            "clock-id": "defClock-id",
-            "server-id": "defServer",
-            bla: "defBla",
-        });
-        expect(res.isOk()).toBe(true);
-        expect(res.Ok()).toEqual({
-            name: "test",
-            email: "a@b.de",
-            "clock-id": "123",
-            "server-id": "456",
-            bla: "defBla",
-        });
-    });
-    it("recorded getParamsResult with default", () => {
-        const url = URI.from("http://host/bla/blub?name=test&email=a@b.de&clock-id=123&server-id=456");
-        const res = url.getParamsResult({
-            name: "defName",
-            email: param.REQUIRED,
-            "clock-id": false,
-            "server-id": undefined,
-            bla: "defBla",
-        });
-        expect(res.isOk()).toBe(true);
-        expect(res.Ok()).toEqual({
-            name: "test",
-            email: "a@b.de",
-            "clock-id": "123",
-            "server-id": "456",
-            bla: "defBla",
-        });
-    });
-    it("recorded getParamsResult with default to empty string", () => {
-        const url = URI.from("http://host/bla/blub?name=test&email=a@b.de&clock-id=123&server-id=456");
-        const res = url.getParamsResult({
-            name: "defName",
-            email: param.REQUIRED,
-            "clock-id": false,
-            "server-id": undefined,
-            bla: "",
-        });
-        expect(res.isOk()).toBe(true);
-        expect(res.Ok()).toEqual({
-            name: "test",
-            email: "a@b.de",
-            "clock-id": "123",
-            "server-id": "456",
-            bla: "",
-        });
-    });
-    it("recorded getParamsResult with required default", () => {
-        const url = URI.from("http://host/bla/blub?name=test&email=a@b.de&clock-id=123&server-id=456");
-        const res = url.getParamsResult({
-            name: "defName",
-            email: true,
-            "clock-id": false,
-            "server-id": undefined,
-            bla: param.REQUIRED,
-        });
-        expect(res.isErr()).toBe(true);
-    });
-    it("recorded getParamsResult optional", () => {
-        const url = URI.from("http://host/bla/blub?name=test&email=a@b.de&clock-id=123&server-id=456");
-        const res = url.getParamsResult({
-            name: "defName",
-            huhu: "defHuhu",
-            "clock-id": param.REQUIRED,
-            email: param.OPTIONAL,
-            maler: param.OPTIONAL,
-        });
-        expect(res.isOk()).toBeTruthy();
-        expect(res.Ok()).toEqual({
-            "clock-id": "123",
-            name: "test",
-            huhu: "defHuhu",
-            email: "a@b.de",
-        });
-    });
-    it("cleanParams", () => {
-        const url = BuildURI.from("http://host/bla/blub?name=test&email=a@b.de&clock-id=123&server-id=456");
-        expect(url.cleanParams().toString()).toBe("http://host/bla/blub");
-    });
-    it("illegal url relative", () => {
-        expect(URI.from("bla").toString()).equal("file://bla");
-    });
-    it("illegal url absolute", () => {
-        expect(URI.from("/bla").toString()).equal("file:///bla");
-    });
-    describe("applyBase", () => {
-        let base;
-        let ref;
-        beforeEach(() => {
-            base = BuildURI.from("http://example.com/blabla?sock=4");
-            ref = base.clone();
-        });
-        it("toResolv empty -> base", () => {
-            expect(base.resolve("").toString()).toBe(base.toString());
-        });
-        it("toResolv absolute -> absolute", () => {
-            expect(base.resolve("http://murks.com/huhu?sock=4").toString()).toBe("http://murks.com/huhu?sock=4");
-        });
-        it("toResolv relative with out leading / -> base + relative", () => {
-            expect(base.resolve("/meno/huhu").toString()).toBe(ref.pathname("/meno/huhu").toString());
-        });
-        it("toResolv relative without leading / -> base - path + relative", () => {
-            expect(base.resolve("meno/huhu").toString()).toBe(ref.appendRelative("/meno/huhu").toString());
-        });
-        it("toResolv relative with leading ./ -> base - path + relative", () => {
-            expect(base.resolve("./meno/huhu").toString()).toBe(ref.appendRelative("/meno/huhu").toString());
-        });
-    });
-    it("CoerceURI.is", () => {
-        expect(isCoerceURI(0)).toBe(false);
-        expect(isCoerceURI(null)).toBe(false);
-        expect(isCoerceURI(undefined)).toBe(false);
-        expect(isCoerceURI(new URL("http://example.com"))).toBe(true);
-        expect(isCoerceURI(new MutableURL("http://example.com"))).toBe(true);
-        expect(isCoerceURI(URI.from("http://example.com"))).toBe(true);
-        expect(isCoerceURI(BuildURI.from("http://example.com"))).toBe(true);
-        expect(isCoerceURI("http://example.com")).toBe(true);
-    });
-    it("matchScore total", () => {
-        const ref = URI.from("http://example.com/blabla?sock=4");
-        expect(ref.match("http://example.com/blabla?sock=4").score).toBe(4);
-    });
-    it("matchScore nothing", () => {
-        const ref = URI.from("xttp://xample.com/labla?ock=4");
-        expect(ref.match("http://example.com/blabla?sock=4").score).toBe(0);
-    });
-    it("matchScore protocol", () => {
-        const ref = URI.from("http://a.com");
-        expect(ref.match("http://b.com").score).toBe(1);
-    });
-    it("host", () => {
-        const ref = URI.from("https://a.com");
-        expect(ref.match("http://a.com").score).toBe(1);
-    });
-    it("host-port", () => {
-        const ref = URI.from("https://a.com:4711");
-        expect(ref.match("http://b.com:4711").score).toBe(1);
-    });
-    it("no host-port", () => {
-        const ref = URI.from("yttp://a.com/4711");
-        expect(ref.match("xttp://a.com/4711").score).toBe(2);
-    });
-    it("mix host-port", () => {
-        const ref = URI.from("http://a.com/bla/qq/kk");
-        expect(ref.match("xttp://bla/oo/kk").score).toBe(2);
-    });
-    it("mix path", () => {
-        const ref = URI.from("xttp://ab/cd/ed");
-        expect(ref.match("yttp://ab/cd/ed").score).toBe(3);
-    });
-    it("mix path", () => {
-        const ref = URI.from("xttp://ab/Xd/ed");
-        expect(ref.match("yttp://ab/cd/ed").score).toBe(2);
-    });
-    it("not-params", () => {
-        const ref = URI.from("yttp://ed?x=3");
-        expect(ref.match("xttp://ab/cd?x=4").score).toBe(0);
-    });
-    it("one-params", () => {
-        const ref = URI.from("yttp://ed?x=3&y=4");
-        expect(ref.match("xttp://ab/cd?x=4&y=4").score).toBe(1);
-    });
-    it("one-params", () => {
-        const ref = URI.from("yttp://ed?x=3&y=4&o=4");
-        expect(ref.match("xttp://ab/cd?x=4&y=4&o=4").score).toBe(2);
-    });
-    it("cleanParams all", () => {
-        const uri = BuildURI.from("http://key.bag?a=1&b=2&c=3").cleanParams();
-        expect(Array.from(uri.getParams)).toEqual([]);
-    });
-    it("cleanParams not matching", () => {
-        const uri = BuildURI.from("http://key.bag?a=1&b=2&c=3").cleanParams(["A"], "B");
-        expect(Array.from(uri.getParams)).toEqual([
-            ["a", "1"],
-            ["b", "2"],
-            ["c", "3"],
-        ]);
-    });
-    it("cleanParams not matching", () => {
-        const uri = BuildURI.from("http://key.bag?a=1&b=2&c=3").cleanParams(["A"], "B", "a", "a", "b");
-        expect(Array.from(uri.getParams)).toEqual([["c", "3"]]);
-    });
-    it("cleanParams not matching", () => {
-        const uri = BuildURI.from("http://key.bag?a=1&b=2&c=3").cleanParams(["c", "b", "a"]);
-        expect(Array.from(uri.getParams)).toEqual([]);
-    });
-    it("common hash", () => {
-        const uri = URI.from("http://key.bag?a=1&b=2&c=3#hash");
-        expect(uri.hash).toBe("#hash");
-        const buri = BuildURI.from("http://key.bag?a=1&b=2&c=3").hash("hash").URI();
-        expect(buri.hash).toBe("#hash");
-        const hashuri = BuildURI.from("http://key.bag?a=1&b=2&c=3").hash("#hash").URI();
-        expect(hashuri.hash).toBe("#hash");
-    });
-    it("get hashParams", () => {
-        const uri = BuildURI.from("http://key.bag?a=1&b=2&c=3")
-            .hashParams({
-            c: true,
-            a: 1,
-            b: "5",
-            d: new Date("2021-01-01T00:00:00.000Z"),
-        })
-            .URI();
-        expect(uri.hash).toBe("#a=1&b=5&c=true&d=2021-01-01T00%3A00%3A00.000Z");
-        const mergeUri = BuildURI.from("http://key.bag?a=1&b=2&c=3#c=true&a=4&d=9")
-            .hashParams({
-            a: 1,
-            b: "5",
-            d: new Date("2021-01-01T00:00:00.000Z"),
-        }, "merge")
-            .URI();
-        expect(mergeUri.hash).toBe("#a=1&b=5&c=true&d=2021-01-01T00%3A00%3A00.000Z");
-    });
-    it("get hashParams", () => {
-        const buri = BuildURI.from("http://key.bag?a=1&b=2&c=3").hashParams({
-            c: true,
-            a: 1,
-            b: "5",
-            d: new Date("2021-01-01T00:00:00.000Z"),
-        });
-        expect(buri.toString()).toBe("http://key.bag/?a=1&b=2&c=3#a=1&b=5&c=true&d=2021-01-01T00%3A00%3A00.000Z");
-        const rbParam = buri.getHashParams({
-            d: param.REQUIRED,
-            e: "default",
-            f: param.OPTIONAL,
-        });
-        expect(rbParam.Ok()).toEqual({
-            d: "2021-01-01T00:00:00.000Z",
-            e: "default",
-        });
-        const rParam = buri.URI().getHashParams({
-            d: param.REQUIRED,
-            e: "default",
-            f: param.OPTIONAL,
-        });
-        expect(rParam.Ok()).toEqual({
-            d: "2021-01-01T00:00:00.000Z",
-            e: "default",
-        });
-    });
-    it("error hashParams", () => {
-        const buri = BuildURI.from("http://key.bag?a=1&b=2&c=3").hashParams({
-            c: true,
-            a: 1,
-            b: "5",
-            d: new Date("2021-01-01T00:00:00.000Z"),
-        });
-        const rerrParam = buri.getHashParams({
-            a: param.REQUIRED,
-            e: "default",
-            f: param.OPTIONAL,
-            g: param.REQUIRED,
-        });
-        expect(rerrParam.Err().message).toBe("missing parameters: g");
-    });
-    it("local", () => {
-        const fUri = URI.from("file:///ed/bla?x=3&y=4#doof");
-        expect(fUri.withoutHostAndSchema).toBe("/ed/bla?x=3&y=4#doof");
-        const hUri = URI.from("http://bla.com:44/ed/bla?x=3&y=4#doof");
-        expect(hUri.withoutHostAndSchema).toBe("/ed/bla?x=3&y=4#doof");
-    });
-    it("without hash local", () => {
-        const fUri = URI.from("file:///ed/bla?x=3&y=4");
-        expect(fUri.withoutHostAndSchema).toBe("/ed/bla?x=3&y=4");
-        const hUri = URI.from("http://bla.com:44/ed/bla?x=3&y=4");
-        expect(hUri.withoutHostAndSchema).toBe("/ed/bla?x=3&y=4");
-    });
-    it("without search local", () => {
-        const fUri = URI.from("file:///ed/bla");
-        expect(fUri.withoutHostAndSchema).toBe("/ed/bla");
-        const hUri = URI.from("http://bla.com:44/ed/bla");
-        expect(hUri.withoutHostAndSchema).toBe("/ed/bla");
-    });
-    it("without search but hash local", () => {
-        const fUri = URI.from("file:///ed/bla#doof");
-        expect(fUri.withoutHostAndSchema).toBe("/ed/bla#doof");
-        const hUri = URI.from("http://bla.com:44/ed/bla#doof");
-        expect(hUri.withoutHostAndSchema).toBe("/ed/bla#doof");
-    });
-    it("pathname + search + hash", () => {
-        const refUnk = URI.from("yttp://ed/bla?y=4&x=3");
-        expect(refUnk.withoutHostAndSchema).toBe("ed/bla?x=3&y=4");
-        const refHttp = URI.from("http://host/ed/bla?x=3&y=4");
-        expect(refHttp.withoutHostAndSchema).toBe("/ed/bla?x=3&y=4");
-        const refFile = URI.from("file:///ed/bla?x=3&y=4");
-        expect(refFile.withoutHostAndSchema).toBe("/ed/bla?x=3&y=4");
-    });
-    it("onlyHostAndSchema", () => {
-        const fUri = URI.from("file:///ed/bla#doof");
-        expect(fUri.onlyHostAndSchema).toBe("file://");
-        const hUri = URI.from("http://bla.com:44/ed/bla#doof");
-        expect(hUri.onlyHostAndSchema).toBe("http://bla.com:44/");
-        const hplainUri = URI.from("http://bla.com:44");
-        expect(hplainUri.onlyHostAndSchema).toBe("http://bla.com:44/");
-        const fplainUri = URI.from("file:///bla.com");
-        expect(fplainUri.onlyHostAndSchema).toBe("file://");
-    });
-    it("getParams", () => {
-        const uri = URI.from("http://key.bag?a=1&b=2&c=3");
-        expect(Array.from(uri.getParams)).toEqual([
-            ["a", "1"],
-            ["b", "2"],
-            ["c", "3"],
-        ]);
-    });
-    it("getHashes", () => {
-        const euri = URI.from("http://key.bag#");
-        expect(Array.from(euri.getHashes)).toEqual([]);
-        const nouri = URI.from("http://key.bag#kddkdkd");
-        expect(Array.from(nouri.getHashes)).toEqual([["kddkdkd", ""]]);
-        const uri = URI.from("http://key.bag#a=1&b=2&c=3");
-        expect(Array.from(uri.getHashes)).toEqual([
-            ["a", "1"],
-            ["b", "2"],
-            ["c", "3"],
-        ]);
-    });
-});
-//# sourceMappingURL=uri.test.js.map