@angular-wave/angular.ts 0.7.5 → 0.7.8

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.7.5 - July 12, 2025 01:24:07 */
+/* Version: 0.7.8 - July 17, 2025 02:51:20 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -241,7 +241,7 @@ function isWindow(obj) {
  * @returns {boolean}
  */
 function isScope(obj) {
-  return obj && obj.$evalAsync && obj.$watch;
+  return obj && obj.$watch;
 }
 
 /**
@@ -1130,11 +1130,55 @@ function hasOwn(obj, key) {
   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>}
  */
@@ -1687,6 +1731,16 @@ function extractElementNode$1(element) {
   }
 }
 
+/**
+ * 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`.
@@ -1719,7 +1773,7 @@ const $injectTokens = Object.freeze({
   $animate: "$animate",
   $animateCss: "$animateCss",
   $aria: "$aria",
-  $browser: "$browser",
+  $compile: "$compile",
   $controller: "$controller",
   $eventBus: "$eventBus",
   $exceptionHandler: "$exceptionHandler",
@@ -1762,10 +1816,15 @@ function provider(services) {
   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";
 
 /**
@@ -1832,11 +1891,7 @@ class NgModule {
    * @returns {NgModule}
    */
   constant(name, object) {
-    this.invokeQueue.unshift([
-      $injectTokens.$provide,
-      "constant",
-      [name, object],
-    ]);
+    this.invokeQueue.unshift([$injectTokens.$provide, "constant", [name, object]]);
     return this;
   }
 
@@ -1881,11 +1936,7 @@ class NgModule {
     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;
   }
 
@@ -1898,11 +1949,7 @@ class NgModule {
     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;
   }
 
@@ -1915,11 +1962,7 @@ class NgModule {
     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;
   }
 
@@ -1932,11 +1975,7 @@ class NgModule {
     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;
   }
 
