@angular-wave/angular.ts 0.7.7 → 0.8.0

package/src/{core → services}/location/location.spec.js

@@ -1,10 +1,18 @@
 import {
-  LocationHtml5Url,
-  LocationHashbangUrl,
+  decodePath,
+  encodePath,
+  normalizePath,
+  Location,
   LocationProvider,
-} from "./location";
-import { Angular } from "../../loader.js";
-import { createInjector } from "../di/injector.js";
+  parseAppUrl,
+  stripBaseUrl,
+  stripHash,
+  stripFile,
+  serverBase,
+  urlsEqual,
+} from "./location.js";
+import { Angular } from "../../angular.js";
+import { createInjector } from "../../core/di/injector.js";
 
 describe("$location", () => {
   let module;
@@ -24,12 +32,14 @@ describe("$location", () => {
   describe("defaults", () => {
     it('should have hashPrefix of "!"', () => {
       let provider = new LocationProvider();
-      expect(provider.getHashPrefix()).toBe("!");
+      expect(provider.hashPrefixConf).toBe("!");
     });
 
-    it("should not be html5 mode", () => {
+    it("should default to html5 mode with no base and rewrite links", () => {
       let provider = new LocationProvider();
-      expect(provider.getHtml5Mode().enabled).toBeFalse();
+      expect(provider.html5ModeConf.enabled).toBeTrue();
+      expect(provider.html5ModeConf.requireBase).toBeFalse();
+      expect(provider.html5ModeConf.rewriteLinks).toBeTrue();
     });
   });
 
@@ -61,35 +71,28 @@ describe("$location", () => {
 
     it("should not include the drive name in path() on WIN", () => {
       // See issue #4680 for details
-      const locationUrl = new LocationHashbangUrl(
-        "file:///base",
-        "file:///",
-        "#!",
-      );
-      locationUrl.$$parse("file:///base#!/foo?a=b&c#hash");
+      const locationUrl = new Location("file:///base", "file:///", false, "#!");
+      locationUrl.parse("file:///base#!/foo?a=b&c#hash");
 
-      expect(locationUrl.path()).toBe("/foo");
+      expect(locationUrl.getPath()).toBe("/foo");
     });
 
     it("should include the drive name if it was provided in the input url", () => {
-      const locationUrl = new LocationHashbangUrl(
-        "file:///base",
-        "file:///",
-        "#!",
-      );
-      locationUrl.$$parse("file:///base#!/C:/foo?a=b&c#hash");
+      const locationUrl = new Location("file:///base", "file:///", false, "#!");
+      locationUrl.parse("file:///base#!/C:/foo?a=b&c#hash");
 
-      expect(locationUrl.path()).toBe("/C:/foo");
+      expect(locationUrl.getPath()).toBe("/C:/foo");
     });
   });
 
   describe("NewUrl", () => {
     function createLocationHtml5Url() {
-      const locationUrl = new LocationHtml5Url(
+      const locationUrl = new Location(
         "http://www.domain.com:9877/",
         "http://www.domain.com:9877/",
+        true,
       );
-      locationUrl.$$parse(
+      locationUrl.parse(
         "http://www.domain.com:9877/path/b?search=a&b=c&d#hash",
       );
       return locationUrl;
@@ -97,67 +100,64 @@ describe("$location", () => {
 
     it("should provide common getters", () => {
       const locationUrl = createLocationHtml5Url();
-      expect(locationUrl.absUrl()).toBe(
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/path/b?search=a&b=c&d#hash",
       );
-      expect(locationUrl.protocol()).toBe("http");
-      expect(locationUrl.host()).toBe("www.domain.com");
-      expect(locationUrl.port()).toBe(9877);
-      expect(locationUrl.path()).toBe("/path/b");
-      expect(locationUrl.search()).toEqual({ search: "a", b: "c", d: true });
-      expect(locationUrl.hash()).toBe("hash");
-      expect(locationUrl.url()).toBe("/path/b?search=a&b=c&d#hash");
+      expect(locationUrl.getPath()).toBe("/path/b");
+      expect(locationUrl.getSearch()).toEqual({ search: "a", b: "c", d: true });
+      expect(locationUrl.getHash()).toBe("hash");
+      expect(locationUrl.getUrl()).toBe("/path/b?search=a&b=c&d#hash");
     });
 
     it("path() should change path", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.path("/new/path");
-      expect(locationUrl.path()).toBe("/new/path");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setPath("/new/path");
+      expect(locationUrl.getPath()).toBe("/new/path");
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/new/path?search=a&b=c&d#hash",
       );
     });
 
     it("path() should not break on numeric values", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.path(1);
-      expect(locationUrl.path()).toBe("/1");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setPath(1);
+      expect(locationUrl.getPath()).toBe("/1");
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/1?search=a&b=c&d#hash",
       );
     });
 
     it("path() should allow using 0 as path", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.path(0);
-      expect(locationUrl.path()).toBe("/0");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setPath(0);
+      expect(locationUrl.getPath()).toBe("/0");
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/0?search=a&b=c&d#hash",
       );
     });
 
     it("path() should set to empty path on null value", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.path("/foo");
-      expect(locationUrl.path()).toBe("/foo");
-      locationUrl.path(null);
-      expect(locationUrl.path()).toBe("/");
+      locationUrl.setPath("/foo");
+      expect(locationUrl.getPath()).toBe("/foo");
+      locationUrl.setPath(null);
+      expect(locationUrl.getPath()).toBe("/");
     });
 
     it("search() should accept string", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.search("x=y&c");
-      expect(locationUrl.search()).toEqual({ x: "y", c: true });
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setSearch("x=y&c");
+      expect(locationUrl.getSearch()).toEqual({ x: "y", c: true });
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/path/b?x=y&c#hash",
       );
     });
 
     it("search() should accept object", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.search({ one: 1, two: true });
-      expect(locationUrl.search()).toEqual({ one: 1, two: true });
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setSearch({ one: 1, two: true });
+      expect(locationUrl.getSearch()).toEqual({ one: 1, two: true });
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/path/b?one=1&two#hash",
       );
     });
@@ -165,270 +165,258 @@ describe("$location", () => {
     it("search() should copy object", () => {
       const locationUrl = createLocationHtml5Url();
       const obj = { one: 1, two: true, three: null };
-      locationUrl.search(obj);
+      locationUrl.setSearch(obj);
       expect(obj).toEqual({ one: 1, two: true, three: null });
       obj.one = "changed";
-      expect(locationUrl.search()).toEqual({ one: 1, two: true });
-      expect(locationUrl.absUrl()).toBe(
+      expect(locationUrl.getSearch()).toEqual({ one: 1, two: true });
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/path/b?one=1&two#hash",
       );
     });
 
     it("search() should change single parameter", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.search({ id: "old", preserved: true });
-      locationUrl.search("id", "new");
+      locationUrl.setSearch({ id: "old", preserved: true });
+      locationUrl.setSearch("id", "new");
 
-      expect(locationUrl.search()).toEqual({ id: "new", preserved: true });
+      expect(locationUrl.getSearch()).toEqual({ id: "new", preserved: true });
     });
 
     it("search() should remove single parameter", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.search({ id: "old", preserved: true });
-      locationUrl.search("id", null);
+      locationUrl.setSearch({ id: "old", preserved: true });
+      locationUrl.setSearch("id", null);
 
-      expect(locationUrl.search()).toEqual({ preserved: true });
+      expect(locationUrl.getSearch()).toEqual({ preserved: true });
     });
 
     it("search() should remove multiple parameters", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.search({ one: 1, two: true });
-      expect(locationUrl.search()).toEqual({ one: 1, two: true });
-      locationUrl.search({ one: null, two: null });
-      expect(locationUrl.search()).toEqual({});
-      expect(locationUrl.absUrl()).toBe(
-        "http://www.domain.com:9877/path/b#hash",
-      );
+      locationUrl.setSearch({ one: 1, two: true });
+      expect(locationUrl.getSearch()).toEqual({ one: 1, two: true });
+      locationUrl.setSearch({ one: null, two: null });
+      expect(locationUrl.getSearch()).toEqual({});
+      expect(locationUrl.absUrl).toBe("http://www.domain.com:9877/path/b#hash");
     });
 
     it("search() should accept numeric keys", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.search({ 1: "one", 2: "two" });
-      expect(locationUrl.search()).toEqual({ 1: "one", 2: "two" });
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setSearch({ 1: "one", 2: "two" });
+      expect(locationUrl.getSearch()).toEqual({ 1: "one", 2: "two" });
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/path/b?1=one&2=two#hash",
       );
     });
 
     it("search() should handle multiple value", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.search("a&b");
-      expect(locationUrl.search()).toEqual({ a: true, b: true });
+      locationUrl.setSearch("a&b");
+      expect(locationUrl.getSearch()).toEqual({ a: true, b: true });
 
-      locationUrl.search("a", null);
+      locationUrl.setSearch("a", null);
 
-      expect(locationUrl.search()).toEqual({ b: true });
+      expect(locationUrl.getSearch()).toEqual({ b: true });
 
-      locationUrl.search("b", undefined);
-      expect(locationUrl.search()).toEqual({});
+      locationUrl.setSearch("b", undefined);
+      expect(locationUrl.getSearch()).toEqual({});
     });
 
     it("search() should handle single value", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.search("ignore");
-      expect(locationUrl.search()).toEqual({ ignore: true });
-      locationUrl.search(1);
-      expect(locationUrl.search()).toEqual({ 1: true });
+      locationUrl.setSearch("ignore");
+      expect(locationUrl.getSearch()).toEqual({ ignore: true });
+      locationUrl.setSearch(1);
+      expect(locationUrl.getSearch()).toEqual({ 1: true });
     });
 
     it("search() should throw error an incorrect argument", () => {
       const locationUrl = createLocationHtml5Url();
       expect(() => {
-        locationUrl.search(null);
+        locationUrl.setSearch(null);
       }).toThrowError(/isrcharg/);
       expect(() => {
-        locationUrl.search(undefined);
+        locationUrl.setSearch(undefined);
       }).toThrowError(/isrcharg/);
     });
 
     it("hash() should change hash fragment", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.hash("new-hash");
-      expect(locationUrl.hash()).toBe("new-hash");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setHash("new-hash");
+      expect(locationUrl.getHash()).toBe("new-hash");
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/path/b?search=a&b=c&d#new-hash",
       );
     });
 
     it("hash() should accept numeric parameter", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.hash(5);
-      expect(locationUrl.hash()).toBe("5");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setHash(5);
+      expect(locationUrl.getHash()).toBe("5");
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/path/b?search=a&b=c&d#5",
       );
     });
 
     it("hash() should allow using 0", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.hash(0);
-      expect(locationUrl.hash()).toBe("0");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setHash(0);
+      expect(locationUrl.getHash()).toBe("0");
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/path/b?search=a&b=c&d#0",
       );
     });
 
     it("hash() should accept null parameter", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.hash(null);
-      expect(locationUrl.hash()).toBe("");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setHash(null);
+      expect(locationUrl.getHash()).toBe("");
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/path/b?search=a&b=c&d",
       );
     });
 
-    it("url() should change the path, search and hash", () => {
+    it("url getter/setter should change the path, search and hash", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.url("/some/path?a=b&c=d#hhh");
-      expect(locationUrl.url()).toBe("/some/path?a=b&c=d#hhh");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setUrl("/some/path?a=b&c=d#hhh");
+      expect(locationUrl.getUrl()).toBe("/some/path?a=b&c=d#hhh");
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/some/path?a=b&c=d#hhh",
       );
-      expect(locationUrl.path()).toBe("/some/path");
-      expect(locationUrl.search()).toEqual({ a: "b", c: "d" });
-      expect(locationUrl.hash()).toBe("hhh");
+      expect(locationUrl.getPath()).toBe("/some/path");
+      expect(locationUrl.getSearch()).toEqual({ a: "b", c: "d" });
+      expect(locationUrl.getHash()).toBe("hhh");
     });
 
