@angular-wave/angular.ts 0.7.0-beta.1 → 0.7.2

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.7.0-beta.1 - June 19, 2025 01:16:31 */
+/* Version: 0.7.2 - June 28, 2025 21:48:50 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -74,7 +74,7 @@
   }
 
   /**
-   * @param {*} obj
+   * @param {*} obj Reference to check.
    * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
    *                   String ...)
    */
@@ -749,7 +749,7 @@
         key = tryDecodeURIComponent(key);
         if (isDefined(key)) {
           val = isDefined(val) ? tryDecodeURIComponent(val) : true;
-          if (!hasOwn(obj, key)) {
+          if (!hasOwn(obj, /** @type {string} */ (key))) {
             obj[key] = val;
           } else if (Array.isArray(obj[key])) {
             obj[key].push(val);
@@ -789,12 +789,13 @@
    * Tries to decode the URI component without throwing an exception.
    *
    * @param  {string} value potential URI component to check.
-   * @returns {string}
+   * @returns {string|void}
    */
   function tryDecodeURIComponent(value) {
     try {
       return decodeURIComponent(value);
     } catch {
+      return;
     }
   }
 
@@ -1712,7 +1713,78 @@
     }
   }
 
-  const PROVIDE_LITERAL = "$provide";
+  /**
+   * 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`.
+   *
+   * Example:
+   * ```js
+   *
+   * myDirective.$inject = [
+   *   angular.$injectTokens.$animate,
+   *   angular.$injectTokens.$templateRequest,
+   * ];
+   * ```
+   * @type Readonly<Record<string, string>>
+   */
+  const $injectTokens = Object.freeze({
+    $$AnimateRunner: "$$AnimateRunner",
+    $$animateAsyncRun: "$$animateAsyncRun",
+    $$animateCache: "$$animateCache",
+    $$animateCssDriver: "$$animateCssDriver",
+    $$animateJs: "$$animateJs",
+    $$animateJsDriver: "$$animateJsDriver",
+    $$animateQueue: "$$animateQueue",
+    $$animation: "$$animation",
+    $$rAFScheduler: "$$rAFScheduler",
+    $$taskTrackerFactory: "$$taskTrackerFactory",
+    $anchorScroll: "$anchorScroll",
+    $animate: "$animate",
+    $animateCss: "$animateCss",
+    $aria: "$aria",
+    $browser: "$browser",
+    $controller: "$controller",
+    $eventBus: "$eventBus",
+    $exceptionHandler: "$exceptionHandler",
+    $filter: "$filter",
+    $http: "$http",
+    $httpBackend: "$httpBackend",
+    $httpParamSerializer: "$httpParamSerializer",
+    $interpolate: "$interpolate",
+    $location: "$location",
+    $log: "$log",
+    $ngViewScroll: "$ngViewScroll",
+    $parse: "$parse",
+    $rootScope: "$rootScope",
+    $routerGlobals: "$routerGlobals",
+    $sce: "$sce",
+    $sceDelegate: "$sceDelegate",
+    $state: "$state",
+    $stateRegistry: "$stateRegistry",
+    $templateCache: "$templateCache",
+    $templateFactory: "$templateFactory",
+    $templateRequest: "$templateRequest",
+    $transitions: "$transitions",
+    $urlConfig: "$urlConfig",
+    $urlService: "$urlService",
+    $view: "$view",
+    // provide literals
+    $provide: "$provide",
+    $injector: "$injector",
+    $compileProvider: "$compileProvider",
+    $animateProvider: "$animateProvider",
+    $filterProvider: "$filterProvider",
+    $controllerProvider: "$controllerProvider",
+  });
+
+  /**
+   * Utility for mapping to service-names to providers
+   * @param {String[]} services
+   */
+  function provider(services) {
+    return services.map((x) => x + "Provider");
+  }
+
   const INJECTOR_LITERAL = "$injector";
   const COMPILE_LITERAL = "$compileProvider";
   const ANIMATION_LITERAL = "$animateProvider";
@@ -1789,7 +1861,7 @@
      * @returns {NgModule}
      */
     value(name, object) {
-      this.invokeQueue.push([PROVIDE_LITERAL, "value", [name, object]]);
+      this.invokeQueue.push([$injectTokens.$provide, "value", [name, object]]);
       return this;
     }
 
@@ -1799,7 +1871,11 @@
      * @returns {NgModule}
      */
     constant(name, object) {
-      this.invokeQueue.unshift([PROVIDE_LITERAL, "constant", [name, object]]);
+      this.invokeQueue.unshift([
+        $injectTokens.$provide,
+        "constant",
+        [name, object],
+      ]);
       return this;
     }
 
@@ -1845,7 +1921,7 @@
         providerFunction.$$moduleName = name;
       }
       this.invokeQueue.push([
-        PROVIDE_LITERAL,
+        $injectTokens.$provide,
         "factory",
         [name, providerFunction],
       ]);
@@ -1862,7 +1938,7 @@
         serviceFunction.$$moduleName = name;
       }
       this.invokeQueue.push([
-        PROVIDE_LITERAL,
+        $injectTokens.$provide,
         "service",
         [name, serviceFunction],
       ]);
@@ -1878,7 +1954,11 @@
       if (providerType && isFunction(providerType)) {
         providerType.$$moduleName = name;
       }
-      this.invokeQueue.push([PROVIDE_LITERAL, "provider", [name, providerType]]);
+      this.invokeQueue.push([
+        $injectTokens.$provide,
+        "provider",
+        [name, providerType],
+      ]);
       return this;
     }
 
@@ -1891,7 +1971,11 @@
       if (decorFn && isFunction(decorFn)) {
         decorFn.$$moduleName = name;
       }
-      this.configBlocks.push([PROVIDE_LITERAL, "decorator", [name, decorFn]]);
+      this.configBlocks.push([
+        $injectTokens.$provide,
+        "decorator",
+        [name, decorFn],
+      ]);
       return this;
     }
 
@@ -1971,6 +2055,7 @@
       this.cache = {};
       /** @type {boolean} */
       this.strictDi = strictDi;
+      /** @type {string[]} */
       this.path = [];
       /** @type {Object.<string, import("./ng-module.js").NgModule>} */
       this.modules = {};
