@angular-wave/angular.ts 0.7.8 → 0.8.0

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.7.8 - July 17, 2025 02:51:18 */
+/* Version: 0.8.0 - August 2, 2025 17:22:29 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -355,14 +355,6 @@
     return baseExtend(dst, src);
   }
 
-  /**
-   * @param {string} str
-   * @returns {number}
-   */
-  function toInt(str) {
-    return parseInt(str, 10);
-  }
-
   /**
    * @param {any} num
    * @returns {boolean}
@@ -795,7 +787,7 @@
     try {
       return decodeURIComponent(value);
     } catch {
-      return;
+      /* empty */
     }
   }
 
@@ -809,6 +801,7 @@
    *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
    *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
    *                     / "*" / "+" / "," / ";" / "="
+   * @param {string} val
    */
   function encodeUriSegment(val) {
     return encodeUriQuery(val, true)
@@ -1182,6 +1175,36 @@
     return new Promise((resolve) => setTimeout(resolve, t));
   }
 
+  /**
+   * Checks if a given string starts with a specified substring.
+   *
+   * This is a simple polyfill-like function that mimics the behavior of
+   * `String.prototype.startsWith` without using the built-in method.
+   *
+   * @param {string} str - The full string to evaluate.
+   * @param {string} search - The substring to test against the beginning of `str`.
+   * @returns {boolean} `true` if `str` starts with `search`, otherwise `false`.
+   *
+   * @example
+   * startsWith("hello world", "hello");
+   * // returns true
+   *
+   * @example
+   * startsWith("hello world", "world");
+   * // returns false
+   *
+   * @example
+   * startsWith("test", "");
+   * // returns true (empty search string always matches)
+   *
+   * @example
+   * startsWith("abc", "abcd");
+   * // returns false
+   */
+  function startsWith(str, search) {
+    return str.slice(0, search.length) === search;
+  }
+
   /**
    * Expando cache for adding properties to DOM nodes with JavaScript.
    * This used to be an Object in JQLite decorator, but swapped out for a Map
@@ -1765,6 +1788,9 @@
    * @type Readonly<Record<string, string>>
    */
   const $injectTokens = Object.freeze({
+    $attrs: "$attrs",
+    $scope: "$scope",
+    $element: "$element",
     $$AnimateRunner: "$$AnimateRunner",
     $$animateAsyncRun: "$$animateAsyncRun",
     $$animateCache: "$$animateCache",
@@ -1793,6 +1819,7 @@
     $ngViewScroll: "$ngViewScroll",
     $parse: "$parse",
     $rootScope: "$rootScope",
+    $rootElement: "$rootElement",
     $routerGlobals: "$routerGlobals",
     $sce: "$sce",
     $sceDelegate: "$sceDelegate",
@@ -1803,7 +1830,7 @@
     $templateRequest: "$templateRequest",
     $transitions: "$transitions",
     $urlConfig: "$urlConfig",
-    $urlService: "$urlService",
+    $url: "$url",
     $view: "$view",
     // provide literals
     $provide: "$provide",
@@ -2149,8 +2176,7 @@
 
       if (isClass(/** @type {Function} */ (fn))) {
         args.unshift(null);
-        const res = new (Function.prototype.bind.apply(fn, args))();
-        return res;
+        return new (Function.prototype.bind.apply(fn, args))();
       } else {
         return /** @type {Function} */ (fn).apply(self, args);
       }
@@ -2239,8 +2265,7 @@
      */
     factory(serviceName) {
       const provider = this.providerInjector.get(serviceName + providerSuffix$1);
-      const res = this.invoke(provider.$get, provider, undefined, serviceName);
-      return res;
+      return this.invoke(provider.$get, provider, undefined, serviceName);
     }
 
     /**
@@ -2274,8 +2299,7 @@
    */
   function extractArgs$1(fn) {
     const fnText = stringifyFn$1(fn).replace(STRIP_COMMENTS$1, "");
-    const args = fnText.match(ARROW_ARG$1) || fnText.match(FN_ARGS$1);
-    return args;
+    return fnText.match(ARROW_ARG$1) || fnText.match(FN_ARGS$1);
   }
 
   /**
@@ -2566,8 +2590,7 @@
    */
   function extractArgs(fn) {
     const fnText = stringifyFn(fn).replace(STRIP_COMMENTS, "");
-    const args = fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
-    return args;
+    return fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
   }
 
   /**
@@ -3024,11 +3047,7 @@
     }
   }
 
-  const urlParsingNode = document.createElement("a");
   const originUrl = urlResolve(window.location.href);
-  let baseUrlParsingNode;
-
-  urlParsingNode.href = "http://[::1]";
 
   /**
    * @param {import("./interface.js").ResolvableUrl} url
@@ -3038,7 +3057,10 @@
     if (!isString(url))
       return /** @type {import("./interface.js").ParsedUrl} */ (url);
 
-    urlParsingNode.setAttribute("href", /** @type {string} */ (url));
+    const urlParsingNode = new URL(
+      /** @type {string} */ (url),
+      window.location.href,
+    );
 
     const hostname = urlParsingNode.hostname.includes(":")
       ? `[${urlParsingNode.hostname}]`
@@ -3046,9 +3068,7 @@
 
     return {
       href: urlParsingNode.href,
-      protocol: urlParsingNode.protocol
-        ? urlParsingNode.protocol.replace(/:$/, "")
-        : "",
+      protocol: urlParsingNode.protocol,
       host: urlParsingNode.host,
       search: urlParsingNode.search
         ? urlParsingNode.search.replace(/^\?/, "")
@@ -3086,7 +3106,7 @@
    * @returns {boolean} Whether the URL is same-origin as the document base URL.
    */
   function urlIsSameOriginAsBaseUrl(requestUrl) {
-    return urlsAreSameOrigin(requestUrl, getBaseUrl());
+    return urlsAreSameOrigin(requestUrl, document.baseURI);
   }
 
   /**
@@ -3138,27 +3158,6 @@
     return url1.protocol === url2.protocol && url1.host === url2.host;
   }
 
-  /**
-   * Returns the current document base URL.
-   * @returns {string}
-   */
-  function getBaseUrl() {
-    if (document.baseURI) {
-      return document.baseURI;
-    }
-
-    // `document.baseURI` is available everywhere except IE
-    if (!baseUrlParsingNode) {
-      baseUrlParsingNode = document.createElement("a");
-      baseUrlParsingNode.href = ".";
-
-      // Work-around for IE bug described in Implementation Notes. The fix in `urlResolve()` is not
-      // suitable here because we need to track changes to the base URL.
-      baseUrlParsingNode = baseUrlParsingNode.cloneNode(false);
-    }
-    return baseUrlParsingNode.href;
-  }
-
   /**
    * Removes a trailing hash ('#') from the given URL if it exists.
    *
@@ -3480,7 +3479,6 @@
                 "Attempting to use an unsafe value in a safe context.",
               ),
             );
-            return;
           };
 
           if ($injector.has("$sanitize")) {
@@ -3715,7 +3713,6 @@
                 "Attempting to use an unsafe value in a safe context.",
               ),
             );
-            return;
           }
 
           return { trustAs, getTrusted, valueOf };
@@ -3914,7 +3911,7 @@
 
         /**
          * Shorthand method.  `$sce.parseAsHtml(expression string)` →
-         *     {@link ng.$sce#parseAs `$sce.parseAs($sce.HTML, value)`}
+         *     {@link ng.$sceparseAs `$sce.parseAs($sce.HTML, value)`}
          *
          * @param {string} expression String expression to compile.
          * @return {function(context, locals)} A function which represents the compiled expression:
@@ -3927,7 +3924,7 @@
 
         /**
          * Shorthand method.  `$sce.parseAsCss(value)` →
-         *     {@link ng.$sce#parseAs `$sce.parseAs($sce.CSS, value)`}
+         *     {@link ng.$sceparseAs `$sce.parseAs($sce.CSS, value)`}
          *
          * @param {string} expression String expression to compile.
          * @return {function(context, locals)} A function which represents the compiled expression:
@@ -3940,7 +3937,7 @@
 
         /**
          * Shorthand method.  `$sce.parseAsUrl(value)` →
-         *     {@link ng.$sce#parseAs `$sce.parseAs($sce.URL, value)`}
+         *     {@link ng.$sceparseAs `$sce.parseAs($sce.URL, value)`}
          *
          * @param {string} expression String expression to compile.
          * @return {function(context, locals)} A function which represents the compiled expression:
@@ -3953,7 +3950,7 @@
 
         /**
          * Shorthand method.  `$sce.parseAsResourceUrl(value)` →
-         *     {@link ng.$sce#parseAs `$sce.parseAs($sce.RESOURCE_URL, value)`}
+         *     {@link ng.$sceparseAs `$sce.parseAs($sce.RESOURCE_URL, value)`}
          *
          * @param {string} expression String expression to compile.
          * @return {function(context, locals)} A function which represents the compiled expression:
@@ -3966,7 +3963,7 @@
 
         /**
          * Shorthand method.  `$sce.parseAsJs(value)` →
-         *     {@link ng.$sce#parseAs `$sce.parseAs($sce.JS, value)`}
+         *     {@link ng.$sceparseAs `$sce.parseAs($sce.JS, value)`}
          *
          * @param {string} expression String expression to compile.
          * @return {function(context, locals)} A function which represents the compiled expression:
@@ -4523,7 +4520,7 @@
   const DirectiveSuffix = "Directive";
 
   class CompileProvider {
-    static $inject = ["$provide", "$$sanitizeUriProvider"];
+    /* @ignore */ static $inject = ["$provide", "$$sanitizeUriProvider"];
 
     /**
      * @param {import('../../interface.js').Provider} $provide
@@ -5598,8 +5595,7 @@
                 // Null out all of these references for garbage collection
                 compileNodes = transcludeFn = previousCompileContext = null;
               }
-              const linked = compiled.apply(this, arguments);
-              return linked;
+              return compiled.apply(this, arguments);
             };
           }
 
@@ -5943,14 +5939,13 @@
                   //  * `undefined` - a slot that was not declared (i.e. invalid)
                   const slotTranscludeFn = boundTranscludeFn.$$slots[slotName];
                   if (slotTranscludeFn) {
-                    const slotTranscludeRes = slotTranscludeFn(
+                    return slotTranscludeFn(
                       scope,
                       cloneAttachFn,
                       transcludeControllers,
                       futureParentElement,
                       scopeToChild,
                     );
-                    return slotTranscludeRes;
                   }
 
                   if (isUndefined(slotTranscludeFn)) {
@@ -5963,14 +5958,13 @@
                     );
                   }
                 } else {
-                  const boundTranscludeRes = boundTranscludeFn(
+                  return boundTranscludeFn(
                     scope,
                     cloneAttachFn,
                     transcludeControllers,
                     futureParentElement,
                     scopeToChild,
                   );
-                  return boundTranscludeRes;
                 }
               }
             };
@@ -7734,7 +7728,13 @@
 
   class FormController {
     static $nonscope = true;
-    static $inject = ["$element", "$attrs", "$scope", "$animate", "$interpolate"];
+    /* @ignore */ static $inject = [
+      "$element",
+      "$attrs",
+      "$scope",
+      "$animate",
+      "$interpolate",
+    ];
 
     /**
      * @param {Element} $element
@@ -8198,7 +8198,7 @@
     return [
       "$parse",
       function ($parse) {
-        const formDirective = {
+        return {
           name: "form",
           restrict: isNgForm ? "EA" : "E",
           require: ["form", "^^?form"], // first is the form's own ctrl, second is an optional parent form
@@ -8277,9 +8277,6 @@
             };
           },
         };
-
-        return formDirective;
-
         function getSetter(expression) {
           if (expression === "") {
             // create an assignable expression, so forms with an empty name can be renamed later
@@ -8307,7 +8304,7 @@
 
   class NgModelOptionsController {
     static $nonscope = true;
-    static $inject = ["$attrs", "$scope"];
+    /* @ignore */ static $inject = ["$attrs", "$scope"];
 
     /**
      * @param {import('../../core/compile/attributes.js').Attributes} $attrs
@@ -8476,14 +8473,14 @@
 
   class NgModelController {
     static $nonscope = true;
-    static $inject = [
+    /* @ignore */ static $inject = [
       "$scope",
-      "$exceptionHandler",
+      $injectTokens.$exceptionHandler,
       "$attrs",
       "$element",
-      "$parse",
-      "$animate",
-      "$interpolate",
+      $injectTokens.$parse,
+      $injectTokens.$animate,
+      $injectTokens.$interpolate,
     ];
 
     /**
@@ -9130,8 +9127,7 @@
     }
 
     $$parseAndValidate() {
-      const viewValue = this.$$lastCommittedViewValue;
-      let modelValue = viewValue;
+      let modelValue = this.$$lastCommittedViewValue;
       const that = this;
 
       this.$$parserValid = isUndefined(modelValue) ? undefined : true;
@@ -10054,9 +10050,8 @@
   }
 
   function badInputChecker(scope, element, attr, ctrl, parserName) {
-    const node = element;
     const nativeValidation = (ctrl.$$hasNativeValidators = isObject(
-      node.validity,
+      element.validity,
     ));
 
     if (nativeValidation) {
@@ -10603,12 +10598,11 @@
       // TODO REMOVE IS SUPPORT
       // Support: IE9 only
       // In IE9 values are converted to string (e.g. `input.value = null` results in `input.value === 'null'`).
-      const propValue = isDefined(value)
+      element["value"] = isDefined(value)
         ? isProxy(value)
           ? value.$target
           : value
         : null;
-      element["value"] = propValue;
       attr.$set("value", value);
     }
 
@@ -10667,7 +10661,7 @@
     /**
      * @type {Array<string>}
      */
-    static $inject = ["$element", "$scope"];
+    /* @ignore */ static $inject = ["$element", "$scope"];
 
     /**
      * @param {HTMLSelectElement} $element
@@ -11275,6 +11269,7 @@
 
   ngBindHtmlDirective.$inject = [$injectTokens.$parse];
   /**
+   * @param {import('../../core/parse/interface.ts').ParseService} $parse
    * @returns {import('../../interface.ts').Directive}
    */
   function ngBindHtmlDirective($parse) {
@@ -13157,7 +13152,7 @@
    *
    */
   const requiredDirective = [
-    "$parse",
+    $injectTokens.$parse,
     /**
      * @param {import("../../core/parse/interface.ts").ParseService} $parse
      * @returns {import("../../interface.ts").Directive}
@@ -13239,75 +13234,72 @@
    * </div>
    */
   const patternDirective = [
-    "$parse",
+    $injectTokens.$parse,
     /**
      * @param {import("../../core/parse/interface.ts").ParseService} $parse
      * @returns {import("../../interface.ts").Directive}
      */
-    ($parse) => {
-      return {
-        restrict: "A",
-        require: "?ngModel",
-        compile: (_Elm, tAttr) => {
-          let patternExp;
-          let parseFn;
+    ($parse) => ({
+      restrict: "A",
+      require: "?ngModel",
+      compile: (_Elm, tAttr) => {
+        let patternExp;
+        let parseFn;
 
-          if (tAttr["ngPattern"]) {
-            patternExp = tAttr["ngPattern"];
+        if (tAttr["ngPattern"]) {
+          patternExp = tAttr["ngPattern"];
 
-            // ngPattern might be a scope expression, or an inlined regex, which is not parsable.
-            // We get value of the attribute here, so we can compare the old and the new value
-            // in the observer to avoid unnecessary validations
-            if (
-              tAttr["ngPattern"].charAt(0) === "/" &&
-              REGEX_STRING_REGEXP.test(tAttr["ngPattern"])
-            ) {
-              parseFn = function () {
-                return tAttr["ngPattern"];
-              };
-            } else {
-              parseFn = $parse(tAttr["ngPattern"]);
-            }
+          // ngPattern might be a scope expression, or an inlined regex, which is not parsable.
+          // We get value of the attribute here, so we can compare the old and the new value
+          // in the observer to avoid unnecessary validations
+          if (
+            tAttr["ngPattern"].charAt(0) === "/" &&
+            REGEX_STRING_REGEXP.test(tAttr["ngPattern"])
+          ) {
+            parseFn = function () {
+              return tAttr["ngPattern"];
+            };
+          } else {
+            parseFn = $parse(tAttr["ngPattern"]);
           }
+        }
 
-          return function (scope, elm, attr, ctrl) {
-            if (!ctrl) return;
-
-            let attrVal = attr["pattern"];
+        return function (scope, elm, attr, ctrl) {
+          if (!ctrl) return;
+          let attrVal = attr["pattern"];
 
-            if (attr["ngPattern"]) {
-              attrVal = parseFn(scope);
-            } else {
-              patternExp = attr["pattern"];
-            }
+          if (attr["ngPattern"]) {
+            attrVal = parseFn(scope);
+          } else {
+            patternExp = attr["pattern"];
+          }
 
-            let regexp = parsePatternAttr(attrVal, patternExp, elm);
-            attr.$observe("pattern", function (newVal) {
-              const oldRegexp = regexp;
+          let regexp = parsePatternAttr(attrVal, patternExp, elm);
+          attr.$observe("pattern", (newVal) => {
+            const oldRegexp = regexp;
 
-              regexp = parsePatternAttr(newVal, patternExp, elm);
+            regexp = parsePatternAttr(newVal, patternExp, elm);
 
-              if (
-                (oldRegexp && oldRegexp.toString()) !==
-                (regexp && regexp.toString())
-              ) {
-                ctrl["$validate"]();
-              }
-            });
+            if (
+              (oldRegexp && oldRegexp.toString()) !==
+              (regexp && regexp.toString())
+            ) {
+              ctrl["$validate"]();
+            }
+          });
 
-            ctrl["$validators"]["pattern"] = function (modelValue, viewValue) {
-              // HTML5 pattern constraint validates the input value, so we validate the viewValue
-              return (
-                // @ts-ignore
-                ctrl.$isEmpty(viewValue) ||
-                isUndefined(regexp) ||
-                regexp.test(viewValue)
-              );
-            };
+          ctrl["$validators"]["pattern"] = (_modelValue, viewValue) => {
+            // HTML5 pattern constraint validates the input value, so we validate the viewValue
+            return (
+              // @ts-ignore
+              ctrl.$isEmpty(viewValue) ||
+              isUndefined(regexp) ||
+              regexp.test(viewValue)
+            );
           };
-        },
-      };
-    },
+        };
+      },
+    }),
   ];
 
   /**
@@ -13341,7 +13333,7 @@
    *
    */
   const maxlengthDirective = [
-    "$parse",
+    $injectTokens.$parse,
     /**
      * @param {import("../../core/parse/interface.ts").ParseService} $parse
      * @returns {import("../../interface.ts").Directive}
@@ -13413,32 +13405,28 @@
    *
    */
   const minlengthDirective = [
-    "$parse",
-    function ($parse) {
-      return {
-        restrict: "A",
-        require: "?ngModel",
-        link(scope, elm, attr, ctrl) {
-          if (!ctrl) return;
+    $injectTokens.$parse,
+    ($parse) => ({
+      restrict: "A",
+      require: "?ngModel",
+      link(scope, elm, attr, ctrl) {
+        if (!ctrl) return;
 
-          let minlength = attr.minlength || $parse(attr.ngMinlength)(scope);
-          let minlengthParsed = parseLength(minlength) || -1;
+        let minlength = attr.minlength || $parse(attr.ngMinlength)(scope);
+        let minlengthParsed = parseLength(minlength) || -1;
 
-          attr.$observe("minlength", (value) => {
-            if (minlength !== value) {
-              minlengthParsed = parseLength(value) || -1;
-              minlength = value;
-              ctrl.$validate();
-            }
-          });
-          ctrl.$validators.minlength = function (modelValue, viewValue) {
-            return (
-              ctrl.$isEmpty(viewValue) || viewValue.length >= minlengthParsed
-            );
-          };
-        },
-      };
-    },
+        attr.$observe("minlength", (value) => {
+          if (minlength !== value) {
+            minlengthParsed = parseLength(value) || -1;
+            minlength = value;
+            ctrl.$validate();
+          }
+        });
+        ctrl.$validators.minlength = function (modelValue, viewValue) {
+          return ctrl.$isEmpty(viewValue) || viewValue.length >= minlengthParsed;
+        };
+      },
+    }),
   ];
 
   function parsePatternAttr(regex, patternExp, elm) {
@@ -13449,7 +13437,12 @@
     }
 
     if (isString(regex)) {
-      regex = new RegExp(`^${regex}$`);
+      const match = regex.match(/^\/(.*)\/([gimsuy]*)$/);
+      if (match) {
+        regex = new RegExp(match[1], match[2]);
+      } else {
+        regex = new RegExp(`^${regex}$`);
+      }
     }
 
     if (!regex.test) {
@@ -13466,7 +13459,7 @@
   }
 
   function parseLength(val) {
-    const intVal = toInt(val);
+    const intVal = parseInt(val, 10);
     return isNumberNaN(intVal) ? -1 : intVal;
   }
 
@@ -13489,8 +13482,8 @@
     }
 
     $get = [
-      "$location",
-      "$rootScope",
+      $injectTokens.$location,
+      $injectTokens.$rootScope,
       /**
        *
        * @param {import('../services/location/location.js').Location} $location
@@ -13568,7 +13561,7 @@
             ? hash
             : isNumber(hash)
               ? hash.toString()
-              : $location.hash();
+              : $location.getHash();
           let elm;
 
           // empty hash, scroll to the top of the page
@@ -13585,7 +13578,7 @@
         };
 
         // does not scroll when user clicks on anchor link that is currently on
-        // (no url change, no $location.hash() change), browser native does scroll
+        // (no url change, no $location.getHash() change), browser native does scroll
         if (this.autoScrollingEnabled) {
           $rootScope["$location"] = $location;
           $rootScope.$watch("$location.$$hash", (newVal, oldVal) => {
@@ -13958,8 +13951,7 @@
 
   function applyInlineStyle(node, styleTuple) {
     const prop = styleTuple[0];
-    const value = styleTuple[1];
-    node.style[prop] = value;
+    node.style[prop] = styleTuple[1];
   }
 
   function concatWithSpace(a, b) {
@@ -15029,7 +15021,7 @@
       if (Math.abs(Number(limit)) === Infinity) {
         limit = Number(limit);
       } else {
-        limit = toInt(/** @type {string} */ (limit));
+        limit = parseInt(/** @type {string} */ (limit), 10);
       }
       if (isNumberNaN(limit)) return input;
 
@@ -15039,7 +15031,7 @@
       begin =
         !begin || isNaN(/** @type {any} */ (begin))
           ? 0
-          : toInt(/** @type {string} */ (begin));
+          : parseInt(/** @type {string} */ (begin), 10);
       begin =
         begin < 0 ? Math.max(0, /** @type {[]} */ (input).length + begin) : begin;
 
@@ -15233,6 +15225,8 @@
     }
   }
 
+  $IsStateFilter.$inject = [$injectTokens.$state];
+
   /**
    * `isState` Filter: truthy if the current state is the parameter
    *
@@ -15242,18 +15236,19 @@
    * ```html
    * <div ng-if="'stateName' | isState">show if state is 'stateName'</div>
    * ```
-   */
-  $IsStateFilter.$inject = ["$state"];
-  /**
+   *
+   * @param {import('./state/state-service.js').StateProvider} $state
    * @returns {import('../interface.ts').FilterFn}
    */
   function $IsStateFilter($state) {
-    const isFilter = function (state, params, options) {
-      return $state.is(state, params, options);
-    };
+    const isFilter = (state, params, options) =>
+      $state.is(state, params, options);
     isFilter.$stateful = true;
     return isFilter;
   }
+
+  $IncludedByStateFilter.$inject = [$injectTokens.$state];
+
   /**
    * `includedByState` Filter: truthy if the current state includes the parameter
    *
@@ -15263,9 +15258,8 @@
    * ```html
    * <div ng-if="'fullOrPartialStateName' | includedByState">show if state includes 'fullOrPartialStateName'</div>
    * ```
-   */
-  $IncludedByStateFilter.$inject = ["$state"];
-  /**
+   *
+   * @param {import('./state/state-service.js').StateProvider} $state
    * @returns {import('../interface.ts').FilterFn}
    */
   function $IncludedByStateFilter($state) {
@@ -15279,7 +15273,7 @@
   const SUFFIX = "Filter";
 
   class FilterProvider {
-    static $inject = [$injectTokens.$provide];
+    /* @ignore */ static $inject = [$injectTokens.$provide];
 
     /**
      * @param {import('../../interface.ts').Provider} $provide
@@ -17182,173 +17176,177 @@
     return ast.constant;
   }
 
-  function ParseProvider() {
-    const cache = Object.create(null);
-
-    /** @type {function(any):boolean?} */
-    let identStart;
+  class ParseProvider {
+    constructor() {
+      const cache = Object.create(null);
 
-    /** @type {function(any):boolean?} */
-    let identContinue;
+      /** @type {function(any):boolean?} */
+      let identStart;
 
-    /**
-     * Allows defining the set of characters that are allowed in AngularTS expressions. The function
-     * `identifierStart` will get called to know if a given character is a valid character to be the
-     * first character for an identifier. The function `identifierContinue` will get called to know if
-     * a given character is a valid character to be a follow-up identifier character. The functions
-     * `identifierStart` and `identifierContinue` will receive as arguments the single character to be
-     * identifier and the character code point. These arguments will be `string` and `numeric`. Keep in
-     * mind that the `string` parameter can be two characters long depending on the character
-     * representation. It is expected for the function to return `true` or `false`, whether that
-     * character is allowed or not.
-     *
-     * Since this function will be called extensively, keep the implementation of these functions fast,
-     * as the performance of these functions have a direct impact on the expressions parsing speed.
-     *
-     * @param {function(any):boolean} [identifierStart] The function that will decide whether the given character is
-     *   a valid identifier start character.
-     * @param {function(any):boolean} [identifierContinue] The function that will decide whether the given character is
-     *   a valid identifier continue character.
-     * @returns {ParseProvider}
-     */
-    this.setIdentifierFns = function (identifierStart, identifierContinue) {
-      identStart = identifierStart;
-      identContinue = identifierContinue;
-      return this;
-    };
+      /** @type {function(any):boolean?} */
+      let identContinue;
 
-    this.$get = [
-      "$filter",
       /**
+       * Allows defining the set of characters that are allowed in AngularTS expressions. The function
+       * `identifierStart` will get called to know if a given character is a valid character to be the
+       * first character for an identifier. The function `identifierContinue` will get called to know if
+       * a given character is a valid character to be a follow-up identifier character. The functions
+       * `identifierStart` and `identifierContinue` will receive as arguments the single character to be
+       * identifier and the character code point. These arguments will be `string` and `numeric`. Keep in
+       * mind that the `string` parameter can be two characters long depending on the character
+       * representation. It is expected for the function to return `true` or `false`, whether that
+       * character is allowed or not.
+       *
+       * Since this function will be called extensively, keep the implementation of these functions fast,
+       * as the performance of these functions have a direct impact on the expressions parsing speed.
        *
-       * @param {(any) => any} $filter
-       * @returns {import('./interface').ParseService}
+       * @param {function(any):boolean} [identifierStart] The function that will decide whether the given character is
+       *   a valid identifier start character.
+       * @param {function(any):boolean} [identifierContinue] The function that will decide whether the given character is
+       *   a valid identifier continue character.
+       * @returns {ParseProvider}
        */
-      function ($filter) {
-        /** @type {import("./lexer/lexer.js").LexerOptions} */
-        const $lexerOptions = {
-          isIdentifierStart: isFunction(identStart) && identStart,
-          isIdentifierContinue: isFunction(identContinue) && identContinue,
-        };
-        return $parse;
+      this.setIdentifierFns = function (identifierStart, identifierContinue) {
+        identStart = identifierStart;
+        identContinue = identifierContinue;
+        return this;
+      };
 
+      this.$get = [
+        "$filter",
         /**
-         * @param {string} exp
-         * @param interceptorFn
-         * @returns any
+         *
+         * @param {(any) => any} $filter
+         * @returns {import('./interface').ParseService}
          */
-        function $parse(exp, interceptorFn) {
-          let parsedExpression, cacheKey;
-
-          switch (typeof exp) {
-            case "string":
-              exp = exp.trim();
-              cacheKey = exp;
+        function ($filter) {
+          /** @type {import("./lexer/lexer.js").LexerOptions} */
+          const $lexerOptions = {
+            isIdentifierStart: isFunction(identStart) && identStart,
+            isIdentifierContinue: isFunction(identContinue) && identContinue,
+          };
+          return $parse;
 
-              parsedExpression = cache[cacheKey];
+          /**
+           * @param {string} exp
+           * @param interceptorFn
+           * @returns any
+           */
+          function $parse(exp, interceptorFn) {
+            let parsedExpression, cacheKey;
 
-              if (!parsedExpression) {
-                const lexer = new Lexer($lexerOptions);
-                const parser = new Parser(lexer, $filter);
-                parsedExpression = parser.parse(exp);
+            switch (typeof exp) {
+              case "string":
+                exp = exp.trim();
+                cacheKey = exp;
 
-                cache[cacheKey] = addWatchDelegate(parsedExpression);
-              }
-              return addInterceptor(parsedExpression, interceptorFn);
+                parsedExpression = cache[cacheKey];
 
-            case "function":
-              return addInterceptor(exp, interceptorFn);
+                if (!parsedExpression) {
+                  const lexer = new Lexer($lexerOptions);
+                  const parser = new Parser(lexer, $filter);
+                  parsedExpression = parser.parse(exp);
 
-            default:
-              return addInterceptor(() => {}, interceptorFn);
-          }
-        }
+                  cache[cacheKey] = addWatchDelegate(parsedExpression);
+                }
+                return addInterceptor(parsedExpression, interceptorFn);
 
-        /**
-         * @param {Function} parsedExpression
-         * @param interceptorFn
-         * @returns {import('./interface').CompiledExpression|*}
-         */
-        function addInterceptor(parsedExpression, interceptorFn) {
-          if (!interceptorFn) return parsedExpression;
+              case "function":
+                return addInterceptor(exp, interceptorFn);
 
-          // Extract any existing interceptors out of the parsedExpression
-          // to ensure the original parsedExpression is always the $$intercepted
-          // @ts-ignore
-          if (parsedExpression.$$interceptor) {
-            interceptorFn = chainInterceptors(
-              // @ts-ignore
-              parsedExpression.$$interceptor,
-              interceptorFn,
-            );
-            // @ts-ignore
-            parsedExpression = parsedExpression.$$intercepted;
+              default:
+                return addInterceptor(() => {}, interceptorFn);
+            }
           }
 
-          let useInputs = false;
+          /**
+           * @param {Function} parsedExpression
+           * @param interceptorFn
+           * @returns {import('./interface').CompiledExpression|*}
+           */
+          function addInterceptor(parsedExpression, interceptorFn) {
+            if (!interceptorFn) {
+              return parsedExpression;
+            }
 
-          const fn = function interceptedExpression(
-            scope,
-            locals,
-            assign,
-            inputs,
-          ) {
-            const value =
-              useInputs && inputs
-                ? inputs[0]
-                : parsedExpression(scope, locals, assign, inputs);
-            // Do not invoke for getters
-            if (scope?.getter) {
-              return;
+            // Extract any existing interceptors out of the parsedExpression
+            // to ensure the original parsedExpression is always the $$intercepted
+            // @ts-ignore
+            if (parsedExpression.$$interceptor) {
+              interceptorFn = chainInterceptors(
+                // @ts-ignore
+                parsedExpression.$$interceptor,
+                interceptorFn,
+              );
+              // @ts-ignore
+              parsedExpression = parsedExpression.$$intercepted;
             }
-            const res = isFunction(value) ? value() : value;
-            return interceptorFn(isProxy(res) ? res.$target : res);
-          };
 
-          // Maintain references to the interceptor/intercepted
-          fn.$$intercepted = parsedExpression;
-          fn.$$interceptor = interceptorFn;
+            let useInputs = false;
 
-          // Propagate the literal/oneTime/constant attributes
-          // @ts-ignore
-          fn.literal = parsedExpression.literal;
-          // @ts-ignore
-          fn.oneTime = parsedExpression.oneTime;
-          // @ts-ignore
-          fn.constant = parsedExpression.constant;
-          // @ts-ignore
-          fn.decoratedNode = parsedExpression.decoratedNode;
+            const fn = function interceptedExpression(
+              scope,
+              locals,
+              assign,
+              inputs,
+            ) {
+              const value =
+                useInputs && inputs
+                  ? inputs[0]
+                  : parsedExpression(scope, locals, assign, inputs);
+              // Do not invoke for getters
+              if (scope?.getter) {
+                return;
+              }
+              const res = isFunction(value) ? value() : value;
+              return interceptorFn(isProxy(res) ? res.$target : res);
+            };
+
+            // Maintain references to the interceptor/intercepted
+            fn.$$intercepted = parsedExpression;
+            fn.$$interceptor = interceptorFn;
 
-          // Treat the interceptor like filters.
-          // If it is not $stateful then only watch its inputs.
-          // If the expression itself has no inputs then use the full expression as an input.
-          if (!interceptorFn.$stateful) {
+            // Propagate the literal/oneTime/constant attributes
             // @ts-ignore
-            useInputs = !parsedExpression.inputs;
+            fn.literal = parsedExpression.literal;
             // @ts-ignore
-            fn.inputs = parsedExpression.inputs
-              ? // @ts-ignore
-                parsedExpression.inputs
-              : [parsedExpression];
-
-            if (!interceptorFn.$$pure) {
-              fn.inputs = fn.inputs.map(function (e) {
-                // Remove the isPure flag of inputs when it is not absolute because they are now wrapped in a
-                // non-pure interceptor function.
-                if (e.isPure === PURITY_RELATIVE) {
-                  return function depurifier(s) {
-                    return e(s);
-                  };
-                }
-                return e;
-              });
+            fn.oneTime = parsedExpression.oneTime;
+            // @ts-ignore
+            fn.constant = parsedExpression.constant;
+            // @ts-ignore
+            fn.decoratedNode = parsedExpression.decoratedNode;
+
+            // Treat the interceptor like filters.
+            // If it is not $stateful then only watch its inputs.
+            // If the expression itself has no inputs then use the full expression as an input.
+            if (!interceptorFn.$stateful) {
+              // @ts-ignore
+              useInputs = !parsedExpression.inputs;
+              // @ts-ignore
+              fn.inputs = parsedExpression.inputs
+                ? // @ts-ignore
+                  parsedExpression.inputs
+                : [parsedExpression];
+
+              if (!interceptorFn.$$pure) {
+                fn.inputs = fn.inputs.map(function (e) {
+                  // Remove the isPure flag of inputs when it is not absolute because they are now wrapped in a
+                  // non-pure interceptor function.
+                  if (e.isPure === PURITY_RELATIVE) {
+                    return function depurifier(s) {
+                      return e(s);
+                    };
+                  }
+                  return e;
+                });
+              }
             }
-          }
 
-          return addWatchDelegate(fn);
-        }
-      },
-    ];
+            return addWatchDelegate(fn);
+          }
+        },
+      ];
+    }
   }
 
   function constantWatchDelegate(
@@ -17826,8 +17824,7 @@
                         let j = 0;
                         for (; j < ii; j++) {
                           let fn = parseFns[j];
-                          let res = fn(context);
-                          vals[j] = res;
+                          vals[j] = fn(context);
                         }
                         cb(compute(vals));
                       });
@@ -17836,8 +17833,7 @@
                     values[i] = parseFns[i](context);
                   }
 
-                  let res = compute(values);
-                  return res;
+                  return compute(values);
                 } catch (err) {
                   interr(text, err);
                 }
@@ -18229,6 +18225,7 @@
     });
 
     let useApplyAsync = false;
+
     /**
      * Configure $http service to combine processing of multiple http responses received at around
      * the same time via {@link ng.$rootScope.Scope#$applyAsync $rootScope.$applyAsync}. This can result in
@@ -18261,7 +18258,7 @@
      *
      * {@link ng.$http#interceptors Interceptors detailed info}
      */
-    const interceptorFactories = (this.interceptors = []);
+    this.interceptors = [];
 
     /**
      * Array containing URLs whose origins are trusted to receive the XSRF token. See the
@@ -18298,8 +18295,10 @@
      *     $http.get('https://stats.example.com/activity').then(...);
      *   }]);
      * ```
+     *
+     * @type {string[]}
      */
-    const xsrfTrustedOrigins = (this.xsrfTrustedOrigins = []);
+    this.xsrfTrustedOrigins = [];
 
     /**
      * This property is deprecated. Use {@link $httpProvider#xsrfTrustedOrigins xsrfTrustedOrigins}
@@ -18345,7 +18344,7 @@
          */
         const reversedInterceptors = [];
 
-        interceptorFactories.forEach((interceptorFactory) => {
+        this.interceptors.forEach((interceptorFactory) => {
           reversedInterceptors.unshift(
             isString(interceptorFactory)
               ? $injector.get(interceptorFactory)
@@ -18356,7 +18355,9 @@
         /**
          * A function to check request URLs against a list of allowed origins.
          */
-        const urlIsAllowedOrigin = urlIsAllowedOriginFactory(xsrfTrustedOrigins);
+        const urlIsAllowedOrigin = urlIsAllowedOriginFactory(
+          this.xsrfTrustedOrigins,
+        );
 
         /**
          * @property {Array.<Object>} requestConfig Array of config objects for currently pending
@@ -18855,24 +18856,13 @@
   }
 
   /**
-   * HTTP backend used by the {@link ng.$http service} that delegates to
-   * XMLHttpRequest object and deals with browser incompatibilities.
-   *
-   * You should never need to use this service directly, instead use the higher-level abstractions:
-   * {@link ng.$http $http}.
-   *
-   */
-  /**
-   * HTTP backend used by the {@link ng.$http service} that delegates to
+   * HTTP backend used by the `$http` that delegates to
    * XMLHttpRequest object and deals with browser incompatibilities.
-   *
-   * You should never need to use this service directly, instead use the higher-level abstractions:
-   * {@link ng.$http $http}.
-   *
+   * You should never need to use this service directly.
    */
   class HttpBackendProvider {
     constructor() {
-      this.$get = [() => createHttpBackend()];
+      this.$get = () => createHttpBackend();
     }
   }
 
@@ -18880,7 +18870,21 @@
    * @returns
    */
   function createHttpBackend() {
-    // TODO(vojta): fix the signature
+    /**
+     * Makes an HTTP request using XMLHttpRequest with flexible options.
+     *
+     * @param {string} method - The HTTP method (e.g., "GET", "POST").
+     * @param {string} [url] - The URL to send the request to. Defaults to the current page URL.
+     * @param {*} [post] - The body to send with the request, if any.
+     * @param {function(number, any, string|null, string, string): void} [callback] - Callback invoked when the request completes.
+     * @param {Object<string, string|undefined>} [headers] - Headers to set on the request.
+     * @param {number|Promise<any>} [timeout] - Timeout in ms or a cancellable promise.
+     * @param {boolean} [withCredentials] - Whether to send credentials with the request.
+     * @param {XMLHttpRequestResponseType} [responseType] - The type of data expected in the response.
+     * @param {Object<string, EventListener>} [eventHandlers] - Event listeners for the XMLHttpRequest object.
+     * @param {Object<string, EventListener>} [uploadEventHandlers] - Event listeners for the XMLHttpRequest.upload object.
+     * @returns {void}
+     */
     return function (
       method,
       url,
@@ -18897,34 +18901,31 @@
 
       const xhr = new XMLHttpRequest();
       let abortedByTimeout = false;
+      let timeoutId;
 
       xhr.open(method, url, true);
+
       if (headers) {
-        Object.entries(headers).forEach(([key, value]) => {
+        for (const [key, value] of Object.entries(headers)) {
           if (isDefined(value)) {
             xhr.setRequestHeader(key, value);
           }
-        });
+        }
       }
 
-      xhr.onload = function () {
+      xhr.onload = () => {
+        let status = xhr.status || 0;
         const statusText = xhr.statusText || "";
 
-        let status = xhr.status;
-
-        // fix status code when it is 0 (0 status is undocumented).
-        // Occurs when accessing file resources or on Android 4.1 stock browser
-        // while retrieving files from application cache.
         if (status === 0) {
           status = xhr.response
             ? 200
-            : urlResolve(url).protocol === "file"
+            : new URL(url).protocol === "file:"
               ? 404
               : 0;
         }
 
         completeRequest(
-          callback,
           status,
           xhr.response,
           xhr.getAllResponseHeaders(),
@@ -18933,20 +18934,11 @@
         );
       };
 
-      xhr.onerror = function () {
-        // The response is always empty
-        // See https://xhr.spec.whatwg.org/#request-error-steps and https://fetch.spec.whatwg.org/#concept-network-error
-        completeRequest(callback, -1, null, null, "", "error");
-      };
-      xhr.ontimeout = function () {
-        // The response is always empty
-        // See https://xhr.spec.whatwg.org/#request-error-steps and https://fetch.spec.whatwg.org/#concept-network-error
-        completeRequest(callback, -1, null, null, "", "timeout");
-      };
+      xhr.onerror = () => completeRequest(-1, null, null, "", "error");
+      xhr.ontimeout = () => completeRequest(-1, null, null, "", "timeout");
 
-      xhr.onabort = function () {
+      xhr.onabort = () => {
         completeRequest(
-          callback,
           -1,
           null,
           null,
@@ -18956,16 +18948,15 @@
       };
 
       if (eventHandlers) {
-        eventHandlers &&
-          Object.entries(eventHandlers).forEach(([key, value]) => {
-            xhr.addEventListener(key, value);
-          });
+        for (const [key, handler] of Object.entries(eventHandlers)) {
+          xhr.addEventListener(key, handler);
+        }
       }
 
       if (uploadEventHandlers) {
-        Object.entries(uploadEventHandlers).forEach(([key, value]) => {
-          xhr.upload.addEventListener(key, value);
-        });
+        for (const [key, handler] of Object.entries(uploadEventHandlers)) {
+          xhr.upload.addEventListener(key, handler);
+        }
       }
 
       if (withCredentials) {
@@ -18976,317 +18967,198 @@
         try {
           xhr.responseType = responseType;
         } catch (e) {
-          // WebKit added support for the json responseType value on 09/03/2013
-          // https://bugs.webkit.org/show_bug.cgi?id=73648. Versions of Safari prior to 7 are
-          // known to throw when setting the value "json" as the response type. Other older
-          // browsers implementing the responseType
-          //
-          // The json response type can be ignored if not supported, because JSON payloads are
-          // parsed on the client-side regardless.
-          if (responseType !== "json") {
-            throw e;
-          }
+          if (responseType !== "json") throw e;
         }
       }
 
       xhr.send(isUndefined(post) ? null : post);
 
-      // Since we are using xhr.abort() when a request times out, we have to set a flag that
-      // indicates to requestAborted if the request timed out or was aborted.
-      //
-      // http.timeout = numerical timeout   timeout
-      // http.timeout = $timeout            timeout
-      // http.timeout = promise             abort
-      // xhr.abort()                        abort (The xhr object is normally inaccessible, but
-      //                                    can be exposed with the xhrFactory)
-      /** @type {number} */
-      let timeoutId;
-      if (timeout > 0) {
-        timeoutId = setTimeout(() => {
-          timeoutRequest("timeout");
-        }, timeout);
+      if (typeof timeout === "number" && timeout > 0) {
+        timeoutId = setTimeout(() => timeoutRequest("timeout"), timeout);
       } else if (isPromiseLike(timeout)) {
-        timeout.then(() => {
-          timeoutRequest(isDefined(timeout.$$timeoutId) ? "timeout" : "abort");
+        /** @type {Promise} */ (timeout).then(() => {
+          timeoutRequest(isDefined(timeout["$$timeoutId"]) ? "timeout" : "abort");
         });
       }
 
+      /**
+       * @param {"timeout"|"abort"} reason
+       */
       function timeoutRequest(reason) {
         abortedByTimeout = reason === "timeout";
-        if (xhr) {
-          xhr.abort();
-        }
+        if (xhr) xhr.abort();
       }
 
+      /**
+       * @param {number} status - HTTP status code or -1 for network errors.
+       * @param {*} response - The parsed or raw response from the server.
+       * @param {string|null} headersString - The raw response headers as a string.
+       * @param {string} statusText - The status text returned by the server.
+       * @param {"complete"|"error"|"timeout"|"abort"} xhrStatus - Final status of the request.
+       */
       function completeRequest(
-        callback,
         status,
         response,
         headersString,
         statusText,
         xhrStatus,
       ) {
-        // cancel timeout and subsequent timeout promise resolution
         if (isDefined(timeoutId)) {
           clearTimeout(timeoutId);
         }
-
         callback(status, response, headersString, statusText, xhrStatus);
       }
     };
   }
 
+  const PATH_MATCH = /^([^?#]*)(\?([^#]*))?(#(.*))?$/;
+  const $locationMinErr = minErr("$location");
+
+  let urlUpdatedByLocation = false;
+
   /**
-   * @typedef {Object} DefaultPorts
-   * @property {number} http
-   * @property {number} https
-   * @property {number} ftp
+   * @ignore
+   * The pathname, beginning with "/"
+   * @type {string}
    */
+  let $$path;
 
   /**
-   * Represents the configuration options for HTML5 mode.
-   *
-   * @typedef {Object} Html5Mode
-   * @property {boolean} enabled - (default: false) If true, will rely on `history.pushState` to
-   *     change URLs where supported. Falls back to hash-prefixed paths in browsers that do not
-   *     support `pushState`.
-   * @property {boolean} requireBase - (default: `true`) When html5Mode is enabled, specifies
-   *     whether or not a `<base>` tag is required to be present. If both `enabled` and `requireBase`
-   *     are true, and a `<base>` tag is not present, an error will be thrown when `$location` is injected.
-   *     See the {@link guide/$location $location guide} for more information.
-   * @property {boolean|string} rewriteLinks - (default: `true`) When html5Mode is enabled, enables or
-   *     disables URL rewriting for relative links. If set to a string, URL rewriting will only apply to links
-   *     with an attribute that matches the given string. For example, if set to `'internal-link'`, URL rewriting
-   *     will only occur for `<a internal-link>` links. Note that [attribute name normalization](guide/directive#normalization)
-   *     does not apply here, so `'internalLink'` will **not** match `'internal-link'`.
+   * @type {Object.<string,boolean|Array>}
    */
-
-  /** @type {DefaultPorts} */
-  const DEFAULT_PORTS = { http: 80, https: 443, ftp: 21 };
-  const PATH_MATCH = /^([^?#]*)(\?([^#]*))?(#(.*))?$/;
-  const $locationMinErr = minErr("$location");
+  let $$search;
 
   /**
-   * @abstract
+   * @ignore
+   * The hash string, minus the hash symbol
+   * @type {string}
    */
+  let $$hash;
+
   class Location {
     /**
      * @param {string} appBase application base URL
      * @param {string} appBaseNoFile application base URL stripped of any filename
+     * @param {boolean} [html5] Defaults to true
+     * @param {string} [prefix] URL path prefix for html5 mode or hash prefix for hashbang mode
      */
-    constructor(appBase, appBaseNoFile) {
-      const parsedUrl = urlResolve(appBase);
-
+    constructor(appBase, appBaseNoFile, html5 = true, prefix) {
       /** @type {string} */
       this.appBase = appBase;
 
       /** @type {string} */
       this.appBaseNoFile = appBaseNoFile;
 
-      /**
-       * 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}
-       */
-      this.$$absUrl = "";
-
-      /**
-       * If html5 mode is enabled
-       * @type {boolean}
-       */
-      this.$$html5 = false;
-
-      /**
-       * Has any change been replacing?
-       * @type {boolean}
-       */
-      this.$$replace = false;
+      /** @type {boolean} */
+      this.html5 = html5;
 
-      /** @type {string} */
-      this.$$protocol = parsedUrl.protocol;
+      /** @type {string | undefined} */
+      this.basePrefix = html5 ? prefix || "" : undefined;
 
-      /** @type {string} */
-      this.$$host = parsedUrl.hostname;
-
-      /**
-       * The port, without ":"
-       * @type {number}
-       */
-      this.$$port =
-        toInt(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null;
+      /** @type {string | undefined} */
+      this.hashPrefix = html5 ? undefined : prefix;
 
       /**
-       * The pathname, beginning with "/"
+       * 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)
+       * with all segments encoded according to rules specified in [RFC 3986](http://www.ietf.org/rfc/rfc3986.txt).
        * @type {string}
        */
-      this.$$path = undefined;
+      this.absUrl = "";
 
       /**
-       * The hash string, minus the hash symbol
+       * @ignore
+       * Current url
        * @type {string}
        */
-      this.$$hash = undefined;
+      this.$$url = undefined;
 
       /**
-       * Helper property for scope watch changes
-       * @type {boolean}
+       * @ignore
+       * Callback to update browser url
+       * @type {Function}
        */
-      this.$$urlUpdatedByLocation = false;
+      this.$$updateBrowser = undefined;
     }
 
     /**
-     * Return full URL representation with all segments encoded according to rules specified in
-     * [RFC 3986](http://www.ietf.org/rfc/rfc3986.txt).
-     *
-     * @return {string} full URL
-     */
-    absUrl() {
-      return this.$$absUrl;
-    }
-
-    /**
-     * 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`.
      *
-     * @param {string=} url New URL without base prefix (e.g. `/path?a=b#hash`)
-     * @return {Location|string} url
+     * @param {string} url New URL without base prefix (e.g. `/path?a=b#hash`)
+     * @return {Location} url
      */
-    url(url) {
-      if (isUndefined(url)) {
-        return this.$$url;
-      }
-
+    setUrl(url) {
       const match = PATH_MATCH.exec(url);
-      if (match[1] || url === "") this.path(decodeURIComponent(match[1]));
-      if (match[2] || match[1] || url === "") this.search(match[3] || "");
-      this.hash(match[5] || "");
+      if (match[1] || url === "") this.setPath(decodeURIComponent(match[1]));
+      if (match[2] || match[1] || url === "") this.setSearch(match[3] || "");
+      this.setHash(match[5] || "");
 
       return this;
     }
 
     /**
+     * Return URL (e.g. `/path?a=b#hash`) when called without any parameter.
      *
-     * Return protocol of current URL.
-     * @return {string} protocol of current URL
+     * @return {string} url
      */
-    protocol() {
-      return this.$$protocol;
+    getUrl() {
+      return this.$$url;
     }
 
     /**
-     * This method is getter only.
-     *
-     * Return host of current URL.
-     *
-     * Note: compared to the non-AngularTS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
+     * Change path parameter and return `$location`.
      *
-     *
-     * @return {string} host of current URL.
+     * @param {(string|number)} path New path
+     * @return {Location}
      */
-    host() {
-      return this.$$host;
-    }
-
-    /**
-     * This method is getter only.
-     *
-     * Return port of current URL.
-     *
-     *
-     * ```js
-     * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-     * let port = $location.port();
-     * // => 80
-     * ```
-     *
-     * @return {number} port
-     */
-    port() {
-      return this.$$port;
+    setPath(path) {
+      let newPath = path !== null ? path.toString() : "";
+      $$path = newPath.charAt(0) === "/" ? newPath : `/${newPath}`;
+      this.$$compose();
+      return this;
     }
 
     /**
-     * This method is getter / setter.
-     *
-     * Return path of current URL when called without any parameter.
      *
-     * Change path when called with parameter and return `$location`.
+     * Return path of current URL
      *
-     * Note: Path should always begin with forward slash (/), this method will add the forward slash
-     * if it is missing.
-     *
-     *
-     * ```js
-     * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-     * let path = $location.path();
-     * // => "/some/path"
-     * ```
-     *
-     * @param {(string|number)=} path New path
-     * @return {(string|object)} path if called with no parameters, or `$location` if called with a parameter
+     * @return {string}
      */
-    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;
+    getPath() {
+      return $$path;
     }
 
     /**
-     * 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|Location} hash
+     * @param {(string|number)} hash New hash fragment
+     * @return {Location} hash
      */
-    hash(hash) {
-      if (isUndefined(hash)) {
-        return this.$$hash;
-      }
-
-      this.$$hash = hash !== null ? hash.toString() : "";
+    setHash(hash) {
+      $$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.
+     * Returns the hash fragment when called without any parameters.
+     * @return {string} hash
      */
-    replace() {
-      this.$$replace = true;
-      return this;
+    getHash() {
+      return $$hash;
     }
 
     /**
-     * Returns or sets the search part (as object) of current URL when called without any parameter
+     * Sets the search part (as object) of current URL
      *
-     * @param {string|Object=} search New search params - string or hash object.
+     * @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
+     * @returns {Object} Search object or Location object
      */
-    search(search, paramValue) {
+    setSearch(search, paramValue) {
       switch (arguments.length) {
-        case 0:
-          return this.$$search;
         case 1:
           if (isString(search) || isNumber(search)) {
             search = search.toString();
-            this.$$search = parseKeyValue(search);
+            $$search = parseKeyValue(search);
           } else if (isObject(search)) {
             search = structuredClone(search, {});
             // remove object undefined or null properties
@@ -19294,7 +19166,7 @@
               if (value == null) delete search[key];
             });
 
-            this.$$search = search;
+            $$search = search;
           } else {
             throw $locationMinErr(
               "isrcharg",
@@ -19304,9 +19176,10 @@
           break;
         default:
           if (isUndefined(paramValue) || paramValue === null) {
-            delete this.$$search[search];
+            delete $$search[search];
           } else {
-            this.$$search[search] = paramValue;
+            // @ts-ignore
+            $$search[search] = paramValue;
           }
       }
 
@@ -19315,28 +19188,28 @@
     }
 
     /**
-     * Compose url and update `url` and `absUrl` property
-     * @returns {void}
+     * Returns the search part (as object) of current URL
+     *
+     * @returns {Object} Search object or Location object
      */
-    $$compose() {
-      this.$$url = normalizePath(this.$$path, this.$$search, this.$$hash);
-      this.$$absUrl = this.$$normalizeUrl(this.$$url);
-      this.$$urlUpdatedByLocation = true;
+    getSearch() {
+      return $$search;
     }
 
     /**
-     * @param {string} _url
-     * @returns {string}
+     * @private
+     * Compose url and update `url` and `absUrl` property
      */
-    $$normalizeUrl(_url) {
-      throw new Error(`Method not implemented ${_url}`);
+    $$compose() {
+      this.$$url = normalizePath($$path, $$search, $$hash);
+      this.absUrl = this.html5
+        ? this.appBaseNoFile + this.$$url.substring(1)
+        : this.appBase + (this.$$url ? this.hashPrefix + this.$$url : "");
+      urlUpdatedByLocation = true;
+      setTimeout(() => this.$$updateBrowser && this.$$updateBrowser());
     }
 
     /**
-     * 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}
@@ -19344,85 +19217,30 @@
      * 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
+     * @param {any} state
+     * @returns {Location}
      */
-    state(state) {
-      if (!arguments.length) {
-        return this.$$state;
-      }
-
-      if (!(this instanceof LocationHtml5Url) || !this.$$html5) {
+    setState(state) {
+      if (!this.html5) {
         throw $locationMinErr(
           "nostate",
-          "History API state support is available only " +
-            "in HTML5 mode and only in browsers supporting HTML5 History API",
+          "History API state support is available only in HTML5 mode",
         );
       }
-      // The user might modify `stateObject` after invoking `$location.state(stateObject)`
+      // The user might modify `stateObject` after invoking `$location.setState(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;
+      urlUpdatedByLocation = true;
       return this;
     }
 
     /**
-     * @param {string} _url
-     * @param {string} _url2
-     * @returns {boolean}
-     */
-    $$parseLinkUrl(_url, _url2) {
-      throw new Error(`Method not implemented ${_url} ${_url2}`);
-    }
-
-    $$parse(_url) {
-      throw new Error(`Method not implemented ${_url}`);
-    }
-  }
-
-  /**
-   * This object is exposed as $location service when HTML5 mode is enabled and supported
-   */
-  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 || "";
-    }
-
-    /**
-     * Parse given HTML5 (regular) URL string into properties
-     * @param {string} url HTML5 URL
+     * Return the history state object
+     * @returns {any}
      */
-    $$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.substring(1); // first char is always '/'
+    getState() {
+      return this.$$state;
     }
 
     /**
@@ -19430,148 +19248,138 @@
      * @param {string} relHref
      * @returns {boolean}
      */
-    $$parseLinkUrl(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;
+    parseLinkUrl(url, relHref) {
+      if (this.html5) {
+        if (relHref && relHref[0] === "#") {
+          // special case for links to hash fragments:
+          // keep the old url and only replace the hash fragment
+          this.setHash(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;
+        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;
         }
-      } 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);
+        if (rewrittenUrl) {
+          this.parse(rewrittenUrl);
+        }
+        return !!rewrittenUrl;
+      } else {
+        if (stripHash(this.appBase) === stripHash(url)) {
+          this.parse(url);
+          return true;
+        }
+        return false;
       }
-      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.
-   *
-   */
-  class LocationHashbangUrl extends Location {
     /**
-     * @param {string} appBase application base URL
-     * @param {string} appBaseNoFile application base URL stripped of any filename
-     * @param {string} hashPrefix hashbang prefix
+     * Parse given HTML5 (regular) URL string into properties
+     * @param {string} url HTML5 URL
      */
-    constructor(appBase, appBaseNoFile, hashPrefix) {
-      super(appBase, appBaseNoFile);
-      this.hashPrefix = hashPrefix;
-    }
+    parse(url) {
+      if (this.html5) {
+        const pathUrl = stripBaseUrl(this.appBaseNoFile, url);
+        if (!isString(pathUrl)) {
+          throw $locationMinErr(
+            "ipthprfx",
+            'Invalid url "{0}", missing path prefix "{1}".',
+            url,
+            this.appBaseNoFile,
+          );
+        }
 
-    /**
-     * Parse given hashbang URL into properties
-     * @param {string} url Hashbang URL
-     */
-    $$parse(url) {
-      const withoutBaseUrl =
-        stripBaseUrl(this.appBase, url) || stripBaseUrl(this.appBaseNoFile, url);
-      let withoutHashUrl;
+        parseAppUrl(pathUrl, true);
 
-      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;
+        if (!$$path) {
+          $$path = "/";
         }
+
+        this.$$compose();
       } 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;
+        const withoutBaseUrl =
+          stripBaseUrl(this.appBase, url) ||
+          stripBaseUrl(this.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(this.hashPrefix, withoutBaseUrl);
+          if (isUndefined(withoutHashUrl)) {
+            // There was no hashbang prefix so we just have a hash fragment
+            withoutHashUrl = withoutBaseUrl;
+          }
         } else {
-          withoutHashUrl = "";
-          if (isUndefined(withoutBaseUrl)) {
-            this.appBase = url;
-            /** @type {?} */ (this).replace();
+          // 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;
+            }
           }
         }
-      }
 
-      parseAppUrl(withoutHashUrl, this, false);
+        parseAppUrl(withoutHashUrl, false);
 
-      this.$$path = removeWindowsDriveName(
-        this.$$path,
-        withoutHashUrl,
-        this.appBase,
-      );
+        $$path = removeWindowsDriveName($$path, withoutHashUrl, this.appBase);
 
-      this.$$compose();
+        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 AngularTS, we're always using pathnames that
-       * do not include drive names for routing.
-       */
-      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]:(\/.*)/;
-
-        let firstPathSegmentMatch;
-
-        // Get the relative path from the input URL.
-        if (startsWith(url, base)) {
-          url = url.replace(base, "");
-        }
+         * 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 AngularTS, we're always using pathnames that
+         * do not include drive names for routing.
+         */
+        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]:(\/.*)/;
 
-        // The input URL intentionally contains a first path segment that ends with a colon.
-        if (windowsFilePathExp.exec(url)) {
-          return path;
-        }
+          let firstPathSegmentMatch;
 
-        firstPathSegmentMatch = windowsFilePathExp.exec(path);
-        return firstPathSegmentMatch ? firstPathSegmentMatch[1] : path;
-      }
-    }
+          // Get the relative path from the input URL.
+          if (startsWith(url, base)) {
+            url = url.replace(base, "");
+          }
 
-    $$normalizeUrl(url) {
-      return this.appBase + (url ? this.hashPrefix + url : "");
-    }
+          // The input URL intentionally contains a first path segment that ends with a colon.
+          if (windowsFilePathExp.exec(url)) {
+            return path;
+          }
 
-    /**
-     * @param {string} url
-     * @returns {boolean}
-     */
-    $$parseLinkUrl(url) {
-      if (stripHash(this.appBase) === stripHash(url)) {
-        this.$$parse(url);
-        return true;
+          firstPathSegmentMatch = windowsFilePathExp.exec(path);
+          return firstPathSegmentMatch ? firstPathSegmentMatch[1] : path;
+        }
       }
-      return false;
     }
   }
 
@@ -19580,20 +19388,20 @@
       /** @type {string} */
       this.hashPrefixConf = "!";
 
-      /** @type {Html5Mode} */
+      /** @type {import("./interface.ts").Html5Mode} */
       this.html5ModeConf = {
-        enabled: false,
-        requireBase: true,
+        enabled: true,
+        requireBase: false,
         rewriteLinks: true,
       };
 
-      /** @type {Array<import("./interface.js").UrlChangeListener>} */
+      /** @type {Array<import("./interface.ts").UrlChangeListener>} */
       this.urlChangeListeners = [];
       this.urlChangeInit = false;
 
       /** @type {History['state']} */
       this.cachedState = null;
-      /** @typeof {History.state} */
+      /** @type {History['state']} */
       this.lastHistoryState = null;
       /** @type {string} */
       this.lastBrowserUrl = window.location.href;
@@ -19604,14 +19412,19 @@
     // URL API
     /// ///////////////////////////////////////////////////////////
 
+    /**
+     * Updates the browser's current URL and history state.
+     *
+     * @param {string|undefined} url - The target URL to navigate to.
+     * @param {*} [state=null] - Optional history state object to associate with the new URL.
+     * @returns {LocationProvider}
+     */
     setUrl(url, state) {
       if (state === undefined) {
         state = null;
       }
-
-      // setter
       if (url) {
-        url = urlResolve(url).href;
+        url = new URL(url).href;
 
         if (this.lastBrowserUrl === url && this.lastHistoryState === state) {
           return this;
@@ -19628,7 +19441,7 @@
      * Returns the current URL with any empty hash (`#`) removed.
      * @return {string}
      */
-    getUrl() {
+    getBrowserUrl() {
       return trimEmptyHash(window.location.href);
     }
 
@@ -19656,19 +19469,17 @@
 
     /**
      * Fires the state or URL change event.
-     *
-     * @private
      */
-    fireStateOrUrlChange() {
+    #fireStateOrUrlChange() {
       const prevLastHistoryState = this.lastHistoryState;
       this.cacheState();
       if (
-        this.lastBrowserUrl === this.getUrl() &&
+        this.lastBrowserUrl === this.getBrowserUrl() &&
         prevLastHistoryState === this.cachedState
       ) {
         return;
       }
-      this.lastBrowserUrl = this.getUrl();
+      this.lastBrowserUrl = this.getBrowserUrl();
       this.lastHistoryState = this.cachedState;
       this.urlChangeListeners.forEach((listener) => {
         listener(trimEmptyHash(window.location.href), this.cachedState);
@@ -19681,131 +19492,75 @@
      * @param {import("./interface.js").UrlChangeListener} callback - The callback function to register.
      * @returns void
      */
-    onUrlChange(callback) {
+    #onUrlChange(callback) {
       if (!this.urlChangeInit) {
-        window.addEventListener("popstate", this.fireStateOrUrlChange.bind(this));
+        window.addEventListener(
+          "popstate",
+          this.#fireStateOrUrlChange.bind(this),
+        );
         window.addEventListener(
           "hashchange",
-          this.fireStateOrUrlChange.bind(this),
+          this.#fireStateOrUrlChange.bind(this),
         );
         this.urlChangeInit = true;
       }
       this.urlChangeListeners.push(callback);
     }
 
-    /**
-     * The default value for the prefix is `'!'`.
-     * @param {string=} prefix Prefix for hash part (containing path and search)
-     * @returns {void}
-     */
-    setHashPrefix(prefix) {
-      this.hashPrefixConf = prefix;
-    }
-
-    /**
-     * Current hash prefix
-     * @returns {string}
-     */
-    getHashPrefix() {
-      return this.hashPrefixConf;
-    }
-
-    /**
-     * Configures html5 mode
-     * @param {(boolean|Html5Mode)=} mode If boolean, sets `html5Mode.enabled` to value. Otherwise, accepts html5Mode object
-     *
-     * @returns {void}
-     */
-    setHtml5Mode(mode) {
-      if (isBoolean(mode)) {
-        this.html5ModeConf.enabled = /** @type {boolean} */ (mode);
-      }
-      if (isObject(mode)) {
-        const html5Mode = /** @type {Html5Mode} */ (mode);
-        if (isDefined(html5Mode.enabled) && isBoolean(html5Mode.enabled)) {
-          this.html5ModeConf.enabled = html5Mode.enabled;
-        }
-
-        if (
-          isDefined(html5Mode.requireBase) &&
-          isBoolean(html5Mode.requireBase)
-        ) {
-          this.html5ModeConf.requireBase = html5Mode.requireBase;
-        }
-
-        if (
-          isDefined(html5Mode.rewriteLinks) &&
-          (isBoolean(html5Mode.rewriteLinks) || isString(html5Mode.rewriteLinks))
-        ) {
-          this.html5ModeConf.rewriteLinks = html5Mode.rewriteLinks;
-        }
-      }
-    }
-
-    /**
-     * Returns html5 mode cofiguration
-     * @returns {Html5Mode}
-     */
-    getHtml5Mode() {
-      return this.html5ModeConf;
-    }
-
     $get = [
-      "$rootScope",
-      "$rootElement",
+      $injectTokens.$rootScope,
+      $injectTokens.$rootElement,
       /**
        *
        * @param {import('../../core/scope/scope.js').Scope} $rootScope
        * @param {Element} $rootElement
-       * @returns
+       * @returns {Location}
        */
       ($rootScope, $rootElement) => {
         /** @type {Location} */
         let $location;
-        let LocationMode;
         const baseHref = getBaseHref(); // if base[href] is undefined, it defaults to ''
         const initialUrl = trimEmptyHash(window.location.href);
         let appBase;
 
-        if (this.getHtml5Mode().enabled) {
-          if (!baseHref && this.getHtml5Mode().requireBase) {
+        if (this.html5ModeConf.enabled) {
+          if (!baseHref && this.html5ModeConf.requireBase) {
             throw $locationMinErr(
               "nobase",
               "$location in HTML5 mode requires a <base> tag to be present!",
             );
           }
           appBase = serverBase(initialUrl) + (baseHref || "/");
-          LocationMode = LocationHtml5Url;
         } else {
           appBase = stripHash(initialUrl);
-          LocationMode = LocationHashbangUrl;
         }
         const appBaseNoFile = stripFile(appBase);
 
-        $location = new LocationMode(
+        $location = new Location(
           appBase,
           appBaseNoFile,
-          `#${this.getHashPrefix()}`,
+          this.html5ModeConf.enabled,
+          `#${this.hashPrefixConf}`,
         );
-        $location.$$parseLinkUrl(initialUrl, initialUrl);
+        $location.parseLinkUrl(initialUrl, initialUrl);
 
         $location.$$state = this.state();
 
         const IGNORE_URI_REGEXP = /^\s*(javascript|mailto):/i;
 
         const setBrowserUrlWithFallback = (url, state) => {
-          const oldUrl = $location.url();
+          const oldUrl = $location.getUrl();
           const oldState = $location.$$state;
           try {
             this.setUrl(url, state);
 
-            // Make sure $location.state() returns referentially identical (not just deeply equal)
+            // Make sure $location.getState() returns referentially identical (not just deeply equal)
             // state object; this makes possible quick checking if the state changed in the digest
             // loop. Checking deep equality would be too expensive.
             $location.$$state = this.state();
           } catch (e) {
             // Restore old values if pushState fails
-            $location.url(/** @type {string} */ (oldUrl));
+            $location.setUrl(/** @type {string} */ (oldUrl));
             $location.$$state = oldState;
 
             throw e;
@@ -19816,7 +19571,7 @@
           "click",
           /** @param {MouseEvent} event */
           (event) => {
-            const rewriteLinks = this.getHtml5Mode().rewriteLinks;
+            const rewriteLinks = this.html5ModeConf.rewriteLinks;
             // TODO(vojta): rewrite link when opening in new tab/window (in legacy browser)
             // currently we open nice url link and redirect then
 
@@ -19825,7 +19580,6 @@
               event.ctrlKey ||
               event.metaKey ||
               event.shiftKey ||
-              event.which === 2 ||
               event.button === 2
             ) {
               return;
@@ -19860,7 +19614,7 @@
               // an animation.
 
               const scvAnimatedString = /** @type {unknown} */ (absHref);
-              absHref = urlResolve(
+              absHref = new URL(
                 /** @type {SVGAnimatedString } */ (scvAnimatedString).animVal,
               ).href;
             }
@@ -19873,7 +19627,7 @@
               !elm.getAttribute("target") &&
               !event.defaultPrevented
             ) {
-              if ($location.$$parseLinkUrl(absHref, relHref)) {
+              if ($location.parseLinkUrl(absHref, relHref)) {
                 // We do a preventDefault for all urls that are part of the AngularTS application,
                 // in html5mode and also without, so that we are able to abort navigation without
                 // getting double entries in the location history.
@@ -19884,14 +19638,14 @@
         );
 
         // rewrite hashbang url <> html5 url
-        if ($location.absUrl() !== initialUrl) {
-          this.setUrl($location.absUrl(), true);
+        if ($location.absUrl !== initialUrl) {
+          this.setUrl($location.absUrl, true);
         }
 
         let initializing = true;
 
         // update $location when $browser url changes
-        this.onUrlChange((newUrl, newState) => {
+        this.#onUrlChange((newUrl, newState) => {
           if (!startsWith(newUrl, appBaseNoFile)) {
             // If we are navigating outside of the app then force a reload
             window.location.href = newUrl;
@@ -19899,10 +19653,10 @@
           }
 
           Promise.resolve().then(() => {
-            const oldUrl = $location.absUrl();
+            const oldUrl = $location.absUrl;
             const oldState = $location.$$state;
             let defaultPrevented;
-            $location.$$parse(newUrl);
+            $location.parse(newUrl);
             $location.$$state = newState;
 
             defaultPrevented = $rootScope.$broadcast(
@@ -19915,10 +19669,10 @@
 
             // if the location was changed by a `$locationChangeStart` handler then stop
             // processing this location change
-            if ($location.absUrl() !== newUrl) return;
+            if ($location.absUrl !== newUrl) return;
 
             if (defaultPrevented) {
-              $location.$$parse(oldUrl);
+              $location.parse(oldUrl);
               $location.$$state = oldState;
               setBrowserUrlWithFallback(oldUrl, oldState);
             } else {
@@ -19930,21 +19684,21 @@
 
         // update browser
         const updateBrowser = () => {
-          if (initializing || $location.$$urlUpdatedByLocation) {
-            $location.$$urlUpdatedByLocation = false;
+          if (initializing || urlUpdatedByLocation) {
+            urlUpdatedByLocation = false;
 
-            const oldUrl = /** @type {string} */ (this.getUrl());
-            const newUrl = $location.absUrl();
+            const oldUrl = /** @type {string} */ (this.getBrowserUrl());
+            const newUrl = $location.absUrl;
             const oldState = this.state();
             const urlOrStateChanged =
               !urlsEqual(oldUrl, newUrl) ||
-              ($location.$$html5 && oldState !== $location.$$state);
+              ($location.html5 && oldState !== $location.$$state);
 
             if (initializing || urlOrStateChanged) {
               initializing = false;
 
               setTimeout(() => {
-                const newUrl = $location.absUrl();
+                const newUrl = $location.absUrl;
                 const { defaultPrevented } = $rootScope.$broadcast(
                   "$locationChangeStart",
                   newUrl,
@@ -19955,10 +19709,10 @@
 
                 // if the location was changed by a `$locationChangeStart` handler then stop
                 // processing this location change
-                if ($location.absUrl() !== newUrl) return;
+                if ($location.absUrl !== newUrl) return;
 
                 if (defaultPrevented) {
-                  $location.$$parse(oldUrl);
+                  $location.parse(oldUrl);
                   $location.$$state = oldState;
                 } else {
                   if (urlOrStateChanged) {
@@ -19972,13 +19726,8 @@
               });
             }
           }
-
-          $location.$$replace = false;
-
-          // we don't need to return anything because $evalAsync will make the digest loop dirty when
-          // there is a change
         };
-
+        $location.$$updateBrowser = updateBrowser;
         updateBrowser();
         $rootScope.$on("$updateBrowser", updateBrowser);
 
@@ -19987,7 +19736,7 @@
         function afterLocationChange(oldUrl, oldState) {
           $rootScope.$broadcast(
             "$locationChangeSuccess",
-            $location.absUrl(),
+            $location.absUrl,
             oldUrl,
             $location.$$state,
             oldState,
@@ -19999,28 +19748,63 @@
 
   /**
    * ///////////////////////////
-   *          HELPERS
+   *     PRIVATE HELPERS
    * ///////////////////////////
    */
 
   /**
-   * Encode path using encodeUriSegment, ignoring forward slashes
+   * @ignore
+   * Encodes a URL path by encoding each path segment individually using `encodeUriSegment`,
+   * while preserving forward slashes (`/`) as segment separators.
    *
-   * @param {string} path Path to encode
-   * @returns {string}
+   * This function first decodes any existing percent-encodings (such as `%20` or `%2F`)
+   * in each segment to prevent double encoding, except for encoded forward slashes (`%2F`),
+   * which are replaced with literal slashes before decoding to keep path boundaries intact.
+   *
+   * After decoding, each segment is re-encoded with `encodeUriSegment` according to RFC 3986,
+   * encoding only characters that must be encoded in a path segment.
+   *
+   * The encoded segments are then rejoined with `/` to form the encoded path.
+   *
+   * @param {string} path - The URL path string to encode. May contain multiple segments separated by `/`.
+   * @returns {string} The encoded path, where each segment is encoded, but forward slashes are preserved.
+   *
+   * @example
+   * encodePath("user profile/images/pic 1.jpg")
+   * // returns "user%20profile/images/pic%201.jpg"
+   *
+   * @example
+   * encodePath("folder1%2Fsub/folder2")
+   * // returns "folder1%2Fsub/folder2"
    */
   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, "/"));
+      // Decode any existing encodings (e.g. %20, %2F) to prevent double-encoding
+      // But keep slashes intact (they were split on)
+      const decodedSegment = decodeURIComponent(
+        segments[i].replace(/%2F/gi, "/"),
+      );
+      segments[i] = encodeUriSegment(decodedSegment);
     }
 
     return segments.join("/");
   }
 
+  /**
+   * @ignore
+   * Decodes each segment of a URL path.
+   *
+   * Splits the input path by "/", decodes each segment using decodeURIComponent,
+   * and if html5Mode is enabled, re-encodes any forward slashes inside segments
+   * as "%2F" to avoid confusion with path separators.
+   *
+   * @param {string} path - The URL path to decode.
+   * @param {boolean} html5Mode - If true, encodes forward slashes in segments as "%2F".
+   * @returns {string} The decoded path with segments optionally encoding slashes.
+   */
   function decodePath(path, html5Mode) {
     const segments = path.split("/");
     let i = segments.length;
@@ -20036,6 +19820,33 @@
     return segments.join("/");
   }
 
+  /**
+   * @ignore
+   * Normalizes a URL path by encoding the path segments, query parameters, and hash fragment.
+   *
+   * - Path segments are encoded using `encodePath`, which encodes each segment individually.
+   * - Query parameters (`searchValue`) are converted to a query string using `toKeyValue`.
+   * - Hash fragment (`hashValue`) is encoded using `encodeUriSegment` and prefixed with `#`.
+   *
+   * This function returns a fully constructed URL path with optional query and hash components.
+   *
+   * @param {string} pathValue - The base URL path (e.g., "folder/item name").
+   * @param {Object.<string, any> | string | null} searchValue - An object or string representing query parameters.
+   *   - If an object, it can contain strings, numbers, booleans, or arrays of values.
+   *   - If a string, it is assumed to be a raw query string.
+   *   - If null or undefined, no query string is added.
+   * @param {string | null} hashValue - The URL fragment (everything after `#`). If null or undefined, no hash is added.
+   *
+   * @returns {string} The normalized URL path including encoded path, optional query string, and optional hash.
+   *
+   * @example
+   * normalizePath("products/list", { category: "books", page: 2 }, "section1")
+   * // returns "products/list?category=books&page=2#section1"
+   *
+   * @example
+   * normalizePath("user profile/images", null, null)
+   * // returns "user%20profile/images"
+   */
   function normalizePath(pathValue, searchValue, hashValue) {
     const search = toKeyValue(searchValue);
     const hash = hashValue ? `#${encodeUriSegment(hashValue)}` : "";
@@ -20044,7 +19855,15 @@
     return path + (search ? `?${search}` : "") + hash;
   }
 
-  function parseAppUrl(url, locationObj, html5Mode) {
+  /**
+   * @ignore
+   * Parses the application URL and updates the location object with path, search, and hash.
+   *
+   * @param {string} url - The URL string to parse.
+   * @param {boolean} html5Mode - Whether HTML5 mode is enabled (affects decoding).
+   * @throws Will throw an error if the URL starts with invalid slashes.
+   */
+  function parseAppUrl(url, html5Mode) {
     if (/^\s*[\\/]{2,}/.test(url)) {
       throw $locationMinErr("badpath", 'Invalid url "{0}".', url);
     }
@@ -20058,22 +19877,20 @@
       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);
+    $$path = decodePath(path, html5Mode);
+    $$search = parseKeyValue(match.search);
+    $$hash = decodeURIComponent(match.hash);
 
     // make sure path starts with '/';
-    if (locationObj.$$path && locationObj.$$path.charAt(0) !== "/") {
-      locationObj.$$path = `/${locationObj.$$path}`;
+    if ($$path && $$path.charAt(0) !== "/") {
+      $$path = `/${$$path}`;
     }
   }
 
-  function startsWith(str, search) {
-    return str.slice(0, search.length) === search;
-  }
-
   /**
-   *
+   * @ignore
+   * Returns the substring of `url` after the `base` string if `url` starts with `base`.
+   * Returns `undefined` if `url` does not start with `base`.
    * @param {string} base
    * @param {string} url
    * @returns {string} returns text from `url` after `base` or `undefined` if it does not begin with
@@ -20085,25 +19902,96 @@
     }
   }
 
+  /**
+   * @ignore
+   * Removes the hash fragment (including the '#') from the given URL string.
+   *
+   * @param {string} url - The URL string to process.
+   * @returns {string} The URL without the hash fragment.
+   */
   function stripHash(url) {
     const index = url.indexOf("#");
     return index === -1 ? url : url.substring(0, index);
   }
 
+  /**
+   * @ignore
+   * Removes the file name (and any hash) from a URL, returning the base directory path.
+   *
+   * For example:
+   * - Input: "https://example.com/path/to/file.js"
+   *   Output: "https://example.com/path/to/"
+   *
+   * - Input: "https://example.com/path/to/file.js#section"
+   *   Output: "https://example.com/path/to/"
+   *
+   * @param {string} url - The URL from which to strip the file name and hash.
+   * @returns {string} The base path of the URL, ending with a slash.
+   */
   function stripFile(url) {
     return url.substring(0, stripHash(url).lastIndexOf("/") + 1);
   }
 
-  /* return the server only (scheme://host:port) */
+  /**
+   * @ignore
+   * Extracts the base server URL (scheme, host, and optional port) from a full URL.
+   *
+   * If no path is present, returns the full URL.
+   *
+   * For example:
+   * - Input: "https://example.com/path/to/file"
+   *   Output: "https://example.com"
+   *
+   * - Input: "http://localhost:3000/api/data"
+   *   Output: "http://localhost:3000"
+   *
+   * @param {string} url - The full URL to extract the server base from.
+   * @returns {string} The server base, including scheme and host (and port if present).
+   */
   function serverBase(url) {
-    return url.substring(0, url.indexOf("/", url.indexOf("//") + 2));
+    const start = url.indexOf("//") + 2;
+    const slashIndex = url.indexOf("/", start);
+    return slashIndex === -1 ? url : url.substring(0, slashIndex);
   }
 
-  // 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
+  /**
+   * @ignore
+   * Determine if two URLs are equal despite potential differences in encoding,
+   * trailing slashes, or empty hash fragments, such as between $location.absUrl() and $browser.url().
+   *
+   * @param {string} a - First URL to compare.
+   * @param {string} b - Second URL to compare.
+   * @returns {boolean} True if URLs are equivalent after normalization.
+   */
   function urlsEqual(a, b) {
-    return a === b || urlResolve(a).href === urlResolve(b).href;
+    return normalizeUrl(a) === normalizeUrl(b);
+  }
+
+  /**
+   * @ignore
+   * Normalize a URL by resolving it via a DOM anchor element,
+   * removing trailing slashes (except root), and trimming empty hashes.
+   *
+   * @param {string} url - URL to normalize.
+   * @returns {string} Normalized URL string.
+   */
+  function normalizeUrl(url) {
+    const anchor = document.createElement("a");
+    anchor.href = url;
+
+    let normalized = anchor.href;
+
+    // Remove trailing slash unless it's root (e.g., https://example.com/)
+    if (normalized.endsWith("/") && !/^https?:\/\/[^/]+\/$/.test(normalized)) {
+      normalized = normalized.slice(0, -1);
+    }
+
+    // Remove empty hash (e.g., https://example.com/foo# -> https://example.com/foo)
+    if (normalized.endsWith("#")) {
+      normalized = normalized.slice(0, -1);
+    }
+
+    return normalized;
   }
 
   /**
@@ -20257,7 +20145,7 @@
                 Array.isArray(target.$nonscope) &&
                 target.$nonscope.includes(key))
             ) {
-              continue;
+              /* empty */
             } else {
               target[key] = createScope(target[key], proxy.$handler);
             }
@@ -20736,6 +20624,7 @@
 
     /**
      * @param {Listener[]} listeners
+     * @param {Function} filter
      */
     #scheduleListener(listeners, filter = (val) => val) {
       Promise.resolve().then(() => {
@@ -21386,8 +21275,7 @@
   function calculateWatcherCount(model) {
     const childIds = collectChildIds(model).add(model.$id);
 
-    /** @type {number} */
-    const count = Array.from(model.watchers.values()).reduce(
+    return Array.from(model.watchers.values()).reduce(
       (count, watcherArray) =>
         count +
         watcherArray.reduce(
@@ -21397,7 +21285,6 @@
         ),
       0,
     );
-    return count;
   }
 
   /**
@@ -23088,8 +22975,7 @@
 
               temporaryStyles.forEach((entry) => {
                 const key = entry[0];
-                const value = entry[1];
-                node.style[key] = value;
+                node.style[key] = entry[1];
               });
 
               applyAnimationClasses(element, options);
@@ -25815,11 +25701,6 @@
     if (idx >= 0) array.splice(idx, 1);
     return array;
   }
-  /** pushes a values to an array and returns the value */
-  const pushTo = curry((arr, val) => {
-    arr.push(val);
-    return val;
-  });
 
   /**
    * Applies a set of defaults to an options object.  The options object is filtered
@@ -26604,12 +26485,14 @@
 
       /** @type {Array<(item: T) => void>} */
       this._evictListeners = [];
+    }
 
-      /**
-       * Register a listener that will be called with the evicted item.
-       * @type {(listener: (item: T) => void) => void}
-       */
-      this.onEvict = pushTo(this._evictListeners);
+    /**
+     * Register a listener that will be called with the evicted item.
+     * @param {(item: T) => void} listener
+     */
+    onEvict(listener) {
+      this._evictListeners.push(listener);
     }
 
     /**
@@ -27804,8 +27687,13 @@
       // The param keys specified by the incoming toParams
       return toPath.map(makeInheritedParamsNode);
     }
+
     /**
      * Computes the tree changes (entering, exiting) between a fromPath and toPath.
+     * @param {PathNode[]} fromPath
+     * @param {PathNode[]} toPath
+     * @param {boolean} [reloadState]
+     * @returns {import("../transition/interface.js").TreeChanges}
      */
     static treeChanges(fromPath, toPath, reloadState) {
       const max = Math.min(fromPath.length, toPath.length);
@@ -28171,7 +28059,7 @@
       name = name || "$default";
       // Account for views: { header: "headerComponent" }
       if (isString(config)) config = { component: config };
-      // Make a shallow copy of the config object
+      // Make a shallow copy of the urlConfig object
       config = Object.assign({}, config);
       // Do not allow a view to mix props for component-style view with props for template/controller-style view
       if (hasAnyKey(compKeys, config) && hasAnyKey(nonCompKeys, config)) {
@@ -28325,8 +28213,7 @@
       this._listeners = [];
       this._pluginapi = {
         _registeredUIView: (id) => {
-          const res = find(this._ngViews, (view) => view.id === id);
-          return res;
+          return find(this._ngViews, (view) => view.id === id);
         },
         _registeredUIViews: () => this._ngViews,
         _activeViewConfigs: () => this._viewConfigs,
@@ -28364,8 +28251,7 @@
         throw new Error(
           "ViewService: No view config factory registered for type " + decl.$type,
         );
-      const cfgs = cfgFactory(path, decl);
-      return cfgs;
+      return cfgFactory(path, decl);
     }
     /**
      * Deactivates a ViewConfig.
@@ -29672,9 +29558,9 @@
      *
      * If the target state is not valid, an error is thrown.
      *
-     * @param fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
+     * @param {Array<import('../path/path-node.js').PathNode>} fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
      *        encapsulates the "from state".
-     * @param targetState The target state and parameters being transitioned to (also, the transition options)
+     * @param {import('../state/target-state.js').TargetState} targetState The target state and parameters being transitioned to (also, the transition options)
      * @param {import('../transition/transition-service.js').TransitionProvider} transitionService The [[TransitionService]] instance
      * @param {import('../globals.js').RouterGlobals} globals
      */
@@ -30218,8 +30104,8 @@
           ).length
         );
       };
-      const newTC = this.treeChanges();
-      const pendTC = pending && pending.treeChanges();
+      const newTC = this._treeChanges;
+      const pendTC = pending && pending._treeChanges;
       if (
         pendTC &&
         same(pendTC.to, newTC.to) &&
@@ -30860,7 +30746,7 @@
    * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
    */
   class TransitionProvider {
-    static $inject = ["$routerGlobalsProvider", "$viewProvider"];
+    /* @ignore */ static $inject = provider([$injectTokens.$routerGlobals, $injectTokens.$view]);
 
     /**
      * @param {import('../globals.js').RouterGlobals} globals
@@ -30891,10 +30777,10 @@
     }
 
     $get = [
-      "$state",
-      "$urlService",
-      "$stateRegistry",
-      "$view",
+      $injectTokens.$state,
+      $injectTokens.$url,
+      $injectTokens.$stateRegistry,
+      $injectTokens.$view,
       (stateService, urlService, stateRegistry, viewService) => {
         // Lazy load state trees
         this._deregisterHookFns.lazyLoad = registerLazyLoadHook(
@@ -31132,7 +31018,10 @@
       return this.globals.$current;
     }
 
-    static $inject = ["$routerGlobalsProvider", "$transitionsProvider"];
+    /* @ignore */ static $inject = [
+      "$routerGlobalsProvider",
+      "$transitionsProvider",
+    ];
 
     // Needs access to urlService, stateRegistry
     /**
@@ -31211,9 +31100,9 @@
      * - **params** `{object}` - returns an array of state params that are ensured to
      *   be a super-set of parent's params.
      * - **views** `{object}` - returns a views object where each key is an absolute view
-     *   name (i.e. "viewName@stateName") and each value is the config object
+     *   name (i.e. "viewName@stateName") and each value is the urlConfig object
      *   (template, controller) for the view. Even when you don't use the views object
-     *   explicitly on a state config, one is still created for you internally.
+     *   explicitly on a state urlConfig, one is still created for you internally.
      *   So by decorating this builder function you have access to decorating template
      *   and controller properties.
      * - **ownParams** `{object}` - returns an array of params that belong to the state,
@@ -31231,10 +31120,10 @@
      *   let result = {},
      *       views = parent(state);
      *
-     *   angular.forEach(views, function (config, name) {
+     *   angular.forEach(views, function (urlConfig, name) {
      *     let autoName = (state.name + '.' + name).replace('.', '/');
-     *     config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';
-     *     result[name] = config;
+     *     urlConfig.templateUrl = urlConfig.templateUrl || '/partials/' + autoName + '.html';
+     *     result[name] = urlConfig;
      *   });
      *   return result;
      * });
@@ -31258,7 +31147,7 @@
      * @param {object} func A function that is responsible for decorating the original
      * builder function. The function receives two parameters:
      *
-     *   - `{object}` - state - The state config object.
+     *   - `{object}` - state - The state urlConfig object.
      *   - `{object}` - super - The original builder function.
      *
      * @return {object} $stateProvider - $stateProvider instance
@@ -31491,7 +31380,7 @@
       const globals = this.globals;
       const latestSuccess = globals.successfulTransitions.peekTail();
       const rootPath = () => [new PathNode(this.stateRegistry.root())];
-      return latestSuccess ? latestSuccess.treeChanges().to : rootPath();
+      return latestSuccess ? latestSuccess._treeChanges.to : rootPath();
     }
     /**
      * Low-level method for transitioning to a new state.
@@ -31826,10 +31715,10 @@
     }
 
     $get = [
-      "$http",
-      "$templateCache",
-      "$templateRequest",
-      "$injector",
+      $injectTokens.$http,
+      $injectTokens.$templateCache,
+      $injectTokens.$templateRequest,
+      $injectTokens.$injector,
       /**
        * @param {import("interface.ts").HttpService} $http
        * @param {import("../services/template-cache/interface.ts").TemplateCache} $templateCache
@@ -32372,9 +32261,9 @@
      * // returns { id: 'bob', q: 'hello', r: null }
      * ```
      *
-     * @param path    The URL path to match, e.g. `$location.path()`.
-     * @param search  URL search parameters, e.g. `$location.search()`.
-     * @param hash    URL hash e.g. `$location.hash()`.
+     * @param path    The URL path to match, e.g. `$location.getPath()`.
+     * @param search  URL search parameters, e.g. `$location.getSearch()`.
+     * @param hash    URL hash e.g. `$location.getHash()`.
      *
      * @returns The captured parameter values.
      */
@@ -32888,6 +32777,7 @@
       this.$id = -1;
       this._group = undefined;
       this.handler = handler || ((x) => x);
+      this.priority = undefined;
     }
 
     /**
@@ -32901,7 +32791,9 @@
     }
   }
 
-  const prioritySort = (a, b) => (b.priority || 0) - (a.priority || 0);
+  function prioritySort(a, b) {
+    return (b.priority || 0) - (a.priority || 0);
+  }
 
   const typeSort = (a, b) => {
     const weights = { STATE: 4, URLMATCHER: 4, REGEXP: 3, RAW: 2, OTHER: 1 };
@@ -32932,8 +32824,7 @@
    *   - Equally sorted State and UrlMatcher rules will each match the URL.
    *     Then, the *best* match is chosen based on how many parameter values were matched.
    */
-  let defaultRuleSortFn;
-  defaultRuleSortFn = (a, b) => {
+  function defaultRuleSortFn(a, b) {
     let cmp = prioritySort(a, b);
     if (cmp !== 0) return cmp;
     cmp = typeSort(a, b);
@@ -32941,7 +32832,8 @@
     cmp = urlMatcherSort(a, b);
     if (cmp !== 0) return cmp;
     return idSort(a, b);
-  };
+  }
+
   function getHandlerFn(handler) {
     if (
       !isFunction(handler) &&
@@ -32963,9 +32855,10 @@
    *
    * The most commonly used methods are [[otherwise]] and [[when]].
    *
-   * This API is found at `$urlService.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
+   * This API is found at `$url.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
    */
   class UrlRules {
+    /** @param {UrlRuleFactory} urlRuleFactory */
     constructor(urlRuleFactory) {
       this._sortFn = defaultRuleSortFn;
       this._rules = [];
@@ -33268,39 +33161,37 @@
    * API for URL management
    */
   class UrlService {
-    static $inject = [
-      "$locationProvider",
-      "$stateProvider",
-      "$routerGlobalsProvider",
-      "$urlConfigProvider",
-    ];
+    static $inject = provider([
+      $injectTokens.$location,
+      $injectTokens.$state,
+      $injectTokens.$routerGlobals,
+      $injectTokens.$urlConfig,
+    ]);
+
+    /** @type {import("../../services/location/location").Location} */
+    $location;
 
     /**
      * @param {import("../../services/location/location").LocationProvider} $locationProvider
      * @param {import("../../router/state/state-service.js").StateProvider} stateService
-     * @param globals
+     * @param {import("../../router/globals.js").RouterGlobals} globals
      * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
      */
     constructor($locationProvider, stateService, globals, urlConfigProvider) {
+      this.$locationProvider = $locationProvider;
       this.stateService = stateService;
       this.stateService.urlService = this; // circular wiring
-      this.$locationProvider = $locationProvider;
-      this.$location = undefined;
 
       /** Provides services related to the URL */
       this.urlRuleFactory = new UrlRuleFactory(this, this.stateService, globals);
 
       /**
        * The nested [[UrlRules]] API for managing URL rules and rewrites
-       *
-       * See: [[UrlRules]] for details
        * @type {UrlRules}
        */
       this.rules = new UrlRules(this.urlRuleFactory);
       /**
        * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
-       *
-       * See: [[UrlConfig]] for details
        * @type {import("./url-config.js").UrlConfigProvider}
        */
       this.config = urlConfigProvider;
@@ -33308,37 +33199,44 @@
       /** Creates a new [[Param]] for a given location (DefType) */
       this.paramFactory = new ParamFactory(this.config);
 
-      /**
-       * Gets the path part of the current url
-       *
-       * If the current URL is `/some/path?query=value#anchor`, this returns `/some/path`
-       *
-       * @return the path portion of the url
-       */
-      this.path = () => this.$location.path();
-      /**
-       * Gets the search part of the current url as an object
-       *
-       * If the current URL is `/some/path?query=value#anchor`, this returns `{ query: 'value' }`
-       *
-       * @return the search (query) portion of the url, as an object
-       */
-      this.search = () => this.$location.search();
-      /**
-       * Gets the hash part of the current url
-       *
-       * If the current URL is `/some/path?query=value#anchor`, this returns `anchor`
-       *
-       * @return the hash (anchor) portion of the url
-       */
-      this.hash = () => this.$location.hash();
-
       this._urlListeners = [];
     }
 
+    /**
+     * Gets the path part of the current url
+     *
+     * If the current URL is `/some/path?query=value#anchor`, this returns `/some/path`
+     *
+     * @return {string} the path portion of the url
+     */
+    getPath() {
+      return this.$location.getPath();
+    }
+
+    /**
+     * Gets the search part of the current url as an object
+     *
+     * If the current URL is `/some/path?query=value#anchor`, this returns `{ query: 'value' }`
+     *
+     * @return {Object} the search (query) portion of the url, as an object
+     */
+    getSearch() {
+      return this.$location.getSearch();
+    }
+    /**
+     * Gets the hash part of the current url
+     *
+     * If the current URL is `/some/path?query=value#anchor`, this returns `anchor`
+     *
+     * @return {string} the hash (anchor) portion of the url
+     */
+    getHash() {
+      return this.$location.getHash();
+    }
+
     $get = [
-      "$location",
-      "$rootScope",
+      $injectTokens.$location,
+      $injectTokens.$rootScope,
       /**
        *
        * @param {import('../../services/location/location.js').Location} $location
@@ -33352,21 +33250,14 @@
             fn(evt);
           });
         });
-        this.listen();
+        this.listen(true);
         return this;
       },
     ];
 
     /**
-     * @returns {boolean}
+     * @returns {string}
      */
-    html5Mode() {
-      return (
-        this.$locationProvider.getHtml5Mode().enabled &&
-        typeof history !== "undefined"
-      );
-    }
-
     baseHref() {
       return (
         this._baseHref ||
@@ -33421,20 +33312,18 @@
      * @param {string} [newUrl] The new value for the URL.
      *               This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.
      *               It should not include the protocol, site, port, or base path of an absolute HREF.
-     * @param {boolean} [replace] When true, replaces the current history entry (instead of appending it) with this new url
      * @param {any} [state] The history's state object, i.e., pushState (if the LocationServices implementation supports it)
      *
      * @return the url (after potentially being processed)
      */
-    url(newUrl, replace = false, state) {
-      if (isDefined(newUrl)) this.$location.url(newUrl);
-      if (replace) this.$location.replace();
-      if (state) this.$location.state(state);
-      return this.$location.url();
+    url(newUrl, state) {
+      if (isDefined(newUrl)) this.$location.setUrl(newUrl);
+      if (state) this.$location.setState(state);
+      return this.$location.getUrl();
     }
 
     /**
-     * @internal
+     * @private
      *
      * Registers a low level url change handler
      *
@@ -33445,8 +33334,8 @@
      * let deregisterFn = locationServices.onChange((evt) => console.log("url change", evt));
      * ```
      *
-     * @param callback a function that will be called when the url is changing
-     * @return a function that de-registers the callback
+     * @param {Function} callback a function that will be called when the url is changing
+     * @return {Function} a function that de-registers the callback
      */
     onChange(callback) {
       this._urlListeners.push(callback);
@@ -33454,13 +33343,21 @@
     }
 
     /**
-     * Gets the current URL parts
+     * Gets the current URL parts.
+     *
+     * Returns an object with the `path`, `search`, and `hash` components
+     * of the current browser location.
      *
-     * This method returns the different parts of the current URL (the [[path]], [[search]], and [[hash]]) as a [[UrlParts]] object.
+     * @returns {import("../../services/location/interface.ts").UrlParts} The current URL's path, search, and hash.
      */
     parts() {
-      return { path: this.path(), search: this.search(), hash: this.hash() };
+      return {
+        path: this.$location.getPath(),
+        search: this.$location.getSearch(),
+        hash: this.$location.getHash(),
+      };
     }
+
     /**
      * Activates the best rule for the current URL
      *
@@ -33484,16 +33381,16 @@
       if (evt && evt.defaultPrevented) return;
       const stateService = this.stateService;
       const url = {
-        path: this.path(),
-        search: this.search(),
-        hash: this.hash(),
+        path: this.$location.getPath(),
+        search: this.$location.getSearch(),
+        hash: this.$location.getHash(),
       };
       /**
        * @type {*}
        */
       const best = this.match(url);
       const applyResult = pattern([
-        [isString, (newurl) => this.url(newurl, true)],
+        [isString, (newurl) => this.url(newurl)],
         [
           TargetState.isDef,
           (def) => stateService.go(def.state, def.params, def.options),
@@ -33526,7 +33423,7 @@
      * });
      * ```
      *
-     * @param enabled `true` or `false` to start or stop listening to URL changes
+     * @param {boolean} enabled `true` or `false` to start or stop listening to URL changes
      */
     listen(enabled) {
       if (enabled === false) {
@@ -33604,7 +33501,7 @@
      * ```js
      * matcher = $umf.compile("/about/:person");
      * params = { person: "bob" };
-     * $bob = $urlService.href(matcher, params);
+     * $bob = $url.href(matcher, params);
      * // $bob == "/about/bob";
      * ```
      *
@@ -33620,22 +33517,18 @@
       let url = urlMatcher.format(params);
       if (url == null) return null;
       options = options || { absolute: false };
-      const isHtml5 = this.html5Mode();
-      if (!isHtml5 && url !== null) {
-        url = "#" + this.$locationProvider.getHashPrefix() + url;
+      const isHtml5 = this.$locationProvider.html5ModeConf.enabled;
+      if (!isHtml5) {
+        url = "#" + this.$locationProvider.hashPrefixConf + url;
       }
       url = appendBasePath(url, isHtml5, options.absolute, this.baseHref());
       if (!options.absolute || !url) {
         return url;
       }
       const slash = !isHtml5 && url ? "/" : "";
-      const cfgPort = this.$location.port();
-      const port = cfgPort === 80 || cfgPort === 443 ? "" : ":" + cfgPort;
       return [
-        this.$location.protocol(),
-        "://",
-        this.$location.host(),
-        port,
+        `${window.location.protocol}//`,
+        window.location.host,
         slash,
         url,
       ].join("");
@@ -33773,7 +33666,7 @@
     return state.data;
   }
 
-  function getUrlBuilder($urlService, root) {
+  function getUrlBuilder($url, root) {
     return function (stateObject) {
       let stateDec = stateObject.self;
       // For future states, i.e., states whose name ends with `.**`,
@@ -33793,9 +33686,9 @@
       const parsed = parseUrl(stateDec.url);
       const url = !parsed
         ? stateDec.url
-        : $urlService.compile(parsed.val, { state: stateDec });
+        : $url.compile(parsed.val, { state: stateDec });
       if (!url) return null;
-      if (!$urlService.isMatcher(url))
+      if (!$url.isMatcher(url))
         throw new Error(`Invalid url '${url}' in state '${stateObject}'`);
       return parsed && parsed.root
         ? url
@@ -34219,8 +34112,8 @@
    *
    */
   class StateRegistryProvider {
-    static $inject = provider([
-      $injectTokens.$urlService,
+    /* @ignore */ static $inject = provider([
+      $injectTokens.$url,
       $injectTokens.$state,
       $injectTokens.$routerGlobals,
       $injectTokens.$view,
@@ -35120,7 +35013,7 @@
                * @param {string} viewName Name of the view.
                */
               newScope.$emit("$viewContentLoading", name);
-              const cloned = $transclude(newScope, function (clone) {
+              currentEl = $transclude(newScope, function (clone) {
                 setCacheData(clone, "$ngViewAnim", $ngViewAnim);
                 setCacheData(clone, "$ngView", $ngViewData);
                 renderer.enter(clone, $element, function () {
@@ -35136,7 +35029,6 @@
                 });
                 cleanupLastView();
               });
-              currentEl = cloned;
               currentScope = newScope;
               /**
                * Fired once the view is **loaded**, *after* the DOM is rendered.
@@ -35619,7 +35511,6 @@
 
       return {
         restrict: "A",
-        terminal: true,
         link(scope, element, attrs) {
           const eventName =
             attrs["trigger"] ||
@@ -35731,8 +35622,17 @@
             }
 
             if (method === "post" || method === "put") {
-              const data = collectFormData(element);
-              $http[method](url, data).then(handler).catch(handler);
+              let data;
+              const config = {};
+              if (attrs["enctype"]) {
+                config.headers = {
+                  "Content-Type": attrs["enctype"],
+                };
+                data = toKeyValue(collectFormData(element));
+              } else {
+                data = collectFormData(element);
+              }
+              $http[method](url, data, config).then(handler).catch(handler);
             } else {
               $http[method](url).then(handler).catch(handler);
             }
@@ -35746,7 +35646,7 @@
 
   /**
    * Initializes core `ng` module.
-   * @param {import('./loader.js').Angular} angular
+   * @param {import('./angular.js').Angular} angular
    * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
    */
   function registerNgModule(angular) {
@@ -35755,7 +35655,7 @@
         "ng",
         [],
         [
-          "$provide",
+          $injectTokens.$provide,
           /** @param {import("./interface.js").Provider} $provide */
           ($provide) => {
             // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
@@ -35763,7 +35663,7 @@
               $$sanitizeUri: SanitizeUriProvider,
             });
             $provide
-              .provider("$compile", CompileProvider)
+              .provider($injectTokens.$compile, CompileProvider)
               .directive({
                 input: inputDirective,
                 textarea: inputDirective,
@@ -35880,7 +35780,7 @@
               $state: StateProvider,
               $ngViewScroll: ViewScrollProvider,
               $templateFactory: TemplateFactoryProvider,
-              $urlService: UrlService,
+              $url: UrlService,
               $stateRegistry: StateRegistryProvider,
               $eventBus: PubSubProvider,
             });
@@ -35888,14 +35788,12 @@
         ],
       )
       .factory("$stateParams", [
-        "$routerGlobals",
+        $injectTokens.$routerGlobals,
         /**
          * @param {import('./router/globals.js').RouterGlobals} globals
          * @returns {import('./router/params/state-params.js').StateParams }
          */
-        function (globals) {
-          return globals.params;
-        },
+        (globals) => globals.params,
       ])
       .value("$trace", trace);
   }
@@ -35923,7 +35821,7 @@
       /**
        * @type {string} `version` from `package.json`
        */
-      this.version = "0.7.8"; //inserted via rollup plugin
+      this.version = "0.8.0"; //inserted via rollup plugin
 
       /** @type {!Array<string|any>} */
       this.bootsrappedModules = [];