-    it("url() should change only hash when no search and path specified", () => {
+    it("url getter/setter should change only hash when no search and path specified", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.url("#some-hash");
+      locationUrl.setUrl("#some-hash");
 
-      expect(locationUrl.hash()).toBe("some-hash");
-      expect(locationUrl.url()).toBe("/path/b?search=a&b=c&d#some-hash");
-      expect(locationUrl.absUrl()).toBe(
+      expect(locationUrl.getHash()).toBe("some-hash");
+      expect(locationUrl.getUrl()).toBe("/path/b?search=a&b=c&d#some-hash");
+      expect(locationUrl.absUrl).toBe(
         "http://www.domain.com:9877/path/b?search=a&b=c&d#some-hash",
       );
     });
 
-    it("url() should change only search and hash when no path specified", () => {
+    it("setUrl() should change only search and hash when no path specified", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.url("?a=b");
+      locationUrl.setUrl("?a=b");
 
-      expect(locationUrl.search()).toEqual({ a: "b" });
-      expect(locationUrl.hash()).toBe("");
-      expect(locationUrl.path()).toBe("/path/b");
+      expect(locationUrl.getSearch()).toEqual({ a: "b" });
+      expect(locationUrl.getHash()).toBe("");
+      expect(locationUrl.getPath()).toBe("/path/b");
     });
 
-    it("url() should reset search and hash when only path specified", () => {
+    it("setUrl() should reset search and hash when only path specified", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.url("/new/path");
+      locationUrl.setUrl("/new/path");
 
-      expect(locationUrl.path()).toBe("/new/path");
-      expect(locationUrl.search()).toEqual({});
-      expect(locationUrl.hash()).toBe("");
+      expect(locationUrl.getPath()).toBe("/new/path");
+      expect(locationUrl.getSearch()).toEqual({});
+      expect(locationUrl.getHash()).toBe("");
     });
 
-    it("url() should change path when empty string specified", () => {
+    it("setUrl() should change path when empty string specified", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.url("");
+      locationUrl.setUrl("");
 
-      expect(locationUrl.path()).toBe("/");
-      expect(locationUrl.search()).toEqual({});
-      expect(locationUrl.hash()).toBe("");
-    });
-
-    it("replace should set $$replace flag and return itself", () => {
-      const locationUrl = createLocationHtml5Url();
-      expect(locationUrl.$$replace).toBe(false);
-
-      locationUrl.replace();
-      expect(locationUrl.$$replace).toBe(true);
-      expect(locationUrl.replace()).toBe(locationUrl);
+      expect(locationUrl.getPath()).toBe("/");
+      expect(locationUrl.getSearch()).toEqual({});
+      expect(locationUrl.getHash()).toBe("");
     });
 
     it("should parse new url", () => {
-      let locationUrl = new LocationHtml5Url(
-        "http://host.com/",
-        "http://host.com/",
-      );
-      locationUrl.$$parse("http://host.com/base");
-      expect(locationUrl.path()).toBe("/base");
+      let locationUrl = new Location("http://host.com/", "http://host.com/");
+      locationUrl.parse("http://host.com/base");
+      expect(locationUrl.getPath()).toBe("/base");
 
-      locationUrl = new LocationHtml5Url(
-        "http://host.com/",
-        "http://host.com/",
-      );
-      locationUrl.$$parse("http://host.com/base#");
-      expect(locationUrl.path()).toBe("/base");
+      locationUrl = new Location("http://host.com/", "http://host.com/", true);
+      locationUrl.parse("http://host.com/base#");
+      expect(locationUrl.getPath()).toBe("/base");
     });
 
     it("should prefix path with forward-slash", () => {
-      const locationUrl = new LocationHtml5Url(
+      const locationUrl = new Location(
         "http://server/",
         "http://server/",
+        true,
       );
-      locationUrl.path("b");
+      locationUrl.setPath("b");
 
-      expect(locationUrl.path()).toBe("/b");
-      expect(locationUrl.absUrl()).toBe("http://server/b");
+      expect(locationUrl.getPath()).toBe("/b");
+      expect(locationUrl.absUrl).toBe("http://server/b");
     });
 
     it("should set path to forward-slash when empty", () => {
-      const locationUrl = new LocationHtml5Url(
+      const locationUrl = new Location(
         "http://server/",
         "http://server/",
+        true,
       );
-      locationUrl.$$parse("http://server/");
-      expect(locationUrl.path()).toBe("/");
-      expect(locationUrl.absUrl()).toBe("http://server/");
+      locationUrl.parse("http://server/");
+      expect(locationUrl.getPath()).toBe("/");
+      expect(locationUrl.absUrl).toBe("http://server/");
     });
 
     it("setters should return Url object to allow chaining", () => {
       const locationUrl = createLocationHtml5Url();
-      expect(locationUrl.path("/any")).toBe(locationUrl);
-      expect(locationUrl.search("")).toBe(locationUrl);
-      expect(locationUrl.hash("aaa")).toBe(locationUrl);
-      expect(locationUrl.url("/some")).toBe(locationUrl);
+      expect(locationUrl.setPath("/any")).toBe(locationUrl);
+      expect(locationUrl.setSearch("")).toBe(locationUrl);
+      expect(locationUrl.setHash("aaa")).toBe(locationUrl);
+      expect(locationUrl.setUrl("/some")).toBe(locationUrl);
     });
 
     it("should not preserve old properties when parsing new url", () => {
       const locationUrl = createLocationHtml5Url();
-      locationUrl.$$parse("http://www.domain.com:9877/a");
+      locationUrl.parse("http://www.domain.com:9877/a");
 
-      expect(locationUrl.path()).toBe("/a");
-      expect(locationUrl.search()).toEqual({});
-      expect(locationUrl.hash()).toBe("");
-      expect(locationUrl.absUrl()).toBe("http://www.domain.com:9877/a");
+      expect(locationUrl.getPath()).toBe("/a");
+      expect(locationUrl.getSearch()).toEqual({});
+      expect(locationUrl.getHash()).toBe("");
+      expect(locationUrl.absUrl).toBe("http://www.domain.com:9877/a");
     });
 
     // it("should not rewrite when hashbang url is not given", () => {
     //   initService({ html5Mode: true, hashPrefix: "!", supportHistory: true });
     //   initBrowser({ url: "http://domain.com/base/a/b", basePath: "/base" });
-    //   expect($browser.url()).toBe("http://domain.com/base/a/b");
+    //   expect($browser.getUrl()).toBe("http://domain.com/base/a/b");
     // });
 
     it("should prepend path with basePath", () => {
-      const locationUrl = new LocationHtml5Url(
+      const locationUrl = new Location(
         "http://server/base/",
         "http://server/base/",
+        true,
       );
-      locationUrl.$$parse("http://server/base/abc?a");
-      expect(locationUrl.path()).toBe("/abc");
-      expect(locationUrl.search()).toEqual({ a: true });
+      locationUrl.parse("http://server/base/abc?a");
+      expect(locationUrl.getPath()).toBe("/abc");
+      expect(locationUrl.getSearch()).toEqual({ a: true });
 
-      locationUrl.path("/new/path");
-      expect(locationUrl.absUrl()).toBe("http://server/base/new/path?a");
+      locationUrl.setPath("/new/path");
+      expect(locationUrl.absUrl).toBe("http://server/base/new/path?a");
     });
 
     it("should throw error when invalid server url given", () => {
-      const locationUrl = new LocationHtml5Url(
+      const locationUrl = new Location(
         "http://server.org/base/abc",
         "http://server.org/base/",
+        true,
       );
 
       expect(() => {
-        locationUrl.$$parse("http://other.server.org/path#/path");
+        locationUrl.parse("http://other.server.org/path#/path");
       }).toThrowError(/ipthprfx/);
     });
 
     it("should throw error when invalid base url given", () => {
-      const locationUrl = new LocationHtml5Url(
+      const locationUrl = new Location(
         "http://server.org/base/abc",
         "http://server.org/base/",
+        true,
       );
 
       expect(() => {
-        locationUrl.$$parse("http://server.org/path#/path");
+        locationUrl.parse("http://server.org/path#/path");
       }).toThrowError(/ipthprfx/);
     });
 
@@ -437,343 +425,800 @@ describe("$location", () => {
         const locationUrl = createLocationHtml5Url();
         expect(locationUrl.$$state).toEqual(undefined);
 
-        const returned = locationUrl.state({ a: 2 });
+        const returned = locationUrl.setState({ a: 2 });
         expect(locationUrl.$$state).toEqual({ a: 2 });
         expect(returned).toBe(locationUrl);
       });
 
       it("should set state", () => {
         const locationUrl = createLocationHtml5Url();
-        locationUrl.state({ a: 2 });
-        expect(locationUrl.state()).toEqual({ a: 2 });
+        locationUrl.setState({ a: 2 });
+        expect(locationUrl.getState()).toEqual({ a: 2 });
       });
 
       it("should allow to set both URL and state", () => {
         const locationUrl = createLocationHtml5Url();
-        locationUrl.url("/foo").state({ a: 2 });
-        expect(locationUrl.url()).toEqual("/foo");
-        expect(locationUrl.state()).toEqual({ a: 2 });
+        locationUrl.setUrl("/foo").setState({ a: 2 });
+        expect(locationUrl.getUrl()).toEqual("/foo");
+        expect(locationUrl.getState()).toEqual({ a: 2 });
       });
 
       it("should allow to mix state and various URL functions", () => {
         const locationUrl = createLocationHtml5Url();
         locationUrl
-          .path("/foo")
-          .hash("abcd")
-          .state({ a: 2 })
-          .search("bar", "baz");
-
-        expect(locationUrl.path()).toEqual("/foo");
-        expect(locationUrl.state()).toEqual({ a: 2 });
-        expect(locationUrl.search() && locationUrl.search().bar).toBe("baz");
-        expect(locationUrl.hash()).toEqual("abcd");
+          .setPath("/foo")
+          .setHash("abcd")
+          .setState({ a: 2 })
+          .setSearch("bar", "baz");
+
+        expect(locationUrl.getPath()).toEqual("/foo");
+        expect(locationUrl.getState()).toEqual({ a: 2 });
+        expect(locationUrl.getSearch() && locationUrl.getSearch().bar).toBe(
+          "baz",
+        );
+        expect(locationUrl.getHash()).toEqual("abcd");
       });
     });
 
     describe("encoding", () => {
       it("should encode special characters", () => {
         const locationUrl = createLocationHtml5Url();
-        locationUrl.path("/a <>#");
-        locationUrl.search({ "i j": "<>#" });
-        locationUrl.hash("<>#");
-
-        expect(locationUrl.path()).toBe("/a <>#");
-        expect(locationUrl.search()).toEqual({ "i j": "<>#" });
-        expect(locationUrl.hash()).toBe("<>#");
-        expect(locationUrl.absUrl()).toBe(
+        locationUrl.setPath("/a <>#");
+        locationUrl.setSearch({ "i j": "<>#" });
+        locationUrl.setHash("<>#");
+
+        expect(locationUrl.getPath()).toBe("/a <>#");
+        expect(locationUrl.getSearch()).toEqual({ "i j": "<>#" });
+        expect(locationUrl.getHash()).toBe("<>#");
+        expect(locationUrl.absUrl).toBe(
           "http://www.domain.com:9877/a%20%3C%3E%23?i%20j=%3C%3E%23#%3C%3E%23",
         );
       });
 
       it("should not encode !$:@", () => {
         const locationUrl = createLocationHtml5Url();
-        locationUrl.path("/!$:@");
-        locationUrl.search("");
-        locationUrl.hash("!$:@");
+        locationUrl.setPath("/!$:@");
+        locationUrl.setSearch("");
+        locationUrl.setHash("!$:@");
 
-        expect(locationUrl.absUrl()).toBe(
-          "http://www.domain.com:9877/!$:@#!$:@",
-        );
+        expect(locationUrl.absUrl).toBe("http://www.domain.com:9877/!$:@#!$:@");
       });
 
       it("should decode special characters", () => {
-        const locationUrl = new LocationHtml5Url(
+        const locationUrl = new Location(
           "http://host.com/",
           "http://host.com/",
+          true,
         );
-        locationUrl.$$parse(
+        locationUrl.parse(
           "http://host.com/a%20%3C%3E%23?i%20j=%3C%3E%23#x%20%3C%3E%23",
         );
-        expect(locationUrl.path()).toBe("/a <>#");
-        expect(locationUrl.search()).toEqual({ "i j": "<>#" });
-        expect(locationUrl.hash()).toBe("x <>#");
+        expect(locationUrl.getPath()).toBe("/a <>#");
+        expect(locationUrl.getSearch()).toEqual({ "i j": "<>#" });
+        expect(locationUrl.getHash()).toBe("x <>#");
       });
 
       it("should not decode encoded forward slashes in the path", () => {
-        const locationUrl = new LocationHtml5Url(
+        const locationUrl = new Location(
           "http://host.com/base/",
           "http://host.com/base/",
+          true,
         );
-        locationUrl.$$parse("http://host.com/base/a/ng2;path=%2Fsome%2Fpath");
-        expect(locationUrl.path()).toBe("/a/ng2;path=%2Fsome%2Fpath");
-        expect(locationUrl.search()).toEqual({});
-        expect(locationUrl.hash()).toBe("");
-        expect(locationUrl.url()).toBe("/a/ng2;path=%2Fsome%2Fpath");
-        expect(locationUrl.absUrl()).toBe(
+        locationUrl.parse("http://host.com/base/a/ng2;path=%2Fsome%2Fpath");
+        expect(locationUrl.getPath()).toBe("/a/ng2;path=%2Fsome%2Fpath");
+        expect(locationUrl.getSearch()).toEqual({});
+        expect(locationUrl.getHash()).toBe("");
+        expect(locationUrl.getUrl()).toBe("/a/ng2;path=%2Fsome%2Fpath");
+        expect(locationUrl.absUrl).toBe(
           "http://host.com/base/a/ng2;path=%2Fsome%2Fpath",
         );
       });
 
       it("should decode pluses as spaces in urls", () => {
-        const locationUrl = new LocationHtml5Url(
+        const locationUrl = new Location(
           "http://host.com/",
           "http://host.com/",
+          true,
         );
-        locationUrl.$$parse("http://host.com/?a+b=c+d");
-        expect(locationUrl.search()).toEqual({ "a b": "c d" });
+        locationUrl.parse("http://host.com/?a+b=c+d");
+        expect(locationUrl.getSearch()).toEqual({ "a b": "c d" });
       });
 
       it("should retain pluses when setting search queries", () => {
         const locationUrl = createLocationHtml5Url();
-        locationUrl.search({ "a+b": "c+d" });
-        expect(locationUrl.search()).toEqual({ "a+b": "c+d" });
+        locationUrl.setSearch({ "a+b": "c+d" });
+        expect(locationUrl.getSearch()).toEqual({ "a+b": "c+d" });
       });
     });
   });
 
   describe("HashbangUrl", () => {
     function createHashbangUrl() {
-      const locationUrl = new LocationHashbangUrl(
+      const locationUrl = new Location(
         "http://www.server.org:1234/base",
         "http://www.server.org:1234/",
+        false,
         "#!",
       );
-      locationUrl.$$parse("http://www.server.org:1234/base#!/path?a=b&c#hash");
+      locationUrl.parse("http://www.server.org:1234/base#!/path?a=b&c#hash");
       return locationUrl;
     }
 
     it("should parse hashbang url into path and search", () => {
       const locationUrl = createHashbangUrl();
-      expect(locationUrl.protocol()).toBe("http");
-      expect(locationUrl.host()).toBe("www.server.org");
-      expect(locationUrl.port()).toBe(1234);
-      expect(locationUrl.path()).toBe("/path");
-      expect(locationUrl.search()).toEqual({ a: "b", c: true });
-      expect(locationUrl.hash()).toBe("hash");
+      expect(locationUrl.getPath()).toBe("/path");
+      expect(locationUrl.getSearch()).toEqual({ a: "b", c: true });
+      expect(locationUrl.getHash()).toBe("hash");
     });
 
-    it("absUrl() should return hashbang url", () => {
+    it("absUrl should return hashbang url", () => {
       const locationUrl = createHashbangUrl();
-      expect(locationUrl.absUrl()).toBe(
+      expect(locationUrl.absUrl).toBe(
         "http://www.server.org:1234/base#!/path?a=b&c#hash",
       );
 
-      locationUrl.path("/new/path");
-      locationUrl.search({ one: 1 });
-      locationUrl.hash("hhh");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setPath("/new/path");
+      locationUrl.setSearch({ one: 1 });
+      locationUrl.setHash("hhh");
+      expect(locationUrl.absUrl).toBe(
         "http://www.server.org:1234/base#!/new/path?one=1#hhh",
       );
     });
 
     it("should preserve query params in base", () => {
-      const locationUrl = new LocationHashbangUrl(
+      const locationUrl = new Location(
         "http://www.server.org:1234/base?base=param",
         "http://www.server.org:1234/",
+        false,
         "#",
       );
-      locationUrl.$$parse(
+      locationUrl.parse(
         "http://www.server.org:1234/base?base=param#/path?a=b&c#hash",
       );
-      expect(locationUrl.absUrl()).toBe(
+      expect(locationUrl.absUrl).toBe(
         "http://www.server.org:1234/base?base=param#/path?a=b&c#hash",
       );
 
-      locationUrl.path("/new/path");
-      locationUrl.search({ one: 1 });
-      locationUrl.hash("hhh");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.setPath("/new/path");
+      locationUrl.setSearch({ one: 1 });
+      locationUrl.setHash("hhh");
+      expect(locationUrl.absUrl).toBe(
         "http://www.server.org:1234/base?base=param#/new/path?one=1#hhh",
       );
     });
 
     it("should prefix path with forward-slash", () => {
-      const locationUrl = new LocationHashbangUrl(
+      const locationUrl = new Location(
         "http://host.com/base",
         "http://host.com/",
+        false,
         "#",
       );
-      locationUrl.$$parse("http://host.com/base#path");
-      expect(locationUrl.path()).toBe("/path");
-      expect(locationUrl.absUrl()).toBe("http://host.com/base#/path");
+      locationUrl.parse("http://host.com/base#path");
+      expect(locationUrl.getPath()).toBe("/path");
+      expect(locationUrl.absUrl).toBe("http://host.com/base#/path");
 
-      locationUrl.path("wrong");
-      expect(locationUrl.path()).toBe("/wrong");
-      expect(locationUrl.absUrl()).toBe("http://host.com/base#/wrong");
+      locationUrl.setPath("wrong");
+      expect(locationUrl.getPath()).toBe("/wrong");
+      expect(locationUrl.absUrl).toBe("http://host.com/base#/wrong");
     });
 
     it("should set path to forward-slash when empty", () => {
-      const locationUrl = new LocationHashbangUrl(
+      const locationUrl = new Location(
         "http://server/base",
         "http://server/",
+        false,
         "#!",
       );
-      locationUrl.$$parse("http://server/base");
-      locationUrl.path("aaa");
+      locationUrl.parse("http://server/base");
+      locationUrl.setPath("aaa");
 
-      expect(locationUrl.path()).toBe("/aaa");
-      expect(locationUrl.absUrl()).toBe("http://server/base#!/aaa");
+      expect(locationUrl.getPath()).toBe("/aaa");
+      expect(locationUrl.absUrl).toBe("http://server/base#!/aaa");
     });
 
     it("should not preserve old properties when parsing new url", () => {
       const locationUrl = createHashbangUrl();
-      locationUrl.$$parse("http://www.server.org:1234/base#!/");
+      locationUrl.parse("http://www.server.org:1234/base#!/");
 
-      expect(locationUrl.path()).toBe("/");
-      expect(locationUrl.search()).toEqual({});
-      expect(locationUrl.hash()).toBe("");
-      expect(locationUrl.absUrl()).toBe("http://www.server.org:1234/base#!/");
+      expect(locationUrl.getPath()).toBe("/");
+      expect(locationUrl.getSearch()).toEqual({});
+      expect(locationUrl.getHash()).toBe("");
+      expect(locationUrl.absUrl).toBe("http://www.server.org:1234/base#!/");
     });
 
     it("should insert default hashbang if a hash is given with no hashbang prefix", () => {
       const locationUrl = createHashbangUrl();
 
-      locationUrl.$$parse("http://www.server.org:1234/base#/path");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.parse("http://www.server.org:1234/base#/path");
+      expect(locationUrl.absUrl).toBe(
         "http://www.server.org:1234/base#!#%2Fpath",
       );
-      expect(locationUrl.hash()).toBe("/path");
-      expect(locationUrl.path()).toBe("");
+      expect(locationUrl.getHash()).toBe("/path");
+      expect(locationUrl.getPath()).toBe("");
 
-      locationUrl.$$parse("http://www.server.org:1234/base#");
-      expect(locationUrl.absUrl()).toBe("http://www.server.org:1234/base");
-      expect(locationUrl.hash()).toBe("");
-      expect(locationUrl.path()).toBe("");
+      locationUrl.parse("http://www.server.org:1234/base#");
+      expect(locationUrl.absUrl).toBe("http://www.server.org:1234/base");
+      expect(locationUrl.getHash()).toBe("");
+      expect(locationUrl.getPath()).toBe("");
     });
 
     it("should ignore extra path segments if no hashbang is given", () => {
       const locationUrl = createHashbangUrl();
-      locationUrl.$$parse("http://www.server.org:1234/base/extra/path");
-      expect(locationUrl.absUrl()).toBe("http://www.server.org:1234/base");
-      expect(locationUrl.path()).toBe("");
-      expect(locationUrl.hash()).toBe("");
+      locationUrl.parse("http://www.server.org:1234/base/extra/path");
+      expect(locationUrl.absUrl).toBe("http://www.server.org:1234/base");
+      expect(locationUrl.getPath()).toBe("");
+      expect(locationUrl.getHash()).toBe("");
     });
 
     describe("encoding", () => {
       it("should encode special characters", () => {
         const locationUrl = createHashbangUrl();
-        locationUrl.path("/a <>#");
-        locationUrl.search({ "i j": "<>#" });
-        locationUrl.hash("<>#");
-
-        expect(locationUrl.path()).toBe("/a <>#");
-        expect(locationUrl.search()).toEqual({ "i j": "<>#" });
-        expect(locationUrl.hash()).toBe("<>#");
-        expect(locationUrl.absUrl()).toBe(
+        locationUrl.setPath("/a <>#");
+        locationUrl.setSearch({ "i j": "<>#" });
+        locationUrl.setHash("<>#");
+
+        expect(locationUrl.getPath()).toBe("/a <>#");
+        expect(locationUrl.getSearch()).toEqual({ "i j": "<>#" });
+        expect(locationUrl.getHash()).toBe("<>#");
+        expect(locationUrl.absUrl).toBe(
           "http://www.server.org:1234/base#!/a%20%3C%3E%23?i%20j=%3C%3E%23#%3C%3E%23",
         );
       });
 
       it("should not encode !$:@", () => {
         const locationUrl = createHashbangUrl();
-        locationUrl.path("/!$:@");
-        locationUrl.search("");
-        locationUrl.hash("!$:@");
+        locationUrl.setPath("/!$:@");
+        locationUrl.setSearch("");
+        locationUrl.setHash("!$:@");
 
-        expect(locationUrl.absUrl()).toBe(
+        expect(locationUrl.absUrl).toBe(
           "http://www.server.org:1234/base#!/!$:@#!$:@",
         );
       });
 
       it("should decode special characters", () => {
-        const locationUrl = new LocationHashbangUrl(
+        const locationUrl = new Location(
           "http://host.com/a",
           "http://host.com/",
+          false,
           "#",
         );
-        locationUrl.$$parse(
+        locationUrl.parse(
           "http://host.com/a#/%20%3C%3E%23?i%20j=%3C%3E%23#x%20%3C%3E%23",
         );
-        expect(locationUrl.path()).toBe("/ <>#");
-        expect(locationUrl.search()).toEqual({ "i j": "<>#" });
-        expect(locationUrl.hash()).toBe("x <>#");
+        expect(locationUrl.getPath()).toBe("/ <>#");
+        expect(locationUrl.getSearch()).toEqual({ "i j": "<>#" });
+        expect(locationUrl.getHash()).toBe("x <>#");
       });
 
       it("should return decoded characters for search specified in URL", () => {
-        const locationUrl = new LocationHtml5Url(
+        const locationUrl = new Location(
           "http://host.com/",
           "http://host.com/",
+          true,
         );
-        locationUrl.$$parse("http://host.com/?q=1%2F2%203");
-        expect(locationUrl.search()).toEqual({ q: "1/2 3" });
+        locationUrl.parse("http://host.com/?q=1%2F2%203");
+        expect(locationUrl.getSearch()).toEqual({ q: "1/2 3" });
       });
 
       it("should return decoded characters for search specified with setter", () => {
-        const locationUrl = new LocationHtml5Url(
+        const locationUrl = new Location(
           "http://host.com/",
           "http://host.com/",
+          true,
         );
-        locationUrl.$$parse("http://host.com/");
-        locationUrl.search("q", "1/2 3");
-        expect(locationUrl.search()).toEqual({ q: "1/2 3" });
+        locationUrl.parse("http://host.com/");
+        locationUrl.setSearch("q", "1/2 3");
+        expect(locationUrl.getSearch()).toEqual({ q: "1/2 3" });
       });
 
       it("should return an array for duplicate params", () => {
-        const locationUrl = new LocationHtml5Url(
+        const locationUrl = new Location(
           "http://host.com",
           "http://host.com",
+          true,
         );
-        locationUrl.$$parse("http://host.com");
-        locationUrl.search("q", ["1/2 3", "4/5 6"]);
-        expect(locationUrl.search()).toEqual({ q: ["1/2 3", "4/5 6"] });
+        locationUrl.parse("http://host.com");
+        locationUrl.setSearch("q", ["1/2 3", "4/5 6"]);
+        expect(locationUrl.getSearch()).toEqual({ q: ["1/2 3", "4/5 6"] });
       });
 
       it("should encode an array correctly from search and add to url", () => {
-        const locationUrl = new LocationHtml5Url(
+        const locationUrl = new Location(
           "http://host.com",
           "http://host.com",
+          true,
         );
-        locationUrl.$$parse("http://host.com");
-        locationUrl.search({ q: ["1/2 3", "4/5 6"] });
-        expect(locationUrl.absUrl()).toEqual(
+        locationUrl.parse("http://host.com");
+        locationUrl.setSearch({ q: ["1/2 3", "4/5 6"] });
+        expect(locationUrl.absUrl).toEqual(
           "http://host.com?q=1%2F2%203&q=4%2F5%206",
         );
       });
 
       it("should rewrite params when specifying a single param in search", () => {
-        const locationUrl = new LocationHtml5Url(
+        const locationUrl = new Location(
           "http://host.com",
           "http://host.com",
+          true,
         );
-        locationUrl.$$parse("http://host.com");
-        locationUrl.search({ q: "1/2 3" });
-        expect(locationUrl.absUrl()).toEqual("http://host.com?q=1%2F2%203");
-        locationUrl.search({ q: "4/5 6" });
-        expect(locationUrl.absUrl()).toEqual("http://host.com?q=4%2F5%206");
+        locationUrl.parse("http://host.com");
+        locationUrl.setSearch({ q: "1/2 3" });
+        expect(locationUrl.absUrl).toEqual("http://host.com?q=1%2F2%203");
+        locationUrl.setSearch({ q: "4/5 6" });
+        expect(locationUrl.absUrl).toEqual("http://host.com?q=4%2F5%206");
       });
 
-      it("url() should decode non-component special characters in hashbang mode", () => {
-        const locationUrl = new LocationHashbangUrl(
+      it("url getter/setter should decode non-component special characters in hashbang mode", () => {
+        const locationUrl = new Location(
           "http://host.com",
           "http://host.com",
+          false,
         );
-        locationUrl.$$parse("http://host.com");
-        locationUrl.url("/foo%3Abar");
-        expect(locationUrl.path()).toEqual("/foo:bar");
+        locationUrl.parse("http://host.com");
+        locationUrl.setUrl("/foo%3Abar");
+        expect(locationUrl.getPath()).toEqual("/foo:bar");
       });
 
-      it("url() should decode non-component special characters in html5 mode", () => {
-        const locationUrl = new LocationHtml5Url(
+      it("url getter/setter should decode non-component special characters in html5 mode", () => {
+        const locationUrl = new Location(
           "http://host.com",
           "http://host.com",
+          true,
         );
-        locationUrl.$$parse("http://host.com");
-        locationUrl.url("/foo%3Abar");
-        expect(locationUrl.path()).toEqual("/foo:bar");
+        locationUrl.parse("http://host.com");
+        locationUrl.setUrl("/foo%3Abar");
+        expect(locationUrl.getPath()).toEqual("/foo:bar");
       });
     });
   });
 
+  describe("encodePath", () => {
+    it("should encode each segment but preserve slashes", () => {
+      const input = "user profile/images/pic 1.jpg";
+      const result = encodePath(input);
+      expect(result).toBe("user%20profile/images/pic%201.jpg");
+    });
+
+    it("should re-encode previously encoded forward slashes as literal slashes", () => {
+      const input = "folder1%2Fsub/folder2";
+      const result = encodePath(input);
+      expect(result).toBe("folder1%2Fsub/folder2");
+    });
+
+    it("should handle special characters properly", () => {
+      const input = "a$bc/def@gh";
+      const result = encodePath(input);
+      expect(result).toBe("a$bc/def@gh");
+    });
+
+    it("should return empty string for empty path", () => {
+      const input = "";
+      const result = encodePath(input);
+      expect(result).toBe("");
+    });
+
+    it("should handle single segment", () => {
+      const input = "hello world";
+      const result = encodePath(input);
+      expect(result).toBe("hello%20world");
+    });
+
+    it("should not double encode already encoded segments except slashes", () => {
+      const input = "one%20two/three%2Ffour";
+      const result = encodePath(input);
+      expect(result).toBe("one%20two/three%2Ffour");
+    });
+
+    it("should not double encode already encoded segments", () => {
+      const input = "double%20encoded";
+      const result = encodePath(input);
+      expect(result).toBe("double%20encoded");
+    });
+
+    it("should preserve double encoded segments as-is (single decode only)", () => {
+      const input = "double%2520encoded";
+      const result = encodePath(input);
+      expect(result).toBe("double%2520encoded"); // double % stays double encoded
+    });
+
+    it("should preserve leading and trailing slashes", () => {
+      const input = "/a b/c d/";
+      const result = encodePath(input);
+      expect(result).toBe("/a%20b/c%20d/");
+    });
+
+    it("should preserve multiple consecutive slashes as empty segments", () => {
+      const input = "foo//bar///baz";
+      const result = encodePath(input);
+      expect(result).toBe("foo//bar///baz");
+    });
+
+    it("should not encode RFC 3986 reserved characters in segments", () => {
+      const input = "key=value/param+test";
+      const result = encodePath(input);
+      expect(result).toBe("key=value/param+test");
+    });
+
+    it("should encode unicode characters properly", () => {
+      const input = "café/naïve";
+      const result = encodePath(input);
+      expect(result).toBe("caf%C3%A9/na%C3%AFve");
+    });
+
+    it("should handle input with only slashes", () => {
+      const input = "///";
+      const result = encodePath(input);
+      expect(result).toBe("///");
+    });
+
+    it("should treat encoded slashes as literal and decoded slashes as separators", () => {
+      const input = "part1%2Fsub/part2";
+      const result = encodePath(input);
+      expect(result).toBe("part1%2Fsub/part2");
+    });
+  });
+
+  describe("decodePath", () => {
+    it("should decode percent-encoded segments", () => {
+      const input = "hello%20world/abc%40def";
+      const result = decodePath(input, false);
+      expect(result).toBe("hello world/abc@def");
+    });
+
+    it("should encode slashes as %2F in html5Mode", () => {
+      const input = "section%2Fname/data";
+      const result = decodePath(input, true);
+      expect(result).toBe("section%2Fname/data");
+    });
+
+    it("should preserve decoded forward slashes in html5Mode", () => {
+      const input = "foo/bar%2Fbaz/qux";
+      const result = decodePath(input, true);
+      // 'bar/baz' becomes 'bar%2Fbaz'
+      expect(result).toBe("foo/bar%2Fbaz/qux");
+    });
+
+    it("should not change decoded slashes when html5Mode is false", () => {
+      const input = "foo/bar%2Fbaz/qux";
+      const result = decodePath(input, false);
+      expect(result).toBe("foo/bar/baz/qux");
+    });
+
+    it("should handle empty segments correctly", () => {
+      const input = "a//b";
+      const result = decodePath(input, false);
+      expect(result).toBe("a//b"); // empty segment remains
+    });
+
+    it("should decode already decoded values without errors", () => {
+      const input = "simple/path";
+      const result = decodePath(input, false);
+      expect(result).toBe("simple/path");
+    });
+
+    it("should decode and re-encode all forward slashes in segments when html5Mode is true", () => {
+      const input = "a%2Fb/c%2Fd";
+      const result = decodePath(input, true);
+      expect(result).toBe("a%2Fb/c%2Fd");
+    });
+
+    it("should return an empty string if given an empty string", () => {
+      expect(decodePath("", false)).toBe("");
+      expect(decodePath("", true)).toBe("");
+    });
+
+    it("should decode double-encoded segments only once", () => {
+      const input = "double%2520encoded"; // '%2520' = '%20'
+      const result = decodePath(input, false);
+      expect(result).toBe("double%20encoded"); // Only decode once
+    });
+
+    it("should correctly decode reserved URI characters", () => {
+      const input = "%3A%3B%26%3D";
+      const result = decodePath(input, false);
+      expect(result).toBe(":;&=");
+    });
+
+    it("should throw URIError for malformed percent encodings", () => {
+      const input = "bad%encoding";
+      expect(() => decodePath(input, false)).toThrowError(URIError);
+    });
+
+    it("should preserve leading and trailing empty segments", () => {
+      const input = "/path/with/trailing/";
+      const result = decodePath(input, false);
+      expect(result).toBe("/path/with/trailing/");
+    });
+
+    it("should re-encode slashes inside segments when html5Mode is true", () => {
+      const input = "path%2Fsegment/next";
+      const result = decodePath(input, true);
+      expect(result).toBe("path%2Fsegment/next");
+    });
+
+    it("should handle completely empty segments (multiple slashes)", () => {
+      const input = "///";
+      const result = decodePath(input, false);
+      expect(result).toBe("///");
+    });
+  });
+
+  describe("normalizePath", () => {
+    it("should encode the path, append search and hash correctly", () => {
+      const path = "folder name/file name";
+      const search = { q: "test", page: "1" };
+      const hash = "section 2";
+
+      const result = normalizePath(path, search, hash);
+      expect(result).toBe(
+        "folder%20name/file%20name?q=test&page=1#section%202",
+      );
+    });
+
+    it("should return path only if no search and no hash", () => {
+      const path = "simple/path";
+      const result = normalizePath(path, null, null);
+      expect(result).toBe("simple/path");
+    });
+
+    it("should correctly encode search params from object", () => {
+      const search = { a: "1", b: "2" };
+      const result = normalizePath("path", search, null);
+      expect(result).toBe("path?a=1&b=2");
+    });
+
+    it("should correctly encode array values in search", () => {
+      const search = { a: ["1", "2"] };
+      const result = normalizePath("path", search, null);
+      // Expected: a=1&a=2 (both keys repeated)
+      expect(result).toBe("path?a=1&a=2");
+    });
+
+    it("should handle boolean true values", () => {
+      const search = { flag: true };
+      const result = normalizePath("path", search, null);
+      expect(result).toBe("path?flag");
+    });
+
+    it("should encode hash value properly", () => {
+      const path = "path";
+      const hash = "hello world";
+      const result = normalizePath(path, null, hash);
+      expect(result).toBe("path#hello%20world");
+    });
+
+    it("should not append ? if search is empty string or empty object", () => {
+      expect(normalizePath("path", "", "hash")).toBe("path#hash");
+      expect(normalizePath("path", {}, "hash")).toBe("path#hash");
+    });
+
+    it("should handle empty path gracefully", () => {
+      const result = normalizePath("", { a: "1" }, "h");
+      expect(result).toBe("?a=1#h");
+    });
+  });
+
+  describe("parseAppUrl", () => {
+    let locationObj;
+
+    beforeEach(() => {
+      locationObj = new Location(
+        "http://www.domain.com:9877/",
+        "http://www.domain.com:9877/",
+      );
+    });
+
+    it("should throw error on url starting with // or \\\\", () => {
+      expect(() => parseAppUrl("//invalid/path", false)).toThrowError(
+        /Invalid url/,
+      );
+      expect(() => parseAppUrl("\\\\invalid\\path", false)).toThrowError(
+        /Invalid url/,
+      );
+    });
+
+    it("should add leading slash if missing and parse url correctly", () => {
+      parseAppUrl("some/path?foo=bar#hashValue", false);
+      expect(locationObj.getPath()).toBe("/some/path");
+      expect(locationObj.getSearch()).toEqual(
+        jasmine.objectContaining({ foo: "bar" }),
+      );
+      expect(locationObj.getHash()).toBe("hashValue");
+    });
+
+    it("should keep leading slash if present", () => {
+      parseAppUrl("/already/slashed?x=1#abc", locationObj, false);
+      expect(locationObj.getPath()).toBe("/already/slashed");
+      expect(locationObj.getSearch()).toEqual(
+        jasmine.objectContaining({ x: "1" }),
+      );
+      expect(locationObj.getHash()).toBe("abc");
+    });
+
+    it("should remove leading slash from path if prefixed and path starts with slash", () => {
+      parseAppUrl("foo/bar", locationObj, false);
+      expect(locationObj.getPath().charAt(0)).toBe("/");
+      expect(locationObj.getPath()).toBe("/foo/bar");
+    });
+
+    it("should set empty $$search when no query params", () => {
+      parseAppUrl("/pathOnly", locationObj, false);
+      expect(locationObj.getSearch()).toEqual({});
+    });
+
+    it("should decode hash correctly", () => {
+      parseAppUrl("/path#%23encoded", locationObj, false);
+      expect(locationObj.getHash()).toBe("#encoded");
+    });
+  });
+
+  describe("stripBaseUrl", () => {
+    it("should return substring after base if url starts with base", () => {
+      expect(stripBaseUrl("/base", "/base/some/path")).toBe("/some/path");
+      expect(
+        stripBaseUrl("http://example.com", "http://example.com/page"),
+      ).toBe("/page");
+      expect(stripBaseUrl("", "/anything")).toBe("/anything"); // empty base returns full url
+    });
+
+    it("should return empty string if url equals base", () => {
+      expect(stripBaseUrl("/base", "/base")).toBe("");
+    });
+
+    it("should return undefined if url does not start with base", () => {
+      expect(stripBaseUrl("/base", "/notbase/something")).toBeUndefined();
+      expect(
+        stripBaseUrl("http://example.com", "https://example.com/page"),
+      ).toBeUndefined();
+    });
+
+    it("should handle base being longer than url", () => {
+      expect(stripBaseUrl("/longer/base", "/short")).toBeUndefined();
+    });
+
+    it("should be case sensitive", () => {
+      expect(stripBaseUrl("/Base", "/base/something")).toBeUndefined();
+    });
+  });
+
+  describe("stripHash", () => {
+    it("should return the same URL if there is no hash", () => {
+      expect(stripHash("http://example.com/path")).toBe(
+        "http://example.com/path",
+      );
+      expect(stripHash("/some/path")).toBe("/some/path");
+    });
+
+    it("should remove the hash and everything after it", () => {
+      expect(stripHash("http://example.com/path#section1")).toBe(
+        "http://example.com/path",
+      );
+      expect(stripHash("/path/to/resource#hashvalue")).toBe(
+        "/path/to/resource",
+      );
+    });
+
+    it("should remove hash even if it is at the very end", () => {
+      expect(stripHash("http://example.com/#")).toBe("http://example.com/");
+    });
+
+    it("should handle empty string input", () => {
+      expect(stripHash("")).toBe("");
+    });
+
+    it("should handle hash only string", () => {
+      expect(stripHash("#hashonly")).toBe("");
+    });
+  });
+
+  describe("stripFile", () => {
+    it("removes filename from URL without hash", () => {
+      const input = "https://example.com/path/to/file.js";
+      const expected = "https://example.com/path/to/";
+      expect(stripFile(input)).toBe(expected);
+    });
+
+    it("removes filename and hash from URL", () => {
+      const input = "https://example.com/path/to/file.js#section";
+      const expected = "https://example.com/path/to/";
+      expect(stripFile(input)).toBe(expected);
+    });
+
+    it("handles root URL with file", () => {
+      const input = "https://example.com/file.js";
+      const expected = "https://example.com/";
+      expect(stripFile(input)).toBe(expected);
+    });
+
+    it("handles URL with no file", () => {
+      const input = "https://example.com/path/to/";
+      const expected = "https://example.com/path/to/";
+      expect(stripFile(input)).toBe(expected);
+    });
+
+    it("handles relative URL with file and hash", () => {
+      const input = "docs/static/app.js#v1";
+      const expected = "docs/static/";
+      expect(stripFile(input)).toBe(expected);
+    });
+  });
+
+  describe("serverBase", () => {
+    it("returns server base for https URL without port", () => {
+      const input = "https://example.com/path/to/resource";
+      const expected = "https://example.com";
+      expect(serverBase(input)).toBe(expected);
+    });
+
+    it("returns server base for http URL with port", () => {
+      const input = "http://localhost:8080/api/data";
+      const expected = "http://localhost:8080";
+      expect(serverBase(input)).toBe(expected);
+    });
+
+    it("returns server base for URL with subdomain", () => {
+      const input = "https://api.example.com/v1/query";
+      const expected = "https://api.example.com";
+      expect(serverBase(input)).toBe(expected);
+    });
+
+    it("returns full URL if no path is present", () => {
+      const input = "https://example.com";
+      const expected = "https://example.com";
+      expect(serverBase(input)).toBe(expected);
+    });
+
+    it("handles trailing slash after host", () => {
+      const input = "https://example.com/";
+      const expected = "https://example.com";
+      expect(serverBase(input)).toBe(expected);
+    });
+  });
+
+  describe("urlsEqual", () => {
+    it("matches same URL", () => {
+      expect(
+        urlsEqual("http://example.com/foo", "http://example.com/foo"),
+      ).toBe(true);
+    });
+
+    it("ignores trailing slash", () => {
+      expect(
+        urlsEqual("http://example.com/foo/", "http://example.com/foo"),
+      ).toBe(true);
+    });
+
+    it("ignores encoded spaces", () => {
+      expect(
+        urlsEqual("http://example.com/foo%20bar", "http://example.com/foo bar"),
+      ).toBe(true);
+    });
+
+    it("ignores empty hash", () => {
+      expect(
+        urlsEqual("http://example.com/foo#", "http://example.com/foo"),
+      ).toBe(true);
+    });
+
+    it("resolves relative to base href", () => {
+      const base = document.createElement("base");
+      base.href = "http://localhost/";
+      document.head.appendChild(base);
+
+      expect(urlsEqual("/bar", "http://localhost/bar")).toBe(true);
+
+      document.head.removeChild(base); // cleanup
+    });
+
+    it("returns false for different paths", () => {
+      expect(
+        urlsEqual("http://example.com/foo", "http://example.com/bar"),
+      ).toBe(false);
+    });
+  });
+
   // describe("location watch", () => {
   //   it("should not update browser if only the empty hash fragment is cleared", () => {
   //     initService({ supportHistory: true });
@@ -794,7 +1239,7 @@ describe("$location", () => {
   //     mockUpBrowser({ initialUrl: "http://new.com/#", baseHref: "/" });
   //     inject(($browser, $location, $window) => {
   //       expect($browser.url()).toBe("http://new.com/");
-  //       expect($location.absUrl()).toBe("http://new.com/");
+  //       expect($location.absUrl).toBe("http://new.com/");
   //       expect($window.location.href).toBe("http://new.com/#");
   //     });
   //   });
@@ -809,8 +1254,8 @@ describe("$location", () => {
   //       let handlerCalled = false;
   //       $rootScope.$on("$locationChangeSuccess", () => {
   //         handlerCalled = true;
-  //         if ($location.path() !== "/") {
-  //           $location.path("/").replace();
+  //         if ($location.getPath() !== "/") {
+  //           $location.setPath("/").replace();
   //         }
   //       });
   //       expect($browser.url()).toEqual("http://server/base/#!/home");
@@ -899,7 +1344,7 @@ describe("$location", () => {
   //       $rootScope,
   //       $window,
   //     ) => {
-  //       $location.url("baz");
+  //       $location.setUrl("baz");
   //       $rootScope.$digest();
 
   //       const originalUrl = $window.location.href;
@@ -911,7 +1356,7 @@ describe("$location", () => {
   //       });
 
   //       expect($browser.url()).toBe("http://foo.bar/#!/baz/qux");
-  //       expect($location.absUrl()).toBe("http://foo.bar/#!/baz/qux");
+  //       expect($location.absUrl).toBe("http://foo.bar/#!/baz/qux");
 
   //       $rootScope.$apply(() => {
   //         $rootScope.$evalAsync(() => {
@@ -920,7 +1365,7 @@ describe("$location", () => {
   //       });
 
   //       expect($browser.url()).toBe("http://foo.bar/#!/baz/quux");
-  //       expect($location.absUrl()).toBe("http://foo.bar/#!/baz/quux");
+  //       expect($location.absUrl).toBe("http://foo.bar/#!/baz/quux");
   //     }));
 
   //     it("should correctly update `$location` from URL and not digest infinitely", inject((
@@ -929,7 +1374,7 @@ describe("$location", () => {
   //       $rootScope,
   //       $window,
   //     ) => {
-  //       $location.url("baz");
+  //       $location.setUrl("baz");
   //       $rootScope.$digest();
 
   //       $rootScope.$apply(() => {
@@ -941,16 +1386,16 @@ describe("$location", () => {
   //       ($window).triggerHandler("hashchange");
 
   //       expect($browser.url()).toBe("http://foo.bar/#!/baz/qux");
-  //       expect($location.absUrl()).toBe("http://foo.bar/#!/baz/qux");
+  //       expect($location.absUrl).toBe("http://foo.bar/#!/baz/qux");
   //     }));
   //   });
 
   //   function updatePathOnLocationChangeSuccessTo(newPath, newParams) {
   //     inject(($rootScope, $location) => {
   //       $rootScope.$on("$locationChangeSuccess", (event, newUrl, oldUrl) => {
-  //         $location.path(newPath);
+  //         $location.setPath(newPath);
   //         if (newParams) {
-  //           $location.search(newParams);
+  //           $location.setSearch(newParams);
   //         }
   //       });
   //     });
@@ -971,7 +1416,7 @@ describe("$location", () => {
   //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/#!/Home");
-  //         expect($location.path()).toEqual("/Home");
+  //         expect($location.getPath()).toEqual("/Home");
   //         expect($browserUrl).toHaveBeenCalledTimes(1);
   //       });
   //     });
@@ -993,7 +1438,7 @@ describe("$location", () => {
   //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/#!/");
-  //         expect($location.path()).toEqual("/");
+  //         expect($location.getPath()).toEqual("/");
   //         expect($browserUrl).toHaveBeenCalledTimes(1);
   //         expect($browserUrl.calls.argsFor(0)).toEqual([
   //           "http://server/app/#!/",
@@ -1016,7 +1461,7 @@ describe("$location", () => {
   //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/#!/Home");
-  //         expect($location.path()).toEqual("/Home");
+  //         expect($location.getPath()).toEqual("/Home");
   //         expect($browserUrl).toHaveBeenCalledTimes(1);
   //         expect($browserUrl.calls.argsFor(0)).toEqual([
   //           "http://server/app/#!/Home",
@@ -1039,7 +1484,7 @@ describe("$location", () => {
   //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/#!/");
-  //         expect($location.path()).toEqual("/");
+  //         expect($location.getPath()).toEqual("/");
   //         expect($browserUrl).toHaveBeenCalledTimes(1);
   //       });
   //     });
@@ -1061,7 +1506,7 @@ describe("$location", () => {
   //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/Home");
-  //         expect($location.path()).toEqual("/Home");
+  //         expect($location.getPath()).toEqual("/Home");
   //         expect($browserUrl).toHaveBeenCalledTimes(1);
   //       });
   //     });
@@ -1081,7 +1526,7 @@ describe("$location", () => {
   //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/");
-  //         expect($location.path()).toEqual("/");
+  //         expect($location.getPath()).toEqual("/");
   //         expect($browserUrl).not.toHaveBeenCalled();
   //       });
   //     });
@@ -1101,7 +1546,7 @@ describe("$location", () => {
   //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/Home");
-  //         expect($location.path()).toEqual("/Home");
+  //         expect($location.getPath()).toEqual("/Home");
   //         expect($browserUrl).toHaveBeenCalledTimes(1);
   //       });
   //     });
@@ -1121,7 +1566,7 @@ describe("$location", () => {
   //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/");
-  //         expect($location.path()).toEqual("/");
+  //         expect($location.getPath()).toEqual("/");
   //         expect($browserUrl).not.toHaveBeenCalled();
   //       });
   //     });
@@ -1141,8 +1586,8 @@ describe("$location", () => {
 
   //         $rootScope.$digest();
 
-  //         expect($location.path()).toEqual("/");
-  //         expect($location.search()).toEqual({ q: "'" });
+  //         expect($location.getPath()).toEqual("/");
+  //         expect($location.getSearch()).toEqual({ q: "'" });
   //         expect($browserUrl).toHaveBeenCalledTimes(1);
   //       });
   //     });
@@ -1154,12 +1599,12 @@ describe("$location", () => {
   //     initService({ html5Mode: false, hashPrefix: "!", supportHistory: true });
   //     mockUpBrowser({ initialUrl: "http://new.com/a/b#!", baseHref: "/a/b" });
   //     inject(($window, $browser, $location, $rootScope) => {
-  //       spyOn($location, "$$parse").and.callThrough();
+  //       spyOn($location, "parse").and.callThrough();
   //       $window.location.href = "http://new.com/a/b#!/aaa";
   //       $browser.$$checkUrlChange();
-  //       expect($location.absUrl()).toBe("http://new.com/a/b#!/aaa");
-  //       expect($location.path()).toBe("/aaa");
-  //       expect($location.$$parse).toHaveBeenCalled();
+  //       expect($location.absUrl).toBe("http://new.com/a/b#!/aaa");
+  //       expect($location.getPath()).toBe("/aaa");
+  //       expect($location.parse).toHaveBeenCalled();
   //     });
   //   });
 
@@ -1174,10 +1619,10 @@ describe("$location", () => {
   //       $rootScope.$apply(() => {
   //         $window.location.href = NEW_URL;
   //         $browser.$$checkUrlChange(); // simulate firing event from browser
-  //         expect($location.absUrl()).toBe(OLD_URL); // should be async
+  //         expect($location.absUrl).toBe(OLD_URL); // should be async
   //       });
 
-  //       expect($location.absUrl()).toBe(NEW_URL);
+  //       expect($location.absUrl).toBe(NEW_URL);
   //     });
   //   });
 
@@ -1195,12 +1640,12 @@ describe("$location", () => {
   //           notRunYet = false;
   //           $window.location.href = NEW_URL;
   //           $browser.$$checkUrlChange(); // simulate firing event from browser
-  //           expect($location.absUrl()).toBe(OLD_URL); // should be async
+  //           expect($location.absUrl).toBe(OLD_URL); // should be async
   //         }
   //       });
 
   //       $rootScope.$digest();
-  //       expect($location.absUrl()).toBe(NEW_URL);
+  //       expect($location.absUrl).toBe(NEW_URL);
   //     });
   //   });
 
@@ -1212,7 +1657,7 @@ describe("$location", () => {
   //         $browser,
   //         "url",
   //       ).and.callThrough();
-  //       $location.path("/new/path");
+  //       $location.setPath("/new/path");
   //       expect($browserUrl).not.toHaveBeenCalled();
   //       $rootScope.$apply();
 
@@ -1229,10 +1674,10 @@ describe("$location", () => {
   //         $browser,
   //         "url",
   //       ).and.callThrough();
-  //       $location.path("/new/path");
+  //       $location.setPath("/new/path");
 
   //       $rootScope.$watch(() => {
-  //         $location.search("a=b");
+  //         $location.setSearch("a=b");
   //       });
 
   //       $rootScope.$apply();
@@ -1249,7 +1694,7 @@ describe("$location", () => {
   //         $browser,
   //         "url",
   //       ).and.callThrough();
-  //       $location.path("/n/url").replace();
+  //       $location.setPath("/n/url").replace();
   //       $rootScope.$apply();
 
   //       expect($browserUrl).toHaveBeenCalled();
@@ -1267,16 +1712,16 @@ describe("$location", () => {
   //     mockUpBrowser({ initialUrl: "http://new.com/a/b#!", baseHref: "/a/b" });
   //     inject(($rootScope, $browser, $location) => {
   //       // init watches
-  //       $location.url("/initUrl");
+  //       $location.setUrl("/initUrl");
   //       $rootScope.$apply();
 
   //       // changes url but resets it before digest
-  //       $location.url("/newUrl").replace().url("/initUrl");
+  //       $location.setUrl("/newUrl").replace().url("/initUrl");
   //       $rootScope.$apply();
   //       expect($location.$$replace).toBe(false);
 
   //       // set the url to the old value
-  //       $location.url("/newUrl").replace();
+  //       $location.setUrl("/newUrl").replace();
   //       $rootScope.$apply();
   //       expect($location.$$replace).toBe(false);
 
@@ -1294,7 +1739,7 @@ describe("$location", () => {
   //       $rootScope.$watch(
   //         () => true,
   //         () => {
-  //           $location.path("/changed");
+  //           $location.setPath("/changed");
   //         },
   //       );
 
@@ -1307,7 +1752,7 @@ describe("$location", () => {
   //     initService({ html5Mode: false, hashPrefix: "", supportHistory: true });
   //     mockUpBrowser({ initialUrl: "http://new.com/a/b", baseHref: "/a/b" });
   //     inject(($rootScope, $browser, $location) => {
-  //       $location.hash("test");
+  //       $location.setHash("test");
 
   //       $rootScope.$digest();
   //       expect($browser.url()).toBe("http://new.com/a/b##test");
@@ -1324,7 +1769,7 @@ describe("$location", () => {
   //       state: { a: 2 },
   //     });
   //     inject(($location) => {
-  //       expect($location.state()).toEqual({ a: 2 });
+  //       expect($location.getState()).toEqual({ a: 2 });
   //     });
   //   });
 
@@ -1335,7 +1780,7 @@ describe("$location", () => {
   //       $window.history.pushState({ b: 3 });
   //       $rootScope.$digest();
 
-  //       expect($location.state()).toEqual({ b: 3 });
+  //       expect($location.getState()).toEqual({ b: 3 });
 
   //       $window.history.pushState(
   //         { b: 4 },
@@ -1344,10 +1789,10 @@ describe("$location", () => {
   //       );
   //       $rootScope.$digest();
 
-  //       expect($location.path()).toBe("/c");
-  //       expect($location.search()).toEqual({ d: "e" });
-  //       expect($location.hash()).toBe("f");
-  //       expect($location.state()).toEqual({ b: 4 });
+  //       expect($location.getPath()).toBe("/c");
+  //       expect($location.getSearch()).toEqual({ d: "e" });
+  //       expect($location.getHash()).toBe("f");
+  //       expect($location.getState()).toEqual({ b: 4 });
   //     });
   //   });
 
@@ -1362,9 +1807,9 @@ describe("$location", () => {
   //       $window.history.pushState({}, null, "http://server/app/Home?q='");
   //       $rootScope.$digest();
 
-  //       expect($location.absUrl()).toEqual("http://server/app/Home?q='");
-  //       expect($location.path()).toEqual("/Home");
-  //       expect($location.search()).toEqual({ q: "'" });
+  //       expect($location.absUrl).toEqual("http://server/app/Home?q='");
+  //       expect($location.getPath()).toEqual("/Home");
+  //       expect($location.getSearch()).toEqual({ q: "'" });
   //     });
   //   });
 
@@ -1379,9 +1824,9 @@ describe("$location", () => {
   //       $window.location.href = "http://server/app/Home?q='";
   //       ($window).triggerHandler("popstate");
 
-  //       expect($location.absUrl()).toEqual("http://server/app/Home?q='");
-  //       expect($location.path()).toEqual("/Home");
-  //       expect($location.search()).toEqual({ q: "'" });
+  //       expect($location.absUrl).toEqual("http://server/app/Home?q='");
+  //       expect($location.getPath()).toEqual("/Home");
+  //       expect($location.getSearch()).toEqual({ q: "'" });
   //     });
   //   });
 
@@ -1393,7 +1838,7 @@ describe("$location", () => {
   //         $browser,
   //         "url",
   //       ).and.callThrough();
-  //       $location.path("/n/url").state({ a: 2 }).replace();
+  //       $location.setPath("/n/url").state({ a: 2 }).replace();
   //       $rootScope.$apply();
 
   //       expect($browserUrl).toHaveBeenCalled();
@@ -1417,11 +1862,11 @@ describe("$location", () => {
   //         "url",
   //       ).and.callThrough();
   //       $location
-  //         .path("/n/url")
+  //         .setPath("/n/url")
   //         .state({ a: 2 })
   //         .replace()
   //         .state({ b: 3 })
-  //         .path("/o/url");
+  //         .setPath("/o/url");
   //       $rootScope.$apply();
 
   //       expect($browserUrl).toHaveBeenCalled();
@@ -1444,7 +1889,7 @@ describe("$location", () => {
   //         $browser,
   //         "url",
   //       ).and.callThrough();
-  //       $location.state({ a: 2 }).replace().state({ b: 3 });
+  //       $location.setState({ a: 2 }).replace().state({ b: 3 });
   //       $rootScope.$apply();
 
   //       expect($browserUrl).toHaveBeenCalled();
@@ -1464,7 +1909,7 @@ describe("$location", () => {
 
   //     inject(($rootScope, $location) => {
   //       // init watches
-  //       $location.url("/initUrl").state({ a: 2 });
+  //       $location.setUrl("/initUrl").state({ a: 2 });
   //       $rootScope.$apply();
 
   //       // changes url & state but resets them before digest
@@ -1478,7 +1923,7 @@ describe("$location", () => {
   //       expect($location.$$replace).toBe(false);
 
   //       // set the url to the old value
-  //       $location.url("/newUrl").state({ a: 2 }).replace();
+  //       $location.setUrl("/newUrl").state({ a: 2 }).replace();
   //       $rootScope.$apply();
   //       expect($location.$$replace).toBe(false);
 
@@ -1495,7 +1940,7 @@ describe("$location", () => {
 
   //     inject(($rootScope, $location, $browser) => {
   //       const o = { a: 2 };
-  //       $location.state(o);
+  //       $location.setState(o);
   //       o.a = 3;
   //       $rootScope.$apply();
   //       expect($browser.state()).toEqual({ a: 3 });
@@ -1506,14 +1951,14 @@ describe("$location", () => {
   //     });
   //   });
 
-  //   it("should make $location.state() referencially identical with $browser.state() after digest", () => {
+  //   it("should make $location.getState() referencially identical with $browser.state() after digest", () => {
   //     initService({ html5Mode: true, supportHistory: true });
   //     mockUpBrowser({ initialUrl: "http://new.com/a/b/", baseHref: "/a/b/" });
 
   //     inject(($rootScope, $location, $browser) => {
-  //       $location.state({ a: 2 });
+  //       $location.setState({ a: 2 });
   //       $rootScope.$apply();
-  //       expect($location.state()).toBe($browser.state());
+  //       expect($location.getState()).toBe($browser.state());
   //     });
   //   });
 
@@ -1522,9 +1967,9 @@ describe("$location", () => {
   //     mockUpBrowser({ initialUrl: "http://new.com/a/b/", baseHref: "/a/b/" });
 
   //     inject(($rootScope, $location) => {
-  //       $location.url("/foo").state({ a: 2 });
+  //       $location.setUrl("/foo").state({ a: 2 });
   //       $rootScope.$apply();
-  //       expect($location.state()).toEqual({ a: 2 });
+  //       expect($location.getState()).toEqual({ a: 2 });
   //     });
   //   });
 
@@ -1533,14 +1978,14 @@ describe("$location", () => {
   //     mockUpBrowser({ initialUrl: "http://new.com/a/b/", baseHref: "/a/b/" });
 
   //     inject(($rootScope, $location, $browser) => {
-  //       $location.url("/foo").state({ a: 2 });
+  //       $location.setUrl("/foo").state({ a: 2 });
   //       $rootScope.$apply();
 
   //       const $browserUrl = spyOnlyCallsWithArgs(
   //         $browser,
   //         "url",
   //       ).and.callThrough();
-  //       $location.url("/bar");
+  //       $location.setUrl("/bar");
   //       $rootScope.$apply();
 
   //       expect($browserUrl).toHaveBeenCalled();
@@ -1579,8 +2024,8 @@ describe("$location", () => {
   //     });
   //     inject(($rootScope, $location, $browser) => {
   //       expect($browser.url()).toBe("http://domain.com/base/index.html#!/a/b");
-  //       $location.path("/new");
-  //       $location.search({ a: true });
+  //       $location.setPath("/new");
+  //       $location.setSearch({ a: true });
   //       $rootScope.$apply();
   //       expect($browser.url()).toBe(
   //         "http://domain.com/base/index.html#!/new?a",
@@ -1596,8 +2041,8 @@ describe("$location", () => {
   //     });
   //     inject(($rootScope, $location, $browser) => {
   //       expect($browser.url()).toBe("http://domain.com/base/index.html#/a/b");
-  //       $location.path("/new");
-  //       $location.search({ a: true });
+  //       $location.setPath("/new");
+  //       $location.setSearch({ a: true });
   //       $rootScope.$apply();
   //       expect($browser.url()).toBe("http://domain.com/base/index.html#/new?a");
   //     });
@@ -1618,8 +2063,8 @@ describe("$location", () => {
   //         expect($browser.url()).toBe(
   //           "http://domain.com/base/index.html#!!/a/b",
   //         );
-  //         $location.path("/new");
-  //         $location.search({ a: true });
+  //         $location.setPath("/new");
+  //         $location.setSearch({ a: true });
   //         $rootScope.$apply();
   //         expect($browser.url()).toBe(
   //           "http://domain.com/base/index.html#!!/new?a",
@@ -1670,8 +2115,8 @@ describe("$location", () => {
   //     });
   //     inject(($rootScope, $location, $browser) => {
   //       expect($browser.url()).toBe("http://domain.com/base/old/index.html#a");
-  //       $location.path("/new");
-  //       $location.search({ a: true });
+  //       $location.setPath("/new");
+  //       $location.setSearch({ a: true });
   //       $rootScope.$apply();
   //       expect($browser.url()).toBe("http://domain.com/base/new?a#a");
   //     });
@@ -1685,11 +2130,11 @@ describe("$location", () => {
   //     });
   //     inject(($rootScope, $location, $browser) => {
   //       expect($browser.url()).toBe("http://domain.com/base/a/b");
-  //       $location.path("/new");
-  //       $location.hash("abc");
+  //       $location.setPath("/new");
+  //       $location.setHash("abc");
   //       $rootScope.$apply();
   //       expect($browser.url()).toBe("http://domain.com/base/new#abc");
-  //       expect($location.path()).toBe("/new");
+  //       expect($location.getPath()).toBe("/new");
   //     });
   //   });
 
@@ -1701,7 +2146,7 @@ describe("$location", () => {
   //     });
   //     inject(($rootScope, $location, $browser) => {
   //       expect($browser.url()).toBe("http://domain.com/base/a/b");
-  //       expect($location.path()).toBe("/a/b");
+  //       expect($location.getPath()).toBe("/a/b");
   //     });
   //   });
   // });
@@ -1898,7 +2343,7 @@ describe("$location", () => {
   //     );
   //   });
 
-  //   it('should produce relative paths correctly when $location.path() is "/" when history enabled on old browser', () => {
+  //   it('should produce relative paths correctly when $location.getPath() is "/" when history enabled on old browser', () => {
   //     configureTestLink({ linkHref: "partial1" });
   //     initService({ html5Mode: true, supportHistory: false, hashPrefix: "!" });
   //     inject(
@@ -1909,7 +2354,7 @@ describe("$location", () => {
   //       setupRewriteChecks(),
   //       ($browser, $location, $rootScope) => {
   //         $rootScope.$apply(() => {
-  //           $location.path("/");
+  //           $location.setPath("/");
   //         });
   //         browserTrigger(link, "click");
   //         expectRewriteTo(
@@ -2226,11 +2671,11 @@ describe("$location", () => {
   //       setupRewriteChecks(),
   //       ($browser, $location, $rootScope) => {
   //         $rootScope.$apply(() => {
-  //           $location.path("/some");
-  //           $location.hash("foo");
+  //           $location.setPath("/some");
+  //           $location.setHash("foo");
   //         });
   //         browserTrigger(link, "click");
-  //         expect($location.hash()).toBe("link");
+  //         expect($location.getHash()).toBe("link");
   //         expectRewriteTo(
   //           $browser,
   //           "http://host.com/base/index.html#!/some#link",
@@ -2250,11 +2695,11 @@ describe("$location", () => {
   //       setupRewriteChecks(),
   //       ($browser, $location, $rootScope) => {
   //         $rootScope.$apply(() => {
-  //           $location.path("/some");
-  //           $location.hash("foo");
+  //           $location.setPath("/some");
+  //           $location.setHash("foo");
   //         });
   //         browserTrigger(link, "click");
-  //         expect($location.hash()).toBe("link");
+  //         expect($location.getHash()).toBe("link");
   //         expectRewriteTo($browser, "http://host.com/base/some#link");
   //       },
   //     );
@@ -2566,9 +3011,9 @@ describe("$location", () => {
   //       $log.info("after", newUrl, oldUrl, $browser.url());
   //     });
 
-  //     expect($location.url()).toEqual("");
-  //     $location.url("/somePath");
-  //     expect($location.url()).toEqual("/somePath");
+  //     expect($location.getUrl()).toEqual("");
+  //     $location.setUrl("/somePath");
+  //     expect($location.getUrl()).toEqual("/somePath");
   //     expect($browser.url()).toEqual("http://server/");
   //     expect($log.info.logs).toEqual([]);
 
@@ -2586,7 +3031,7 @@ describe("$location", () => {
   //       "http://server/",
   //       "http://server/#!/somePath",
   //     ]);
-  //     expect($location.url()).toEqual("/somePath");
+  //     expect($location.getUrl()).toEqual("/somePath");
   //     expect($browser.url()).toEqual("http://server/#!/somePath");
   //   }));
 
@@ -2597,7 +3042,7 @@ describe("$location", () => {
   //     $log,
   //   ) => {
   //     expect($browser.url()).toEqual("http://server/");
-  //     expect($location.url()).toEqual("");
+  //     expect($location.getUrl()).toEqual("");
 
   //     $rootScope.$on("$locationChangeStart", (event, newUrl, oldUrl) => {
   //       $log.info("before", newUrl, oldUrl, $browser.url());
@@ -2607,9 +3052,9 @@ describe("$location", () => {
   //       throw new Error("location should have been canceled");
   //     });
 
-  //     expect($location.url()).toEqual("");
-  //     $location.url("/somePath");
-  //     expect($location.url()).toEqual("/somePath");
+  //     expect($location.getUrl()).toEqual("");
+  //     $location.setUrl("/somePath");
+  //     expect($location.getUrl()).toEqual("/somePath");
   //     expect($browser.url()).toEqual("http://server/");
   //     expect($log.info.logs).toEqual([]);
 
@@ -2622,7 +3067,7 @@ describe("$location", () => {
   //       "http://server/",
   //     ]);
   //     expect($log.info.logs[1]).toBeUndefined();
-  //     expect($location.url()).toEqual("");
+  //     expect($location.getUrl()).toEqual("");
   //     expect($browser.url()).toEqual("http://server/");
   //   }));
 
@@ -2635,14 +3080,14 @@ describe("$location", () => {
   //     $rootScope.$on("$locationChangeStart", (event, newUrl, oldUrl) => {
   //       $log.info("before", newUrl, oldUrl, $browser.url());
   //       if (newUrl === "http://server/#!/somePath") {
-  //         $location.url("/redirectPath");
+  //         $location.setUrl("/redirectPath");
   //       }
   //     });
   //     $rootScope.$on("$locationChangeSuccess", (event, newUrl, oldUrl) => {
   //       $log.info("after", newUrl, oldUrl, $browser.url());
   //     });
 
-  //     $location.url("/somePath");
+  //     $location.setUrl("/somePath");
   //     $rootScope.$apply();
 
   //     expect($log.info.logs.shift()).toEqual([
@@ -2664,7 +3109,7 @@ describe("$location", () => {
   //       "http://server/#!/redirectPath",
   //     ]);
 
-  //     expect($location.url()).toEqual("/redirectPath");
+  //     expect($location.getUrl()).toEqual("/redirectPath");
   //     expect($browser.url()).toEqual("http://server/#!/redirectPath");
   //   }));
 
@@ -2678,14 +3123,14 @@ describe("$location", () => {
   //       $log.info("before", newUrl, oldUrl, $browser.url());
   //       if (newUrl === "http://server/#!/somePath") {
   //         event.preventDefault();
-  //         $location.url("/redirectPath");
+  //         $location.setUrl("/redirectPath");
   //       }
   //     });
   //     $rootScope.$on("$locationChangeSuccess", (event, newUrl, oldUrl) => {
   //       $log.info("after", newUrl, oldUrl, $browser.url());
   //     });
 
-  //     $location.url("/somePath");
+  //     $location.setUrl("/somePath");
   //     $rootScope.$apply();
 
   //     expect($log.info.logs.shift()).toEqual([
@@ -2707,7 +3152,7 @@ describe("$location", () => {
   //       "http://server/#!/redirectPath",
   //     ]);
 
-  //     expect($location.url()).toEqual("/redirectPath");
+  //     expect($location.getUrl()).toEqual("/redirectPath");
   //     expect($browser.url()).toEqual("http://server/#!/redirectPath");
   //   }));
 
@@ -2720,16 +3165,16 @@ describe("$location", () => {
   //     $rootScope.$on("$locationChangeStart", (event, newUrl, oldUrl) => {
   //       $log.info("before", newUrl, oldUrl, $browser.url());
   //       if (newUrl === "http://server/#!/somePath") {
-  //         $location.url("/redirectPath");
+  //         $location.setUrl("/redirectPath");
   //       } else if (newUrl === "http://server/#!/redirectPath") {
-  //         $location.url("/redirectPath2");
+  //         $location.setUrl("/redirectPath2");
   //       }
   //     });
   //     $rootScope.$on("$locationChangeSuccess", (event, newUrl, oldUrl) => {
   //       $log.info("after", newUrl, oldUrl, $browser.url());
   //     });
 
-  //     $location.url("/somePath");
+  //     $location.setUrl("/somePath");
   //     $rootScope.$apply();
 
   //     expect($log.info.logs.shift()).toEqual([
@@ -2757,7 +3202,7 @@ describe("$location", () => {
   //       "http://server/#!/redirectPath2",
   //     ]);
 
-  //     expect($location.url()).toEqual("/redirectPath2");
+  //     expect($location.getUrl()).toEqual("/redirectPath2");
   //     expect($browser.url()).toEqual("http://server/#!/redirectPath2");
   //   }));
 
@@ -2770,7 +3215,7 @@ describe("$location", () => {
   //     $rootScope.$apply(); // clear initial $locationChangeStart
 
   //     expect($browser.url()).toEqual("http://server/");
-  //     expect($location.url()).toEqual("");
+  //     expect($location.getUrl()).toEqual("");
 
   //     $rootScope.$on("$locationChangeStart", (event, newUrl, oldUrl) => {
   //       $log.info("start", newUrl, oldUrl);
@@ -2800,11 +3245,11 @@ describe("$location", () => {
   //     $rootScope,
   //     $log,
   //   ) => {
-  //     $location.url("/somepath");
+  //     $location.setUrl("/somepath");
   //     $rootScope.$apply();
 
   //     expect($browser.url()).toEqual("http://server/#!/somepath");
-  //     expect($location.url()).toEqual("/somepath");
+  //     expect($location.getUrl()).toEqual("/somepath");
 
   //     $rootScope.$on("$locationChangeStart", (event, newUrl, oldUrl) => {
   //       $log.info("start", newUrl, oldUrl);
@@ -2837,7 +3282,7 @@ describe("$location", () => {
   //     $rootScope.$on("$locationChangeStart", (event, newUrl, oldUrl) => {
   //       $log.info("before", newUrl, oldUrl, $browser.url());
   //       if (newUrl === "http://server/#!/somePath") {
-  //         $location.url("/redirectPath");
+  //         $location.setUrl("/redirectPath");
   //       }
   //     });
   //     $rootScope.$on("$locationChangeSuccess", (event, newUrl, oldUrl) => {
@@ -2866,7 +3311,7 @@ describe("$location", () => {
   //       "http://server/#!/redirectPath",
   //     ]);
 
-  //     expect($location.url()).toEqual("/redirectPath");
+  //     expect($location.getUrl()).toEqual("/redirectPath");
   //     expect($browser.url()).toEqual("http://server/#!/redirectPath");
   //   }));
 
@@ -2880,7 +3325,7 @@ describe("$location", () => {
   //       $log.info("before", newUrl, oldUrl, $browser.url());
   //       if (newUrl === "http://server/#!/somePath") {
   //         event.preventDefault();
-  //         $location.url("/redirectPath");
+  //         $location.setUrl("/redirectPath");
   //       }
   //     });
   //     $rootScope.$on("$locationChangeSuccess", (event, newUrl, oldUrl) => {
@@ -2909,7 +3354,7 @@ describe("$location", () => {
   //       "http://server/#!/redirectPath",
   //     ]);
 
-  //     expect($location.url()).toEqual("/redirectPath");
+  //     expect($location.getUrl()).toEqual("/redirectPath");
   //     expect($browser.url()).toEqual("http://server/#!/redirectPath");
   //   }));
 
@@ -2985,17 +3430,17 @@ describe("$location", () => {
   //     const base = $browser.url();
 
   //     $rootScope.$on("$locationChangeStart", () => {
-  //       log($location.path());
+  //       log($location.getPath());
   //     });
 
   //     // change through $location service
   //     $rootScope.$apply(() => {
-  //       $location.path("/myNewPath");
+  //       $location.setPath("/myNewPath");
   //     });
 
   //     // reset location
   //     $rootScope.$apply(() => {
-  //       $location.path("");
+  //       $location.setPath("");
   //     });
 
   //     // change through $browser
@@ -3007,100 +3452,32 @@ describe("$location", () => {
   // });
 
   describe("$locationProvider", () => {
-    describe("html5Mode", () => {
-      it("should set enabled, requireBase and rewriteLinks when called with object", () => {
+    describe("html5ModeConf", () => {
+      it("should have default values", () => {
         module.config(($locationProvider) => {
-          $locationProvider.setHtml5Mode({
+          expect($locationProvider.html5ModeConf).toEqual({
             enabled: true,
             requireBase: false,
-            rewriteLinks: false,
-          });
-          expect($locationProvider.getHtml5Mode()).toEqual({
-            enabled: true,
-            requireBase: false,
-            rewriteLinks: false,
-          });
-        });
-        createInjector(["test1"]);
-      });
-
-      it("should only overwrite existing properties if values are of the correct type", () => {
-        module.config(($locationProvider) => {
-          $locationProvider.setHtml5Mode({
-            enabled: "duh",
-            requireBase: "probably",
-            rewriteLinks: 0,
-          });
-
-          expect($locationProvider.getHtml5Mode()).toEqual({
-            enabled: false,
-            requireBase: true,
             rewriteLinks: true,
           });
         });
-
-        createInjector(["test1"]);
-      });
-
-      it("should support setting rewriteLinks to a string", () => {
-        module.config(($locationProvider) => {
-          $locationProvider.setHtml5Mode({
-            rewriteLinks: "yes-rewrite",
-          });
-
-          expect($locationProvider.getHtml5Mode().rewriteLinks).toEqual(
-            "yes-rewrite",
-          );
-        });
-
-        createInjector(["test1"]);
-      });
-
-      it("should not set unknown input properties to html5Mode object", () => {
-        module.config(($locationProvider) => {
-          $locationProvider.setHtml5Mode({
-            someProp: "foo",
-          });
-
-          expect($locationProvider.getHtml5Mode()).toEqual({
-            enabled: false,
-            requireBase: true,
-            rewriteLinks: true,
-          });
-        });
-
-        createInjector(["test1"]);
-      });
-
-      it("should default to enabled:false, requireBase:true and rewriteLinks:true", () => {
-        module.config(($locationProvider) => {
-          expect($locationProvider.getHtml5Mode()).toEqual({
-            enabled: false,
-            requireBase: true,
-            rewriteLinks: true,
-          });
-        });
-
         createInjector(["test1"]);
       });
     });
   });
 
-  describe("LocationHtml5Url", () => {
+  describe("Location with html5 url", () => {
     let locationUrl;
     let locationUmlautUrl;
     let locationIndexUrl;
 
     beforeEach(() => {
-      locationUrl = new LocationHtml5Url(
-        "http://server/pre/",
-        "http://server/pre/",
-      );
-      locationUmlautUrl = new LocationHtml5Url(
+      locationUrl = new Location("http://server/pre/", "http://server/pre/");
+      locationUmlautUrl = new Location(
         "http://särver/pre/",
         "http://särver/pre/",
       );
-      locationIndexUrl = new LocationHtml5Url(
+      locationIndexUrl = new Location(
         "http://server/pre/index.html",
         "http://server/pre/",
       );
@@ -3209,17 +3586,18 @@ describe("$location", () => {
     // });
 
     it("should support state", () => {
-      expect(locationUrl.state({ a: 2 }).state()).toEqual({ a: 2 });
+      expect(locationUrl.setState({ a: 2 }).getState()).toEqual({ a: 2 });
     });
   });
 
-  describe("LocationHashbangUrl", () => {
+  describe("Location with hashbang url", () => {
     let locationUrl;
 
     it("should rewrite URL", () => {
-      locationUrl = new LocationHashbangUrl(
+      locationUrl = new Location(
         "http://server/pre/",
         "http://server/pre/",
+        false,
         "#",
       );
 
@@ -3239,73 +3617,74 @@ describe("$location", () => {
     });
 
     it("should not set hash if one was not originally specified", () => {
-      locationUrl = new LocationHashbangUrl(
+      locationUrl = new Location(
         "http://server/pre/index.html",
         "http://server/pre/",
+        false,
         "#",
       );
 
-      locationUrl.$$parse("http://server/pre/index.html");
-      expect(locationUrl.url()).toBe("");
-      expect(locationUrl.absUrl()).toBe("http://server/pre/index.html");
+      locationUrl.parse("http://server/pre/index.html");
+      expect(locationUrl.getUrl()).toBe("");
+      expect(locationUrl.absUrl).toBe("http://server/pre/index.html");
     });
 
     it("should parse hash if one was specified", () => {
-      locationUrl = new LocationHashbangUrl(
+      locationUrl = new Location(
         "http://server/pre/index.html",
         "http://server/pre/",
+        false,
         "#",
       );
 
-      locationUrl.$$parse("http://server/pre/index.html#/foo/bar");
-      expect(locationUrl.url()).toBe("/foo/bar");
-      expect(locationUrl.absUrl()).toBe(
-        "http://server/pre/index.html#/foo/bar",
-      );
+      locationUrl.parse("http://server/pre/index.html#/foo/bar");
+      expect(locationUrl.getUrl()).toBe("/foo/bar");
+      expect(locationUrl.absUrl).toBe("http://server/pre/index.html#/foo/bar");
     });
 
     it("should prefix hash url with / if one was originally missing", () => {
-      locationUrl = new LocationHashbangUrl(
+      locationUrl = new Location(
         "http://server/pre/index.html",
         "http://server/pre/",
+        false,
         "#",
       );
 
-      locationUrl.$$parse(
-        "http://server/pre/index.html#not-starting-with-slash",
-      );
-      expect(locationUrl.url()).toBe("/not-starting-with-slash");
-      expect(locationUrl.absUrl()).toBe(
+      locationUrl.parse("http://server/pre/index.html#not-starting-with-slash");
+      expect(locationUrl.getUrl()).toBe("/not-starting-with-slash");
+      expect(locationUrl.absUrl).toBe(
         "http://server/pre/index.html#/not-starting-with-slash",
       );
     });
 
     it("should not strip stuff from path just because it looks like Windows drive when it's not", () => {
-      locationUrl = new LocationHashbangUrl(
+      locationUrl = new Location(
         "http://server/pre/index.html",
         "http://server/pre/",
+        false,
         "#",
       );
 
-      locationUrl.$$parse(
+      locationUrl.parse(
         "http://server/pre/index.html#http%3A%2F%2Fexample.com%2F",
       );
-      expect(locationUrl.url()).toBe("/http://example.com/");
-      expect(locationUrl.absUrl()).toBe(
+      expect(locationUrl.getUrl()).toBe("/http://example.com/");
+      expect(locationUrl.absUrl).toBe(
         "http://server/pre/index.html#/http://example.com/",
       );
     });
 
     it("should allow navigating outside the original base URL", () => {
-      locationUrl = new LocationHashbangUrl(
+      locationUrl = new Location(
         "http://server/pre/index.html",
         "http://server/pre/",
+        false,
         "#",
       );
 
-      locationUrl.$$parse("http://server/next/index.html");
-      expect(locationUrl.url()).toBe("");
-      expect(locationUrl.absUrl()).toBe("http://server/next/index.html");
+      locationUrl.parse("http://server/next/index.html");
+      expect(locationUrl.getUrl()).toBe("");
+      expect(locationUrl.absUrl).toBe("http://server/next/index.html");
     });
   });
 
@@ -3315,7 +3694,7 @@ describe("$location", () => {
   //     const parser = document.createElement("a");
   //     parser.href = options.initialUrl;
 
-  //     $windowProvider.$get = function () {
+  //     $windowProvider.$get = () => {
   //       const win = {};
   //       angular.extend(win, window);
   //       // Ensure `window` is a reference to the mock global object, so that
@@ -3377,7 +3756,7 @@ describe("$location", () => {
   //         $sniffer,
   //         $$taskTrackerFactory,
   //       );
-  //       browser.baseHref = function () {
+  //       browser.baseHref = () => {
   //         return options.baseHref;
   //       };
   //       return browser;
@@ -3399,8 +3778,8 @@ describe("$location", () => {
   }
 
   function parseLinkAndReturn(location, url, relHref) {
-    if (location.$$parseLinkUrl(url, relHref)) {
-      return location.absUrl();
+    if (location.parseLinkUrl(url, relHref)) {
+      return location.absUrl;
     }
     return undefined;
   }