@angular-wave/angular.ts 0.7.5 → 0.7.8

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.7.5 - July 12, 2025 01:24:05 */
+/* Version: 0.7.8 - July 17, 2025 02:51:18 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -247,7 +247,7 @@
    * @returns {boolean}
    */
   function isScope(obj) {
-    return obj && obj.$evalAsync && obj.$watch;
+    return obj && obj.$watch;
   }
 
   /**
@@ -1136,11 +1136,55 @@
     return Object.prototype.hasOwnProperty.call(obj, key);
   }
 
+  /**
+   * Wraps a function so it can only be called once.
+   * Subsequent calls do nothing and return undefined.
+   *
+   * @param {Function} fn - The function to wrap.
+   * @returns {Function} A new function that will call `fn` only once.
+   */
+  function callBackOnce(fn) {
+    let called = false;
+
+    return function (...args) {
+      if (!called) {
+        called = true;
+        return fn.apply(this, args);
+      }
+    };
+  }
+
+  /**
+   * Wraps a function so it will only be called starting from the second invocation.
+   * The first call does nothing and returns undefined.
+   *
+   * @param {Function} fn - The function to wrap.
+   * @returns {Function} A new function that will skip the first call.
+   */
+  function callBackAfterFirst(fn) {
+    let calledOnce = false;
+
+    return function (...args) {
+      if (calledOnce) {
+        return fn.apply(this, args);
+      }
+      calledOnce = true;
+    };
+  }
+
+  /**
+   * Delays execution for a specified number of milliseconds.
+   *
+   * @param {number} [t=0] - The number of milliseconds to wait. Defaults to 0.
+   * @returns {Promise<void>} A promise that resolves after the delay.
+   */
+  function wait(t = 0) {
+    return new Promise((resolve) => setTimeout(resolve, t));
+  }
+
   /**
    * 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
-   * for performance reasons and convenience methods. A proxy is available for
-   * additional logic handling.
    *
    * @type {Map<number, import('../interface.ts').ExpandoStore>}
    */
@@ -1693,6 +1737,16 @@
     }
   }
 
+  /**
+   * Returns the base href of the document.
+   *
+   * @returns {string} The base href.
+   */
+  function getBaseHref() {
+    const href = document.querySelector("base")?.getAttribute("href");
+    return href ? href.replace(/^(https?:)?\/\/[^/]*/, "") : "";
+  }
+
   /**
    * A helper list of tokens matching the standard injectables that come predefined in the core `ng` module.
    * These string tokens are commonly injected into services, directives, or components via `$inject`.
@@ -1725,7 +1779,7 @@
     $animate: "$animate",
     $animateCss: "$animateCss",
     $aria: "$aria",
-    $browser: "$browser",
+    $compile: "$compile",
     $controller: "$controller",
     $eventBus: "$eventBus",
     $exceptionHandler: "$exceptionHandler",
@@ -1768,10 +1822,15 @@
     return services.map((x) => x + "Provider");
   }
 
+  /** @private */
   const INJECTOR_LITERAL = "$injector";
+  /** @private */
   const COMPILE_LITERAL = "$compileProvider";
+  /** @private */
   const ANIMATION_LITERAL = "$animateProvider";
+  /** @private */
   const FILTER_LITERAL = "$filterProvider";
+  /** @private */
   const CONTROLLER_LITERAL = "$controllerProvider";
 
   /**
@@ -1838,11 +1897,7 @@
      * @returns {NgModule}
      */
     constant(name, object) {
-      this.invokeQueue.unshift([
-        $injectTokens.$provide,
-        "constant",
-        [name, object],
-      ]);
+      this.invokeQueue.unshift([$injectTokens.$provide, "constant", [name, object]]);
       return this;
     }
 
@@ -1887,11 +1942,7 @@
       if (providerFunction && isFunction(providerFunction)) {
         providerFunction.$$moduleName = name;
       }
-      this.invokeQueue.push([
-        $injectTokens.$provide,
-        "factory",
-        [name, providerFunction],
-      ]);
+      this.invokeQueue.push([$injectTokens.$provide, "factory", [name, providerFunction]]);
       return this;
     }
 
@@ -1904,11 +1955,7 @@
       if (serviceFunction && isFunction(serviceFunction)) {
         serviceFunction.$$moduleName = name;
       }
-      this.invokeQueue.push([
-        $injectTokens.$provide,
-        "service",
-        [name, serviceFunction],
-      ]);
+      this.invokeQueue.push([$injectTokens.$provide, "service", [name, serviceFunction]]);
       return this;
     }
 
@@ -1921,11 +1968,7 @@
       if (providerType && isFunction(providerType)) {
         providerType.$$moduleName = name;
       }
-      this.invokeQueue.push([
-        $injectTokens.$provide,
-        "provider",
-        [name, providerType],
-      ]);
+      this.invokeQueue.push([$injectTokens.$provide, "provider", [name, providerType]]);
       return this;
     }
 
@@ -1938,11 +1981,7 @@
       if (decorFn && isFunction(decorFn)) {
         decorFn.$$moduleName = name;
       }
-      this.configBlocks.push([
-        $injectTokens.$provide,
-        "decorator",
-        [name, decorFn],
-      ]);
+      this.configBlocks.push([$injectTokens.$provide, "decorator", [name, decorFn]]);
       return this;
     }
 