@@ -2181,8 +2220,11 @@ class InjectorService extends AbstractInjector {
    */
   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;
   }
 
   /**
@@ -2299,9 +2341,6 @@ function createInjector(modulesToLoad, strictDi = false) {
   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),
@@ -2328,15 +2367,10 @@ function createInjector(modulesToLoad, strictDi = false) {
   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;
 
@@ -2465,7 +2499,7 @@ function createInjector(modulesToLoad, strictDi = false) {
 
       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
@@ -2531,7 +2565,6 @@ function extractArgs(fn) {
 }
 
 /**
- *
  * @param {any} fn
  * @param {boolean} [strictDi]
  * @param {String} [name]
@@ -2570,10 +2603,6 @@ function annotate(fn, strictDi, name) {
   return $inject;
 }
 
-/**
- * @param {function(string, any):any} delegate
- * @returns {any}
- */
 function supportObject(delegate) {
   return function (key, value) {
     if (isObject(key)) {
@@ -2989,32 +3018,25 @@ class ControllerProvider {
   }
 }
 
-/**
- * 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,
@@ -3039,7 +3061,7 @@ function urlResolve(url) {
  * 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.
  */
@@ -3053,7 +3075,7 @@ function urlIsSameOrigin(requestUrl) {
  * 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.
  */
@@ -3067,7 +3089,7 @@ function urlIsSameOriginAsBaseUrl(requestUrl) {
  *
  * @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) {
@@ -3080,7 +3102,7 @@ function urlIsAllowedOriginFactory(trustedOriginUrls) {
    * 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.
@@ -3096,9 +3118,9 @@ function urlIsAllowedOriginFactory(trustedOriginUrls) {
 /**
  * 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.
@@ -3131,7 +3153,17 @@ function getBaseUrl() {
   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");
 
@@ -3187,6 +3219,7 @@ function adjustMatcher(matcher) {
       .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.
@@ -3448,6 +3481,11 @@ class SceDelegateProvider {
           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 (
@@ -3455,7 +3493,7 @@ class SceDelegateProvider {
             );
           }
           // definitely a regex.  See adjustMatchers()
-          return !!matcher.exec(parsedUrl.href);
+          return !!(/** @type {RegExp} */ (matcher).exec(parsedUrl.href));
         }
 
         function isResourceUrlAllowedByPolicy(url) {
@@ -3960,9 +3998,13 @@ function SceProvider() {
  * 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}`);
@@ -3971,7 +4013,7 @@ const ngEventDirectives = {};
       "$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) => {
@@ -3988,7 +4030,7 @@ const ngEventDirectives = {};
 /**
  *
  * @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}
@@ -4029,7 +4071,7 @@ class Attributes {
   /**
    * @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]
@@ -4627,7 +4669,7 @@ class CompileProvider {
             "$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 = [];
@@ -4955,7 +4997,7 @@ class CompileProvider {
       /**
        * @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
@@ -8440,7 +8482,7 @@ class NgModelController {
 
   /**
    * @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
@@ -9837,7 +9879,6 @@ function createDateInputType(type, regexp, parseDate) {
     element,
     attr,
     ctrl,
-    $browser,
     $filter,
     $parse,
   ) {
@@ -10114,15 +10155,7 @@ function isValidForStep(viewValue, stepBase, step) {
   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);
@@ -10438,15 +10471,7 @@ function parseConstantExpr($parse, context, name, expression, fallback) {
   return fallback;
 }
 
-function checkboxInputType(
-  scope,
-  element,
-  attr,
-  ctrl,
-  $browser,
-  $filter,
-  $parse,
-) {
+function checkboxInputType(scope, element, attr, ctrl, $filter, $parse) {
   const trueValue = parseConstantExpr(
     $parse,
     scope,
@@ -10484,30 +10509,25 @@ function checkboxInputType(
   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,
           );
@@ -11216,9 +11236,15 @@ function ngBindDirective() {
      * @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"]),
+      );
     },
   };
 }
@@ -11620,7 +11646,7 @@ ngIncludeDirective.$inject = [
  * @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(
@@ -11739,7 +11765,7 @@ function ngIncludeDirective(
 // 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
@@ -11945,7 +11971,7 @@ function ngRepeatDirective($animate) {
     transclude: "element",
     priority: 1000,
     terminal: true,
-    compile: (_$element, $attr) => {
+    compile: ($element, $attr) => {
       const expression = $attr["ngRepeat"];
       const hasAnimate = !!$attr["animate"];
 
@@ -11991,6 +12017,14 @@ function ngRepeatDirective($animate) {
         );
       }
 
+      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.
@@ -12002,174 +12036,181 @@ function ngRepeatDirective($animate) {
         // 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"]),
+        );
       };
     },
   };
@@ -12206,6 +12247,7 @@ function ngStyleDirective() {
 ngSwitchDirective.$inject = ["$animate"];
 
 /**
+ * @param {*} $animate
  * @returns {import('../../interface.ts').Directive}
  */
 function ngSwitchDirective($animate) {
@@ -12353,525 +12395,515 @@ const NG_OPTIONS_REGEXP =
 // 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.
@@ -12890,113 +12922,114 @@ const ngOptionsDirective = [
  *                                               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
@@ -13039,10 +13072,10 @@ Object.entries(ALIASED_ATTR).forEach(([ngAttr]) => {
       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;
           }
         }
@@ -13068,7 +13101,7 @@ Object.entries(ALIASED_ATTR).forEach(([ngAttr]) => {
 
           if (
             attrName === "href" &&
-            toString.call(element.href) === "[object SVGAnimatedString]"
+            toString.call(element["href"]) === "[object SVGAnimatedString]"
           ) {
             name = "xlinkHref";
             attr.$attr[name] = "href";
@@ -13454,7 +13487,7 @@ class AnchorScrollProvider {
     "$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
      */
@@ -13553,7 +13586,7 @@ class AnchorScrollProvider {
           // 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
@@ -14472,216 +14505,6 @@ function AnimateProvider($provide) {
   ];
 }
 
-/**
- * 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 () {
@@ -14887,7 +14710,9 @@ class TemplateCacheProvider {
   /**
    * @returns {import('./interface.ts').TemplateCache}
    */
-  $get = () => this.cache;
+  $get() {
+    return this.cache;
+  }
 }
 
 /**
@@ -14934,9 +14759,9 @@ class TemplateCacheProvider {
  * @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.
@@ -15420,7 +15245,7 @@ function $IsStateFilter($state) {
   const isFilter = function (state, params, options) {
     return $state.is(state, params, options);
   };
-  //isFilter.$stateful = true;
+  isFilter.$stateful = true;
   return isFilter;
 }
 /**
@@ -15441,53 +15266,52 @@ function $IncludedByStateFilter($state) {
   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;
@@ -15626,7 +15450,7 @@ class ASTInterpreter {
         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);
@@ -15639,7 +15463,7 @@ class ASTInterpreter {
                 ? { 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)) {
@@ -15655,7 +15479,7 @@ class ASTInterpreter {
       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;
@@ -15666,7 +15490,7 @@ class ASTInterpreter {
         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));
@@ -15693,7 +15517,7 @@ class ASTInterpreter {
             });
           }
         });
-        return function (scope, locals, assign) {
+        return (scope, locals, assign) => {
           const value = {};
           for (let i = 0; i < args.length; ++i) {
             if (args[i].computed) {
@@ -15709,17 +15533,12 @@ class ASTInterpreter {
           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;
     }
   }
 
@@ -15730,7 +15549,7 @@ class ASTInterpreter {
    * @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;
@@ -15748,7 +15567,7 @@ class ASTInterpreter {
    * @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;
@@ -15766,7 +15585,7 @@ class ASTInterpreter {
    * @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;
     };
@@ -15780,7 +15599,7 @@ class ASTInterpreter {
    * @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);
@@ -15796,7 +15615,7 @@ class ASTInterpreter {
    * @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);
@@ -15812,14 +15631,14 @@ class ASTInterpreter {
    * @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;
     };
@@ -15833,7 +15652,7 @@ class ASTInterpreter {
    * @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;
     };
@@ -15847,7 +15666,7 @@ class ASTInterpreter {
    * @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;
     };
@@ -15861,7 +15680,7 @@ class ASTInterpreter {
    * @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;
     };
@@ -15875,7 +15694,7 @@ class ASTInterpreter {
    * @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;
     };
@@ -15889,7 +15708,7 @@ class ASTInterpreter {
    * @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;
     };
@@ -15903,7 +15722,7 @@ class ASTInterpreter {
    * @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;
     };
@@ -15917,7 +15736,7 @@ class ASTInterpreter {
    * @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;
     };
@@ -15931,7 +15750,7 @@ class ASTInterpreter {
    * @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;
     };
@@ -15945,7 +15764,7 @@ class ASTInterpreter {
    * @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;
     };
@@ -15972,7 +15791,7 @@ class ASTInterpreter {
    * @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;
     };
@@ -15987,7 +15806,7 @@ class ASTInterpreter {
    * @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);
@@ -16002,9 +15821,8 @@ class ASTInterpreter {
    * @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;
   }
 
   /**
@@ -16015,7 +15833,7 @@ class ASTInterpreter {
    * @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] = {};
@@ -16040,7 +15858,7 @@ class ASTInterpreter {
    * @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;
@@ -16070,7 +15888,7 @@ class ASTInterpreter {
    * @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) {
@@ -18491,21 +18309,17 @@ function HttpProvider() {
   });
 
   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>}
        */
@@ -18575,8 +18389,6 @@ function HttpProvider() {
           ? $injector.get(config.paramSerializer)
           : config.paramSerializer;
 
-        $browser.$$incOutstandingRequestCount("$http");
-
         const requestInterceptors = [];
         const responseInterceptors = [];
         let promise = Promise.resolve(config);
@@ -18600,7 +18412,6 @@ function HttpProvider() {
         promise = chainInterceptors(promise, requestInterceptors);
         promise = promise.then(serverRequest);
         promise = chainInterceptors(promise, responseInterceptors);
-        promise = promise.finally(completeOutstandingRequest);
 
         return promise;
 
@@ -18617,10 +18428,6 @@ function HttpProvider() {
           return promise;
         }
 
-        function completeOutstandingRequest() {
-          $browser.$$completeOutstandingRequest(() => {}, "$http");
-        }
-
         function executeHeaderFns(headers, config) {
           let headerContent;
           const processedHeaders = {};
@@ -19059,24 +18866,14 @@ function HttpProvider() {
  */
 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,
@@ -19090,7 +18887,7 @@ function createHttpBackend($browser) {
     eventHandlers,
     uploadEventHandlers,
   ) {
-    url = url || $browser.url();
+    url = url || trimEmptyHash(window.location.href);
 
     const xhr = new XMLHttpRequest();
     let abortedByTimeout = false;
@@ -19298,7 +19095,7 @@ class Location {
      */
     this.$$replace = false;
 
-    /** @type {import('../url-utils/url-utils').HttpProtocol} */
+    /** @type {string} */
     this.$$protocol = parsedUrl.protocol;
 
     /** @type {string} */
@@ -19365,7 +19162,7 @@ class Location {
   /**
    *
    * 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;
@@ -19666,12 +19463,13 @@ class LocationHtml5Url extends Location {
  * 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;
@@ -19782,6 +19580,111 @@ class LocationProvider {
       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);
   }
 
   /**
@@ -19843,21 +19746,19 @@ class LocationProvider {
 
   $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) {
@@ -19882,20 +19783,20 @@ class LocationProvider {
       );
       $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));
@@ -19903,7 +19804,7 @@ class LocationProvider {
 
           throw e;
         }
-      }
+      };
 
       $rootElement.addEventListener(
         "click",
@@ -19971,10 +19872,6 @@ class LocationProvider {
               // 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();
-              // }
             }
           }
         },
@@ -19982,20 +19879,20 @@ class LocationProvider {
 
       // 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;
@@ -20030,9 +19927,9 @@ class LocationProvider {
         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);
@@ -20291,7 +20188,7 @@ function nextId() {
  */
 let $parse;
 
-/**@type {import('../exception-handler.js').ErrorHandler} */
+/**@type {import('../../services/exception/exception-handler.js').ErrorHandler} */
 let $exceptionHandler;
 
 /**
@@ -20312,7 +20209,7 @@ class RootScopeProvider {
     "$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) => {
@@ -20723,7 +20620,6 @@ class Scope {
       $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,
@@ -21229,10 +21125,6 @@ class Scope {
     return res;
   }
 
-  async $evalAsync(expr, locals) {
-    return await this.$eval(expr, locals);
-  }
-
   /**
    * @param {Object} newTarget
    */
@@ -21514,152 +21406,6 @@ function collectChildIds(child) {
   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");
 
 /**
@@ -21719,7 +21465,7 @@ function TemplateRequestProvider() {
     "$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
@@ -21734,6 +21480,7 @@ function TemplateRequestProvider() {
         // 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);
@@ -21799,7 +21546,7 @@ function TemplateRequestProvider() {
   ];
 }
 
-/** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider } */
+/** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider */
 
 /**
  * Private service to sanitize uris for links and images. Used by $compile.
@@ -21851,7 +21598,7 @@ class SanitizeUriProvider {
   }
 
   /**
-   * @returns {import("./interface.js").SanitizerFn} Sanitizer function.
+   * @returns {import("./interface").SanitizerFn}
    */
   $get() {
     return (uri, isMediaUrl) => {
@@ -21975,7 +21722,7 @@ class NgMessageCtrl {
   reRender() {
     if (!this.renderLater) {
       this.renderLater = true;
-      this.$scope.$evalAsync(() => {
+      Promise.resolve().then(() => {
         if (this.renderLater && this.cachedCollection) {
           this.render(this.cachedCollection);
         }
@@ -22108,6 +21855,10 @@ const ngMessageDirective = ngMessageDirectiveFactory(false);
 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) {
@@ -25188,7 +24939,7 @@ function AnimationProvider() {
 
 /**
  * Service provider that creates a requestAnimationFrame-based scheduler.
- * @implements {ServiceProvider}
+ * @type {ServiceProvider}
  */
 class RafSchedulerProvider {
   constructor() {
@@ -26940,7 +26691,6 @@ class Queue {
  *
  * This is where we hold the global mutable state such as current state, current
  * params, current transition, etc.
- * @implements {ServiceProvider}
  */
 class RouterGlobals {
   constructor() {
@@ -29581,6 +29331,11 @@ class Glob {
      */
     this.regexp = new RegExp("^" + regexpString + "$");
   }
+
+  /**
+   * @param {string} name
+   * @return {boolean}
+   */
   matches(name) {
     return this.regexp.test("." + name);
   }
@@ -33515,7 +33270,7 @@ class UrlService {
   ];
 
   /**
-   * @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
@@ -33524,9 +33279,7 @@ class UrlService {
     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);
@@ -33579,18 +33332,15 @@ class UrlService {
 
   $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);
@@ -33614,7 +33364,7 @@ class UrlService {
   baseHref() {
     return (
       this._baseHref ||
-      (this._baseHref = this.$browser.baseHref() || window.location.pathname)
+      (this._baseHref = getBaseHref() || window.location.pathname)
     );
   }
 
@@ -34461,7 +34211,6 @@ class StateQueueManager {
  *
  * This API is found at `$stateRegistry` ([[UIRouter.stateRegistry]])
  *
- * @implements {ServiceProvider}
  */
 class StateRegistryProvider {
   static $inject = provider([
@@ -35090,12 +34839,10 @@ function $StateRefActiveDirective(
         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();
     },
@@ -35227,11 +34974,20 @@ function $StateRefActiveDirective(
  * });
  * ```
  */
+
+/** @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 {
@@ -35262,7 +35018,6 @@ let ngView = [
     };
     const directive = {
       count: 0,
-
       terminal: true,
       priority: 400,
       transclude: "element",
@@ -35599,11 +35354,12 @@ function ngChannelDirective($eventBus) {
   };
 }
 
-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 {
@@ -35612,19 +35368,19 @@ function ngSetterDirective($parse, $log) {
       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) => {
@@ -35644,16 +35400,11 @@ function ngSetterDirective($parse, $log) {
         }
       });
 
-      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);
@@ -35668,13 +35419,20 @@ function ngSetterDirective($parse, $log) {
 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");
 
 /**
@@ -35701,7 +35459,7 @@ function getEventNameForElement(element) {
  * 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
@@ -35792,9 +35550,11 @@ function createHttpDirective(method, attrName) {
    * @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.
      *
@@ -35855,16 +35615,38 @@ function createHttpDirective(method, attrName) {
       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;
@@ -35881,18 +35663,67 @@ function createHttpDirective(method, attrName) {
           }
 
           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);
@@ -35900,6 +35731,8 @@ function createHttpDirective(method, attrName) {
             $http[method](url).then(handler).catch(handler);
           }
         });
+
+        scope.$on("$destroy", () => clearInterval(intervalId));
       },
     };
   };
@@ -35911,13 +35744,13 @@ function createHttpDirective(method, attrName) {
  * @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({
@@ -36018,7 +35851,6 @@ function registerNgModule(angular) {
             $$animateQueue: AnimateQueueProvider,
             $$AnimateRunner: AnimateRunnerFactoryProvider,
             $$animateAsyncRun: AnimateAsyncRunFactoryProvider,
-            $browser: BrowserProvider,
             $controller: ControllerProvider,
             $exceptionHandler: ExceptionHandlerProvider,
             $filter: FilterProvider,
@@ -36034,7 +35866,6 @@ function registerNgModule(angular) {
             $routerGlobals: RouterGlobals,
             $sce: SceProvider,
             $sceDelegate: SceDelegateProvider,
-            $$taskTrackerFactory: TaskTrackerFactoryProvider,
             $templateCache: TemplateCacheProvider,
             $templateRequest: TemplateRequestProvider,
             $urlConfig: UrlConfigProvider,
@@ -36061,8 +35892,6 @@ function registerNgModule(angular) {
       },
     ])
     .value("$trace", trace);
-
-  return ng;
 }
 
 const ngMinErr = minErr("ng");
@@ -36088,7 +35917,7 @@ class Angular {
     /**
      * @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 = [];
@@ -36328,12 +36157,7 @@ class Angular {
           name,
         );
       }
-      const moduleInstance = new NgModule(
-        name,
-        requires,
-        /** @type {Function} */ (configFn),
-      );
-      return moduleInstance;
+      return new NgModule(name, requires, /** @type {Function} */ (configFn));
     });
   }
 }