@@ -2089,6 +2174,7 @@
     /**
      * @abstract
      * @param {string} _serviceName
+     * @returns {any}
      */
     factory(_serviceName) {
       console.error(`Unhandled ${_serviceName}`);
@@ -2240,7 +2326,6 @@
   const FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
   const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
   const $injectorMinErr$1 = minErr(INJECTOR_LITERAL);
-
   const providerSuffix = "Provider";
 
   /**
@@ -2608,7 +2693,7 @@
         this._node = element;
       }
 
-      // Nandle array of elements
+      // Handle array of elements
       else if (element instanceof Array) {
         if (element.length == 1) {
           this.initial = element[0].cloneNode(true);
@@ -2651,8 +2736,6 @@
       } else {
         this._element = undefined;
       }
-      // this._nodes = undefined;
-      // this.isList = false;
     }
 
     /** @param {Array<Node>} nodes */
@@ -3387,7 +3470,7 @@
         "$exceptionHandler",
         /**
          *
-         * @param {import("../../core/di/internal-injector").InjectorService} $injector
+         * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
          * @param {*} $$sanitizeUri
          * @param {ErrorHandler} $exceptionHandler
          * @returns
@@ -3614,14 +3697,11 @@
               if (isResourceUrlAllowedByPolicy(maybeTrusted)) {
                 return maybeTrusted;
               }
-              $exceptionHandler(
-                $sceMinErr(
-                  "insecurl",
-                  "Blocked loading resource from url not allowed by $sceDelegate policy.  URL: {0}",
-                  maybeTrusted.toString(),
-                ),
+              throw $sceMinErr(
+                "insecurl",
+                "Blocked loading resource from url not allowed by $sceDelegate policy.  URL: {0}",
+                maybeTrusted.toString(),
               );
-              return;
             } else if (type === SCE_CONTEXTS.HTML) {
               // htmlSanitizer throws its own error when no sanitizer is available.
               return htmlSanitizer();
@@ -3662,8 +3742,7 @@
     this.$get = [
       "$parse",
       "$sceDelegate",
-      "$exceptionHandler",
-      function ($parse, $sceDelegate, $exceptionHandler) {
+      function ($parse, $sceDelegate) {
         const sce = shallowCopy(SCE_CONTEXTS);
 
         /**
@@ -3907,11 +3986,7 @@
             return parse(enumValue, expr);
           };
           sce[snakeToCamel(`get_trusted_${lName}`)] = function (value) {
-            try {
-              return getTrusted(enumValue, value);
-            } catch (e) {
-              $exceptionHandler(e);
-            }
+            return getTrusted(enumValue, value);
           };
           sce[snakeToCamel(`trust_as_${lName}`)] = function (value) {
             return trustAs(enumValue, value);
@@ -3990,6 +4065,9 @@
   const SIMPLE_ATTR_NAME = /^\w/;
   const specialAttrHolder = document.createElement("div");
 
+  /**
+   * @implements {Record<string, any>}
+   */
   class Attributes {
     static $nonscope = true;
 
@@ -3999,7 +4077,7 @@
      * @param {import("../exception-handler.js").ErrorHandler} $exceptionHandler
      * @param {*} $sce
      * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
-     * @param {*} [attributesToCopy]
+     * @param {Object} [attributesToCopy]
      */
     constructor(
       $rootScope,
@@ -4446,7 +4524,7 @@
 
     /**
      * @param {import('../../interface.js').Provider} $provide
-     * @param $$sanitizeUriProvider
+     * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $$sanitizeUriProvider
      */
     constructor($provide, $$sanitizeUriProvider) {
       const hasDirectives = {};
@@ -4458,7 +4536,7 @@
        * @param {import("../scope/scope.js").Scope} scope
        * @param {string} directiveName
        * @param {boolean} isController
-       * @returns {Object} a configuartion object for attribute bindings
+       * @returns {Object} a configuration object for attribute bindings
        */
       function parseIsolateBindings(scope, directiveName, isController) {
         const LOCAL_REGEXP = /^([@&]|[=<]())(\??)\s*([\w$]*)$/;
@@ -4754,13 +4832,13 @@
        * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
        *
        * @param {RegExp=} regexp New regexp to trust urls with.
-       * @returns {RegExp|CompileProvider} Current RegExp if called without value or self for
+       * @returns {RegExp|import('../sanitize/sanitize-uri.js').SanitizeUriProvider} Current RegExp if called without value or self for
        *    chaining otherwise.
        */
       this.aHrefSanitizationTrustedUrlList = function (regexp) {
         if (isDefined(regexp)) {
           $$sanitizeUriProvider.aHrefSanitizationTrustedUrlList(regexp);
-          return this;
+          return;
         }
         return $$sanitizeUriProvider.aHrefSanitizationTrustedUrlList();
       };
@@ -4777,13 +4855,13 @@
        * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
        *
        * @param {RegExp=} regexp New regexp to trust urls with.
-       * @returns {RegExp|CompileProvider} Current RegExp if called without value or self for
+       * @returns {RegExp|import('../sanitize/sanitize-uri.js').SanitizeUriProvider} Current RegExp if called without value or self for
        *    chaining otherwise.
        */
       this.imgSrcSanitizationTrustedUrlList = function (regexp) {
         if (isDefined(regexp)) {
           $$sanitizeUriProvider.imgSrcSanitizationTrustedUrlList(regexp);
-          return this;
+          return;
         }
         return $$sanitizeUriProvider.imgSrcSanitizationTrustedUrlList();
       };
@@ -5597,6 +5675,7 @@
               let controllerScope;
               let elementControllers;
               let transcludeFn;
+              let scopeToChild = scope;
 
               /** @type {NodeRef} */
               let $element;
@@ -5768,7 +5847,7 @@
               // RECURSION
               // We only pass the isolate scope, if the isolate directive has a template,
               // otherwise the child elements do not belong to the isolate directive.
-              var scopeToChild = scope;
+
               if (
                 newIsolateScopeDirective &&
                 (newIsolateScopeDirective.template ||
@@ -6773,6 +6852,8 @@
               .catch((error) => {
                 if (isError(error)) {
                   $exceptionHandler(error);
+                } else {
+                  $exceptionHandler(new Error(error));
                 }
               });
 
@@ -6880,11 +6961,12 @@
             type = (type || "html").toLowerCase();
             switch (type) {
               case "svg":
-              case "math":
-                /** @type {HTMLDivElement} */
-                var wrapper = document.createElement("div");
+              case "math": {
+                const wrapper =
+                  /** @type {HTMLDivElement} */ document.createElement("div");
                 wrapper.innerHTML = `<${type}>${template}</${type}>`;
                 return wrapper.childNodes[0].childNodes;
+              }
               default:
                 return template;
             }
@@ -6960,21 +7042,22 @@
             // If you want to programmatically set explicitly trusted unsafe URLs, you should use
             // `$sce.trustAsHtml` on the whole `img` tag and inject it into the DOM using the
             // `ng-bind-html` directive.
-            var result = "";
+            let result = "";
 
             // first check if there are spaces because it's not the same pattern
-            var trimmedSrcset = trim(value);
+            const trimmedSrcset = trim(value);
             //                (   999x   ,|   999w   ,|   ,|,   )
-            var srcPattern = /(\s+\d+x\s*,|\s+\d+w\s*,|\s+,|,\s+)/;
-            var pattern = /\s/.test(trimmedSrcset) ? srcPattern : /(,)/;
+            const srcPattern = /(\s+\d+x\s*,|\s+\d+w\s*,|\s+,|,\s+)/;
+            const pattern = /\s/.test(trimmedSrcset) ? srcPattern : /(,)/;
 
             // split srcset into tuple of uri and descriptor except for the last item
-            var rawUris = trimmedSrcset.split(pattern);
+            const rawUris = trimmedSrcset.split(pattern);
 
             // for each tuples
-            var nbrUrisWith2parts = Math.floor(rawUris.length / 2);
-            for (var i = 0; i < nbrUrisWith2parts; i++) {
-              var innerIdx = i * 2;
+            const nbrUrisWith2parts = Math.floor(rawUris.length / 2);
+            let i;
+            for (i = 0; i < nbrUrisWith2parts; i++) {
+              const innerIdx = i * 2;
               // sanitize the uri
               result += $sce.getTrustedMediaUrl(trim(rawUris[innerIdx]));
               // add the descriptor
@@ -6982,7 +7065,7 @@
             }
 
             // split the last item into uri and descriptor
-            var lastTuple = trim(rawUris[i * 2]).split(/\s/);
+            const lastTuple = trim(rawUris[i * 2]).split(/\s/);
 
             // sanitize the last uri
             result += $sce.getTrustedMediaUrl(trim(lastTuple[0]));
@@ -7286,7 +7369,7 @@
                     removeWatchCollection.push(removeWatch);
                     break;
 
-                  case "=":
+                  case "=": {
                     if (!hasOwn(attrs, attrName)) {
                       if (optional) {
                         break;
@@ -7299,7 +7382,6 @@
                     }
 
                     parentGet = $parse(attrs[attrName]);
-                    var complexExpression = !!parentGet.inputs;
                     if (parentGet.literal) {
                       compare = equals$1;
                     } else {
@@ -7324,7 +7406,7 @@
                     lastValue = destination.$target[scopeName] = parentGet(
                       scope.$target,
                     );
-                    var parentValueWatch = function parentValueWatch(
+                    const parentValueWatch = function parentValueWatch(
                       parentValue,
                     ) {
                       if (!compare(parentValue, destination[scopeName])) {
@@ -7356,7 +7438,7 @@
                         scope.$watch(
                           expr,
                           (val) => {
-                            var res = $parse(attrs[attrName], parentValueWatch);
+                            const res = $parse(attrs[attrName], parentValueWatch);
                             if (val) {
                               if (parentGet.literal) {
                                 scope.$target[attrName] = val;
@@ -7382,7 +7464,7 @@
                             return;
                           }
                           if (
-                            (complexExpression && !parentGet.literal) ||
+                            (!!parentGet.inputs && !parentGet.literal) ||
                             (isUndefined(attrs[attrName]) && isDefined(val))
                           ) {
                             destination.$target[attrName] = lastValue;
@@ -7414,6 +7496,7 @@
                     }
                     removeWatchCollection.push(removeWatch);
                     break;
+                  }
 
                   case "<":
                     if (!hasOwn(attrs, attrName)) {
@@ -10363,13 +10446,19 @@
     };
 
     element.addEventListener("change", listener);
-
+    // NgModelController call
     ctrl.$render = function () {
       let { value } = attr;
       if (doTrim) {
         value = trim(value);
       }
-      element.checked = value === ctrl.$viewValue;
+      const deproxy = isProxy(ctrl.$viewValue)
+        ? ctrl.$viewValue.$target
+        : ctrl.$viewValue;
+      // the proxy may reach down two levels
+      element.checked =
+        (isProxy(value) ? value.$target : value) ===
+        (isProxy(deproxy) ? deproxy.$target : deproxy);
     };
 
     attr.$observe("value", ctrl.$render);
@@ -11164,7 +11253,6 @@
    */
   function ngBindDirective() {
     return {
-      restrict: "EA",
       /**
        * @param {import('../../core/scope/scope.js').Scope} scope
        * @param {Element} element
@@ -11183,7 +11271,6 @@
    */
   function ngBindTemplateDirective() {
     return {
-      restrict: "EA",
       /**
        * @param {import('../../core/scope/scope.js').Scope} _scope
        * @param {Element} element
@@ -11197,7 +11284,7 @@
     };
   }
 
-  ngBindHtmlDirective.$inject = ["$parse"];
+  ngBindHtmlDirective.$inject = [$injectTokens.$parse];
   /**
    * @returns {import('../../interface.ts').Directive}
    */
@@ -11232,7 +11319,6 @@
 
     return function () {
       return {
-        restrict: "EA",
         /**
          * @param {import("../../core/scope/scope.js").Scope} scope
          * @param {Element} element
@@ -11396,7 +11482,6 @@
    */
   function ngCloakDirective() {
     return {
-      restrict: "EA",
       compile(element, attr) {
         attr.$set("ngCloak", undefined);
         element.classList.remove("ng-cloak");
@@ -11552,26 +11637,36 @@
     };
   }
 
-  ngIncludeDirective.$inject = ["$templateRequest", "$anchorScroll", "$animate"];
+  ngIncludeDirective.$inject = [
+    $injectTokens.$templateRequest,
+    $injectTokens.$anchorScroll,
+    $injectTokens.$animate,
+    $injectTokens.$exceptionHandler,
+  ];
 
   /**
    *
    * @param {*} $templateRequest
    * @param {import("../../services/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
    * @param {*} $animate
-   * @returns
+   * @param {import('../../core/error-handler.js').ErrorHandler} $exceptionHandler
+   * @returns {import('../../interface.js').Directive}
    */
-  function ngIncludeDirective($templateRequest, $anchorScroll, $animate) {
+  function ngIncludeDirective(
+    $templateRequest,
+    $anchorScroll,
+    $animate,
+    $exceptionHandler,
+  ) {
     return {
-      restrict: "EA",
       priority: 400,
       terminal: true,
       transclude: "element",
       controller: () => {},
       compile(_element, attr) {
-        const srcExp = attr.ngInclude || attr.src;
-        const onloadExp = attr.onload || "";
-        const autoScrollExp = attr.autoscroll;
+        const srcExp = attr["ngInclude"] || attr["src"];
+        const onloadExp = attr["onload"] || "";
+        const autoScrollExp = attr["autoscroll"];
 
         return (scope, $element, _$attr, ctrl, $transclude) => {
           function maybeScroll() {
@@ -11624,7 +11719,7 @@
                   if (scope.$$destroyed) return;
                   if (thisChangeId !== changeCounter) return;
                   const newScope = scope.$new();
-                  ctrl.template = response;
+                  ctrl["template"] = response;
 
                   // Note: This will also link all children of ng-include that were contained in the original
                   // html. If that content contains controllers, ... they could pollute/change the scope.
@@ -11647,19 +11742,20 @@
                   currentScope.$emit("$includeContentLoaded", src);
                   scope.$eval(onloadExp);
                 },
-                () => {
+                (err) => {
                   if (scope.$$destroyed) return;
 
                   if (thisChangeId === changeCounter) {
                     cleanupLastIncludeContent();
                     scope.$emit("$includeContentError", src);
                   }
+                  $exceptionHandler(new Error(err));
                 },
               );
               scope.$emit("$includeContentRequested", src);
             } else {
               cleanupLastIncludeContent();
-              ctrl.template = null;
+              ctrl["template"] = null;
             }
           });
         };
@@ -11680,7 +11776,6 @@
    */
   function ngIncludeFillContentDirective($compile) {
     return {
-      restrict: "EA",
       priority: -400,
       require: "ngInclude",
       link(scope, $element, _$attr, ctrl) {
@@ -11716,7 +11811,6 @@
    */
   function ngNonBindableDirective() {
     return {
-      restrict: "EA",
       terminal: true,
       priority: 1000,
     };
@@ -11826,7 +11920,7 @@
   const VAR_OR_TUPLE_REGEX =
     /^(?:(\s*[$\w]+)|\(\s*([$\w]+)\s*,\s*([$\w]+)\s*\))$/;
 
-  ngRepeatDirective.$inject = ["$animate"];
+  ngRepeatDirective.$inject = [$injectTokens.$animate];
 
   /**
    * TODO // Add type for animate service
@@ -11938,15 +12032,15 @@
           let lastBlockMap = Object.create(null);
           // watch props
           $scope.$watch(rhs, (collection) => {
-            var index,
+            let index,
               length,
               previousNode = $element, // node that cloned nodes should be inserted after
               // initialized to the comment node anchor
-              nextNode,
-              // Same as lastBlockMap but it has the current state. It will become the
+              nextNode;
+            const // Same as lastBlockMap but it has the current state. It will become the
               // lastBlockMap on the next iteration.
-              nextBlockMap = Object.create(null),
-              collectionLength,
+              nextBlockMap = Object.create(null);
+            let collectionLength,
               key,
               value, // key/value of iteration
               trackById,
@@ -12012,7 +12106,7 @@
             }
 
             // remove leftover items
-            for (var blockKey in lastBlockMap) {
+            for (let blockKey in lastBlockMap) {
               block = lastBlockMap[blockKey];
               elementsToRemove = block.clone;
               if (hasAnimate) {
@@ -12230,7 +12324,7 @@
       transclude: "element",
       terminal: true,
       priority: 1200,
-      restrict: "EA",
+
       require: "^ngSwitch",
       link(scope, element, attrs, ctrl, $transclude) {
         const cases = attrs["ngSwitchWhen"]
@@ -12257,7 +12351,6 @@
    */
   function ngSwitchDefaultDirective() {
     return {
-      restrict: "EA",
       transclude: "element",
       terminal: true,
       priority: 1200,
@@ -12271,6 +12364,12 @@
 
   const ngOptionsMinErr = minErr("ngOptions");
 
+  /** @type {HTMLOptionElement} */
+  const optionTemplate = document.createElement("option");
+
+  /** @type {HTMLOptGroupElement} */
+  const optGroupTemplate = document.createElement("optgroup");
+
   const NG_OPTIONS_REGEXP =
     /^\s*([\s\S]+?)(?:\s+as\s+([\s\S]+?))?(?:\s+group\s+by\s+([\s\S]+?))?(?:\s+disable\s+when\s+([\s\S]+?))?\s+for\s+(?:([$\w][$\w]*)|(?:\(\s*([$\w][$\w]*)\s*,\s*([$\w][$\w]*)\s*\)))\s+in\s+([\s\S]+?)(?:\s+track\s+by\s+([\s\S]+?))?$/;
   // 1: value expression (valueFn)
@@ -12293,6 +12392,12 @@
      * @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) {
@@ -12419,7 +12524,9 @@
           }),
 
           getOptions() {
+            /** @type {Option[]} */
             const optionItems = [];
+            /** @type {Object.<string, Option>} */
             const selectValueMap = {};
 
             // The option values were already computed in the `getWatchables` fn,
@@ -12470,23 +12577,17 @@
         };
       }
 
-      // Support: IE 9 only
-      // We can't just ('<option>') since JQLite is not smart enough
-      // to create it in <select> and IE barfs otherwise.
-      const optionTemplate = document.createElement("option");
-      const optGroupTemplate = document.createElement("optgroup");
-
       /**
        *
        * @param {import("../../core/scope/scope.js").Scope} scope
        * @param {HTMLSelectElement} selectElement
-       * @param {*} attr
+       * @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;
+        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.
@@ -12513,7 +12614,7 @@
 
         let options;
         const ngOptions = parseOptionsExpression(
-          attr.ngOptions,
+          attr["ngOptions"],
           selectElement,
           scope,
         );
@@ -12572,14 +12673,14 @@
           // 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 (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
@@ -12632,11 +12733,10 @@
           // compile the element since there might be bindings in it
           const linkFn = $compile(selectCtrl.emptyOption);
           assertArg$1(linkFn, "LinkFn required");
-          linkFn(scope);
-
           selectElement.prepend(selectCtrl.emptyOption);
+          linkFn(scope);
 
-          if (selectCtrl.emptyOption[0].nodeType === Node.COMMENT_NODE) {
+          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;
@@ -12678,7 +12778,12 @@
         // ------------------------------------------------------------------ //
 
         function addOptionElement(option, parent) {
-          const optionElement = optionTemplate.cloneNode(false);
+          /**
+           * @type {HTMLOptionElement}
+           */
+          const optionElement = /** @type {HTMLOptionElement} */ (
+            optionTemplate.cloneNode(false)
+          );
           parent.appendChild(optionElement);
           updateOptionElement(option, optionElement);
         }
@@ -12823,7 +12928,6 @@
      */
     function ($compile) {
       return {
-        restrict: "EA",
         compile: function ngTranscludeCompile(tElement) {
           // Remove and cache any original content to act as a fallback
           const fallbackLinkFn = $compile(tElement.childNodes);
@@ -12984,7 +13088,7 @@
   ["src", "srcset", "href"].forEach((attrName) => {
     const normalized = directiveNormalize(`ng-${attrName}`);
     ngAttributeAliasDirectives[normalized] = [
-      "$sce",
+      $injectTokens.$sce,
       function ($sce) {
         return {
           priority: 99, // it needs to run after the attributes are interpolated
@@ -13135,8 +13239,8 @@
         restrict: "A",
         require: "?ngModel",
         compile: (_Elm, tAttr) => {
-          var patternExp;
-          var parseFn;
+          let patternExp;
+          let parseFn;
 
           if (tAttr["ngPattern"]) {
             patternExp = tAttr["ngPattern"];
@@ -13159,7 +13263,7 @@
           return function (scope, elm, attr, ctrl) {
             if (!ctrl) return;
 
-            var attrVal = attr["pattern"];
+            let attrVal = attr["pattern"];
 
             if (attr["ngPattern"]) {
               attrVal = parseFn(scope);
@@ -13167,9 +13271,9 @@
               patternExp = attr["pattern"];
             }
 
-            var regexp = parsePatternAttr(attrVal, patternExp, elm);
+            let regexp = parsePatternAttr(attrVal, patternExp, elm);
             attr.$observe("pattern", function (newVal) {
-              var oldRegexp = regexp;
+              const oldRegexp = regexp;
 
               regexp = parsePatternAttr(newVal, patternExp, elm);
 
@@ -13374,10 +13478,6 @@
       this.autoScrollingEnabled = true;
     }
 
-    disableAutoScrolling() {
-      this.autoScrollingEnabled = false;
-    }
-
     $get = [
       "$location",
       "$rootScope",
@@ -13764,7 +13864,7 @@
     };
 
     Object.entries(flags).forEach(([klass, val]) => {
-      var prop, allow;
+      let prop, allow;
       if (val === ADD_CLASS) {
         prop = "addClass";
         allow = !existing[klass] || existing[klass + REMOVE_CLASS_SUFFIX];
@@ -13891,6 +13991,8 @@
   }
 
   AnimateProvider.$inject = ["$provide"];
+
+  /** @param {import('../interface.ts').Provider} $provide */
   function AnimateProvider($provide) {
     const provider = this;
     let classNameFilter = null;
@@ -13930,7 +14032,7 @@
      * ```
      *
      * @param {string} name The name of the animation (this is what the class-based CSS value will be compared to).
-     * @param {Function} factory The factory function that will be executed to return the animation
+     * @param {import("../interface.ts").Injectable} factory The factory function that will be executed to return the animation
      *                           object.
      */
     this.register = function (name, factory) {
@@ -14612,13 +14714,13 @@
   function AnimateAsyncRunFactoryProvider() {
     this.$get = [
       function () {
-        var waitQueue = [];
+        let waitQueue = [];
 
         function waitForTick(fn) {
           waitQueue.push(fn);
           if (waitQueue.length > 1) return;
           window.requestAnimationFrame(function () {
-            for (var i = 0; i < waitQueue.length; i++) {
+            for (let i = 0; i < waitQueue.length; i++) {
               waitQueue[i]();
             }
             waitQueue = [];
@@ -14626,7 +14728,7 @@
         }
 
         return function () {
-          var passed = false;
+          let passed = false;
           waitForTick(function () {
             passed = true;
           });
@@ -14869,7 +14971,7 @@
 
   /** @typedef {import('../services/log').LogService} LogService */
 
-  /** @typedef {import("./error-handler.ts").ErrorHandler }  ErrorHandler */
+  /** @typedef {import("./error-handler.ts").ErrorHandler}  ErrorHandler */
 
   /**
    * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.
@@ -15163,7 +15265,7 @@
     return [].slice.call(input, begin, end);
   }
 
-  orderByFilter.$inject = ["$parse"];
+  orderByFilter.$inject = [$injectTokens.$parse];
 
   /**
    * @returns {import('../interface.ts').FilterFn}
@@ -15405,7 +15507,6 @@
     this.$get = [
       "$injector",
       /**
-       *
        * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
        * @returns
        */
@@ -17296,10 +17397,10 @@
     const cache = Object.create(null);
 
     /** @type {function(any):boolean?} */
-    var identStart;
+    let identStart;
 
     /** @type {function(any):boolean?} */
-    var identContinue;
+    let identContinue;
 
     /**
      * Allows defining the set of characters that are allowed in AngularTS expressions. The function
@@ -17336,7 +17437,7 @@
        */
       function ($filter) {
         /** @type {import("./lexer/lexer.js").LexerOptions} */
-        var $lexerOptions = {
+        const $lexerOptions = {
           isIdentifierStart: isFunction(identStart) && identStart,
           isIdentifierContinue: isFunction(identContinue) && identContinue,
         };
@@ -17348,7 +17449,7 @@
          * @returns any
          */
         function $parse(exp, interceptorFn) {
-          var parsedExpression, cacheKey;
+          let parsedExpression, cacheKey;
 
           switch (typeof exp) {
             case "string":
@@ -17358,8 +17459,8 @@
               parsedExpression = cache[cacheKey];
 
               if (!parsedExpression) {
-                var lexer = new Lexer($lexerOptions);
-                var parser = new Parser(lexer, $filter);
+                const lexer = new Lexer($lexerOptions);
+                const parser = new Parser(lexer, $filter);
                 parsedExpression = parser.parse(exp);
 
                 cache[cacheKey] = addWatchDelegate(parsedExpression);
@@ -20427,6 +20528,7 @@
      * @param {Object} target - The target object.
      * @param {string} property - The name of the property being set.
      * @param {*} value - The new value being assigned to the property.
+     * @param {Proxy} proxy - The proxy intercepting property access
      * @returns {boolean} - Returns true to indicate success of the operation.
      */
     set(target, property, value, proxy) {
@@ -20463,13 +20565,13 @@
             const listeners = this.watchers.get(property);
 
             if (listeners) {
-              this.scheduleListener(listeners);
+              this.#scheduleListener(listeners);
             }
 
             const foreignListeners = this.foreignListeners.get(property);
 
             if (foreignListeners) {
-              this.scheduleListener(foreignListeners);
+              this.#scheduleListener(foreignListeners);
             }
           }
 
@@ -20494,16 +20596,16 @@
             const listeners = this.watchers.get(property);
 
             if (listeners) {
-              this.scheduleListener(listeners);
+              this.#scheduleListener(listeners);
             }
 
             const foreignListeners = this.foreignListeners.get(property);
 
             if (foreignListeners) {
-              this.scheduleListener(foreignListeners);
+              this.#scheduleListener(foreignListeners);
             }
 
-            this.checkeListenersForAllKeys(value);
+            this.#checkeListenersForAllKeys(value);
           }
           target[property] = createScope(value, this);
           //setDeepValue(target[property], value);
@@ -20524,7 +20626,7 @@
             let listeners = this.watchers.get(property);
 
             if (listeners) {
-              this.scheduleListener(listeners);
+              this.#scheduleListener(listeners);
             }
           }
 
@@ -20536,7 +20638,7 @@
           let listeners = this.watchers.get(property);
 
           if (listeners) {
-            this.scheduleListener(listeners);
+            this.#scheduleListener(listeners);
           }
 
           if (Array.isArray(target)) {
@@ -20545,7 +20647,7 @@
               keys.forEach((key) => {
                 const listeners = this.watchers.get(key);
                 if (listeners) {
-                  this.scheduleListener(listeners);
+                  this.#scheduleListener(listeners);
                 }
               });
             }
@@ -20558,9 +20660,10 @@
         if (isUndefined(target[property]) && isProxy(value)) {
           this.foreignProxies.add(value);
           target[property] = value;
-          return true;
+          if (!this.watchers.has(property)) {
+            return true;
+          }
         }
-
         if (isUndefined(value)) {
           target[property] = value;
         } else {
@@ -20589,7 +20692,7 @@
           this.watchers.get(property)?.forEach((l) => listeners.push(l));
           if (listeners.length > 0) {
             // check if the listener actually appllies to this target
-            this.scheduleListener(listeners, (x) => {
+            this.#scheduleListener(listeners, (x) => {
               return x.filter((x) => {
                 if (!x.watchProp) return true;
                 // Compute the expected target based on `watchProp`
@@ -20617,7 +20720,7 @@
               );
             }
 
-            this.scheduleListener(foreignListeners);
+            this.#scheduleListener(foreignListeners);
           }
         }
 
@@ -20627,7 +20730,7 @@
             const listeners = this.watchers.get(key);
             if (listeners) {
               if (this.scheduled !== listeners) {
-                this.scheduleListener(listeners);
+                this.#scheduleListener(listeners);
               }
             }
           });
@@ -20637,22 +20740,6 @@
       }
     }
 
-    checkeListenersForAllKeys(value) {
-      if (isUndefined(value)) {
-        return;
-      }
-      Object.keys(value).forEach((k) => {
-        const listeners = this.watchers.get(k);
-
-        if (listeners) {
-          this.scheduleListener(listeners);
-        }
-        if (isObject(value[k])) {
-          this.checkeListenersForAllKeys(value[k]);
-        }
-      });
-    }
-
     /**
      * Intercepts property access on the target object. It checks for specific
      * properties (`watch` and `sync`) and binds their methods. For other properties,
@@ -20675,8 +20762,6 @@
 
       this.propertyMap = {
         $watch: this.$watch.bind(this),
-        $watchGroup: this.$watchGroup.bind(this),
-        $watchCollection: this.$watchCollection.bind(this),
         $new: this.$new.bind(this),
         $newIsolate: this.$newIsolate.bind(this),
         $destroy: this.$destroy.bind(this),
@@ -20684,7 +20769,7 @@
         $apply: this.$apply.bind(this),
         $evalAsync: this.$evalAsync.bind(this),
         $postUpdate: this.$postUpdate.bind(this),
-        $isRoot: this.isRoot.bind(this),
+        $isRoot: this.#isRoot.bind(this),
         $target: target,
         $proxy: this.$proxy,
         $on: this.$on.bind(this),
@@ -20696,8 +20781,6 @@
         $root: this.$root,
         $children: this.$children,
         $id: this.$id,
-        registerForeignKey: this.registerForeignKey.bind(this),
-        notifyListener: this.notifyListener.bind(this),
         $merge: this.$merge.bind(this),
         $getById: this.$getById.bind(this),
       };
@@ -20718,7 +20801,7 @@
 
         // TODO aditional testing
         if (property === "unshift") {
-          this.scheduleListener(this.scheduled);
+          this.#scheduleListener(this.scheduled);
         }
       }
 
@@ -20731,26 +20814,6 @@
       }
     }
 
-    /**
-     * @private
-     * @param {Listener[]} listeners
-     */
-    scheduleListener(listeners, filter = (val) => val) {
-      Promise.resolve().then(() => {
-        let index = 0;
-        let filteredListeners = filter(listeners);
-        while (index < filteredListeners.length) {
-          const listener = filteredListeners[index];
-          if (listener.foreignListener) {
-            listener.foreignListener.notifyListener(listener, this.$target);
-          } else {
-            this.notifyListener(listener, this.$target);
-          }
-          index++;
-        }
-      });
-    }
-
     deleteProperty(target, property) {
       // Currently deletes $model
       if (target[property] && target[property][isProxySymbol]) {
@@ -20758,20 +20821,20 @@
 
         let listeners = this.watchers.get(property);
         if (listeners) {
-          this.scheduleListener(listeners);
+          this.#scheduleListener(listeners);
         }
         if (this.objectListeners.has(this.$proxy)) {
           let keys = this.objectListeners.get(this.$proxy);
           keys.forEach((key) => {
             listeners = this.watchers.get(key);
             if (listeners) {
-              this.scheduleListener(listeners);
+              this.#scheduleListener(listeners);
             }
           });
         }
 
         if (this.scheduled) {
-          this.scheduleListener(this.scheduled);
+          this.#scheduleListener(this.scheduled);
           this.scheduled = [];
         }
         return true;
@@ -20784,19 +20847,54 @@
         keys.forEach((key) => {
           const listeners = this.watchers.get(key);
           if (listeners) {
-            this.scheduleListener(listeners);
+            this.#scheduleListener(listeners);
           }
         });
       } else {
         const listeners = this.watchers.get(property);
         if (listeners) {
-          this.scheduleListener(listeners, target[property]);
+          this.#scheduleListener(listeners, target[property]);
         }
       }
 
       return true;
     }
 
+    #checkeListenersForAllKeys(value) {
+      if (isUndefined(value)) {
+        return;
+      }
+      Object.keys(value).forEach((k) => {
+        const listeners = this.watchers.get(k);
+
+        if (listeners) {
+          this.#scheduleListener(listeners);
+        }
+        if (isObject(value[k])) {
+          this.#checkeListenersForAllKeys(value[k]);
+        }
+      });
+    }
+
+    /**
+     * @param {Listener[]} listeners
+     */
+    #scheduleListener(listeners, filter = (val) => val) {
+      Promise.resolve().then(() => {
+        let index = 0;
+        let filteredListeners = filter(listeners);
+        while (index < filteredListeners.length) {
+          const listener = filteredListeners[index];
+          if (listener.foreignListener) {
+            listener.foreignListener.#notifyListener(listener, this.$target);
+          } else {
+            this.#notifyListener(listener, this.$target);
+          }
+          index++;
+        }
+      });
+    }
+
     /**
      * Registers a watcher for a property along with a listener function. The listener
      * function is invoked when changes to that property are detected.
@@ -20814,7 +20912,6 @@
       if (get.constant) {
         if (listenerFn) {
           Promise.resolve().then(() => {
-            // @ts-ignore
             let res = get();
             while (isFunction(res)) {
               res = res();
@@ -20873,11 +20970,11 @@
           keys.push(get.decoratedNode.body[0].expression.left.toWatch[0]?.name);
           keys.push(get.decoratedNode.body[0].expression.right.toWatch[0]?.name);
           keys.forEach((key) => {
-            this.registerKey(key, listener);
+            this.#registerKey(key, listener);
           });
           return () => {
             keys.forEach((key) => {
-              this.deregisterKey(key, listener.id);
+              this.#deregisterKey(key, listener.id);
             });
           };
         }
@@ -20910,13 +21007,13 @@
             }
           });
           keys.forEach((key) => {
-            this.registerKey(key, listener);
-            this.scheduleListener([listener]);
+            this.#registerKey(key, listener);
+            this.#scheduleListener([listener]);
           });
 
           return () => {
             keys.forEach((key) => {
-              this.deregisterKey(key, listener.id);
+              this.#deregisterKey(key, listener.id);
             });
           };
         }
@@ -20939,10 +21036,10 @@
               watchProp.split(".").slice(0, -1).join("."),
             )(listener.originalTarget);
             if (potentialProxy && this.foreignProxies.has(potentialProxy)) {
-              potentialProxy.$handler.registerForeignKey(key, listener);
-              potentialProxy.$handler.scheduleListener([listener]);
+              potentialProxy.$handler.#registerForeignKey(key, listener);
+              potentialProxy.$handler.#scheduleListener([listener]);
               return () => {
-                return potentialProxy.$handler.deregisterKey(key, listener.id);
+                return potentialProxy.$handler.#deregisterKey(key, listener.id);
               };
             }
           }
@@ -20973,12 +21070,12 @@
             })
             .filter((x) => !!x);
           keys.forEach((key) => {
-            this.registerKey(key, listener);
-            this.scheduleListener([listener]);
+            this.#registerKey(key, listener);
+            this.#scheduleListener([listener]);
           });
           return () => {
             keys.forEach((key) => {
-              this.deregisterKey(key, listener.id);
+              this.#deregisterKey(key, listener.id);
             });
           };
         }
@@ -21040,39 +21137,31 @@
 
       if (keySet.length > 0) {
         keySet.forEach((key) => {
-          this.registerKey(key, listener);
+          this.#registerKey(key, listener);
         });
       } else {
-        this.registerKey(key, listener);
+        this.#registerKey(key, listener);
       }
 
       if (!lazy) {
-        this.scheduleListener([listener]);
+        this.#scheduleListener([listener]);
       }
       return () => {
         if (keySet.length > 0) {
           let res = true;
           keySet.forEach((key) => {
-            let success = this.deregisterKey(key, listener.id);
+            let success = this.#deregisterKey(key, listener.id);
             if (!success) {
               res = false;
             }
           });
           return res;
         } else {
-          return this.deregisterKey(key, listener.id);
+          return this.#deregisterKey(key, listener.id);
         }
       };
     }
 
-    $watchGroup(watchArray, listenerFn) {
-      watchArray.forEach((x) => this.$watch(x, listenerFn));
-    }
-
-    $watchCollection(watchProp, listenerFn) {
-      return this.$watch(watchProp, listenerFn);
-    }
-
     $new(childInstance) {
       let child;
       if (childInstance) {
@@ -21102,7 +21191,6 @@
 
     $newIsolate(instance) {
       let child = instance ? Object.create(instance) : Object.create(null);
-      // child.$root = this.$root;
       const proxy = new Proxy(child, new Scope(this, this.$root));
       this.$children.push(proxy);
       return proxy;
@@ -21115,7 +21203,7 @@
       return proxy;
     }
 
-    registerKey(key, listener) {
+    #registerKey(key, listener) {
       if (this.watchers.has(key)) {
         this.watchers.get(key).push(listener);
       } else {
@@ -21123,7 +21211,7 @@
       }
     }
 
-    registerForeignKey(key, listener) {
+    #registerForeignKey(key, listener) {
       if (this.foreignListeners.has(key)) {
         this.foreignListeners.get(key).push(listener);
       } else {
@@ -21131,7 +21219,7 @@
       }
     }
 
-    deregisterKey(key, id) {
+    #deregisterKey(key, id) {
       const listenerList = this.watchers.get(key);
       if (!listenerList) return false;
 
@@ -21147,21 +21235,21 @@
       return true;
     }
 
-    deregisterForeignKey(key, id) {
-      const listenerList = this.foreignListeners.get(key);
-      if (!listenerList) return false;
+    // deregisterForeignKey(key, id) {
+    //   const listenerList = this.foreignListeners.get(key);
+    //   if (!listenerList) return false;
 
-      const index = listenerList.findIndex((x) => x.id === id);
-      if (index === -1) return false;
+    //   const index = listenerList.findIndex((x) => x.id === id);
+    //   if (index === -1) return false;
 
-      listenerList.splice(index, 1);
-      if (listenerList.length) {
-        this.foreignListeners.set(key, listenerList);
-      } else {
-        this.foreignListeners.delete(key);
-      }
-      return true;
-    }
+    //   listenerList.splice(index, 1);
+    //   if (listenerList.length) {
+    //     this.foreignListeners.set(key, listenerList);
+    //   } else {
+    //     this.foreignListeners.delete(key);
+    //   }
+    //   return true;
+    // }
 
     $eval(expr, locals) {
       const fn = $parse(expr);
@@ -21189,12 +21277,19 @@
       return await this.$eval(expr, locals);
     }
 
+    /**
+     * @param {Object} newTarget
+     */
     $merge(newTarget) {
       Object.entries(newTarget).forEach(([key, value]) => {
-        this.set(this.$target, key, value);
+        this.set(this.$target, key, value, this.$proxy);
       });
     }
 
+    /**
+     * @param {import('../../interface.js').Expression} expr
+     * @returns {any}
+     */
     $apply(expr) {
       try {
         return $parse(expr)(this.$proxy);
@@ -21203,6 +21298,11 @@
       }
     }
 
+    /**
+     * @param {string} name
+     * @param {Function} listener
+     * @returns {(function(): void)|*}
+     */
     $on(name, listener) {
       let namedListeners = this.$$listeners.get(name);
       if (!namedListeners) {
@@ -21225,10 +21325,10 @@
     /**
      * @param {string} name
      * @param  {...any} args
-     * @returns
+     * @returns {void}
      */
     $emit(name, ...args) {
-      return this.eventHelper(
+      return this.#eventHelper(
         { name: name, event: undefined, broadcast: false },
         ...args,
       );
@@ -21240,21 +21340,20 @@
      * @returns {any}
      */
     $broadcast(name, ...args) {
-      return this.eventHelper(
+      return this.#eventHelper(
         { name: name, event: undefined, broadcast: true },
         ...args,
       );
     }
 
     /**
-     * @private
      * @returns {void}
      */
-    eventHelper({ name, event, broadcast }, ...args) {
+    #eventHelper({ name, event, broadcast }, ...args) {
       if (!broadcast) {
         if (!this.$$listeners.has(name)) {
           if (this.$parent) {
-            return this.$parent.$handler.eventHelper(
+            return this.$parent.$handler.#eventHelper(
               { name: name, event: event, broadcast: broadcast },
               ...args,
             );
@@ -21309,7 +21408,7 @@
       if (broadcast) {
         if (this.$children.length > 0) {
           this.$children.forEach((child) => {
-            event = child["$handler"].eventHelper(
+            event = child["$handler"].#eventHelper(
               { name: name, event: event, broadcast: broadcast },
               ...args,
             );
@@ -21318,7 +21417,7 @@
         return event;
       } else {
         if (this.$parent) {
-          return this.$parent?.eventHelper(
+          return this.$parent.#eventHelper(
             { name: name, event: event, broadcast: broadcast },
             ...args,
           );
@@ -21329,10 +21428,9 @@
     }
 
     /**
-     * @private
      * @returns {boolean}
      */
-    isRoot() {
+    #isRoot() {
       return this.$root == /** @type {Scope} */ (this);
     }
 
@@ -21351,7 +21449,7 @@
         );
       });
 
-      if (this.isRoot()) {
+      if (this.#isRoot()) {
         this.watchers.clear();
       } else {
         let i = this.$parent.$children.filter((x) => x.$id == this.$id)[0];
@@ -21364,11 +21462,9 @@
     }
 
     /**
-     * Invokes the registered listener function with watched property changes.
-     *
      * @param {Listener} listener - The property path that was changed.
      */
-    notifyListener(listener, target) {
+    #notifyListener(listener, target) {
       const { originalTarget, listenerFn, watchFn } = listener;
       try {
         let newVal = watchFn(originalTarget);
@@ -21427,6 +21523,8 @@
     }
   }
 
+  /*------------- Private helpers -------------*/
+
   /**
    * @param {Scope} model
    * @returns {number}
@@ -21460,7 +21558,14 @@
     return ids;
   }
 
+  /** @typedef {import('../interface.ts').ServiceProvider} ServiceProvider */
+  /** @typedef {import('../interface.ts').AnnotatedFactory} AnnotatedFactory */
+
+  /**
+   * @implements {ServiceProvider}
+   */
   class TaskTrackerFactoryProvider {
+    /** @type {AnnotatedFactory} */
     $get = [
       "$log",
       /**
@@ -21599,7 +21704,7 @@
     }
   }
 
-  var $templateRequestMinErr = minErr("$templateRequest");
+  const $templateRequestMinErr = minErr("$templateRequest");
 
   /**
    * Used to configure the options passed to the {@link $http} service when making a template request.
@@ -21608,7 +21713,7 @@
    * requesting a template.
    */
   function TemplateRequestProvider() {
-    var httpOptions;
+    let httpOptions;
 
     /**
      * The options to be passed to the {@link $http} service when making the request.
@@ -21674,13 +21779,17 @@
           // AngularTS accept any script directive, no matter its name. However, we
           // still need to unwrap trusted types.
           if (!isString(tpl) || !$templateCache.has(tpl)) {
-            tpl = $sce.getTrustedResourceUrl(tpl);
-            if (!tpl) {
-              return Promise.reject("Template not found");
+            try {
+              tpl = $sce.getTrustedResourceUrl(tpl);
+              if (!tpl) {
+                return Promise.reject("Template not found");
+              }
+            } catch (e) {
+              return Promise.reject(e.message);
             }
           }
 
-          var transformResponse =
+          let transformResponse =
             $http.defaults && $http.defaults.transformResponse;
 
           if (Array.isArray(transformResponse)) {
@@ -21792,6 +21901,7 @@
       return (uri, isMediaUrl) => {
         if (!uri) return uri;
 
+        /** @type {RegExp} */
         const regex = isMediaUrl
           ? this._imgSrcSanitizationTrustedUrlList
           : this._aHrefSanitizationTrustedUrlList;
@@ -21831,7 +21941,7 @@
       this.head = undefined;
       this.default = undefined;
 
-      this.$scope.$watchCollection(
+      this.$scope.$watch(
         this.$attrs["ngMessages"] || this.$attrs["for"],
         this.render.bind(this),
       );
@@ -22073,7 +22183,7 @@
 
             if (dynamicExp) {
               assignRecords(scope.$eval(dynamicExp));
-              scope.$watchCollection(dynamicExp, assignRecords);
+              scope.$watch(dynamicExp, assignRecords);
             } else {
               assignRecords(staticExp);
             }
@@ -22232,7 +22342,7 @@
     };
   }
 
-  ngDisabledAriaDirective.$inject = ["$aria"];
+  ngDisabledAriaDirective.$inject = [$injectTokens.$aria];
   function ngDisabledAriaDirective($aria) {
     return $aria.$$watchExpr(
       "ngDisabled",
@@ -22242,7 +22352,7 @@
     );
   }
 
-  ngShowAriaDirective.$inject = ["$aria"];
+  ngShowAriaDirective.$inject = [$injectTokens.$aria];
   function ngShowAriaDirective($aria) {
     return $aria.$$watchExpr("ngShow", "aria-hidden", [], true);
   }
@@ -22261,11 +22371,11 @@
     };
   }
 
-  ngClickAriaDirective.$inject = ["$aria", "$parse"];
+  ngClickAriaDirective.$inject = [$injectTokens.$aria, $injectTokens.$parse];
   function ngClickAriaDirective($aria, $parse) {
     return {
       restrict: "A",
-      compile(elem, attr) {
+      compile(_elem, attr) {
         if (hasOwn(attr, ARIA_DISABLE_ATTR)) return;
 
         const fn = $parse(attr.ngClick);
@@ -22325,7 +22435,7 @@
     };
   }
 
-  ngRequiredAriaDirective.$inject = ["$aria"];
+  ngRequiredAriaDirective.$inject = [$injectTokens.$aria];
   function ngRequiredAriaDirective($aria) {
     return $aria.$$watchExpr(
       "ngRequired",
@@ -22345,7 +22455,7 @@
     );
   }
 
-  ngValueAriaDirective.$inject = ["$aria"];
+  ngValueAriaDirective.$inject = [$injectTokens.$aria];
   function ngValueAriaDirective($aria) {
     return $aria.$$watchExpr(
       "ngValue",
@@ -22355,12 +22465,12 @@
     );
   }
 
-  ngHideAriaDirective.$inject = ["$aria"];
+  ngHideAriaDirective.$inject = [$injectTokens.$aria];
   function ngHideAriaDirective($aria) {
     return $aria.$$watchExpr("ngHide", "aria-hidden", [], false);
   }
 
-  ngReadonlyAriaDirective.$inject = ["$aria"];
+  ngReadonlyAriaDirective.$inject = [$injectTokens.$aria];
   function ngReadonlyAriaDirective($aria) {
     return $aria.$$watchExpr(
       "ngReadonly",
@@ -22370,7 +22480,7 @@
     );
   }
 
-  ngModelAriaDirective.$inject = ["$aria"];
+  ngModelAriaDirective.$inject = [$injectTokens.$aria];
   function ngModelAriaDirective($aria) {
     function shouldAttachAttr(attr, normalizedAttr, elem, allowNonAriaNodes) {
       return (
@@ -22513,7 +22623,7 @@
     };
   }
 
-  ngDblclickAriaDirective.$inject = ["$aria"];
+  ngDblclickAriaDirective.$inject = [$injectTokens.$aria];
   function ngDblclickAriaDirective($aria) {
     return function (scope, elem, attr) {
       if (hasOwn(attr, ARIA_DISABLE_ATTR)) return;
@@ -22765,6 +22875,7 @@
           // all of the animation functions should create
           // a copy of the options data, however, if a
           // parent service has already created a copy then
+          let delayStyle;
           // we should stick to using that
           let options = initialOptions || {};
           if (!options.$$prepared) {
@@ -22977,13 +23088,12 @@
             return closeAndReturnNoopAnimator();
           }
 
-          var activeClasses = pendClasses(
+          let activeClasses = pendClasses(
             preparationClasses,
             ACTIVE_CLASS_SUFFIX,
           );
 
           if (options.delay != null) {
-            var delayStyle;
             if (typeof options.delay !== "boolean") {
               delayStyle = parseFloat(options.delay);
               // number in options.delay means we have to recalculate the delay for the closing timeout
@@ -25646,30 +25756,27 @@
       link(scope, $element, attrs, ctrl, $transclude) {
         let previousElement;
         let previousScope;
-        scope.$watchCollection(
-          attrs["ngAnimateSwap"] || attrs["for"],
-          (value) => {
-            if (previousElement) {
-              $animate.leave(previousElement);
-            }
-            if (previousScope) {
-              previousScope.$destroy();
-              previousScope = null;
-            }
-            if (value) {
-              $transclude((clone, childScope) => {
-                previousElement = clone;
-                previousScope = childScope;
-                $animate.enter(clone, null, $element);
-              });
-            }
-          },
-        );
+        scope.$watch(attrs["ngAnimateSwap"] || attrs["for"], (value) => {
+          if (previousElement) {
+            $animate.leave(previousElement);
+          }
+          if (previousScope) {
+            previousScope.$destroy();
+            previousScope = null;
+          }
+          if (value) {
+            $transclude((clone, childScope) => {
+              previousElement = clone;
+              previousScope = childScope;
+              $animate.enter(clone, null, $element);
+            });
+          }
+        });
       },
     };
   }
 
-  $$AnimateChildrenDirective.$inject = ["$interpolate"];
+  $$AnimateChildrenDirective.$inject = [$injectTokens.$interpolate];
 
   /**
    * @param {*} $interpolate
@@ -27579,7 +27686,7 @@
       Object.prototype.hasOwnProperty.bind(cfg || {}),
     ).length === 0;
 
-  var DefType;
+  let DefType;
   (function (DefType) {
     DefType[(DefType["PATH"] = 0)] = "PATH";
     DefType[(DefType["SEARCH"] = 1)] = "SEARCH";
@@ -28866,6 +28973,26 @@
     }
   }
 
+  /** @typedef {import('../../interface.js').ServiceProvider} ServiceProvider
+
+  /**
+   * Configurable provider for an injectable event bus
+   * @implements {ServiceProvider}
+   */
+  class PubSubProvider {
+    constructor() {
+      /**
+       * @type {PubSub}
+       */
+      this.eventBus = EventBus;
+    }
+
+    /**
+     * @returns {PubSub}
+     */
+    $get = () => this.eventBus;
+  }
+
   class PubSub {
     /**
      * Topic-based publish/subscribe channel.  Maintains a map of topics to
@@ -30993,6 +31120,7 @@
 
     /**
      * @param {import('../globals.js').RouterGlobals} globals
+     * @param viewService
      */
     constructor(globals, viewService) {
       this._transitionCount = 0;
@@ -34133,6 +34261,10 @@
    * using the [[builder]] method.
    */
   class StateBuilder {
+    /**
+     * @param {import('./state-matcher.js').StateMatcher} matcher
+     * @param urlService
+     */
     constructor(matcher, urlService) {
       this.matcher = matcher;
       this.$injector = undefined;
@@ -34340,12 +34472,12 @@
    * @implements {ServiceProvider}
    */
   class StateRegistryProvider {
-    static $inject = [
-      "$urlServiceProvider",
-      "$stateProvider",
-      "$routerGlobalsProvider",
-      "$viewProvider",
-    ];
+    static $inject = provider([
+      $injectTokens.$urlService,
+      $injectTokens.$state,
+      $injectTokens.$routerGlobals,
+      $injectTokens.$view,
+    ]);
 
     /**
      * @param urlService
@@ -34643,7 +34775,7 @@
         // HACK: This is to allow ng-clicks to be processed before the transition is initiated:
         const transition = setTimeout(function () {
           if (!el.getAttribute("disabled")) {
-            var res = $state.go(
+            const res = $state.go(
               target.ngState,
               target.ngStateParams,
               target.ngStateOpts,
@@ -35138,7 +35270,7 @@
       };
       const directive = {
         count: 0,
-        restrict: "EA",
+
         terminal: true,
         priority: 400,
         transclude: "element",
@@ -35273,7 +35405,6 @@
     const getControllerAs = parse("viewDecl.controllerAs");
     const getResolveAs = parse("viewDecl.resolveAs");
     return {
-      restrict: "EA",
       priority: -400,
       compile: function (tElement) {
         const initial = tElement.innerHTML;
@@ -35469,7 +35600,6 @@
    */
   function ngChannelDirective() {
     return {
-      restrict: "EA",
       link: (scope, element, attrs) => {
         const hasTemplate = element.childNodes.length > 0;
         const channel = attrs["ngChannel"];
@@ -35543,7 +35673,7 @@
             characterData: true,
           });
         } else {
-          console.warn("ngSetter: Element is not a valid DOM node.");
+          $log.warn("ngSetter: Element is not a valid DOM node.");
           return;
         }
 
@@ -35553,13 +35683,14 @@
     };
   }
 
-  //injected by Rollup plugin
-  const VERSION = "0.7.0-beta.1";
+  // @private
+
+  const VERSION = "0.7.2";
 
   /**
-   * Initializes `ng`, `animate`, `message`, `aria` and `router` modules.
+   * Initializes core `ng` module.
    * @param {import('./loader.js').Angular} angular
-   * @returns {import('./core/di/ng-module.js').NgModule} `ng`module
+   * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
    */
   function publishExternalAPI(angular) {
     const ng = angular
@@ -35568,6 +35699,7 @@
         [],
         [
           "$provide",
+          /** @type {import('./interface.js').Provider} */
           ($provide) => {
             // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
             $provide.provider({
@@ -35691,12 +35823,17 @@
               $templateFactory: TemplateFactoryProvider,
               $urlService: UrlService,
               $stateRegistry: StateRegistryProvider,
+              $eventBus: PubSubProvider,
             });
           },
         ],
       )
       .factory("$stateParams", [
         "$routerGlobals",
+        /**
+         * @param {import('./router/globals.js').RouterGlobals} globals
+         * @returns {import('./router/params/state-params.js').StateParams }
+         */
         function (globals) {
           return globals.params;
         },
@@ -35744,6 +35881,7 @@
       this.errorHandlingConfig = errorHandlingConfig;
 
       window["angular"] = this;
+      this.$injectTokens = $injectTokens;
       publishExternalAPI(this);
     }