@@ -2187,8 +2226,11 @@
      */
     constructor(providerInjector, strictDi) {
       super(strictDi);
+
+      /** @type {ProviderInjector} */
       this.providerInjector = providerInjector;
-      this.modules = this.providerInjector.modules;
+      /** @type {Object.<string, import("./ng-module.js").NgModule>} */
+      this.modules = providerInjector.modules;
     }
 
     /**
@@ -2305,9 +2347,6 @@
     const loadedModules = new Map(); // Keep track of loaded modules to avoid circular dependencies
 
     const providerCache = {
-      /**
-       * @type {import('../../interface.ts').Provider}
-       */
       $provide: {
         provider: supportObject(provider),
         factory: supportObject(factory),
@@ -2334,15 +2373,10 @@
     const runBlocks = loadModules(modulesToLoad);
     instanceInjector = protoInstanceInjector.get(INJECTOR_LITERAL);
 
-    runBlocks.forEach((fn) => {
-      if (fn) instanceInjector.invoke(fn);
-    });
+    runBlocks.forEach((fn) => fn && instanceInjector.invoke(fn));
 
-    instanceInjector.loadNewModules = function (mods) {
-      loadModules(mods).forEach((fn) => {
-        if (fn) instanceInjector.invoke(fn);
-      });
-    };
+    instanceInjector.loadNewModules = (mods) =>
+      loadModules(mods).forEach((fn) => fn && instanceInjector.invoke(fn));
 
     return instanceInjector;
 
@@ -2471,7 +2505,7 @@
 
         try {
           if (isString(module)) {
-            /** @type {import('./ng-module').NgModule} */
+            /** @type {import('./ng-module.js').NgModule} */
             const moduleFn = window["angular"].module(module);
             instanceInjector.modules[/** @type {string } */ (module)] = moduleFn;
             runBlocks = runBlocks
@@ -2537,7 +2571,6 @@
   }
 
   /**
-   *
    * @param {any} fn
    * @param {boolean} [strictDi]
    * @param {String} [name]
@@ -2576,10 +2609,6 @@
     return $inject;
   }
 
-  /**
-   * @param {function(string, any):any} delegate
-   * @returns {any}
-   */
   function supportObject(delegate) {
     return function (key, value) {
       if (isObject(key)) {
@@ -2995,32 +3024,25 @@
     }
   }
 
-  /**
-   * HTTP protocol
-   * @typedef {"http"|"https"} HttpProtocol
-   */
-
   const urlParsingNode = document.createElement("a");
   const originUrl = urlResolve(window.location.href);
   let baseUrlParsingNode;
 
   urlParsingNode.href = "http://[::1]";
 
+  /**
+   * @param {import("./interface.js").ResolvableUrl} url
+   * @return {import("./interface.js").ParsedUrl}
+   */
   function urlResolve(url) {
-    if (!isString(url)) return url;
+    if (!isString(url))
+      return /** @type {import("./interface.js").ParsedUrl} */ (url);
 
-    const href = url;
+    urlParsingNode.setAttribute("href", /** @type {string} */ (url));
 
-    urlParsingNode.setAttribute("href", href);
-
-    let { hostname } = urlParsingNode;
-    // Support: IE 9-11 only, Edge 16-17 only (fixed in 18 Preview)
-    // IE/Edge don't wrap IPv6 addresses' hostnames in square brackets
-    // when parsed out of an anchor element.
-    const ipv6InBrackets = urlParsingNode.hostname === "[::1]";
-    if (!ipv6InBrackets && hostname.indexOf(":") > -1) {
-      hostname = `[${hostname}]`;
-    }
+    const hostname = urlParsingNode.hostname.includes(":")
+      ? `[${urlParsingNode.hostname}]`
+      : urlParsingNode.hostname;
 
     return {
       href: urlParsingNode.href,
@@ -3045,7 +3067,7 @@
    * Parse a request URL and determine whether this is a same-origin request as the application
    * document.
    *
-   * @param {string|object} requestUrl The url of the request as a string that will be resolved
+   * @param {import("./interface.js").ResolvableUrl} requestUrl The url of the request as a string that will be resolved
    * or a parsed URL object.
    * @returns {boolean} Whether the request is for the same origin as the application document.
    */
@@ -3059,7 +3081,7 @@
    * Note: The base URL is usually the same as the document location (`location.href`) but can
    * be overriden by using the `<base>` tag.
    *
-   * @param {string|object} requestUrl The url of the request as a string that will be resolved
+   * @param {import("./interface.js").ResolvableUrl} requestUrl The url of the request as a string that will be resolved
    * or a parsed URL object.
    * @returns {boolean} Whether the URL is same-origin as the document base URL.
    */
@@ -3073,7 +3095,7 @@
    *
    * @param {string[]} trustedOriginUrls - A list of URLs (strings), whose origins are trusted.
    *
-   * @returns {Function} - A function that receives a URL (string or parsed URL object) and returns
+   * @returns {(url: import("./interface.js").ResolvableUrl) => boolean } - A function that receives a URL (string or parsed URL object) and returns
    *     whether it is of an allowed origin.
    */
   function urlIsAllowedOriginFactory(trustedOriginUrls) {
@@ -3086,7 +3108,7 @@
      * based on a list of trusted-origin URLs. The current location's origin is implicitly
      * trusted.
      *
-     * @param {string|Object} requestUrl - The URL to be checked (provided as a string that will be
+     * @param {import("./interface.js").ResolvableUrl} requestUrl - The URL to be checked (provided as a string that will be
      *     resolved or a parsed URL object).
      *
      * @returns {boolean} - Whether the specified URL is of an allowed origin.
@@ -3102,9 +3124,9 @@
   /**
    * Determine if two URLs share the same origin.
    *
-   * @param {string|Object} url1 - First URL to compare as a string or a normalized URL in the form of
+   * @param {import("./interface.js").ResolvableUrl} url1 - First URL to compare as a string or a normalized URL in the form of
    *     a dictionary object returned by `urlResolve()`.
-   * @param {string|object} url2 - Second URL to compare as a string or a normalized URL in the form
+   * @param {import("./interface.js").ResolvableUrl} url2 - Second URL to compare as a string or a normalized URL in the form
    *     of a dictionary object returned by `urlResolve()`.
    *
    * @returns {boolean} - True if both URLs have the same origin, and false otherwise.
@@ -3137,7 +3159,17 @@
     return baseUrlParsingNode.href;
   }
 
-  /** @typedef {import("../error-handler.ts").ErrorHandler }  ErrorHandler */
+  /**
+   * Removes a trailing hash ('#') from the given URL if it exists.
+   *
+   * @param {string} url
+   * @returns {string}
+   */
+  function trimEmptyHash(url) {
+    return url.replace(/#$/, "");
+  }
+
+  /** @typedef {import("../exception/interface.ts").Interface }  ErrorHandler */
 
   const $sceMinErr = minErr("$sce");
 
@@ -3193,6 +3225,7 @@
         .replace(/\\\*/g, "[^:/.?&;]*");
       return new RegExp(`^${matcher}$`);
     }
+
     if (isRegExp(matcher)) {
       // The only other type of matcher allowed is a Regexp.
       // Match entire URL / disallow partial matches.
@@ -3454,6 +3487,11 @@
             htmlSanitizer = $injector.get("$sanitize");
           }
 
+          /**
+           * @param {string|RegExp} matcher
+           * @param {import("../../shared/url-utils/interface").ParsedUrl} parsedUrl
+           * @return {boolean}
+           */
           function matchUrl(matcher, parsedUrl) {
             if (matcher === "self") {
               return (
@@ -3461,7 +3499,7 @@
               );
             }
             // definitely a regex.  See adjustMatchers()
-            return !!matcher.exec(parsedUrl.href);
+            return !!(/** @type {RegExp} */ (matcher).exec(parsedUrl.href));
           }
 
           function isResourceUrlAllowedByPolicy(url) {
@@ -3966,9 +4004,13 @@
    * A collection of directives that allows creation of custom event handlers that are defined as
    * AngularTS expressions and are compiled and executed within the current scope.
    */
+
+  /**
+   * @type {Record<string, import("../../interface.js").DirectiveFactory>}
+   */
   const ngEventDirectives = {};
 
-  "click copy cut dblclick focus blur keydown keyup keypress load mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup paste submit touchstart touchend touchmove"
+  "click copy cut dblclick focus blur keydown keyup load mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup paste submit touchstart touchend touchmove"
     .split(" ")
     .forEach((eventName) => {
       const directiveName = directiveNormalize(`ng-${eventName}`);
@@ -3977,7 +4019,7 @@
         "$exceptionHandler",
         /**
          * @param {import("../../core/parse/interface.ts").ParseService} $parse
-         * @param {import('../../core/exception-handler.js').ErrorHandler} $exceptionHandler
+         * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
          * @returns
          */
         ($parse, $exceptionHandler) => {
@@ -3994,7 +4036,7 @@
   /**
    *
    * @param {import("../../core/parse/interface.ts").ParseService} $parse
-   * @param {import('../../core/exception-handler.js').ErrorHandler} $exceptionHandler
+   * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
    * @param {string} directiveName
    * @param {string} eventName
    * @returns {import("../../interface.ts").Directive}
@@ -4035,7 +4077,7 @@
     /**
      * @param {import('../scope/scope.js').Scope} $rootScope
      * @param {*} $animate
-     * @param {import("../exception-handler.js").ErrorHandler} $exceptionHandler
+     * @param {import("../../services/exception/exception-handler.js").ErrorHandler} $exceptionHandler
      * @param {*} $sce
      * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
      * @param {Object} [attributesToCopy]
@@ -4633,7 +4675,7 @@
               "$exceptionHandler",
               /**
                * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
-               * @param {import('../exception-handler.js').ErrorHandler} $exceptionHandler
+               * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
                */
               function ($injector, $exceptionHandler) {
                 const directives = [];
@@ -4961,7 +5003,7 @@
         /**
          * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
          * @param {*} $interpolate
-         * @param {import("../exception-handler.js").ErrorHandler} $exceptionHandler
+         * @param {import("../../services/exception/exception-handler.js").ErrorHandler} $exceptionHandler
          * @param {*} $templateRequest
          * @param {import("../parse/interface.ts").ParseService} $parse
          * @param {*} $controller
@@ -8446,7 +8488,7 @@
 
     /**
      * @param {import('../../core/scope/scope.js').Scope} $scope
-     * @param {import('../../core/exception-handler.js').ErrorHandler} $exceptionHandler
+     * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
      * @param {import('../../core/compile/attributes.js').Attributes} $attr
      * @param {Element} $element
      * @param {import("../../core/parse/interface.ts").ParseService} $parse
@@ -9843,7 +9885,6 @@
       element,
       attr,
       ctrl,
-      $browser,
       $filter,
       $parse,
     ) {
@@ -10120,15 +10161,7 @@
     return (value - stepBase) % step === 0;
   }
 
-  function numberInputType(
-    scope,
-    element,
-    attr,
-    ctrl,
-    $browser,
-    $filter,
-    $parse,
-  ) {
+  function numberInputType(scope, element, attr, ctrl, $filter, $parse) {
     badInputChecker(scope, element, attr, ctrl, "number");
     numberFormatterParser(ctrl);
     baseInputType(scope, element, attr, ctrl);
@@ -10444,15 +10477,7 @@
     return fallback;
   }
 
-  function checkboxInputType(
-    scope,
-    element,
-    attr,
-    ctrl,
-    $browser,
-    $filter,
-    $parse,
-  ) {
+  function checkboxInputType(scope, element, attr, ctrl, $filter, $parse) {
     const trueValue = parseConstantExpr(
       $parse,
       scope,
@@ -10490,30 +10515,25 @@
     ctrl.$parsers.push((value) => (value ? trueValue : falseValue));
   }
 
-  /**
-   * @returns {import('../../interface.ts').Directive}
-   */
-  inputDirective.$inject = ["$browser", "$filter", "$parse"];
+  inputDirective.$inject = ["$filter", "$parse"];
 
   /**
-   * @param {import('../../services/browser').Browser} $browser
    * @param {*} $filter
    * @param {*} $parse
-   * @returns
+   * @returns {import('../../interface.ts').Directive}
    */
-  function inputDirective($browser, $filter, $parse) {
+  function inputDirective($filter, $parse) {
     return {
       restrict: "E",
       require: ["?ngModel"],
       link: {
         pre(scope, element, attr, ctrls) {
           if (ctrls[0]) {
-            (inputType[lowercase(attr.type)] || inputType.text)(
+            (inputType[lowercase(attr["type"])] || inputType.text)(
               scope,
               element,
               attr,
               ctrls[0],
-              $browser,
               $filter,
               $parse,
             );
@@ -11222,9 +11242,15 @@
        * @param {import('../../core/compile/attributes.js').Attributes} attr
        */
       link(scope, element, attr) {
-        scope.$watch(attr["ngBind"], (value) => {
-          element.textContent = stringify$1(isProxy(value) ? value.$target : value);
-        });
+        scope.$watch(
+          attr["ngBind"],
+          (value) => {
+            element.textContent = stringify$1(
+              isProxy(value) ? value.$target : value,
+            );
+          },
+          isDefined(attr["lazy"]),
+        );
       },
     };
   }
@@ -11626,7 +11652,7 @@
    * @param {*} $templateRequest
    * @param {import("../../services/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
    * @param {*} $animate
-   * @param {import('../../core/error-handler.js').ErrorHandler} $exceptionHandler
+   * @param {import('../../services/exception/interface.ts').Interface} $exceptionHandler
    * @returns {import('../../interface.js').Directive}
    */
   function ngIncludeDirective(
@@ -11745,7 +11771,7 @@
   // We need this directive so that the element content is already filled when
   // the link function of another directive on the same element as ngInclude
   // is called.
-  ngIncludeFillContentDirective.$inject = ["$compile"];
+  ngIncludeFillContentDirective.$inject = [$injectTokens.$compile];
 
   /**
    * @param {import("../../core/compile/compile.js").CompileFn} $compile
@@ -11951,7 +11977,7 @@
       transclude: "element",
       priority: 1000,
       terminal: true,
-      compile: (_$element, $attr) => {
+      compile: ($element, $attr) => {
         const expression = $attr["ngRepeat"];
         const hasAnimate = !!$attr["animate"];
 
@@ -11997,6 +12023,14 @@
           );
         }
 
+        const swap = callBackOnce(() => {
+          if (isDefined($attr["lazy"]) && isDefined($attr["swap"])) {
+            document
+              .querySelectorAll($attr["swap"])
+              .forEach((x) => removeElement(x));
+          }
+        });
+
         return function ngRepeatLink($scope, $element, $attr, ctrl, $transclude) {
           // Store a list of elements from previous run. This is a hash where key is the item from the
           // iterator, and the value is objects with following properties.
@@ -12008,174 +12042,181 @@
           // hasOwnProperty.
           let lastBlockMap = Object.create(null);
           // watch props
-          $scope.$watch(rhs, (collection) => {
-            let index,
-              length,
-              previousNode = $element, // node that cloned nodes should be inserted after
-              // initialized to the comment node anchor
-              nextNode;
-            const // Same as lastBlockMap but it has the current state. It will become the
-              // lastBlockMap on the next iteration.
-              nextBlockMap = Object.create(null);
-            let collectionLength,
-              key,
-              value, // key/value of iteration
-              trackById,
-              trackByIdFn,
-              collectionKeys,
-              block, // last object information {scope, element, id}
-              nextBlockOrder,
-              elementsToRemove;
-
-            if (aliasAs) {
-              $scope[aliasAs] = collection;
-            }
-
-            if (isArrayLike(collection)) {
-              collectionKeys = collection;
-              trackByIdFn = trackByIdArrayFn;
-            } else {
-              trackByIdFn = trackByIdObjFn;
-              // if object, extract keys, in enumeration order, unsorted
-              collectionKeys = [];
-              for (const itemKey in collection) {
-                if (hasOwn(collection, itemKey) && itemKey.charAt(0) !== "$") {
-                  collectionKeys.push(itemKey);
-                }
+          $scope.$watch(
+            rhs,
+            (collection) => {
+              swap();
+              let index,
+                length,
+                previousNode = $element, // node that cloned nodes should be inserted after
+                // initialized to the comment node anchor
+                nextNode;
+              const // Same as lastBlockMap but it has the current state. It will become the
+                // lastBlockMap on the next iteration.
+                nextBlockMap = Object.create(null);
+              let collectionLength,
+                key,
+                value, // key/value of iteration
+                trackById,
+                trackByIdFn,
+                collectionKeys,
+                block, // last object information {scope, element, id}
+                nextBlockOrder,
+                elementsToRemove;
+
+              if (aliasAs) {
+                $scope[aliasAs] = collection;
               }
-            }
 
-            collectionLength = collectionKeys.length;
-            nextBlockOrder = new Array(collectionLength);
-
-            // locate existing items
-            for (index = 0; index < collectionLength; index++) {
-              key = collection === collectionKeys ? index : collectionKeys[index];
-              value = collection[key];
-              trackById = trackByIdFn($scope, key, value);
-              if (lastBlockMap[trackById]) {
-                // found previously seen block
-                block = lastBlockMap[trackById];
-                delete lastBlockMap[trackById];
-                nextBlockMap[trackById] = block;
-                nextBlockOrder[index] = block;
-              } else if (nextBlockMap[trackById]) {
-                // if collision detected. restore lastBlockMap and throw an error
-                Object.values(nextBlockOrder).forEach((block) => {
-                  if (block && block.scope) lastBlockMap[block.id] = block;
-                });
-                throw ngRepeatMinErr(
-                  "dupes",
-                  "Duplicates keys in a repeater are not allowed. Repeater: {0}, Duplicate key: {1} for value: {2}",
-                  expression,
-                  trackById,
-                  value,
-                );
+              if (isArrayLike(collection)) {
+                collectionKeys = collection;
+                trackByIdFn = trackByIdArrayFn;
               } else {
-                // new never before seen block
-                nextBlockOrder[index] = {
-                  id: trackById,
-                  scope: undefined,
-                  clone: undefined,
-                };
-                nextBlockMap[trackById] = true;
+                trackByIdFn = trackByIdObjFn;
+                // if object, extract keys, in enumeration order, unsorted
+                collectionKeys = [];
+                for (const itemKey in collection) {
+                  if (hasOwn(collection, itemKey) && itemKey.charAt(0) !== "$") {
+                    collectionKeys.push(itemKey);
+                  }
+                }
               }
-            }
 
-            // remove leftover items
-            for (let blockKey in lastBlockMap) {
-              block = lastBlockMap[blockKey];
-              elementsToRemove = block.clone;
-              if (hasAnimate) {
-                $animate.leave(elementsToRemove);
-              } else {
-                elementsToRemove.remove();
+              collectionLength = collectionKeys.length;
+              nextBlockOrder = new Array(collectionLength);
+
+              // locate existing items
+              for (index = 0; index < collectionLength; index++) {
+                key =
+                  collection === collectionKeys ? index : collectionKeys[index];
+                value = collection[key];
+                trackById = trackByIdFn($scope, key, value);
+                if (lastBlockMap[trackById]) {
+                  // found previously seen block
+                  block = lastBlockMap[trackById];
+                  delete lastBlockMap[trackById];
+                  nextBlockMap[trackById] = block;
+                  nextBlockOrder[index] = block;
+                } else if (nextBlockMap[trackById]) {
+                  // if collision detected. restore lastBlockMap and throw an error
+                  Object.values(nextBlockOrder).forEach((block) => {
+                    if (block && block.scope) lastBlockMap[block.id] = block;
+                  });
+                  throw ngRepeatMinErr(
+                    "dupes",
+                    "Duplicates keys in a repeater are not allowed. Repeater: {0}, Duplicate key: {1} for value: {2}",
+                    expression,
+                    trackById,
+                    value,
+                  );
+                } else {
+                  // new never before seen block
+                  nextBlockOrder[index] = {
+                    id: trackById,
+                    scope: undefined,
+                    clone: undefined,
+                  };
+                  nextBlockMap[trackById] = true;
+                }
               }
-              if (elementsToRemove.parentNode) {
-                // if the element was not removed yet because of pending animation, mark it as deleted
-                // so that we can ignore it later
-                for (
-                  index = 0, length = elementsToRemove.length;
-                  index < length;
-                  index++
-                ) {
-                  elementsToRemove[index][NG_REMOVED] = true;
+
+              // remove leftover items
+              for (let blockKey in lastBlockMap) {
+                block = lastBlockMap[blockKey];
+                elementsToRemove = block.clone;
+                if (hasAnimate) {
+                  $animate.leave(elementsToRemove);
+                } else {
+                  elementsToRemove.remove();
                 }
+                if (elementsToRemove.parentNode) {
+                  // if the element was not removed yet because of pending animation, mark it as deleted
+                  // so that we can ignore it later
+                  for (
+                    index = 0, length = elementsToRemove.length;
+                    index < length;
+                    index++
+                  ) {
+                    elementsToRemove[index][NG_REMOVED] = true;
+                  }
+                }
+                block.scope.$destroy();
               }
-              block.scope.$destroy();
-            }
 
-            for (index = 0; index < collectionLength; index++) {
-              key = collection === collectionKeys ? index : collectionKeys[index];
-              value = collection[key];
-              block = nextBlockOrder[index];
+              for (index = 0; index < collectionLength; index++) {
+                key =
+                  collection === collectionKeys ? index : collectionKeys[index];
+                value = collection[key];
+                block = nextBlockOrder[index];
 
-              if (block.scope) {
-                // if we have already seen this object, then we need to reuse the
-                // associated scope/element
+                if (block.scope) {
+                  // if we have already seen this object, then we need to reuse the
+                  // associated scope/element
 
-                nextNode = previousNode;
+                  nextNode = previousNode;
 
-                // skip nodes that are already pending removal via leave animation
-                do {
-                  nextNode = nextNode.nextSibling;
-                } while (nextNode && nextNode[NG_REMOVED]);
+                  // skip nodes that are already pending removal via leave animation
+                  do {
+                    nextNode = nextNode.nextSibling;
+                  } while (nextNode && nextNode[NG_REMOVED]);
 
-                if (getBlockStart(block) !== nextNode) {
-                  // existing item which got moved
-                  $animate.move(getBlockNodes(block.clone), null, previousNode);
-                }
-                previousNode = getBlockEnd(block);
-                updateScope(
-                  block.scope,
-                  index,
-                  valueIdentifier,
-                  value,
-                  keyIdentifier,
-                  key,
-                  collectionLength,
-                );
-              } else {
-                // new item which we don't know about
-                $transclude(
-                  /**
-                   * Clone attach function
-                   * @param {Array<NodeList>} clone
-                   * @param {import("../../core/scope/scope.js").Scope} scope
-                   */
-
-                  (clone, scope) => {
-                    block.scope = scope;
-                    const endNode = clone;
-                    if (hasAnimate) {
-                      $animate.enter(clone, null, previousNode);
-                    } else {
-                      // @ts-ignore
-                      previousNode.after(clone);
-                    }
+                  if (getBlockStart(block) !== nextNode) {
+                    // existing item which got moved
+                    $animate.move(getBlockNodes(block.clone), null, previousNode);
+                  }
+                  previousNode = getBlockEnd(block);
+                  updateScope(
+                    block.scope,
+                    index,
+                    valueIdentifier,
+                    value,
+                    keyIdentifier,
+                    key,
+                    collectionLength,
+                  );
+                } else {
+                  // new item which we don't know about
+                  $transclude(
+                    /**
+                     * Clone attach function
+                     * @param {Array<NodeList>} clone
+                     * @param {import("../../core/scope/scope.js").Scope} scope
+                     */
 
-                    // @ts-ignore
-                    previousNode = endNode;
-                    // Note: We only need the first/last node of the cloned nodes.
-                    // However, we need to keep the reference to the dom wrapper as it might be changed later
-                    // by a directive with templateUrl when its template arrives.
-                    block.clone = clone;
-                    nextBlockMap[block.id] = block;
-                    updateScope(
-                      block.scope,
-                      index,
-                      valueIdentifier,
-                      value,
-                      keyIdentifier,
-                      key,
-                      collectionLength,
-                    );
-                  },
-                );
+                    (clone, scope) => {
+                      block.scope = scope;
+                      const endNode = clone;
+                      if (hasAnimate) {
+                        $animate.enter(clone, null, previousNode);
+                      } else {
+                        // @ts-ignore
+                        previousNode.after(clone);
+                      }
+
+                      // @ts-ignore
+                      previousNode = endNode;
+                      // Note: We only need the first/last node of the cloned nodes.
+                      // However, we need to keep the reference to the dom wrapper as it might be changed later
+                      // by a directive with templateUrl when its template arrives.
+                      block.clone = clone;
+                      nextBlockMap[block.id] = block;
+                      updateScope(
+                        block.scope,
+                        index,
+                        valueIdentifier,
+                        value,
+                        keyIdentifier,
+                        key,
+                        collectionLength,
+                      );
+                    },
+                  );
+                }
               }
-            }
-            lastBlockMap = nextBlockMap;
-          });
+              lastBlockMap = nextBlockMap;
+            },
+            isDefined($attr["lazy"]),
+          );
         };
       },
     };
@@ -12212,6 +12253,7 @@
   ngSwitchDirective.$inject = ["$animate"];
 
   /**
+   * @param {*} $animate
    * @returns {import('../../interface.ts').Directive}
    */
   function ngSwitchDirective($animate) {
@@ -12359,525 +12401,515 @@
   // 8: collection expression
   // 9: track by expression
 
-  const ngOptionsDirective = [
-    "$compile",
-    "$parse",
+  ngOptionsDirective.$inject = ["$compile", "$parse"];
+  /**
+   *
+   * @param {import("../../core/compile/compile.js").CompileFn} $compile
+   * @param {import("../../core/parse/interface.ts").ParseService} $parse
+   * @returns {import("../../interface.ts").Directive}
+   */
+  function ngOptionsDirective($compile, $parse) {
     /**
-     *
-     * @param {import("../../core/compile/compile.js").CompileFn} $compile
-     * @param {import("../../core/parse/interface.ts").ParseService} $parse
+     * @param {import('../../interface.ts').Expression} optionsExp
+     * @param {HTMLSelectElement} selectElement
+     * @param {import('../../core/scope/scope.js').Scope} scope
      * @returns
      */
-    function ($compile, $parse) {
-      /**
-       * @param {import('../../interface.ts').Expression} optionsExp
-       * @param {HTMLSelectElement} selectElement
-       * @param {import('../../core/scope/scope.js').Scope} scope
-       * @returns
-       */
-      function parseOptionsExpression(optionsExp, selectElement, scope) {
-        const match = optionsExp.match(NG_OPTIONS_REGEXP);
-        if (!match) {
-          throw ngOptionsMinErr(
-            "iexp",
-            "Expected expression in form of " +
-              "'_select_ (as _label_)? for (_key_,)?_value_ in _collection_'" +
-              " but got '{0}'. Element: {1}",
-            optionsExp,
-            startingTag(selectElement),
-          );
-        }
-        // Extract the parts from the ngOptions expression
-
-        // The variable name for the value of the item in the collection
-        const valueName = match[5] || match[7];
-        // The variable name for the key of the item in the collection
-        const keyName = match[6];
-
-        // An expression that generates the viewValue for an option if there is a label expression
-        const selectAs = / as /.test(match[0]) && match[1];
-        // An expression that is used to track the id of each object in the options collection
-        const trackBy = match[9];
-        // An expression that generates the viewValue for an option if there is no label expression
-        const valueFn = $parse(match[2] ? match[1] : valueName);
-        const selectAsFn = selectAs && $parse(selectAs);
-        const viewValueFn = selectAsFn || valueFn;
-        const trackByFn = trackBy && $parse(trackBy);
-
-        // Get the value by which we are going to track the option
-        // if we have a trackFn then use that (passing scope and locals)
-        // otherwise just hash the given viewValue
-        const getTrackByValueFn = trackBy
-          ? function (value, locals) {
-              return trackByFn(scope, locals);
-            }
-          : function getHashOfValue(value) {
-              return hashKey(value);
-            };
-        const getTrackByValue = function (value, key) {
-          return getTrackByValueFn(value, getLocals(value, key));
-        };
+    function parseOptionsExpression(optionsExp, selectElement, scope) {
+      const match = optionsExp.match(NG_OPTIONS_REGEXP);
+      if (!match) {
+        throw ngOptionsMinErr(
+          "iexp",
+          "Expected expression in form of " +
+            "'_select_ (as _label_)? for (_key_,)?_value_ in _collection_'" +
+            " but got '{0}'. Element: {1}",
+          optionsExp,
+          startingTag(selectElement),
+        );
+      }
+      // Extract the parts from the ngOptions expression
+
+      // The variable name for the value of the item in the collection
+      const valueName = match[5] || match[7];
+      // The variable name for the key of the item in the collection
+      const keyName = match[6];
+
+      // An expression that generates the viewValue for an option if there is a label expression
+      const selectAs = / as /.test(match[0]) && match[1];
+      // An expression that is used to track the id of each object in the options collection
+      const trackBy = match[9];
+      // An expression that generates the viewValue for an option if there is no label expression
+      const valueFn = $parse(match[2] ? match[1] : valueName);
+      const selectAsFn = selectAs && $parse(selectAs);
+      const viewValueFn = selectAsFn || valueFn;
+      const trackByFn = trackBy && $parse(trackBy);
+
+      // Get the value by which we are going to track the option
+      // if we have a trackFn then use that (passing scope and locals)
+      // otherwise just hash the given viewValue
+      const getTrackByValueFn = trackBy
+        ? function (value, locals) {
+            return trackByFn(scope, locals);
+          }
+        : function getHashOfValue(value) {
+            return hashKey(value);
+          };
+      const getTrackByValue = function (value, key) {
+        return getTrackByValueFn(value, getLocals(value, key));
+      };
 
-        const displayFn = $parse(match[2] || match[1]);
-        const groupByFn = $parse(match[3] || "");
-        const disableWhenFn = $parse(match[4] || "");
-        const valuesFn = $parse(match[8]);
-
-        const locals = {};
-        let getLocals = keyName
-          ? function (value, key) {
-              locals[keyName] = key;
-              locals[valueName] = value;
-              return locals;
-            }
-          : function (value) {
-              locals[valueName] = value;
-              return locals;
-            };
+      const displayFn = $parse(match[2] || match[1]);
+      const groupByFn = $parse(match[3] || "");
+      const disableWhenFn = $parse(match[4] || "");
+      const valuesFn = $parse(match[8]);
+
+      const locals = {};
+      let getLocals = keyName
+        ? function (value, key) {
+            locals[keyName] = key;
+            locals[valueName] = value;
+            return locals;
+          }
+        : function (value) {
+            locals[valueName] = value;
+            return locals;
+          };
 
-        class Option {
-          constructor(selectValue, viewValue, label, group, disabled) {
-            this.selectValue = selectValue;
-            this.viewValue = viewValue;
-            this.label = label;
-            this.group = group;
-            this.disabled = disabled;
-          }
+      class Option {
+        constructor(selectValue, viewValue, label, group, disabled) {
+          this.selectValue = selectValue;
+          this.viewValue = viewValue;
+          this.label = label;
+          this.group = group;
+          this.disabled = disabled;
         }
+      }
 
-        function getOptionValuesKeys(optionValues) {
-          let optionValuesKeys;
+      function getOptionValuesKeys(optionValues) {
+        let optionValuesKeys;
 
-          if (!keyName && isArrayLike(optionValues)) {
-            optionValuesKeys = optionValues;
-          } else {
-            // if object, extract keys, in enumeration order, unsorted
-            optionValuesKeys = [];
-            for (const itemKey in optionValues) {
-              if (hasOwn(optionValues, itemKey) && itemKey.charAt(0) !== "$") {
-                optionValuesKeys.push(itemKey);
-              }
+        if (!keyName && isArrayLike(optionValues)) {
+          optionValuesKeys = optionValues;
+        } else {
+          // if object, extract keys, in enumeration order, unsorted
+          optionValuesKeys = [];
+          for (const itemKey in optionValues) {
+            if (hasOwn(optionValues, itemKey) && itemKey.charAt(0) !== "$") {
+              optionValuesKeys.push(itemKey);
             }
           }
-          return optionValuesKeys;
         }
+        return optionValuesKeys;
+      }
 
-        return {
-          trackBy,
-          getTrackByValue,
-          getWatchables: $parse(valuesFn, (optionValues) => {
-            // Create a collection of things that we would like to watch (watchedArray)
-            // so that they can all be watched using a single $watchCollection
-            // that only runs the handler once if anything changes
-            const watchedArray = [];
-            optionValues = optionValues || [];
-
-            const optionValuesKeys = getOptionValuesKeys(optionValues);
-            const optionValuesLength = optionValuesKeys.length;
-            for (let index = 0; index < optionValuesLength; index++) {
-              const key =
-                optionValues === optionValuesKeys
-                  ? index
-                  : optionValuesKeys[index];
-              const value = optionValues[key];
-
-              const locals = getLocals(value, key);
-              const selectValue = getTrackByValueFn(value, locals);
-              watchedArray.push(selectValue);
-
-              // Only need to watch the displayFn if there is a specific label expression
-              if (match[2] || match[1]) {
-                const label = displayFn(scope, locals);
-                watchedArray.push(label);
-              }
-
-              // Only need to watch the disableWhenFn if there is a specific disable expression
-              if (match[4]) {
-                const disableWhen = disableWhenFn(scope, locals);
-                watchedArray.push(disableWhen);
-              }
-            }
-            return watchedArray;
-          }),
-
-          getOptions() {
-            /** @type {Option[]} */
-            const optionItems = [];
-            /** @type {Object.<string, Option>} */
-            const selectValueMap = {};
-
-            // The option values were already computed in the `getWatchables` fn,
-            // which must have been called to trigger `getOptions`
-            const optionValues = valuesFn(scope) || [];
-            const optionValuesKeys = getOptionValuesKeys(optionValues);
-            const optionValuesLength = optionValuesKeys.length;
-
-            for (let index = 0; index < optionValuesLength; index++) {
-              const key =
-                optionValues === optionValuesKeys
-                  ? index
-                  : optionValuesKeys[index];
-              const value = optionValues[key];
-              const locals = getLocals(value, key);
-              const viewValue = viewValueFn(scope, locals);
-              const selectValue = getTrackByValueFn(viewValue, locals);
+      return {
+        trackBy,
+        getTrackByValue,
+        getWatchables: $parse(valuesFn, (optionValues) => {
+          // Create a collection of things that we would like to watch (watchedArray)
+          // so that they can all be watched using a single $watchCollection
+          // that only runs the handler once if anything changes
+          const watchedArray = [];
+          optionValues = optionValues || [];
+
+          const optionValuesKeys = getOptionValuesKeys(optionValues);
+          const optionValuesLength = optionValuesKeys.length;
+          for (let index = 0; index < optionValuesLength; index++) {
+            const key =
+              optionValues === optionValuesKeys ? index : optionValuesKeys[index];
+            const value = optionValues[key];
+
+            const locals = getLocals(value, key);
+            const selectValue = getTrackByValueFn(value, locals);
+            watchedArray.push(selectValue);
+
+            // Only need to watch the displayFn if there is a specific label expression
+            if (match[2] || match[1]) {
               const label = displayFn(scope, locals);
-              const group = groupByFn(scope, locals);
-              const disabled = disableWhenFn(scope, locals);
-              const optionItem = new Option(
-                selectValue,
-                viewValue,
-                label,
-                group,
-                disabled,
-              );
+              watchedArray.push(label);
+            }
+
+            // Only need to watch the disableWhenFn if there is a specific disable expression
+            if (match[4]) {
+              const disableWhen = disableWhenFn(scope, locals);
+              watchedArray.push(disableWhen);
+            }
+          }
+          return watchedArray;
+        }),
+
+        getOptions() {
+          /** @type {Option[]} */
+          const optionItems = [];
+          /** @type {Object.<string, Option>} */
+          const selectValueMap = {};
+
+          // The option values were already computed in the `getWatchables` fn,
+          // which must have been called to trigger `getOptions`
+          const optionValues = valuesFn(scope) || [];
+          const optionValuesKeys = getOptionValuesKeys(optionValues);
+          const optionValuesLength = optionValuesKeys.length;
+
+          for (let index = 0; index < optionValuesLength; index++) {
+            const key =
+              optionValues === optionValuesKeys ? index : optionValuesKeys[index];
+            const value = optionValues[key];
+            const locals = getLocals(value, key);
+            const viewValue = viewValueFn(scope, locals);
+            const selectValue = getTrackByValueFn(viewValue, locals);
+            const label = displayFn(scope, locals);
+            const group = groupByFn(scope, locals);
+            const disabled = disableWhenFn(scope, locals);
+            const optionItem = new Option(
+              selectValue,
+              viewValue,
+              label,
+              group,
+              disabled,
+            );
 
-              optionItems.push(optionItem);
-              selectValueMap[selectValue] = optionItem;
-            }
+            optionItems.push(optionItem);
+            selectValueMap[selectValue] = optionItem;
+          }
 
-            return {
-              items: optionItems,
-              selectValueMap,
-              getOptionFromViewValue(value) {
-                return selectValueMap[getTrackByValue(value)];
-              },
-              getViewValueFromOption(option) {
-                // If the viewValue could be an object that may be mutated by the application,
-                // we need to make a copy and not return the reference to the value on the option.
-                return trackBy
-                  ? structuredClone(option.viewValue)
-                  : option.viewValue;
-              },
-            };
-          },
-        };
-      }
+          return {
+            items: optionItems,
+            selectValueMap,
+            getOptionFromViewValue(value) {
+              return selectValueMap[getTrackByValue(value)];
+            },
+            getViewValueFromOption(option) {
+              // If the viewValue could be an object that may be mutated by the application,
+              // we need to make a copy and not return the reference to the value on the option.
+              return trackBy
+                ? structuredClone(option.viewValue)
+                : option.viewValue;
+            },
+          };
+        },
+      };
+    }
 
-      /**
-       *
-       * @param {import("../../core/scope/scope.js").Scope} scope
-       * @param {HTMLSelectElement} selectElement
-       * @param {import("../../core/compile/attributes.js").Attributes} attr
-       * @param {*} ctrls
-       */
-      function ngOptionsPostLink(scope, selectElement, attr, ctrls) {
-        const selectCtrl = ctrls[0];
-        const ngModelCtrl = ctrls[1];
-        const multiple = attr["multiple"];
-
-        // The emptyOption allows the application developer to provide their own custom "empty"
-        // option when the viewValue does not match any of the option values.
-        for (
-          let i = 0, children = selectElement.childNodes, ii = children.length;
-          i < ii;
-          i++
-        ) {
-          if (/** @type {HTMLOptionElement} */ (children[i]).value === "") {
-            selectCtrl.hasEmptyOption = true;
-            selectCtrl.emptyOption = children[i];
-            break;
-          }
+    /**
+     *
+     * @param {import("../../core/scope/scope.js").Scope} scope
+     * @param {HTMLSelectElement} selectElement
+     * @param {import("../../core/compile/attributes.js").Attributes} attr
+     * @param {*} ctrls
+     */
+    function ngOptionsPostLink(scope, selectElement, attr, ctrls) {
+      const selectCtrl = ctrls[0];
+      const ngModelCtrl = ctrls[1];
+      const multiple = attr["multiple"];
+
+      // The emptyOption allows the application developer to provide their own custom "empty"
+      // option when the viewValue does not match any of the option values.
+      for (
+        let i = 0, children = selectElement.childNodes, ii = children.length;
+        i < ii;
+        i++
+      ) {
+        if (/** @type {HTMLOptionElement} */ (children[i]).value === "") {
+          selectCtrl.hasEmptyOption = true;
+          selectCtrl.emptyOption = children[i];
+          break;
         }
+      }
 
-        // The empty option will be compiled and rendered before we first generate the options
-        emptyElement(selectElement);
+      // The empty option will be compiled and rendered before we first generate the options
+      emptyElement(selectElement);
 
-        const providedEmptyOption = !!selectCtrl.emptyOption;
+      const providedEmptyOption = !!selectCtrl.emptyOption;
 
-        const unknownOption = optionTemplate.cloneNode(false);
-        // TODO double check
-        unknownOption.nodeValue = "?";
+      const unknownOption = optionTemplate.cloneNode(false);
+      // TODO double check
+      unknownOption.nodeValue = "?";
 
-        let options;
-        const ngOptions = parseOptionsExpression(
-          attr["ngOptions"],
-          selectElement,
-          scope,
-        );
-        // This stores the newly created options before they are appended to the select.
-        // Since the contents are removed from the fragment when it is appended,
-        // we only need to create it once.
-        const listFragment = document.createDocumentFragment();
-
-        // Overwrite the implementation. ngOptions doesn't use hashes
-        selectCtrl.generateUnknownOptionValue = () => "?";
-
-        // Update the controller methods for multiple selectable options
-        if (!multiple) {
-          selectCtrl.writeValue = function writeNgOptionsValue(value) {
-            // The options might not be defined yet when ngModel tries to render
-            if (!options) return;
-
-            const selectedOption =
-              selectElement.options[selectElement.selectedIndex];
-            const option = options.getOptionFromViewValue(value);
-
-            // Make sure to remove the selected attribute from the previously selected option
-            // Otherwise, screen readers might get confused
-            if (selectedOption) selectedOption.removeAttribute("selected");
-
-            if (option) {
-              // Don't update the option when it is already selected.
-              // For example, the browser will select the first option by default. In that case,
-              // most properties are set automatically - except the `selected` attribute, which we
-              // set always
-
-              if (selectElement.value !== option.selectValue) {
-                selectCtrl.removeUnknownOption();
-
-                selectElement.value = option.selectValue;
-                option.element.selected = true;
-              }
+      let options;
+      const ngOptions = parseOptionsExpression(
+        attr["ngOptions"],
+        selectElement,
+        scope,
+      );
+      // This stores the newly created options before they are appended to the select.
+      // Since the contents are removed from the fragment when it is appended,
+      // we only need to create it once.
+      const listFragment = document.createDocumentFragment();
+
+      // Overwrite the implementation. ngOptions doesn't use hashes
+      selectCtrl.generateUnknownOptionValue = () => "?";
+
+      // Update the controller methods for multiple selectable options
+      if (!multiple) {
+        selectCtrl.writeValue = function writeNgOptionsValue(value) {
+          // The options might not be defined yet when ngModel tries to render
+          if (!options) return;
+
+          const selectedOption =
+            selectElement.options[selectElement.selectedIndex];
+          const option = options.getOptionFromViewValue(value);
+
+          // Make sure to remove the selected attribute from the previously selected option
+          // Otherwise, screen readers might get confused
+          if (selectedOption) selectedOption.removeAttribute("selected");
+
+          if (option) {
+            // Don't update the option when it is already selected.
+            // For example, the browser will select the first option by default. In that case,
+            // most properties are set automatically - except the `selected` attribute, which we
+            // set always
+
+            if (selectElement.value !== option.selectValue) {
+              selectCtrl.removeUnknownOption();
 
-              option.element.setAttribute("selected", "selected");
-            } else {
-              selectCtrl.selectUnknownOrEmptyOption(value);
+              selectElement.value = option.selectValue;
+              option.element.selected = true;
             }
-          };
 
-          selectCtrl.readValue = function readNgOptionsValue() {
-            const selectedOption = options.selectValueMap[selectElement.value];
+            option.element.setAttribute("selected", "selected");
+          } else {
+            selectCtrl.selectUnknownOrEmptyOption(value);
+          }
+        };
 
-            if (selectedOption && !selectedOption.disabled) {
-              selectCtrl.unselectEmptyOption();
-              selectCtrl.removeUnknownOption();
-              return options.getViewValueFromOption(selectedOption);
-            }
-            return null;
-          };
+        selectCtrl.readValue = function readNgOptionsValue() {
+          const selectedOption = options.selectValueMap[selectElement.value];
 
-          // If we are using `track by` then we must watch the tracked value on the model
-          // since ngModel only watches for object identity change
-          // FIXME: When a user selects an option, this watch will fire needlessly
-          if (ngOptions.trackBy) {
-            scope.$watch(
-              ngOptions.getTrackByValue(ngModelCtrl.$viewValue),
-              () => {
-                ngModelCtrl.$render();
-              },
-            );
+          if (selectedOption && !selectedOption.disabled) {
+            selectCtrl.unselectEmptyOption();
+            selectCtrl.removeUnknownOption();
+            return options.getViewValueFromOption(selectedOption);
           }
-        } else {
-          selectCtrl.writeValue = function writeNgOptionsMultiple(values) {
-            // The options might not be defined yet when ngModel tries to render
-            if (!options) return;
-
-            // Only set `<option>.selected` if necessary, in order to prevent some browsers from
-            // scrolling to `<option>` elements that are outside the `<select>` element's viewport.
-            const selectedOptions =
-              (values && values.map(getAndUpdateSelectedOption)) || [];
-
-            options.items.forEach((option) => {
-              if (option.element.selected && !includes(selectedOptions, option)) {
-                option.element.selected = false;
-              }
-            });
-          };
+          return null;
+        };
 
-          selectCtrl.readValue = function readNgOptionsMultiple() {
-            const selectedValues = selectElement.value || [];
-            const selections = [];
-            // @ts-ignore
-            selectedValues.forEach((value) => {
-              const option = options.selectValueMap[value];
-              if (option && !option.disabled)
-                selections.push(options.getViewValueFromOption(option));
-            });
+        // If we are using `track by` then we must watch the tracked value on the model
+        // since ngModel only watches for object identity change
+        // FIXME: When a user selects an option, this watch will fire needlessly
+        if (ngOptions.trackBy) {
+          scope.$watch(ngOptions.getTrackByValue(ngModelCtrl.$viewValue), () => {
+            ngModelCtrl.$render();
+          });
+        }
+      } else {
+        selectCtrl.writeValue = function writeNgOptionsMultiple(values) {
+          // The options might not be defined yet when ngModel tries to render
+          if (!options) return;
 
-            return selections;
-          };
+          // Only set `<option>.selected` if necessary, in order to prevent some browsers from
+          // scrolling to `<option>` elements that are outside the `<select>` element's viewport.
+          const selectedOptions =
+            (values && values.map(getAndUpdateSelectedOption)) || [];
 
-          // If we are using `track by` then we must watch these tracked values on the model
-          // since ngModel only watches for object identity change
-          // if (ngOptions.trackBy) {
-          //   scope.$watchCollection(
-          //     () => {
-          //       if (Array.isArray(ngModelCtrl.$viewValue)) {
-          //         return ngModelCtrl.$viewValue.map((value) =>
-          //           ngOptions.getTrackByValue(value),
-          //         );
-          //       }
-          //     },
-          //     () => {
-          //       ngModelCtrl.$render();
-          //     },
-          //   );
-          // }
-        }
+          options.items.forEach((option) => {
+            if (option.element.selected && !includes(selectedOptions, option)) {
+              option.element.selected = false;
+            }
+          });
+        };
 
-        if (providedEmptyOption) {
-          // compile the element since there might be bindings in it
-          const linkFn = $compile(selectCtrl.emptyOption);
-          assertArg$1(linkFn, "LinkFn required");
-          selectElement.prepend(selectCtrl.emptyOption);
-          linkFn(scope);
+        selectCtrl.readValue = function readNgOptionsMultiple() {
+          const selectedValues = selectElement.value || [];
+          const selections = [];
+          // @ts-ignore
+          selectedValues.forEach((value) => {
+            const option = options.selectValueMap[value];
+            if (option && !option.disabled)
+              selections.push(options.getViewValueFromOption(option));
+          });
+
+          return selections;
+        };
 
-          if (selectCtrl.emptyOption.nodeType === Node.COMMENT_NODE) {
-            // This means the empty option has currently no actual DOM node, probably because
-            // it has been modified by a transclusion directive.
-            selectCtrl.hasEmptyOption = false;
+        // If we are using `track by` then we must watch these tracked values on the model
+        // since ngModel only watches for object identity change
+        // if (ngOptions.trackBy) {
+        //   scope.$watchCollection(
+        //     () => {
+        //       if (Array.isArray(ngModelCtrl.$viewValue)) {
+        //         return ngModelCtrl.$viewValue.map((value) =>
+        //           ngOptions.getTrackByValue(value),
+        //         );
+        //       }
+        //     },
+        //     () => {
+        //       ngModelCtrl.$render();
+        //     },
+        //   );
+        // }
+      }
 
-            // Redefine the registerOption function, which will catch
-            // options that are added by ngIf etc. (rendering of the node is async because of
-            // lazy transclusion)
-            selectCtrl.registerOption = function (optionScope, optionEl) {
-              if (optionEl.value === "") {
-                selectCtrl.hasEmptyOption = true;
-                selectCtrl.emptyOption = optionEl;
-                // This ensures the new empty option is selected if previously no option was selected
-                ngModelCtrl.$render();
+      if (providedEmptyOption) {
+        // compile the element since there might be bindings in it
+        const linkFn = $compile(selectCtrl.emptyOption);
+        assertArg$1(linkFn, "LinkFn required");
+        selectElement.prepend(selectCtrl.emptyOption);
+        linkFn(scope);
+
+        if (selectCtrl.emptyOption.nodeType === Node.COMMENT_NODE) {
+          // This means the empty option has currently no actual DOM node, probably because
+          // it has been modified by a transclusion directive.
+          selectCtrl.hasEmptyOption = false;
+
+          // Redefine the registerOption function, which will catch
+          // options that are added by ngIf etc. (rendering of the node is async because of
+          // lazy transclusion)
+          selectCtrl.registerOption = function (optionScope, optionEl) {
+            if (optionEl.value === "") {
+              selectCtrl.hasEmptyOption = true;
+              selectCtrl.emptyOption = optionEl;
+              // This ensures the new empty option is selected if previously no option was selected
+              ngModelCtrl.$render();
 
-                optionEl.addEventListener("$destroy", () => {
-                  const needsRerender = selectCtrl.$isEmptyOptionSelected();
+              optionEl.addEventListener("$destroy", () => {
+                const needsRerender = selectCtrl.$isEmptyOptionSelected();
 
-                  selectCtrl.hasEmptyOption = false;
-                  selectCtrl.emptyOption = undefined;
+                selectCtrl.hasEmptyOption = false;
+                selectCtrl.emptyOption = undefined;
 
-                  if (needsRerender) ngModelCtrl.$render();
-                });
-              }
-            };
-          }
+                if (needsRerender) ngModelCtrl.$render();
+              });
+            }
+          };
         }
+      }
 
-        // We will re-render the option elements if the option values or labels change
+      // We will re-render the option elements if the option values or labels change
 
-        // let watchables = ngOptions.getWatchables();
-        // watchables.forEach((i) => {
-        //   scope.$watch(i, updateOptions);
-        // });
-        scope.$watch(
-          ngOptions.getWatchables.decoratedNode.body[0].expression.name,
-          updateOptions,
-        );
+      // let watchables = ngOptions.getWatchables();
+      // watchables.forEach((i) => {
+      //   scope.$watch(i, updateOptions);
+      // });
+      scope.$watch(
+        ngOptions.getWatchables.decoratedNode.body[0].expression.name,
+        updateOptions,
+      );
 
-        // ------------------------------------------------------------------ //
+      // ------------------------------------------------------------------ //
 
-        function addOptionElement(option, parent) {
-          /**
-           * @type {HTMLOptionElement}
-           */
-          const optionElement = /** @type {HTMLOptionElement} */ (
-            optionTemplate.cloneNode(false)
-          );
-          parent.appendChild(optionElement);
-          updateOptionElement(option, optionElement);
-        }
+      function addOptionElement(option, parent) {
+        /**
+         * @type {HTMLOptionElement}
+         */
+        const optionElement = /** @type {HTMLOptionElement} */ (
+          optionTemplate.cloneNode(false)
+        );
+        parent.appendChild(optionElement);
+        updateOptionElement(option, optionElement);
+      }
 
-        function getAndUpdateSelectedOption(viewValue) {
-          const option = options.getOptionFromViewValue(viewValue);
-          const element = option && option.element;
+      function getAndUpdateSelectedOption(viewValue) {
+        const option = options.getOptionFromViewValue(viewValue);
+        const element = option && option.element;
 
-          if (element && !element.selected) element.selected = true;
+        if (element && !element.selected) element.selected = true;
 
-          return option;
-        }
+        return option;
+      }
 
-        function updateOptionElement(option, element) {
-          option.element = element;
-          element.disabled = option.disabled;
-          // Support: IE 11 only, Edge 12-13 only
-          // NOTE: The label must be set before the value, otherwise IE 11 & Edge create unresponsive
-          // selects in certain circumstances when multiple selects are next to each other and display
-          // the option list in listbox style, i.e. the select is [multiple], or specifies a [size].
-          // See https://github.com/angular/angular.js/issues/11314 for more info.
-          // This is unfortunately untestable with unit / e2e tests
-          if (option.label !== element.label) {
-            element.label = option.label;
-            element.textContent = option.label;
-          }
-          element.value = option.selectValue;
+      function updateOptionElement(option, element) {
+        option.element = element;
+        element.disabled = option.disabled;
+        // Support: IE 11 only, Edge 12-13 only
+        // NOTE: The label must be set before the value, otherwise IE 11 & Edge create unresponsive
+        // selects in certain circumstances when multiple selects are next to each other and display
+        // the option list in listbox style, i.e. the select is [multiple], or specifies a [size].
+        // See https://github.com/angular/angular.js/issues/11314 for more info.
+        // This is unfortunately untestable with unit / e2e tests
+        if (option.label !== element.label) {
+          element.label = option.label;
+          element.textContent = option.label;
         }
+        element.value = option.selectValue;
+      }
 
-        function updateOptions() {
-          const previousValue = options && selectCtrl.readValue();
+      function updateOptions() {
+        const previousValue = options && selectCtrl.readValue();
 
-          // We must remove all current options, but cannot simply set innerHTML = null
-          // since the providedEmptyOption might have an ngIf on it that inserts comments which we
-          // must preserve.
-          // Instead, iterate over the current option elements and remove them or their optgroup
-          // parents
-          if (options) {
-            for (let i = options.items.length - 1; i >= 0; i--) {
-              const option = options.items[i];
-              if (isDefined(option.group)) {
-                removeElement(option.element.parentNode);
-              } else {
-                removeElement(option.element);
-              }
+        // We must remove all current options, but cannot simply set innerHTML = null
+        // since the providedEmptyOption might have an ngIf on it that inserts comments which we
+        // must preserve.
+        // Instead, iterate over the current option elements and remove them or their optgroup
+        // parents
+        if (options) {
+          for (let i = options.items.length - 1; i >= 0; i--) {
+            const option = options.items[i];
+            if (isDefined(option.group)) {
+              removeElement(option.element.parentNode);
+            } else {
+              removeElement(option.element);
             }
           }
+        }
 
-          options = ngOptions.getOptions();
+        options = ngOptions.getOptions();
 
-          const groupElementMap = {};
+        const groupElementMap = {};
 
-          options.items.forEach((option) => {
-            let groupElement;
+        options.items.forEach((option) => {
+          let groupElement;
 
-            if (isDefined(option.group)) {
-              // This option is to live in a group
-              // See if we have already created this group
-              groupElement = groupElementMap[option.group];
-
-              if (!groupElement) {
-                groupElement = optGroupTemplate.cloneNode(false);
-                listFragment.appendChild(groupElement);
-
-                // Update the label on the group element
-                // "null" is special cased because of Safari
-                /** @type {HTMLOptGroupElement} */
-                (groupElement).label =
-                  option.group === null ? "null" : option.group;
-
-                // Store it for use later
-                groupElementMap[option.group] = groupElement;
-              }
+          if (isDefined(option.group)) {
+            // This option is to live in a group
+            // See if we have already created this group
+            groupElement = groupElementMap[option.group];
 
-              addOptionElement(option, groupElement);
-            } else {
-              // This option is not in a group
-              addOptionElement(option, listFragment);
+            if (!groupElement) {
+              groupElement = optGroupTemplate.cloneNode(false);
+              listFragment.appendChild(groupElement);
+
+              // Update the label on the group element
+              // "null" is special cased because of Safari
+              /** @type {HTMLOptGroupElement} */
+              (groupElement).label =
+                option.group === null ? "null" : option.group;
+
+              // Store it for use later
+              groupElementMap[option.group] = groupElement;
             }
-          });
 
-          selectElement.appendChild(listFragment);
+            addOptionElement(option, groupElement);
+          } else {
+            // This option is not in a group
+            addOptionElement(option, listFragment);
+          }
+        });
 
-          ngModelCtrl.$render();
+        selectElement.appendChild(listFragment);
 
-          // Check to see if the value has changed due to the update to the options
-          if (!ngModelCtrl.$isEmpty(previousValue)) {
-            const nextValue = selectCtrl.readValue();
-            const isNotPrimitive = ngOptions.trackBy || multiple;
-            if (
-              isNotPrimitive
-                ? !equals$1(previousValue, nextValue)
-                : previousValue !== nextValue
-            ) {
-              ngModelCtrl.$setViewValue(nextValue);
-              ngModelCtrl.$render();
-            }
+        ngModelCtrl.$render();
+
+        // Check to see if the value has changed due to the update to the options
+        if (!ngModelCtrl.$isEmpty(previousValue)) {
+          const nextValue = selectCtrl.readValue();
+          const isNotPrimitive = ngOptions.trackBy || multiple;
+          if (
+            isNotPrimitive
+              ? !equals$1(previousValue, nextValue)
+              : previousValue !== nextValue
+          ) {
+            ngModelCtrl.$setViewValue(nextValue);
+            ngModelCtrl.$render();
           }
         }
       }
+    }
 
-      return {
-        restrict: "A",
-        terminal: true,
-        require: ["select", "ngModel"],
-        link: {
-          pre: function ngOptionsPreLink(scope, selectElement, attr, ctrls) {
-            // Deactivate the SelectController.register method to prevent
-            // option directives from accidentally registering themselves
-            // (and unwanted $destroy handlers etc.)
-            ctrls[0].registerOption = () => {};
-          },
-          post: ngOptionsPostLink,
+    return {
+      restrict: "A",
+      terminal: true,
+      require: ["select", "ngModel"],
+      link: {
+        pre: function ngOptionsPreLink(scope, selectElement, attr, ctrls) {
+          // Deactivate the SelectController.register method to prevent
+          // option directives from accidentally registering themselves
+          // (and unwanted $destroy handlers etc.)
+          ctrls[0].registerOption = () => {};
         },
-      };
-    },
-  ];
+        post: ngOptionsPostLink,
+      },
+    };
+  }
 
   /**
    * Directive that marks the insertion point for the transcluded DOM of the nearest parent directive that uses transclusion.
@@ -12896,113 +12928,114 @@
    *                                               or its value is the same as the name of the attribute then the default slot is used.
    */
   const ngTranscludeMinErr = minErr("ngTransclude");
-  const ngTranscludeDirective = [
-    "$compile",
 
-    /**
-     * @param {import("../../core/compile/compile.js").CompileFn} $compile
-     * @returns {import("../../interface.ts").Directive}
-     */
-    function ($compile) {
-      return {
-        compile: function ngTranscludeCompile(tElement) {
-          // Remove and cache any original content to act as a fallback
-          const fallbackLinkFn = $compile(tElement.childNodes);
-          emptyElement(tElement);
+  ngTranscludeDirective.$inject = ["$compile"];
+  /**
+   * @param {import("../../core/compile/compile.js").CompileFn} $compile
+   * @returns {import("../../interface.ts").Directive}
+   */
+  function ngTranscludeDirective($compile) {
+    return {
+      compile: function ngTranscludeCompile(tElement) {
+        // Remove and cache any original content to act as a fallback
+        const fallbackLinkFn = $compile(tElement.childNodes);
+        emptyElement(tElement);
 
-          /**
-           *
-           * @param {import("../../core/scope/scope.js").Scope} $scope
-           * @param {Element} $element
-           * @param {import("../../core/compile/attributes.js").Attributes} $attrs
-           * @param {*} _controller
-           * @param {*} $transclude
-           */
-          function ngTranscludePostLink(
-            $scope,
-            $element,
-            $attrs,
-            _controller,
-            $transclude,
-          ) {
-            if (!$transclude) {
-              throw ngTranscludeMinErr(
-                "orphan",
-                "Illegal use of ngTransclude directive in the template! " +
-                  "No parent directive that requires a transclusion found. " +
-                  "Element: {0}",
-                startingTag($element),
-              );
-            }
+        /**
+         *
+         * @param {import("../../core/scope/scope.js").Scope} $scope
+         * @param {Element} $element
+         * @param {import("../../core/compile/attributes.js").Attributes} $attrs
+         * @param {*} _controller
+         * @param {*} $transclude
+         */
+        function ngTranscludePostLink(
+          $scope,
+          $element,
+          $attrs,
+          _controller,
+          $transclude,
+        ) {
+          if (!$transclude) {
+            throw ngTranscludeMinErr(
+              "orphan",
+              "Illegal use of ngTransclude directive in the template! " +
+                "No parent directive that requires a transclusion found. " +
+                "Element: {0}",
+              startingTag($element),
+            );
+          }
 
-            // If the attribute is of the form: `ng-transclude="ng-transclude"` then treat it like the default
-            if ($attrs["ngTransclude"] === $attrs.$attr.ngTransclude) {
-              $attrs["ngTransclude"] = "";
-            }
-            const slotName = $attrs["ngTransclude"] || $attrs["ngTranscludeSlot"];
+          // If the attribute is of the form: `ng-transclude="ng-transclude"` then treat it like the default
+          if ($attrs["ngTransclude"] === $attrs.$attr.ngTransclude) {
+            $attrs["ngTransclude"] = "";
+          }
+          const slotName = $attrs["ngTransclude"] || $attrs["ngTranscludeSlot"];
 
-            // If the slot is required and no transclusion content is provided then this call will throw an error
-            $transclude(ngTranscludeCloneAttachFn, null, slotName);
+          // If the slot is required and no transclusion content is provided then this call will throw an error
+          $transclude(ngTranscludeCloneAttachFn, null, slotName);
 
-            // If the slot is optional and no transclusion content is provided then use the fallback content
-            if (slotName && !$transclude.isSlotFilled(slotName)) {
-              useFallbackContent();
-            }
+          // If the slot is optional and no transclusion content is provided then use the fallback content
+          if (slotName && !$transclude.isSlotFilled(slotName)) {
+            useFallbackContent();
+          }
 
-            /**
-             * @param {NodeList | Node} clone
-             * @param {import("../../core/scope/scope.js").Scope} transcludedScope
-             */
-            function ngTranscludeCloneAttachFn(clone, transcludedScope) {
-              if (notWhitespace(clone)) {
-                if (clone instanceof NodeList) {
-                  Array.from(clone).forEach((el) => {
-                    $element.append(el);
-                  });
-                } else {
-                  $element.append(/** @type {Node} */ (clone));
-                }
+          /**
+           * @param {NodeList | Node} clone
+           * @param {import("../../core/scope/scope.js").Scope} transcludedScope
+           */
+          function ngTranscludeCloneAttachFn(clone, transcludedScope) {
+            if (notWhitespace(clone)) {
+              if (clone instanceof NodeList) {
+                Array.from(clone).forEach((el) => {
+                  $element.append(el);
+                });
               } else {
-                useFallbackContent();
-                // There is nothing linked against the transcluded scope since no content was available,
-                // so it should be safe to clean up the generated scope.
-                transcludedScope.$destroy();
+                $element.append(/** @type {Node} */ (clone));
               }
+            } else {
+              useFallbackContent();
+              // There is nothing linked against the transcluded scope since no content was available,
+              // so it should be safe to clean up the generated scope.
+              transcludedScope.$destroy();
             }
+          }
 
-            function useFallbackContent() {
-              // Since this is the fallback content rather than the transcluded content,
-              // we link against the scope of this directive rather than the transcluded scope
-              fallbackLinkFn(
-                $scope,
+          function useFallbackContent() {
+            // Since this is the fallback content rather than the transcluded content,
+            // we link against the scope of this directive rather than the transcluded scope
+            fallbackLinkFn(
+              $scope,
 
-                (clone) => {
-                  // @ts-ignore
-                  $element.append(clone);
-                },
-              );
-            }
+              (clone) => {
+                // @ts-ignore
+                $element.append(clone);
+              },
+            );
+          }
 
-            function notWhitespace(node) {
-              if (node instanceof Array) {
-                return false;
-              } else if (
-                node.nodeType !== Node.TEXT_NODE ||
-                node.nodeValue.trim()
-              ) {
-                return true;
-              }
+          function notWhitespace(node) {
+            if (node instanceof Array) {
+              return false;
+            } else if (
+              node.nodeType !== Node.TEXT_NODE ||
+              node.nodeValue.trim()
+            ) {
+              return true;
             }
           }
+        }
 
-          return ngTranscludePostLink;
-        },
-      };
-    },
-  ];
+        return ngTranscludePostLink;
+      },
+    };
+  }
 
   const REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
 
+  /**
+   * @type {Record<string, import("../../interface.js").DirectiveFactory>}
+   */
   const ngAttributeAliasDirectives = {};
 
   // boolean attrs are evaluated
@@ -13045,10 +13078,10 @@
         link(scope, element, attr) {
           // special case ngPattern when a literal regular expression value
           // is used as the expression (this way we don't have to watch anything).
-          if (ngAttr === "ngPattern" && attr.ngPattern.charAt(0) === "/") {
-            const match = attr.ngPattern.match(REGEX_STRING_REGEXP);
+          if (ngAttr === "ngPattern" && attr["ngPattern"].charAt(0) === "/") {
+            const match = attr["ngPattern"].match(REGEX_STRING_REGEXP);
             if (match) {
-              attr.$set("ngPattern", new RegExp(match[1], match[2]));
+              attr.$set("ngPattern", new RegExp(match[1], match[2]).toString());
               return;
             }
           }
@@ -13074,7 +13107,7 @@
 
             if (
               attrName === "href" &&
-              toString.call(element.href) === "[object SVGAnimatedString]"
+              toString.call(element["href"]) === "[object SVGAnimatedString]"
             ) {
               name = "xlinkHref";
               attr.$attr[name] = "href";
@@ -13460,7 +13493,7 @@
       "$rootScope",
       /**
        *
-       * @param {import('../core/location/location.js').Location} $location
+       * @param {import('../services/location/location.js').Location} $location
        * @param {import('../core/scope/scope.js').Scope} $rootScope
        * @returns
        */
@@ -13559,7 +13592,7 @@
             // skip the initial scroll if $location.hash is empty
             if (newVal === oldVal && newVal === "") return;
 
-            const action = () => $rootScope.$evalAsync(scroll);
+            const action = () => Promise.resolve().then(scroll);
             if (document.readyState === "complete") {
               // Force the action to be run async for consistent behavior
               // from the action's point of view
@@ -14478,216 +14511,6 @@
     ];
   }
 
-  /**
-   * Removes a trailing hash ('#') from the given URL if it exists.
-   *
-   * @param {string} url
-   * @returns {string}
-   */
-  function trimEmptyHash(url) {
-    return url.replace(/#$/, "");
-  }
-
-  /**
-   * @typedef {function(string, string|null): any} UrlChangeListener
-   */
-
-  /**
-   * This object has two goals:
-   *
-   * - hide all the global state in the browser caused by the window object
-   * - abstract away all the browser specific features and inconsistencies
-   */
-  class Browser {
-    /**
-     * @param {import('../core/task-tracker-factory.js').TaskTracker} taskTracker
-     */
-    constructor(taskTracker) {
-      /**
-       * @type {import('../core/task-tracker-factory.js').TaskTracker} taskTracker
-       */
-      this.taskTracker = taskTracker;
-      this.pendingDeferIds = {};
-      /** @type {Array<UrlChangeListener>} */
-      this.urlChangeListeners = [];
-      this.urlChangeInit = false;
-
-      /** @type {any} */
-      this.cachedState = null;
-      /** @type {any} */
-      this.lastHistoryState = null;
-      /** @type {string} */
-      this.lastBrowserUrl = window.location.href;
-      /** @type {HTMLBaseElement | null} */
-      this.baseElement = document.querySelector("base");
-
-      // Task-tracking API
-      this.$$completeOutstandingRequest =
-        this.taskTracker.completeTask.bind(taskTracker);
-      this.$$incOutstandingRequestCount =
-        this.taskTracker.incTaskCount.bind(taskTracker);
-      this.notifyWhenNoOutstandingRequests =
-        this.taskTracker.notifyWhenNoPendingTasks.bind(taskTracker);
-
-      this.cacheState();
-    }
-
-    /// ///////////////////////////////////////////////////////////
-    // URL API
-    /// ///////////////////////////////////////////////////////////
-
-    url(url, state) {
-      if (state === undefined) {
-        state = null;
-      }
-
-      // setter
-      if (url) {
-        url = urlResolve(url).href;
-
-        if (this.lastBrowserUrl === url && this.lastHistoryState === state) {
-          return this;
-        }
-
-        this.lastBrowserUrl = url;
-        this.lastHistoryState = state;
-        history.pushState(state, "", url);
-        this.cacheState();
-        return this;
-      }
-
-      // getter
-      return trimEmptyHash(window.location.href);
-    }
-
-    /**
-     * Returns the cached state.
-     *
-     * @returns {any} The cached state.
-     */
-    state() {
-      return this.cachedState;
-    }
-
-    /**
-     * Caches the current state and fires the URL change event.
-     *
-     * @private
-     */
-    cacheStateAndFireUrlChange() {
-      this.fireStateOrUrlChange();
-    }
-
-    /**
-     * Caches the current state.
-     *
-     * @private
-     */
-    cacheState() {
-      const currentState = history.state ?? null;
-      if (!equals$1(currentState, this.lastCachedState)) {
-        this.cachedState = currentState;
-        this.lastCachedState = currentState;
-        this.lastHistoryState = currentState;
-      }
-    }
-
-    /**
-     * Fires the state or URL change event.
-     *
-     * @private
-     */
-    fireStateOrUrlChange() {
-      const prevLastHistoryState = this.lastHistoryState;
-      this.cacheState();
-
-      if (
-        this.lastBrowserUrl === this.url() &&
-        prevLastHistoryState === this.cachedState
-      ) {
-        return;
-      }
-
-      this.lastBrowserUrl = /** @type {string} */ (this.url());
-      this.lastHistoryState = this.cachedState;
-      this.urlChangeListeners.forEach((listener) => {
-        listener(trimEmptyHash(window.location.href), this.cachedState);
-      });
-    }
-
-    /**
-     * Registers a callback to be called when the URL changes.
-     *
-     * @param {UrlChangeListener} callback - The callback function to register.
-     * @returns {UrlChangeListener} The registered callback function.
-     */
-    onUrlChange(callback) {
-      if (!this.urlChangeInit) {
-        window.addEventListener(
-          "popstate",
-          this.cacheStateAndFireUrlChange.bind(this),
-        );
-        window.addEventListener(
-          "hashchange",
-          this.cacheStateAndFireUrlChange.bind(this),
-        );
-
-        this.urlChangeInit = true;
-      }
-
-      this.urlChangeListeners.push(callback);
-      return callback;
-    }
-
-    $$applicationDestroyed() {
-      window.removeEventListener(
-        "popstate",
-        this.cacheStateAndFireUrlChange.bind(this),
-      );
-      window.removeEventListener(
-        "hashchange",
-        this.cacheStateAndFireUrlChange.bind(this),
-      );
-    }
-
-    $$checkUrlChange() {
-      this.fireStateOrUrlChange();
-    }
-
-    /// ///////////////////////////////////////////////////////////
-    // Misc API
-    /// ///////////////////////////////////////////////////////////
-
-    /**
-     * Returns the base href of the document.
-     *
-     * @returns {string} The base href.
-     */
-    baseHref() {
-      const href = this.baseElement?.getAttribute("href");
-      return href ? href.replace(/^(https?:)?\/\/[^/]*/, "") : "";
-    }
-  }
-
-  /**
-   * This object has two goals:
-   *
-   * - hide all the global state in the browser caused by the window object
-   * - abstract away all the browser specific features and inconsistencies
-   *
-   * Remove this in the future
-   */
-  class BrowserProvider {
-    $get = [
-      "$$taskTrackerFactory",
-      /**
-       * @param {import('../core/task-tracker-factory.js').TaskTracker} $$taskTrackerFactory
-       * @returns {Browser}
-       */
-      ($$taskTrackerFactory) => new Browser($$taskTrackerFactory),
-    ];
-  }
-
   function AnimateAsyncRunFactoryProvider() {
     this.$get = [
       function () {
@@ -14893,7 +14716,9 @@
     /**
      * @returns {import('./interface.ts').TemplateCache}
      */
-    $get = () => this.cache;
+    $get() {
+      return this.cache;
+    }
   }
 
   /**
@@ -14940,9 +14765,9 @@
    * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
    */
 
-  /** @typedef {import('../services/log/interface.ts').LogService} LogService */
+  /** @typedef {import('../log/interface.ts').LogService} LogService */
 
-  /** @typedef {import("./error-handler.ts").ErrorHandler}  ErrorHandler */
+  /** @typedef {import("./interface.ts").Interface}  ErrorHandler */
 
   /**
    * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.
@@ -15426,7 +15251,7 @@
     const isFilter = function (state, params, options) {
       return $state.is(state, params, options);
     };
-    //isFilter.$stateful = true;
+    isFilter.$stateful = true;
     return isFilter;
   }
   /**
@@ -15447,53 +15272,52 @@
     const includesFilter = function (state, params, options) {
       return $state.includes(state, params, options);
     };
-    //includesFilter.$stateful = true;
+    includesFilter.$stateful = true;
     return includesFilter;
   }
 
-  FilterProvider.$inject = ["$provide"];
+  const SUFFIX = "Filter";
 
-  /**
-   * @param {import('../../interface.ts').Provider} $provide
-   */
-  function FilterProvider($provide) {
-    const suffix = "Filter";
+  class FilterProvider {
+    static $inject = [$injectTokens.$provide];
+
+    /**
+     * @param {import('../../interface.ts').Provider} $provide
+     */
+    constructor($provide) {
+      this.$provide = $provide;
+      this.register({
+        filter: filterFilter,
+        json: jsonFilter,
+        limitTo: limitToFilter,
+        orderBy: orderByFilter,
+        isState: $IsStateFilter,
+        includedByState: $IncludedByStateFilter,
+      });
+    }
 
     /**
      * @param {string|Record<string, import('../../interface.ts').FilterFactory>} name
-     * @param {import('../../interface.ts').FilterFactory} factory
-     * @return {import('../../interface.ts').ServiceProvider}
+     * @param {import('../../interface.ts').FilterFactory} [factory]
+     * @return {import('../../interface.ts').Provider}
      */
-    function register(name, factory) {
+    register(name, factory) {
       if (isObject(name)) {
         Object.entries(name).forEach(([key, filter]) => {
-          register(key, filter);
+          this.register(key, filter);
         });
       }
-      return $provide.factory(name + suffix, factory);
+      return this.$provide.factory(name + SUFFIX, factory);
     }
 
-    this.register = register;
-
-    this.$get = [
-      "$injector",
+    $get = [
+      $injectTokens.$injector,
       /**
        * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
-       * @returns
+       * @returns {import('../../interface.ts').FilterFn}
        */
-      function ($injector) {
-        return function (name) {
-          return $injector.get(name + suffix);
-        };
-      },
+      ($injector) => (/** @type {string} */ name) => $injector.get(name + SUFFIX),
     ];
-
-    register("filter", filterFilter);
-    register("json", jsonFilter);
-    register("limitTo", limitToFilter);
-    register("orderBy", orderByFilter);
-    register("isState", $IsStateFilter);
-    register("includedByState", $IncludedByStateFilter);
   }
 
   const PURITY_ABSOLUTE = 1;
@@ -15632,7 +15456,7 @@
           if (ast.filter) right = this.$filter(ast.callee.name);
           if (!ast.filter) right = this.recurse(ast.callee, true);
           return ast.filter
-            ? function (scope, locals, assign) {
+            ? (scope, locals, assign) => {
                 const values = [];
                 for (let i = 0; i < args.length; ++i) {
                   const res = args[i](scope, locals, assign);
@@ -15645,7 +15469,7 @@
                   ? { context: undefined, name: undefined, value }
                   : value;
               }
-            : function (scope, locals, assign) {
+            : (scope, locals, assign) => {
                 const rhs = right(scope, locals, assign);
                 let value;
                 if (rhs.value != null && isFunction(rhs.value)) {
@@ -15661,7 +15485,7 @@
         case ASTType.AssignmentExpression:
           left = this.recurse(ast.left, true, 1);
           right = this.recurse(ast.right);
-          return function (scope, locals, assign) {
+          return (scope, locals, assign) => {
             const lhs = left(scope, locals, assign);
             const rhs = right(scope, locals, assign);
             lhs.context[lhs.name] = rhs;
@@ -15672,7 +15496,7 @@
           ast.elements.forEach((expr) => {
             args.push(self.recurse(expr));
           });
-          return function (scope, locals, assign) {
+          return (scope, locals, assign) => {
             const value = [];
             for (let i = 0; i < args.length; ++i) {
               value.push(args[i](scope, locals, assign));
@@ -15699,7 +15523,7 @@
               });
             }
           });
-          return function (scope, locals, assign) {
+          return (scope, locals, assign) => {
             const value = {};
             for (let i = 0; i < args.length; ++i) {
               if (args[i].computed) {
@@ -15715,17 +15539,12 @@
             return context ? { value } : value;
           };
         case ASTType.ThisExpression:
-          return function (scope) {
-            return context ? { value: scope } : scope;
-          };
+          return (scope) => (context ? { value: scope } : scope);
         case ASTType.LocalsExpression:
-          return function (scope, locals) {
-            return context ? { value: locals } : locals;
-          };
+          return (scope, locals) => (context ? { value: locals } : locals);
         case ASTType.NGValueParameter:
-          return function (scope, locals, assign) {
-            return context ? { value: assign } : assign;
-          };
+          return (scope, locals, assign) =>
+            context ? { value: assign } : assign;
       }
     }
 
@@ -15736,7 +15555,7 @@
      * @returns {function} The unary plus function.
      */
     "unary+"(argument, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         let arg = argument(scope, locals, assign);
         if (isDefined(arg)) {
           arg = +arg;
@@ -15754,7 +15573,7 @@
      * @returns {function} The unary minus function.
      */
     "unary-"(argument, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         let arg = argument(scope, locals, assign);
         if (isDefined(arg)) {
           arg = -arg;
@@ -15772,7 +15591,7 @@
      * @returns {function} The unary negation function.
      */
     "unary!"(argument, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = !argument(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15786,7 +15605,7 @@
      * @returns {function} The binary plus function.
      */
     "binary+"(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const lhs = left(scope, locals, assign);
         const rhs = right(scope, locals, assign);
         const arg = plusFn(lhs, rhs);
@@ -15802,7 +15621,7 @@
      * @returns {function} The binary minus function.
      */
     "binary-"(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const lhs = left(scope, locals, assign);
         const rhs = right(scope, locals, assign);
         const arg = (isDefined(lhs) ? lhs : 0) - (isDefined(rhs) ? rhs : 0);
@@ -15818,14 +15637,14 @@
      * @returns {function} The binary multiplication function.
      */
     "binary*"(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) * right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
     }
 
     "binary/"(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) / right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15839,7 +15658,7 @@
      * @returns {function} The binary division function.
      */
     "binary%"(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) % right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15853,7 +15672,7 @@
      * @returns {function} The binary strict equality function.
      */
     "binary==="(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) === right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15867,7 +15686,7 @@
      * @returns {function} The binary strict inequality function.
      */
     "binary!=="(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) !== right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15881,7 +15700,7 @@
      * @returns {function} The binary equality function.
      */
     "binary=="(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) == right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15895,7 +15714,7 @@
      * @returns {function} The binary inequality function.
      */
     "binary!="(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) != right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15909,7 +15728,7 @@
      * @returns {function} The binary less-than function.
      */
     "binary<"(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) < right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15923,7 +15742,7 @@
      * @returns {function} The binary greater-than function.
      */
     "binary>"(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) > right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15937,7 +15756,7 @@
      * @returns {function} The binary less-than-or-equal-to function.
      */
     "binary<="(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) <= right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15951,7 +15770,7 @@
      * @returns {function} The binary greater-than-or-equal-to function.
      */
     "binary>="(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) >= right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15978,7 +15797,7 @@
      * @returns {function} The binary logical OR function.
      */
     "binary||"(left, right, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = left(scope, locals, assign) || right(scope, locals, assign);
         return context ? { value: arg } : arg;
       };
@@ -15993,7 +15812,7 @@
      * @returns {function} The ternary conditional function.
      */
     "ternary?:"(test, alternate, consequent, context) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const arg = test(scope, locals, assign)
           ? alternate(scope, locals, assign)
           : consequent(scope, locals, assign);
@@ -16008,9 +15827,8 @@
      * @returns {import("./interface.ts").CompiledExpressionFunction} The function returning the literal value.
      */
     value(value, context) {
-      return function () {
-        return context ? { context: undefined, name: undefined, value } : value;
-      };
+      return () =>
+        context ? { context: undefined, name: undefined, value } : value;
     }
 
     /**
@@ -16021,7 +15839,7 @@
      * @returns {import("./interface.ts").CompiledExpressionFunction} The function returning the identifier value.
      */
     identifier(name, context, create) {
-      return function (scope, locals) {
+      return (scope, locals) => {
         const base = locals && name in locals ? locals : scope;
         if (create && create !== 1 && base && base[name] == null) {
           base[name] = {};
@@ -16046,7 +15864,7 @@
      * @returns {function} The function returning the computed member value.
      */
     computedMember(left, right, context, create) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const lhs = left(scope, locals, assign);
         let rhs;
         let value;
@@ -16076,7 +15894,7 @@
      * @returns {function} The function returning the non-computed member value.
      */
     nonComputedMember(left, right, context, create) {
-      return function (scope, locals, assign) {
+      return (scope, locals, assign) => {
         const lhs = left(scope, locals, assign);
         if (create && create !== 1) {
           if (lhs && lhs[right] == null) {
@@ -18497,21 +18315,17 @@
     });
 
     this.$get = [
-      "$browser",
       "$httpBackend",
-      "$rootScope",
       "$injector",
       "$sce",
       /**
        *
-       * @param {*} $browser
        * @param {*} $httpBackend
-       * @param {import("../../core/scope/scope.js").Scope} $rootScope
        * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
        * @param {*} $sce
        * @returns
        */
-      function ($browser, $httpBackend, $rootScope, $injector, $sce) {
+      function ($httpBackend, $injector, $sce) {
         /**
          * @type {Map<string, string>}
          */
@@ -18581,8 +18395,6 @@
             ? $injector.get(config.paramSerializer)
             : config.paramSerializer;
 
-          $browser.$$incOutstandingRequestCount("$http");
-
           const requestInterceptors = [];
           const responseInterceptors = [];
           let promise = Promise.resolve(config);
@@ -18606,7 +18418,6 @@
           promise = chainInterceptors(promise, requestInterceptors);
           promise = promise.then(serverRequest);
           promise = chainInterceptors(promise, responseInterceptors);
-          promise = promise.finally(completeOutstandingRequest);
 
           return promise;
 
@@ -18623,10 +18434,6 @@
             return promise;
           }
 
-          function completeOutstandingRequest() {
-            $browser.$$completeOutstandingRequest(() => {}, "$http");
-          }
-
           function executeHeaderFns(headers, config) {
             let headerContent;
             const processedHeaders = {};
@@ -19065,24 +18872,14 @@
    */
   class HttpBackendProvider {
     constructor() {
-      this.$get = [
-        "$browser",
-        /**
-         * @param {import('../browser.js').Browser} $browser
-         * @returns
-         */
-        function ($browser) {
-          return createHttpBackend($browser);
-        },
-      ];
+      this.$get = [() => createHttpBackend()];
     }
   }
 
   /**
-   * @param {import('../browser.js').Browser} $browser
    * @returns
    */
-  function createHttpBackend($browser) {
+  function createHttpBackend() {
     // TODO(vojta): fix the signature
     return function (
       method,
@@ -19096,7 +18893,7 @@
       eventHandlers,
       uploadEventHandlers,
     ) {
-      url = url || $browser.url();
+      url = url || trimEmptyHash(window.location.href);
 
       const xhr = new XMLHttpRequest();
       let abortedByTimeout = false;
@@ -19304,7 +19101,7 @@
        */
       this.$$replace = false;
 
-      /** @type {import('../url-utils/url-utils').HttpProtocol} */
+      /** @type {string} */
       this.$$protocol = parsedUrl.protocol;
 
       /** @type {string} */
@@ -19371,7 +19168,7 @@
     /**
      *
      * Return protocol of current URL.
-     * @return {import("../url-utils/url-utils").HttpProtocol} protocol of current URL
+     * @return {string} protocol of current URL
      */
     protocol() {
       return this.$$protocol;
@@ -19672,12 +19469,13 @@
    * This object is exposed as $location service when developer doesn't opt into html5 mode.
    * It also serves as the base class for html5 mode fallback on legacy browsers.
    *
-   * @constructor
-   * @param {string} appBase application base URL
-   * @param {string} appBaseNoFile application base URL stripped of any filename
-   * @param {string} hashPrefix hashbang prefix
    */
   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
+     */
     constructor(appBase, appBaseNoFile, hashPrefix) {
       super(appBase, appBaseNoFile);
       this.hashPrefix = hashPrefix;
@@ -19788,6 +19586,111 @@
         requireBase: true,
         rewriteLinks: true,
       };
+
+      /** @type {Array<import("./interface.js").UrlChangeListener>} */
+      this.urlChangeListeners = [];
+      this.urlChangeInit = false;
+
+      /** @type {History['state']} */
+      this.cachedState = null;
+      /** @typeof {History.state} */
+      this.lastHistoryState = null;
+      /** @type {string} */
+      this.lastBrowserUrl = window.location.href;
+      this.cacheState();
+    }
+
+    /// ///////////////////////////////////////////////////////////
+    // URL API
+    /// ///////////////////////////////////////////////////////////
+
+    setUrl(url, state) {
+      if (state === undefined) {
+        state = null;
+      }
+
+      // setter
+      if (url) {
+        url = urlResolve(url).href;
+
+        if (this.lastBrowserUrl === url && this.lastHistoryState === state) {
+          return this;
+        }
+
+        this.lastBrowserUrl = url;
+        this.lastHistoryState = state;
+        history.pushState(state, "", url);
+        this.cacheState();
+      }
+    }
+
+    /**
+     * Returns the current URL with any empty hash (`#`) removed.
+     * @return {string}
+     */
+    getUrl() {
+      return trimEmptyHash(window.location.href);
+    }
+
+    /**
+     * Returns the cached state.
+     * @returns {History['state']} The cached state.
+     */
+    state() {
+      return this.cachedState;
+    }
+
+    /**
+     * Caches the current state.
+     *
+     * @private
+     */
+    cacheState() {
+      const currentState = history.state ?? null;
+      if (!equals$1(currentState, this.lastCachedState)) {
+        this.cachedState = currentState;
+        this.lastCachedState = currentState;
+        this.lastHistoryState = currentState;
+      }
+    }
+
+    /**
+     * Fires the state or URL change event.
+     *
+     * @private
+     */
+    fireStateOrUrlChange() {
+      const prevLastHistoryState = this.lastHistoryState;
+      this.cacheState();
+      if (
+        this.lastBrowserUrl === this.getUrl() &&
+        prevLastHistoryState === this.cachedState
+      ) {
+        return;
+      }
+      this.lastBrowserUrl = this.getUrl();
+      this.lastHistoryState = this.cachedState;
+      this.urlChangeListeners.forEach((listener) => {
+        listener(trimEmptyHash(window.location.href), this.cachedState);
+      });
+    }
+
+    /**
+     * Registers a callback to be called when the URL changes.
+     *
+     * @param {import("./interface.js").UrlChangeListener} callback - The callback function to register.
+     * @returns void
+     */
+    onUrlChange(callback) {
+      if (!this.urlChangeInit) {
+        window.addEventListener("popstate", this.fireStateOrUrlChange.bind(this));
+        window.addEventListener(
+          "hashchange",
+          this.fireStateOrUrlChange.bind(this),
+        );
+        this.urlChangeInit = true;
+      }
+      this.urlChangeListeners.push(callback);
     }
 
     /**
@@ -19849,21 +19752,19 @@
 
     $get = [
       "$rootScope",
-      "$browser",
       "$rootElement",
       /**
        *
-       * @param {import('../scope/scope.js').Scope} $rootScope
-       * @param {import('../../services/browser').Browser} $browser
+       * @param {import('../../core/scope/scope.js').Scope} $rootScope
        * @param {Element} $rootElement
        * @returns
        */
-      ($rootScope, $browser, $rootElement) => {
+      ($rootScope, $rootElement) => {
         /** @type {Location} */
         let $location;
         let LocationMode;
-        const baseHref = $browser.baseHref(); // if base[href] is undefined, it defaults to ''
-        const initialUrl = /** @type {string} */ ($browser.url());
+        const baseHref = getBaseHref(); // if base[href] is undefined, it defaults to ''
+        const initialUrl = trimEmptyHash(window.location.href);
         let appBase;
 
         if (this.getHtml5Mode().enabled) {
@@ -19888,20 +19789,20 @@
         );
         $location.$$parseLinkUrl(initialUrl, initialUrl);
 
-        $location.$$state = $browser.state();
+        $location.$$state = this.state();
 
         const IGNORE_URI_REGEXP = /^\s*(javascript|mailto):/i;
 
-        function setBrowserUrlWithFallback(url, state) {
+        const setBrowserUrlWithFallback = (url, state) => {
           const oldUrl = $location.url();
           const oldState = $location.$$state;
           try {
-            $browser.url(url, state);
+            this.setUrl(url, state);
 
             // Make sure $location.state() 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 = $browser.state();
+            $location.$$state = this.state();
           } catch (e) {
             // Restore old values if pushState fails
             $location.url(/** @type {string} */ (oldUrl));
@@ -19909,7 +19810,7 @@
 
             throw e;
           }
-        }
+        };
 
         $rootElement.addEventListener(
           "click",
@@ -19977,10 +19878,6 @@
                 // in html5mode and also without, so that we are able to abort navigation without
                 // getting double entries in the location history.
                 event.preventDefault();
-                // update location manually
-                // if ($location.absUrl() !== $browser.url()) {
-                //   $rootScope.$apply();
-                // }
               }
             }
           },
@@ -19988,20 +19885,20 @@
 
         // rewrite hashbang url <> html5 url
         if ($location.absUrl() !== initialUrl) {
-          $browser.url($location.absUrl(), true);
+          this.setUrl($location.absUrl(), true);
         }
 
         let initializing = true;
 
         // update $location when $browser url changes
-        $browser.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;
             return;
           }
 
-          $rootScope.$evalAsync(() => {
+          Promise.resolve().then(() => {
             const oldUrl = $location.absUrl();
             const oldState = $location.$$state;
             let defaultPrevented;
@@ -20036,9 +19933,9 @@
           if (initializing || $location.$$urlUpdatedByLocation) {
             $location.$$urlUpdatedByLocation = false;
 
-            const oldUrl = /** @type {string} */ ($browser.url());
+            const oldUrl = /** @type {string} */ (this.getUrl());
             const newUrl = $location.absUrl();
-            const oldState = $browser.state();
+            const oldState = this.state();
             const urlOrStateChanged =
               !urlsEqual(oldUrl, newUrl) ||
               ($location.$$html5 && oldState !== $location.$$state);
@@ -20297,7 +20194,7 @@
    */
   let $parse;
 
-  /**@type {import('../exception-handler.js').ErrorHandler} */
+  /**@type {import('../../services/exception/exception-handler.js').ErrorHandler} */
   let $exceptionHandler;
 
   /**
@@ -20318,7 +20215,7 @@
       "$exceptionHandler",
       "$parse",
       /**
-       * @param {import('../exception-handler.js').ErrorHandler} exceptionHandler
+       * @param {import('../../services/exception/exception-handler.js').ErrorHandler} exceptionHandler
        * @param {import('../parse/interface.ts').ParseService} parse
        */
       (exceptionHandler, parse) => {
@@ -20729,7 +20626,6 @@
         $destroy: this.$destroy.bind(this),
         $eval: this.$eval.bind(this),
         $apply: this.$apply.bind(this),
-        $evalAsync: this.$evalAsync.bind(this),
         $postUpdate: this.$postUpdate.bind(this),
         $isRoot: this.#isRoot.bind(this),
         $target: target,
@@ -21235,10 +21131,6 @@
       return res;
     }
 
-    async $evalAsync(expr, locals) {
-      return await this.$eval(expr, locals);
-    }
-
     /**
      * @param {Object} newTarget
      */
@@ -21520,152 +21412,6 @@
     return ids;
   }
 
-  /** @typedef {import('../interface.ts').ServiceProvider} ServiceProvider */
-  /** @typedef {import('../interface.ts').AnnotatedFactory} AnnotatedFactory */
-
-  /**
-   * @implements {ServiceProvider}
-   */
-  class TaskTrackerFactoryProvider {
-    /** @type {AnnotatedFactory} */
-    $get = [
-      "$log",
-      /**
-       * Creates a new `TaskTracker` instance.
-       *
-       * @param {import('../services/log/interface.ts').LogService} log - The logging service.
-       * @returns {TaskTracker} A new `TaskTracker` instance.
-       */
-      (log) => new TaskTracker(log),
-    ];
-  }
-
-  /**
-   * A factory function to create `TaskTracker` instances.
-   *
-   * A `TaskTracker` tracks pending tasks (grouped by type) and notifies interested
-   * parties when all pending tasks (or tasks of a specific type) have been completed.
-   */
-  class TaskTracker {
-    /**
-     * @param {import('../services/log/interface.ts').LogService} log - The logging service.
-     */
-    constructor(log) {
-      /** @private */
-      this.log = log;
-
-      /** @private */
-      this.taskCounts = {};
-
-      /** @private */
-      this.taskCallbacks = [];
-
-      /**
-       * Special task types used for tracking all tasks and default tasks.
-       * @type {string}
-       */
-      this.ALL_TASKS_TYPE = "$$all$$";
-
-      /**
-       * Default task type.
-       * @type {string}
-       */
-      this.DEFAULT_TASK_TYPE = "$$default$$";
-    }
-
-    /**
-     * Completes a task and decrements the associated task counter.
-     * If the counter reaches 0, all corresponding callbacks are executed.
-     *
-     * @param {Function} fn - The function to execute when completing the task.
-     * @param {string} [taskType=this.DEFAULT_TASK_TYPE] - The type of task being completed.
-     */
-    completeTask(fn, taskType = this.DEFAULT_TASK_TYPE) {
-      try {
-        fn();
-      } finally {
-        if (this.taskCounts[taskType]) {
-          this.taskCounts[taskType]--;
-          this.taskCounts[this.ALL_TASKS_TYPE]--;
-        }
-
-        const countForType = this.taskCounts[taskType];
-        const countForAll = this.taskCounts[this.ALL_TASKS_TYPE];
-
-        // If either the overall task queue or the specific task type queue is empty, run callbacks.
-        if (!countForAll || !countForType) {
-          const getNextCallback = !countForAll
-            ? this.getLastCallback.bind(this)
-            : () => this.getLastCallbackForType(taskType);
-
-          let nextCb;
-          while ((nextCb = getNextCallback())) {
-            try {
-              nextCb();
-            } catch (e) {
-              this.log.error(e);
-            }
-          }
-        }
-      }
-    }
-
-    /**
-     * Increments the task count for the specified task type.
-     *
-     * @param {string} [taskType=this.DEFAULT_TASK_TYPE] - The type of task whose count will be increased.
-     */
-    incTaskCount(taskType = this.DEFAULT_TASK_TYPE) {
-      this.taskCounts[taskType] = (this.taskCounts[taskType] || 0) + 1;
-      this.taskCounts[this.ALL_TASKS_TYPE] =
-        (this.taskCounts[this.ALL_TASKS_TYPE] || 0) + 1;
-    }
-
-    /**
-     * Registers a callback to be executed when all pending tasks of the specified type are completed.
-     * If there are no pending tasks of the specified type, the callback is executed immediately.
-     *
-     * @param {Function} callback - The function to execute when no pending tasks remain.
-     * @param {string} [taskType=this.ALL_TASKS_TYPE] - The type of tasks to wait for completion.
-     */
-    notifyWhenNoPendingTasks(callback, taskType = this.ALL_TASKS_TYPE) {
-      if (!this.taskCounts[taskType]) {
-        callback();
-      } else {
-        this.taskCallbacks.push({ type: taskType, cb: callback });
-      }
-    }
-
-    /**
-     * Retrieves and removes the last registered callback from the queue.
-     *
-     * @private
-     * @returns {Function|undefined} The last callback function or undefined if none exist.
-     */
-    getLastCallback() {
-      const cbInfo = this.taskCallbacks.pop();
-      return cbInfo ? cbInfo.cb : undefined;
-    }
-
-    /**
-     * Retrieves and removes the last registered callback for the specified task type.
-     *
-     * @private
-     * @param {string} taskType - The type of task for which the callback was registered.
-     * @returns {Function|undefined} The last callback function for the task type, or undefined if none exist.
-     */
-    getLastCallbackForType(taskType) {
-      for (let i = this.taskCallbacks.length - 1; i >= 0; --i) {
-        const cbInfo = this.taskCallbacks[i];
-        if (cbInfo.type === taskType) {
-          this.taskCallbacks.splice(i, 1);
-          return cbInfo.cb;
-        }
-      }
-      return undefined;
-    }
-  }
-
   const $templateRequestMinErr = minErr("$templateRequest");
 
   /**
@@ -21725,7 +21471,7 @@
       "$sce",
       /**
        *
-       * @param {import('../core/exception-handler.js').ErrorHandler} $exceptionHandler
+       * @param {import('./exception/exception-handler.js').ErrorHandler} $exceptionHandler
        * @param {import('../services/template-cache/interface.ts').TemplateCache} $templateCache
        * @param {import("interface.ts").HttpService} $http
        * @param {*} $sce
@@ -21740,6 +21486,7 @@
           // resources for keys that already are included in there. This also makes
           // AngularTS accept any script directive, no matter its name. However, we
           // still need to unwrap trusted types.
+
           if (!isString(tpl) || !$templateCache.has(tpl)) {
             try {
               tpl = $sce.getTrustedResourceUrl(tpl);
@@ -21805,7 +21552,7 @@
     ];
   }
 
-  /** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider } */
+  /** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider */
 
   /**
    * Private service to sanitize uris for links and images. Used by $compile.
@@ -21857,7 +21604,7 @@
     }
 
     /**
-     * @returns {import("./interface.js").SanitizerFn} Sanitizer function.
+     * @returns {import("./interface").SanitizerFn}
      */
     $get() {
       return (uri, isMediaUrl) => {
@@ -21981,7 +21728,7 @@
     reRender() {
       if (!this.renderLater) {
         this.renderLater = true;
-        this.$scope.$evalAsync(() => {
+        Promise.resolve().then(() => {
           if (this.renderLater && this.cachedCollection) {
             this.render(this.cachedCollection);
           }
@@ -22114,6 +21861,10 @@
   const ngMessageExpDirective = ngMessageDirectiveFactory(false);
   const ngMessageDefaultDirective = ngMessageDirectiveFactory(true);
 
+  /**
+   * @param {boolean} isDefault
+   * @returns {(any) => import("../../interface.js").Directive}
+   */
   function ngMessageDirectiveFactory(isDefault) {
     ngMessageDirective.$inject = ["$animate"];
     function ngMessageDirective($animate) {
@@ -25194,7 +24945,7 @@
 
   /**
    * Service provider that creates a requestAnimationFrame-based scheduler.
-   * @implements {ServiceProvider}
+   * @type {ServiceProvider}
    */
   class RafSchedulerProvider {
     constructor() {
@@ -26946,7 +26697,6 @@
    *
    * This is where we hold the global mutable state such as current state, current
    * params, current transition, etc.
-   * @implements {ServiceProvider}
    */
   class RouterGlobals {
     constructor() {
@@ -29587,6 +29337,11 @@
        */
       this.regexp = new RegExp("^" + regexpString + "$");
     }
+
+    /**
+     * @param {string} name
+     * @return {boolean}
+     */
     matches(name) {
       return this.regexp.test("." + name);
     }
@@ -33521,7 +33276,7 @@
     ];
 
     /**
-     * @param {import("../../core/location/location").LocationProvider} $locationProvider
+     * @param {import("../../services/location/location").LocationProvider} $locationProvider
      * @param {import("../../router/state/state-service.js").StateProvider} stateService
      * @param globals
      * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
@@ -33530,9 +33285,7 @@
       this.stateService = stateService;
       this.stateService.urlService = this; // circular wiring
       this.$locationProvider = $locationProvider;
-
       this.$location = undefined;
-      this.$browser = undefined;
 
       /** Provides services related to the URL */
       this.urlRuleFactory = new UrlRuleFactory(this, this.stateService, globals);
@@ -33585,18 +33338,15 @@
 
     $get = [
       "$location",
-      "$browser",
       "$rootScope",
       /**
        *
-       * @param {import('../../core/location/location.js').Location} $location
-       * @param {import('../../services/browser.js').Browser} $browser
+       * @param {import('../../services/location/location.js').Location} $location
        * @param {import('../../core/scope/scope.js').Scope} $rootScope
        * @returns {UrlService}
        */
-      ($location, $browser, $rootScope) => {
+      ($location, $rootScope) => {
         this.$location = $location;
-        this.$browser = $browser;
         $rootScope.$on("$locationChangeSuccess", (evt) => {
           this._urlListeners.forEach((fn) => {
             fn(evt);
@@ -33620,7 +33370,7 @@
     baseHref() {
       return (
         this._baseHref ||
-        (this._baseHref = this.$browser.baseHref() || window.location.pathname)
+        (this._baseHref = getBaseHref() || window.location.pathname)
       );
     }
 
@@ -34467,7 +34217,6 @@
    *
    * This API is found at `$stateRegistry` ([[UIRouter.stateRegistry]])
    *
-   * @implements {ServiceProvider}
    */
   class StateRegistryProvider {
     static $inject = provider([
@@ -35096,12 +34845,10 @@
           const removeClasses = allClasses.filter(
             (cls) => !addClasses.includes(cls),
           );
-          $scope.$evalAsync(() => {
-            addClasses.forEach((className) => $element.classList.add(className));
-            removeClasses.forEach((className) =>
-              $element.classList.remove(className),
-            );
-          });
+          addClasses.forEach((className) => $element.classList.add(className));
+          removeClasses.forEach((className) =>
+            $element.classList.remove(className),
+          );
         }
         update();
       },
@@ -35233,11 +34980,20 @@
    * });
    * ```
    */
+
+  /** @type {import("../../interface.js").AnnotatedDirectiveFactory} */
   let ngView = [
     "$view",
     "$animate",
     "$ngViewScroll",
     "$interpolate",
+    /**
+     * @param {*} $view
+     * @param {*} $animate
+     * @param {*} $ngViewScroll
+     * @param {*} $interpolate
+     * @returns {import("../../interface.js").Directive}
+     */
     function $ViewDirective($view, $animate, $ngViewScroll, $interpolate) {
       function getRenderer() {
         return {
@@ -35268,7 +35024,6 @@
       };
       const directive = {
         count: 0,
-
         terminal: true,
         priority: 400,
         transclude: "element",
@@ -35605,11 +35360,12 @@
     };
   }
 
-  ngSetterDirective.$inject = ["$parse", "$log"];
+  ngSetterDirective.$inject = [$injectTokens.$parse, $injectTokens.$log];
+
   /**
    * @param {import('../../core/parse/interface.ts').ParseService} $parse
    * @param {import('../../services/log/interface.ts').LogService} $log
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {import('interface.ts').Directive}
    */
   function ngSetterDirective($parse, $log) {
     return {
@@ -35618,19 +35374,19 @@
         const modelExpression = attrs["ngSetter"];
 
         if (!modelExpression) {
-          $log.warn("ngSetter: Model expression is not provided.");
+          $log.warn("ng-setter: expression null");
           return;
         }
 
         const assignModel = $parse(modelExpression).assign;
 
         if (!assignModel) {
-          $log.warn("ngSetter: Invalid model expression.");
+          $log.warn("ng-setter: expression invalid");
           return;
         }
 
         const updateModel = (value) => {
-          assignModel(scope, value);
+          assignModel(scope, value.trim());
         };
 
         const observer = new MutationObserver((mutationsList) => {
@@ -35650,16 +35406,11 @@
           }
         });
 
-        if (element && element) {
-          observer.observe(element, {
-            childList: true,
-            subtree: true,
-            characterData: true,
-          });
-        } else {
-          $log.warn("ngSetter: Element is not a valid DOM node.");
-          return;
-        }
+        observer.observe(element, {
+          childList: true,
+          subtree: true,
+          characterData: true,
+        });
 
         scope.$on("$destroy", () => observer.disconnect());
         updateModel(element.innerHTML);
@@ -35674,13 +35425,20 @@
   function defineDirective(method) {
     const attrName = "ng" + method.charAt(0).toUpperCase() + method.slice(1);
     const directive = createHttpDirective(method, attrName);
-    directive["$inject"] = ["$http", "$compile", "$log"];
+    directive["$inject"] = [$injectTokens.$http, $injectTokens.$compile, $injectTokens.$log, $injectTokens.$parse, $injectTokens.$state];
     return directive;
   }
 
+  /** @type {import('../../interface.ts').DirectiveFactory} */
   const ngGetDirective = defineDirective("get");
+
+  /** @type {import('../../interface.ts').DirectiveFactory} */
   const ngDeleteDirective = defineDirective("delete");
+
+  /** @type {import('../../interface.ts').DirectiveFactory} */
   const ngPostDirective = defineDirective("post");
+
+  /** @type {import('../../interface.ts').DirectiveFactory} */
   const ngPutDirective = defineDirective("put");
 
   /**
@@ -35707,7 +35465,7 @@
    * Handles DOM manipulation based on a swap strategy and server-rendered HTML.
    *
    * @param {string} html - The HTML string returned from the server.
-   * @param {import("../../interface.ts").SwapInsertPosition} swap
+   * @param {import("../../interface.ts").SwapModeType} swap
    * @param {Element} target - The target DOM element to apply the swap to.
    * @param {import('../../core/scope/scope.js').Scope} scope
    * @param {import('../../core/compile/compile.js').CompileFn} $compile
@@ -35798,9 +35556,11 @@
      * @param {import("interface.ts").HttpService} $http
      * @param {import("../../core/compile/compile.js").CompileFn} $compile
      * @param {import("../../services/log/interface.ts").LogService} $log
+     * @param {import("../../core/parse/interface.ts").ParseService} $parse
+     * @param {import("../../router/state/state-service.js").StateProvider} $state
      * @returns {import('../../interface.ts').Directive}
      */
-    return function ($http, $compile, $log) {
+    return function ($http, $compile, $log, $parse, $state) {
       /**
        * Collects form data from the element or its associated form.
        *
@@ -35861,16 +35621,38 @@
         restrict: "A",
         terminal: true,
         link(scope, element, attrs) {
-          /** @type {EventType} */
-          const eventName = getEventNameForElement(element);
+          const eventName =
+            attrs["trigger"] ||
+            /** @type {EventType} */ getEventNameForElement(element);
+
           const tag = element.tagName.toLowerCase();
 
-          element.addEventListener(eventName, (event) => {
+          if (isDefined(attrs["latch"])) {
+            attrs.$observe(
+              "latch",
+              callBackAfterFirst(() =>
+                element.dispatchEvent(new Event(eventName)),
+              ),
+            );
+          }
+
+          let throttled = false;
+          let intervalId;
+
+          if (isDefined(attrs["interval"])) {
+            element.dispatchEvent(new Event(eventName));
+            intervalId = setInterval(
+              () => element.dispatchEvent(new Event(eventName)),
+              parseInt(attrs["interval"]) || 1000,
+            );
+          }
+
+          element.addEventListener(eventName, async (event) => {
             if (/** @type {HTMLButtonElement} */ (element).disabled) return;
             if (tag === "form") event.preventDefault();
 
-            const swap = element.dataset.swap || "innerHTML";
-            const targetSelector = element.dataset.target;
+            const swap = attrs["swap"] || "innerHTML";
+            const targetSelector = attrs["target"];
             const target = targetSelector
               ? document.querySelector(targetSelector)
               : element;
@@ -35887,18 +35669,67 @@
             }
 
             const handler = (res) => {
+              if (isDefined(attrs["loading"])) {
+                attrs.$set("loading", false);
+              }
+
+              if (isDefined(attrs["loadingClass"])) {
+                attrs.$removeClass(attrs["loadingClass"]);
+              }
+
               const html = res.data;
+              if (200 <= res.status && res.status <= 299) {
+                if (isDefined(attrs["success"])) {
+                  $parse(attrs["success"])(scope, { $res: html });
+                }
+
+                if (isDefined(attrs["stateSuccess"])) {
+                  $state.go(attrs["stateSuccess"]);
+                }
+              } else if (400 <= res.status && res.status <= 599) {
+                if (isDefined(attrs["error"])) {
+                  $parse(attrs["error"])(scope, { $res: html });
+                }
+
+                if (isDefined(attrs["stateError"])) {
+                  $state.go(attrs["stateError"]);
+                }
+              }
+
               handleSwapResponse(
                 html,
-                /** @type {import("../../interface.ts").SwapInsertPosition} */ (
-                  swap
-                ),
+                /** @type {import("../../interface.ts").SwapModeType} */ (swap),
                 target,
                 scope,
                 $compile,
               );
             };
 
+            if (isDefined(attrs["delay"])) {
+              await wait(parseInt(attrs["delay"]) | 0);
+            }
+
+            if (throttled) {
+              return;
+            }
+
+            if (isDefined(attrs["throttle"])) {
+              throttled = true;
+              attrs.$set("throttled", true);
+              setTimeout(() => {
+                attrs.$set("throttled", false);
+                throttled = false;
+              }, parseInt(attrs["throttle"]));
+            }
+
+            if (isDefined(attrs["loading"])) {
+              attrs.$set("loading", true);
+            }
+
+            if (isDefined(attrs["loadingClass"])) {
+              attrs.$addClass(attrs["loadingClass"]);
+            }
+
             if (method === "post" || method === "put") {
               const data = collectFormData(element);
               $http[method](url, data).then(handler).catch(handler);
@@ -35906,6 +35737,8 @@
               $http[method](url).then(handler).catch(handler);
             }
           });
+
+          scope.$on("$destroy", () => clearInterval(intervalId));
         },
       };
     };
@@ -35917,13 +35750,13 @@
    * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
    */
   function registerNgModule(angular) {
-    const ng = angular
+    return angular
       .module(
         "ng",
         [],
         [
           "$provide",
-          /** @type {import('./interface.js').Provider} */
+          /** @param {import("./interface.js").Provider} $provide */
           ($provide) => {
             // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
             $provide.provider({
@@ -36024,7 +35857,6 @@
               $$animateQueue: AnimateQueueProvider,
               $$AnimateRunner: AnimateRunnerFactoryProvider,
               $$animateAsyncRun: AnimateAsyncRunFactoryProvider,
-              $browser: BrowserProvider,
               $controller: ControllerProvider,
               $exceptionHandler: ExceptionHandlerProvider,
               $filter: FilterProvider,
@@ -36040,7 +35872,6 @@
               $routerGlobals: RouterGlobals,
               $sce: SceProvider,
               $sceDelegate: SceDelegateProvider,
-              $$taskTrackerFactory: TaskTrackerFactoryProvider,
               $templateCache: TemplateCacheProvider,
               $templateRequest: TemplateRequestProvider,
               $urlConfig: UrlConfigProvider,
@@ -36067,8 +35898,6 @@
         },
       ])
       .value("$trace", trace);
-
-    return ng;
   }
 
   const ngMinErr = minErr("ng");
@@ -36094,7 +35923,7 @@
       /**
        * @type {string} `version` from `package.json`
        */
-      this.version = "0.7.5"; //inserted via rollup plugin
+      this.version = "0.7.8"; //inserted via rollup plugin
 
       /** @type {!Array<string|any>} */
       this.bootsrappedModules = [];
@@ -36334,12 +36163,7 @@
             name,
           );
         }
-        const moduleInstance = new NgModule(
-          name,
-          requires,
-          /** @type {Function} */ (configFn),
-        );
-        return moduleInstance;
+        return new NgModule(name, requires, /** @type {Function} */ (configFn));
       });
     }
   }