@angular-wave/angular.ts 0.0.67 → 0.0.68

package/src/core/location/location.js

@@ -2,7 +2,6 @@ import { JQLite } from "../../shared/jqlite/jqlite";
 import { urlResolve } from "../url-utils/url-utils";
 import {
   encodeUriSegment,
-  forEach,
   isBoolean,
   isDefined,
   isNumber,
@@ -16,406 +15,107 @@ import {
 } from "../../shared/utils";
 import { ScopePhase } from "../scope/scope";
 
-export const PATH_MATCH = /^([^?#]*)(\?([^#]*))?(#(.*))?$/;
-const DEFAULT_PORTS = { http: 80, https: 443, ftp: 21 };
-const $locationMinErr = minErr("$location");
-
-/**
- * Encode path using encodeUriSegment, ignoring forward slashes
- *
- * @param {string} path Path to encode
- * @returns {string}
- */
-function encodePath(path) {
-  const segments = path.split("/");
-  let i = segments.length;
-
-  while (i--) {
-    // decode forward slashes to prevent them from being double encoded
-    segments[i] = encodeUriSegment(segments[i].replace(/%2F/g, "/"));
-  }
-
-  return segments.join("/");
-}
-
-function decodePath(path, html5Mode) {
-  const segments = path.split("/");
-  let i = segments.length;
-
-  while (i--) {
-    segments[i] = decodeURIComponent(segments[i]);
-    if (html5Mode) {
-      // encode forward slashes to prevent them from being mistaken for path separators
-      segments[i] = segments[i].replace(/\//g, "%2F");
-    }
-  }
-
-  return segments.join("/");
-}
-
-function normalizePath(pathValue, searchValue, hashValue) {
-  const search = toKeyValue(searchValue);
-  const hash = hashValue ? `#${encodeUriSegment(hashValue)}` : "";
-  const path = encodePath(pathValue);
-
-  return path + (search ? `?${search}` : "") + hash;
-}
-
-function parseAbsoluteUrl(absoluteUrl, locationObj) {
-  const parsedUrl = urlResolve(absoluteUrl);
-
-  locationObj.$$protocol = parsedUrl.protocol;
-  locationObj.$$host = parsedUrl.hostname;
-  locationObj.$$port =
-    toInt(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null;
-}
-
-const DOUBLE_SLASH_REGEX = /^\s*[\\/]{2,}/;
-function parseAppUrl(url, locationObj, html5Mode) {
-  if (DOUBLE_SLASH_REGEX.test(url)) {
-    throw $locationMinErr("badpath", 'Invalid url "{0}".', url);
-  }
-
-  const prefixed = url.charAt(0) !== "/";
-  if (prefixed) {
-    url = `/${url}`;
-  }
-  const match = urlResolve(url);
-  const path =
-    prefixed && match.pathname.charAt(0) === "/"
-      ? match.pathname.substring(1)
-      : match.pathname;
-  locationObj.$$path = decodePath(path, html5Mode);
-  locationObj.$$search = parseKeyValue(match.search);
-  locationObj.$$hash = decodeURIComponent(match.hash);
-
-  // make sure path starts with '/';
-  if (locationObj.$$path && locationObj.$$path.charAt(0) !== "/") {
-    locationObj.$$path = `/${locationObj.$$path}`;
-  }
-}
-
-function startsWith(str, search) {
-  return str.slice(0, search.length) === search;
-}
-
 /**
- *
- * @param {string} base
- * @param {string} url
- * @returns {string} returns text from `url` after `base` or `undefined` if it does not begin with
- *                   the expected string.
+ * @typedef {Object} DefaultPorts
+ * @property {number} http
+ * @property {number} https
+ * @property {number} ftp
  */
-export function stripBaseUrl(base, url) {
-  if (startsWith(url, base)) {
-    return url.substr(base.length);
-  }
-}
-
-export function stripHash(url) {
-  const index = url.indexOf("#");
-  return index === -1 ? url : url.substr(0, index);
-}
-
-export function stripFile(url) {
-  return url.substr(0, stripHash(url).lastIndexOf("/") + 1);
-}
-
-/* return the server only (scheme://host:port) */
-export function serverBase(url) {
-  return url.substring(0, url.indexOf("/", url.indexOf("//") + 2));
-}
 
 /**
- * LocationHtml5Url represents a URL
- * This object is exposed as $location service when HTML5 mode is enabled and supported
- *
- * @constructor
- * @param {string} appBase application base URL
- * @param {string} appBaseNoFile application base URL stripped of any filename
- * @param {string} basePrefix URL path prefix
+ * @typedef {Object} Html5Mode
+ * @property {boolean} enabled
+ * @property {boolean} requireBase
+ * @property {boolean|string} rewriteLinks
  */
-export function LocationHtml5Url(appBase, appBaseNoFile, basePrefix) {
-  this.$$html5 = true;
-  basePrefix = basePrefix || "";
-  parseAbsoluteUrl(appBase, this);
-
-  /**
-   * Parse given HTML5 (regular) URL string into properties
-   * @param {string} url HTML5 URL
-   * @private
-   */
-  this.$$parse = function (url) {
-    const pathUrl = stripBaseUrl(appBaseNoFile, url);
-    if (!isString(pathUrl)) {
-      throw $locationMinErr(
-        "ipthprfx",
-        'Invalid url "{0}", missing path prefix "{1}".',
-        url,
-        appBaseNoFile,
-      );
-    }
-
-    parseAppUrl(pathUrl, this, true);
-
-    if (!this.$$path) {
-      this.$$path = "/";
-    }
-
-    this.$$compose();
-  };
-
-  this.$$normalizeUrl = function (url) {
-    return appBaseNoFile + url.substr(1); // first char is always '/'
-  };
 
-  this.$$parseLinkUrl = function (url, relHref) {
-    if (relHref && relHref[0] === "#") {
-      // special case for links to hash fragments:
-      // keep the old url and only replace the hash fragment
-      this.hash(relHref.slice(1));
-      return true;
-    }
-    let appUrl;
-    let prevAppUrl;
-    let rewrittenUrl;
-
-    if (isDefined((appUrl = stripBaseUrl(appBase, url)))) {
-      prevAppUrl = appUrl;
-      if (
-        basePrefix &&
-        isDefined((appUrl = stripBaseUrl(basePrefix, appUrl)))
-      ) {
-        rewrittenUrl = appBaseNoFile + (stripBaseUrl("/", appUrl) || appUrl);
-      } else {
-        rewrittenUrl = appBase + prevAppUrl;
-      }
-    } else if (isDefined((appUrl = stripBaseUrl(appBaseNoFile, url)))) {
-      rewrittenUrl = appBaseNoFile + appUrl;
-    } else if (appBaseNoFile === `${url}/`) {
-      rewrittenUrl = appBaseNoFile;
-    }
-    if (rewrittenUrl) {
-      this.$$parse(rewrittenUrl);
-    }
-    return !!rewrittenUrl;
-  };
-}
+/** @type {DefaultPorts} */
+const DEFAULT_PORTS = { http: 80, https: 443, ftp: 21 };
+const PATH_MATCH = /^([^?#]*)(\?([^#]*))?(#(.*))?$/;
+const $locationMinErr = minErr("$location");
 
 /**
- * LocationHashbangUrl represents URL
- * This object is exposed as $location service when developer doesn't opt into html5 mode.
- * It also serves as the base class for html5 mode fallback on legacy browsers.
- *
- * @constructor
- * @param {string} appBase application base URL
- * @param {string} appBaseNoFile application base URL stripped of any filename
- * @param {string} hashPrefix hashbang prefix
+ * @abstract
  */
-export function LocationHashbangUrl(appBase, appBaseNoFile, hashPrefix) {
-  parseAbsoluteUrl(appBase, this);
-
+export class Location {
   /**
-   * Parse given hashbang URL into properties
-   * @param {string} url Hashbang URL
-   * @private
+   * @param {string} appBase application base URL
+   * @param {string} appBaseNoFile application base URL stripped of any filename
    */
-  this.$$parse = function (url) {
-    const withoutBaseUrl =
-      stripBaseUrl(appBase, url) || stripBaseUrl(appBaseNoFile, url);
-    let withoutHashUrl;
-
-    if (!isUndefined(withoutBaseUrl) && withoutBaseUrl.charAt(0) === "#") {
-      // The rest of the URL starts with a hash so we have
-      // got either a hashbang path or a plain hash fragment
-      withoutHashUrl = stripBaseUrl(hashPrefix, withoutBaseUrl);
-      if (isUndefined(withoutHashUrl)) {
-        // There was no hashbang prefix so we just have a hash fragment
-        withoutHashUrl = withoutBaseUrl;
-      }
-    } else {
-      // There was no hashbang path nor hash fragment:
-      // If we are in HTML5 mode we use what is left as the path;
-      // Otherwise we ignore what is left
-      if (this.$$html5) {
-        withoutHashUrl = withoutBaseUrl;
-      } else {
-        withoutHashUrl = "";
-        if (isUndefined(withoutBaseUrl)) {
-          appBase = url;
-          /** @type {?} */ (this).replace();
-        }
-      }
-    }
+  constructor(appBase, appBaseNoFile) {
+    /** @type {string} */
+    this.appBase = appBase;
 
-    parseAppUrl(withoutHashUrl, this, false);
-
-    this.$$path = removeWindowsDriveName(this.$$path, withoutHashUrl, appBase);
+    /** @type {string} */
+    this.appBaseNoFile = appBaseNoFile;
 
-    this.$$compose();
-
-    /*
-     * In Windows, on an anchor node on documents loaded from
-     * the filesystem, the browser will return a pathname
-     * prefixed with the drive name ('/C:/path') when a
-     * pathname without a drive is set:
-     *  * a.setAttribute('href', '/foo')
-     *   * a.pathname === '/C:/foo' //true
-     *
-     * Inside of AngularJS, we're always using pathnames that
-     * do not include drive names for routing.
+    /**
+     * An absolute URL is the full URL, including protocol (http/https ), the optional subdomain (e.g. www ), domain (example.com), and path (which includes the directory and slug).
+     * @type {string}
      */
-    function removeWindowsDriveName(path, url, base) {
-      /*
-      Matches paths for file protocol on windows,
-      such as /C:/foo/bar, and captures only /foo/bar.
-      */
-      const windowsFilePathExp = /^\/[A-Z]:(\/.*)/;
+    this.$$absUrl = "";
 
-      let firstPathSegmentMatch;
-
-      // Get the relative path from the input URL.
-      if (startsWith(url, base)) {
-        url = url.replace(base, "");
-      }
-
-      // The input URL intentionally contains a first path segment that ends with a colon.
-      if (windowsFilePathExp.exec(url)) {
-        return path;
-      }
-
-      firstPathSegmentMatch = windowsFilePathExp.exec(path);
-      return firstPathSegmentMatch ? firstPathSegmentMatch[1] : path;
-    }
-  };
-
-  this.$$normalizeUrl = function (url) {
-    return appBase + (url ? hashPrefix + url : "");
-  };
-
-  this.$$parseLinkUrl = function (url) {
-    if (stripHash(appBase) === stripHash(url)) {
-      this.$$parse(url);
-      return true;
-    }
-    return false;
-  };
-}
-
-/**
- * LocationHashbangUrl represents URL
- * This object is exposed as $location service when html5 history api is enabled but the browser
- * does not support it.
- *
- * @constructor
- * @param {string} appBase application base URL
- * @param {string} appBaseNoFile application base URL stripped of any filename
- * @param {string} hashPrefix hashbang prefix
- */
-export function LocationHashbangInHtml5Url(appBase, appBaseNoFile, hashPrefix) {
-  this.$$html5 = true;
-  LocationHashbangUrl.apply(this, arguments);
-
-  this.$$parseLinkUrl = function (url, relHref) {
-    if (relHref && relHref[0] === "#") {
-      // special case for links to hash fragments:
-      // keep the old url and only replace the hash fragment
-      this.hash(relHref.slice(1));
-      return true;
-    }
+    /**
+     * If html5 mode is enabled
+     * @type {boolean}
+     */
+    this.$$html5 = false;
 
-    let rewrittenUrl;
-    let appUrl;
+    /**
+     * Has any change been replacing?
+     * @type {boolean}
+     */
+    this.$$replace = false;
 
-    if (appBase === stripHash(url)) {
-      rewrittenUrl = url;
-    } else if ((appUrl = stripBaseUrl(appBaseNoFile, url))) {
-      rewrittenUrl = appBase + hashPrefix + appUrl;
-    } else if (appBaseNoFile === `${url}/`) {
-      rewrittenUrl = appBaseNoFile;
-    }
-    if (rewrittenUrl) {
-      this.$$parse(rewrittenUrl);
-    }
-    return !!rewrittenUrl;
-  };
+    /** @type {import('../url-utils/url-utils').HttpProtocol} */
+    this.$$protocol = undefined;
 
-  this.$$normalizeUrl = function (url) {
-    // include hashPrefix in $$absUrl when $$url is empty so IE9 does not reload page because of removal of '#'
-    return appBase + hashPrefix + url;
-  };
-}
+    /** @type {string} */
+    this.$$host = undefined;
 
-const locationPrototype = {
-  /**
-   * Ensure absolute URL is initialized.
-   * @private
-   */
-  $$absUrl: "",
+    /**
+     * The port, without ":"
+     * @type {number}
+     */
+    this.$$port = undefined;
 
-  /**
-   * Are we in html5 mode?
-   * @private
-   */
-  $$html5: false,
+    /**
+     * The pathname, beginning with "/"
+     * @type {string}
+     */
+    this.$$path = undefined;
 
-  /**
-   * Has any change been replacing?
-   * @private
-   */
-  $$replace: false,
+    /**
+     * The hash string, minus the hash symbol
+     * @type {string}
+     */
+    this.$$hash = undefined;
 
-  /**
-   * Compose url and update `url` and `absUrl` property
-   * @private
-   */
-  $$compose() {
-    this.$$url = normalizePath(this.$$path, this.$$search, this.$$hash);
-    this.$$absUrl = this.$$normalizeUrl(this.$$url);
-    this.$$urlUpdatedByLocation = true;
-  },
+    /**
+     * Helper property for scope watch changes
+     * @type {boolean}
+     */
+    this.$$urlUpdatedByLocation = false;
+  }
 
   /**
-   * @ngdoc method
-   * @name $location#absUrl
-   *
-   * @description
-   * This method is getter only.
-   *
    * Return full URL representation with all segments encoded according to rules specified in
    * [RFC 3986](http://www.ietf.org/rfc/rfc3986.txt).
    *
-   *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-   * let absUrl = $location.absUrl();
-   * // => "http://example.com/#/some/path?foo=bar&baz=xoxo"
-   * ```
-   *
    * @return {string} full URL
    */
-  absUrl: locationGetter("$$absUrl"),
+  absUrl() {
+    return this.$$absUrl;
+  }
 
   /**
-   * @ngdoc method
-   * @name $location#url
-   *
-   * @description
    * This method is getter / setter.
    *
    * Return URL (e.g. `/path?a=b#hash`) when called without any parameter.
-   *
    * Change path, search and hash, when called with parameter and return `$location`.
    *
-   *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-   * let url = $location.url();
-   * // => "/some/path?foo=bar&baz=xoxo"
-   * ```
-   *
    * @param {string=} url New URL without base prefix (e.g. `/path?a=b#hash`)
-   * @return {string} url
+   * @return {Location|string} url
    */
   url(url) {
     if (isUndefined(url)) {
@@ -428,33 +128,18 @@ const locationPrototype = {
     this.hash(match[5] || "");
 
     return this;
-  },
+  }
 
   /**
-   * @ngdoc method
-   * @name $location#protocol
-   *
-   * @description
-   * This method is getter only.
    *
    * Return protocol of current URL.
-   *
-   *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-   * let protocol = $location.protocol();
-   * // => "http"
-   * ```
-   *
-   * @return {string} protocol of current URL
+   * @return {import("../url-utils/url-utils").HttpProtocol} protocol of current URL
    */
-  protocol: locationGetter("$$protocol"),
+  protocol() {
+    return this.$$protocol;
+  }
 
   /**
-   * @ngdoc method
-   * @name $location#host
-   *
-   * @description
    * This method is getter only.
    *
    * Return host of current URL.
@@ -462,27 +147,13 @@ const locationPrototype = {
    * Note: compared to the non-AngularJS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
    *
    *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-   * let host = $location.host();
-   * // => "example.com"
-   *
-   * // given URL http://user:password@example.com:8080/#/some/path?foo=bar&baz=xoxo
-   * host = $location.host();
-   * // => "example.com"
-   * host = location.host;
-   * // => "example.com:8080"
-   * ```
-   *
    * @return {string} host of current URL.
    */
-  host: locationGetter("$$host"),
+  host() {
+    return this.$$host;
+  }
 
   /**
-   * @ngdoc method
-   * @name $location#port
-   *
-   * @description
    * This method is getter only.
    *
    * Return port of current URL.
@@ -494,15 +165,13 @@ const locationPrototype = {
    * // => 80
    * ```
    *
-   * @return {Number} port
+   * @return {number} port
    */
-  port: locationGetter("$$port"),
+  port() {
+    return this.$$port;
+  }
 
   /**
-   * @ngdoc method
-   * @name $location#path
-   *
-   * @description
    * This method is getter / setter.
    *
    * Return path of current URL when called without any parameter.
@@ -522,55 +191,58 @@ const locationPrototype = {
    * @param {(string|number)=} path New path
    * @return {(string|object)} path if called with no parameters, or `$location` if called with a parameter
    */
-  path: locationGetterSetter("$$path", (path) => {
-    path = path !== null ? path.toString() : "";
-    return path.charAt(0) === "/" ? path : `/${path}`;
-  }),
+  path(path) {
+    if (isUndefined(path)) {
+      return this.$$path;
+    }
+    let newPath = path !== null ? path.toString() : "";
+    this.$$path = newPath.charAt(0) === "/" ? newPath : `/${newPath}`;
+    this.$$compose();
+    return this;
+  }
 
   /**
-   * @ngdoc method
-   * @name $location#search
-   *
-   * @description
    * This method is getter / setter.
    *
-   * Return search part (as object) of current URL when called without any parameter.
+   * Returns the hash fragment when called without any parameters.
    *
-   * Change search part when called with parameter and return `$location`.
+   * Changes the hash fragment when called with a parameter and returns `$location`.
    *
    *
    * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-   * let searchObject = $location.search();
-   * // => {foo: 'bar', baz: 'xoxo'}
-   *
-   * // set foo to 'yipee'
-   * $location.search('foo', 'yipee');
-   * // $location.search() => {foo: 'yipee', baz: 'xoxo'}
+   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo#hashValue
+   * let hash = $location.hash();
+   * // => "hashValue"
    * ```
    *
-   * @param {string|Object.<string>|Object.<Array.<string>>} search New search params - string or
-   * hash object.
-   *
-   * When called with a single argument the method acts as a setter, setting the `search` component
-   * of `$location` to the specified value.
-   *
-   * If the argument is a hash object containing an array of values, these values will be encoded
-   * as duplicate search parameters in the URL.
-   *
-   * @param {(string|Number|Array<string>|boolean)=} paramValue If `search` is a string or number, then `paramValue`
-   * will override only a single search property.
-   *
-   * If `paramValue` is an array, it will override the property of the `search` component of
-   * `$location` specified via the first argument.
-   *
-   * If `paramValue` is `null`, the property specified via the first argument will be deleted.
-   *
-   * If `paramValue` is `true`, the property specified via the first argument will be added with no
-   * value nor trailing equal sign.
+   * @param {(string|number)=} hash New hash fragment
+   * @return {string|Location} hash
+   */
+  hash(hash) {
+    if (isUndefined(hash)) {
+      return this.$$hash;
+    }
+
+    this.$$hash = hash !== null ? hash.toString() : "";
+    this.$$compose();
+    return this;
+  }
+
+  /**
+   * If called, all changes to $location during the current `$digest` will replace the current history
+   * record, instead of adding a new one.
+   */
+  replace() {
+    this.$$replace = true;
+    return this;
+  }
+
+  /**
+   * Returns or sets the search part (as object) of current URL when called without any parameter
    *
-   * @return {Object} If called with no arguments returns the parsed `search` object. If called with
-   * one or more arguments returns `$location` object itself.
+   * @param {string|Object=} search New search params - string or hash object.
+   * @param {(string|number|Array<string>|boolean)=} paramValue If search is a string or number, then paramValue will override only a single search property.
+   * @returns {Object|Location} Search object or Location object
    */
   search(search, paramValue) {
     switch (arguments.length) {
@@ -603,149 +275,253 @@ const locationPrototype = {
         }
     }
 
-    this.$$compose();
-    return this;
-  },
+    this.$$compose();
+    return this;
+  }
+
+  /**
+   * Compose url and update `url` and `absUrl` property
+   * @returns {void}
+   */
+  $$compose() {
+    this.$$url = normalizePath(this.$$path, this.$$search, this.$$hash);
+    this.$$absUrl = this.$$normalizeUrl(this.$$url);
+    this.$$urlUpdatedByLocation = true;
+  }
+
+  /**
+   * @param {string} _url
+   * @returns {string}
+   */
+  $$normalizeUrl(_url) {
+    throw new Error(`Method not implemented ${_url}`);
+  }
+
+  /**
+   * This method is getter / setter.
+   *
+   * Return the history state object when called without any parameter.
+   *
+   * Change the history state object when called with one parameter and return `$location`.
+   * The state object is later passed to `pushState` or `replaceState`.
+   * See {@link https://developer.mozilla.org/en-US/docs/Web/API/History/pushState#state|History.state}
+   *
+   * NOTE: This method is supported only in HTML5 mode and only in browsers supporting
+   * the HTML5 History API (i.e. methods `pushState` and `replaceState`). If you need to support
+   * older browsers (like IE9 or Android < 4.0), don't use this method.
+   *
+   * @param {any} state State object for pushState or replaceState
+   * @return {any} state
+   */
+  state(state) {
+    if (!arguments.length) {
+      return this.$$state;
+    }
+
+    if (!(this instanceof LocationHtml5Url) || !this.$$html5) {
+      throw $locationMinErr(
+        "nostate",
+        "History API state support is available only " +
+          "in HTML5 mode and only in browsers supporting HTML5 History API",
+      );
+    }
+    // The user might modify `stateObject` after invoking `$location.state(stateObject)`
+    // but we're changing the $$state reference to $browser.state() during the $digest
+    // so the modification window is narrow.
+    this.$$state = isUndefined(state) ? null : state;
+    this.$$urlUpdatedByLocation = true;
+
+    return this;
+  }
+}
+
+/**
+ * This object is exposed as $location service when HTML5 mode is enabled and supported
+ */
+export class LocationHtml5Url extends Location {
+  /**
+   * @param {string} appBase application base URL
+   * @param {string} appBaseNoFile application base URL stripped of any filename
+   * @param {string} basePrefix URL path prefix
+   */
+  constructor(appBase, appBaseNoFile, basePrefix) {
+    super(appBase, appBaseNoFile);
+    this.$$html5 = true;
+    this.basePrefix = basePrefix || "";
+    parseAbsoluteUrl(appBase, this);
+  }
+
+  /**
+   * Parse given HTML5 (regular) URL string into properties
+   * @param {string} url HTML5 URL
+   */
+  $$parse(url) {
+    const pathUrl = stripBaseUrl(this.appBaseNoFile, url);
+    if (!isString(pathUrl)) {
+      throw $locationMinErr(
+        "ipthprfx",
+        'Invalid url "{0}", missing path prefix "{1}".',
+        url,
+        this.appBaseNoFile,
+      );
+    }
+
+    parseAppUrl(pathUrl, this, true);
+
+    if (!this.$$path) {
+      this.$$path = "/";
+    }
+
+    this.$$compose();
+  }
+
+  $$normalizeUrl(url) {
+    return this.appBaseNoFile + url.substr(1); // first char is always '/'
+  }
+
+  $$parseLinkUrl = function (url, relHref) {
+    if (relHref && relHref[0] === "#") {
+      // special case for links to hash fragments:
+      // keep the old url and only replace the hash fragment
+      this.hash(relHref.slice(1));
+      return true;
+    }
+    let appUrl;
+    let prevAppUrl;
+    let rewrittenUrl;
+
+    if (isDefined((appUrl = stripBaseUrl(this.appBase, url)))) {
+      prevAppUrl = appUrl;
+      if (
+        this.basePrefix &&
+        isDefined((appUrl = stripBaseUrl(this.basePrefix, appUrl)))
+      ) {
+        rewrittenUrl =
+          this.appBaseNoFile + (stripBaseUrl("/", appUrl) || appUrl);
+      } else {
+        rewrittenUrl = this.appBase + prevAppUrl;
+      }
+    } else if (isDefined((appUrl = stripBaseUrl(this.appBaseNoFile, url)))) {
+      rewrittenUrl = this.appBaseNoFile + appUrl;
+    } else if (this.appBaseNoFile === `${url}/`) {
+      rewrittenUrl = this.appBaseNoFile;
+    }
+    if (rewrittenUrl) {
+      this.$$parse(rewrittenUrl);
+    }
+    return !!rewrittenUrl;
+  };
+}
+
+/**
+ * LocationHashbangUrl represents URL
+ * This object is exposed as $location service when developer doesn't opt into html5 mode.
+ * It also serves as the base class for html5 mode fallback on legacy browsers.
+ *
+ * @constructor
+ * @param {string} appBase application base URL
+ * @param {string} appBaseNoFile application base URL stripped of any filename
+ * @param {string} hashPrefix hashbang prefix
+ */
+export class LocationHashbangUrl extends Location {
+  constructor(appBase, appBaseNoFile, hashPrefix) {
+    super(appBase, appBaseNoFile);
+    this.appBase = appBase;
+    this.appBaseNoFile = appBaseNoFile;
+    this.hashPrefix = hashPrefix;
+    parseAbsoluteUrl(appBase, this);
+  }
 
   /**
-   * @ngdoc method
-   * @name $location#hash
-   *
-   * @description
-   * This method is getter / setter.
-   *
-   * Returns the hash fragment when called without any parameters.
-   *
-   * Changes the hash fragment when called with a parameter and returns `$location`.
-   *
-   *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo#hashValue
-   * let hash = $location.hash();
-   * // => "hashValue"
-   * ```
-   *
-   * @param {(string|number)=} hash New hash fragment
-   * @return {string} hash
+   * Parse given hashbang URL into properties
+   * @param {string} url Hashbang URL
    */
-  hash: locationGetterSetter("$$hash", (hash) =>
-    hash !== null ? hash.toString() : "",
-  ),
+  $$parse(url) {
+    const withoutBaseUrl =
+      stripBaseUrl(this.appBase, url) || stripBaseUrl(this.appBaseNoFile, url);
+    let withoutHashUrl;
 
-  /**
-   * @ngdoc method
-   * @name $location#replace
-   *
-   * @description
-   * If called, all changes to $location during the current `$digest` will replace the current history
-   * record, instead of adding a new one.
-   */
-  replace() {
-    this.$$replace = true;
-    return this;
-  },
-};
+    if (!isUndefined(withoutBaseUrl) && withoutBaseUrl.charAt(0) === "#") {
+      // The rest of the URL starts with a hash so we have
+      // got either a hashbang path or a plain hash fragment
+      withoutHashUrl = stripBaseUrl(this.hashPrefix, withoutBaseUrl);
+      if (isUndefined(withoutHashUrl)) {
+        // There was no hashbang prefix so we just have a hash fragment
+        withoutHashUrl = withoutBaseUrl;
+      }
+    } else {
+      // There was no hashbang path nor hash fragment:
+      // If we are in HTML5 mode we use what is left as the path;
+      // Otherwise we ignore what is left
+      if (this.$$html5) {
+        withoutHashUrl = withoutBaseUrl;
+      } else {
+        withoutHashUrl = "";
+        if (isUndefined(withoutBaseUrl)) {
+          this.appBase = url;
+          /** @type {?} */ (this).replace();
+        }
+      }
+    }
 
-forEach(
-  [LocationHashbangInHtml5Url, LocationHashbangUrl, LocationHtml5Url],
-  (Location) => {
-    Location.prototype = Object.create(locationPrototype);
+    parseAppUrl(withoutHashUrl, this, false);
 
-    /**
-     * @ngdoc method
-     * @name $location#state
-     *
-     * @description
-     * This method is getter / setter.
-     *
-     * Return the history state object when called without any parameter.
-     *
-     * Change the history state object when called with one parameter and return `$location`.
-     * The state object is later passed to `pushState` or `replaceState`.
-     *
-     * NOTE: This method is supported only in HTML5 mode and only in browsers supporting
-     * the HTML5 History API (i.e. methods `pushState` and `replaceState`). If you need to support
-     * older browsers (like IE9 or Android < 4.0), don't use this method.
+    this.$$path = removeWindowsDriveName(
+      this.$$path,
+      withoutHashUrl,
+      this.appBase,
+    );
+
+    this.$$compose();
+
+    /*
+     * In Windows, on an anchor node on documents loaded from
+     * the filesystem, the browser will return a pathname
+     * prefixed with the drive name ('/C:/path') when a
+     * pathname without a drive is set:
+     *  * a.setAttribute('href', '/foo')
+     *   * a.pathname === '/C:/foo' //true
      *
-     * @param {object=} state State object for pushState or replaceState
-     * @return {object} state
+     * Inside of AngularJS, we're always using pathnames that
+     * do not include drive names for routing.
      */
-    Location.prototype.state = function (state) {
-      if (!arguments.length) {
-        return this.$$state;
-      }
+    function removeWindowsDriveName(path, url, base) {
+      /*
+      Matches paths for file protocol on windows,
+      such as /C:/foo/bar, and captures only /foo/bar.
+      */
+      const windowsFilePathExp = /^\/[A-Z]:(\/.*)/;
 
-      if (Location !== LocationHtml5Url || !this.$$html5) {
-        throw $locationMinErr(
-          "nostate",
-          "History API state support is available only " +
-            "in HTML5 mode and only in browsers supporting HTML5 History API",
-        );
-      }
-      // The user might modify `stateObject` after invoking `$location.state(stateObject)`
-      // but we're changing the $$state reference to $browser.state() during the $digest
-      // so the modification window is narrow.
-      this.$$state = isUndefined(state) ? null : state;
-      this.$$urlUpdatedByLocation = true;
+      let firstPathSegmentMatch;
 
-      return this;
-    };
-  },
-);
+      // Get the relative path from the input URL.
+      if (startsWith(url, base)) {
+        url = url.replace(base, "");
+      }
 
-function locationGetter(property) {
-  return function () {
-    return this[property];
-  };
-}
+      // The input URL intentionally contains a first path segment that ends with a colon.
+      if (windowsFilePathExp.exec(url)) {
+        return path;
+      }
 
-function locationGetterSetter(property, preprocess) {
-  return function (value) {
-    if (isUndefined(value)) {
-      return this[property];
+      firstPathSegmentMatch = windowsFilePathExp.exec(path);
+      return firstPathSegmentMatch ? firstPathSegmentMatch[1] : path;
     }
+  }
 
-    this[property] = preprocess(value);
-    this.$$compose();
+  $$normalizeUrl(url) {
+    return this.appBase + (url ? this.hashPrefix + url : "");
+  }
 
-    return this;
-  };
+  $$parseLinkUrl(url) {
+    if (stripHash(this.appBase) === stripHash(url)) {
+      this.$$parse(url);
+      return true;
+    }
+    return false;
+  }
 }
 
-/**
- * @ngdoc service
- * @name $location
- *
- * @requires $rootElement
- *
- * @description
- * The $location service parses the URL in the browser address bar (based on the
- * [window.location](https://developer.mozilla.org/en/window.location)) and makes the URL
- * available to your application. Changes to the URL in the address bar are reflected into
- * $location service and changes to $location are reflected into the browser address bar.
- *
- * **The $location service:**
- *
- * - Exposes the current URL in the browser address bar, so you can
- *   - Watch and observe the URL.
- *   - Change the URL.
- * - Synchronizes the URL with the browser when the user
- *   - Changes the address bar.
- *   - Clicks the back or forward button (or clicks a History link).
- *   - Clicks on a link.
- * - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
- *
- * For more information see {@link guide/$location Developer Guide: Using $location}
- */
-
-/**
- * @ngdoc provider
- * @name $locationProvider
- *
- *
- * @description
- * Use the `$locationProvider` to configure how the application deep linking paths are stored.
- */
 export function $LocationProvider() {
   let hashPrefix = "!";
   const html5Mode = {
@@ -755,9 +531,6 @@ export function $LocationProvider() {
   };
 
   /**
-   * @ngdoc method
-   * @name $locationProvider#hashPrefix
-   * @description
    * The default value for the prefix is `'!'`.
    * @param {string=} prefix Prefix for hash part (containing path and search)
    * @returns {*} current value if used as getter or itself (chaining) if used as setter
@@ -771,9 +544,6 @@ export function $LocationProvider() {
   };
 
   /**
-   * @ngdoc method
-   * @name $locationProvider#html5Mode
-   * @description
    * @param {(boolean|Object)=} mode If boolean, sets `html5Mode.enabled` to value.
    *   If object, sets `enabled`, `requireBase` and `rewriteLinks` to respective values. Supported
    *   properties:
@@ -816,57 +586,19 @@ export function $LocationProvider() {
     return html5Mode;
   };
 
-  /**
-   * @ngdoc event
-   * @name $location#$locationChangeStart
-   * @eventType broadcast on root scope
-   * @description
-   * Broadcasted before a URL will change.
-   *
-   * This change can be prevented by calling
-   * `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more
-   * details about event object. Upon successful change
-   * {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired.
-   *
-   * The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
-   * the browser supports the HTML5 History API.
-   *
-   * @param {Object} angularEvent Synthetic event object.
-   * @param {string} newUrl New URL
-   * @param {string=} oldUrl URL that was before it was changed.
-   * @param {string=} newState New history state object
-   * @param {string=} oldState History state object that was before it was changed.
-   */
-
-  /**
-   * @ngdoc event
-   * @name $location#$locationChangeSuccess
-   * @eventType broadcast on root scope
-   * @description
-   * Broadcasted after a URL was changed.
-   *
-   * The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
-   * the browser supports the HTML5 History API.
-   *
-   * @param {Object} angularEvent Synthetic event object.
-   * @param {string} newUrl New URL
-   * @param {string=} oldUrl URL that was before it was changed.
-   * @param {string=} newState New history state object
-   * @param {string=} oldState History state object that was before it was changed.
-   */
-
   this.$get = [
     "$rootScope",
     "$browser",
     "$rootElement",
     /**
      *
-     * @param {*} $rootScope
-     * @param {*} $browser
+     * @param {import('../scope/scope').Scope} $rootScope
+     * @param {import('../../services/browser').Browser} $browser
      * @param {JQLite} $rootElement
      * @returns
      */
     function ($rootScope, $browser, $rootElement) {
+      /** @type {Location} */
       let $location;
       let LocationMode;
       const baseHref = $browser.baseHref(); // if base[href] is undefined, it defaults to ''
@@ -895,13 +627,6 @@ export function $LocationProvider() {
 
       const IGNORE_URI_REGEXP = /^\s*(javascript|mailto):/i;
 
-      // Determine if two URLs are equal despite potentially having different encoding/normalizing
-      //  such as $location.absUrl() vs $browser.url()
-      // See https://github.com/angular/angular.js/issues/16592
-      function urlsEqual(a, b) {
-        return a === b || urlResolve(a).href === urlResolve(b).href;
-      }
-
       function setBrowserUrlWithFallback(url, replace, state) {
         const oldUrl = $location.url();
         const oldState = $location.$$state;
@@ -1029,7 +754,7 @@ export function $LocationProvider() {
         if (initializing || $location.$$urlUpdatedByLocation) {
           $location.$$urlUpdatedByLocation = false;
 
-          const oldUrl = $browser.url();
+          const oldUrl = /** @type {string} */ ($browser.url());
           const newUrl = $location.absUrl();
           const oldState = $browser.state();
           const currentReplace = $location.$$replace;
@@ -1091,3 +816,125 @@ export function $LocationProvider() {
     },
   ];
 }
+
+/**
+ * ///////////////////////////
+ *          HELPERS
+ * ///////////////////////////
+ */
+
+/**
+ * Encode path using encodeUriSegment, ignoring forward slashes
+ *
+ * @param {string} path Path to encode
+ * @returns {string}
+ */
+function encodePath(path) {
+  const segments = path.split("/");
+  let i = segments.length;
+
+  while (i--) {
+    // decode forward slashes to prevent them from being double encoded
+    segments[i] = encodeUriSegment(segments[i].replace(/%2F/g, "/"));
+  }
+
+  return segments.join("/");
+}
+
+function decodePath(path, html5Mode) {
+  const segments = path.split("/");
+  let i = segments.length;
+
+  while (i--) {
+    segments[i] = decodeURIComponent(segments[i]);
+    if (html5Mode) {
+      // encode forward slashes to prevent them from being mistaken for path separators
+      segments[i] = segments[i].replace(/\//g, "%2F");
+    }
+  }
+
+  return segments.join("/");
+}
+
+function normalizePath(pathValue, searchValue, hashValue) {
+  const search = toKeyValue(searchValue);
+  const hash = hashValue ? `#${encodeUriSegment(hashValue)}` : "";
+  const path = encodePath(pathValue);
+
+  return path + (search ? `?${search}` : "") + hash;
+}
+
+/**
+ * @param {string} absoluteUrl
+ * @param {Location} locationObj
+ */
+function parseAbsoluteUrl(absoluteUrl, locationObj) {
+  const parsedUrl = urlResolve(absoluteUrl);
+
+  locationObj.$$protocol = parsedUrl.protocol;
+  locationObj.$$host = parsedUrl.hostname;
+  locationObj.$$port =
+    toInt(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null;
+}
+
+function parseAppUrl(url, locationObj, html5Mode) {
+  if (/^\s*[\\/]{2,}/.test(url)) {
+    throw $locationMinErr("badpath", 'Invalid url "{0}".', url);
+  }
+
+  const prefixed = url.charAt(0) !== "/";
+  if (prefixed) {
+    url = `/${url}`;
+  }
+  const match = urlResolve(url);
+  const path =
+    prefixed && match.pathname.charAt(0) === "/"
+      ? match.pathname.substring(1)
+      : match.pathname;
+  locationObj.$$path = decodePath(path, html5Mode);
+  locationObj.$$search = parseKeyValue(match.search);
+  locationObj.$$hash = decodeURIComponent(match.hash);
+
+  // make sure path starts with '/';
+  if (locationObj.$$path && locationObj.$$path.charAt(0) !== "/") {
+    locationObj.$$path = `/${locationObj.$$path}`;
+  }
+}
+
+function startsWith(str, search) {
+  return str.slice(0, search.length) === search;
+}
+
+/**
+ *
+ * @param {string} base
+ * @param {string} url
+ * @returns {string} returns text from `url` after `base` or `undefined` if it does not begin with
+ *                   the expected string.
+ */
+export function stripBaseUrl(base, url) {
+  if (startsWith(url, base)) {
+    return url.substr(base.length);
+  }
+}
+
+export function stripHash(url) {
+  const index = url.indexOf("#");
+  return index === -1 ? url : url.substr(0, index);
+}
+
+export function stripFile(url) {
+  return url.substr(0, stripHash(url).lastIndexOf("/") + 1);
+}
+
+/* return the server only (scheme://host:port) */
+export function serverBase(url) {
+  return url.substring(0, url.indexOf("/", url.indexOf("//") + 2));
+}
+
+// Determine if two URLs are equal despite potentially having different encoding/normalizing
+//  such as $location.absUrl() vs $browser.url()
+// See https://github.com/angular/angular.js/issues/16592
+function urlsEqual(a, b) {
+  return a === b || urlResolve(a).href === urlResolve(b).href;
+}