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

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.7.0-beta.1 - June 19, 2025 01:16:33 */
+/* Version: 0.7.0 - June 28, 2025 13:06:09 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -68,7 +68,7 @@ function uppercase(string) {
 }
 
 /**
- * @param {*} obj
+ * @param {*} obj Reference to check.
  * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
  *                   String ...)
  */
@@ -743,7 +743,7 @@ function parseKeyValue(keyValue) {
       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);
@@ -783,12 +783,13 @@ function toKeyValue(obj) {
  * 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;
   }
 }
 
@@ -1706,7 +1707,78 @@ function extractElementNode$1(element) {
   }
 }
 
-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";
@@ -1783,7 +1855,7 @@ class NgModule {
    * @returns {NgModule}
    */
   value(name, object) {
-    this.invokeQueue.push([PROVIDE_LITERAL, "value", [name, object]]);
+    this.invokeQueue.push([$injectTokens.$provide, "value", [name, object]]);
     return this;
   }
 
@@ -1793,7 +1865,11 @@ class NgModule {
    * @returns {NgModule}
    */
   constant(name, object) {
-    this.invokeQueue.unshift([PROVIDE_LITERAL, "constant", [name, object]]);
+    this.invokeQueue.unshift([
+      $injectTokens.$provide,
+      "constant",
+      [name, object],
+    ]);
     return this;
   }
 
@@ -1839,7 +1915,7 @@ class NgModule {
       providerFunction.$$moduleName = name;
     }
     this.invokeQueue.push([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "factory",
       [name, providerFunction],
     ]);
@@ -1856,7 +1932,7 @@ class NgModule {
       serviceFunction.$$moduleName = name;
     }
     this.invokeQueue.push([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "service",
       [name, serviceFunction],
     ]);
@@ -1872,7 +1948,11 @@ class NgModule {
     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;
   }
 
@@ -1885,7 +1965,11 @@ class NgModule {
     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;
   }
 
@@ -1965,6 +2049,7 @@ class AbstractInjector {
     this.cache = {};
     /** @type {boolean} */
     this.strictDi = strictDi;
+    /** @type {string[]} */
     this.path = [];
     /** @type {Object.<string, import("./ng-module.js").NgModule>} */
     this.modules = {};
@@ -2083,6 +2168,7 @@ class AbstractInjector {
   /**
    * @abstract
    * @param {string} _serviceName
+   * @returns {any}
    */
   factory(_serviceName) {
     console.error(`Unhandled ${_serviceName}`);
@@ -2234,7 +2320,6 @@ const FN_ARG_SPLIT = /,/;
 const FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
 const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
 const $injectorMinErr$1 = minErr(INJECTOR_LITERAL);
-
 const providerSuffix = "Provider";
 
 /**
@@ -2602,7 +2687,7 @@ class NodeRef {
       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);
@@ -2645,8 +2730,6 @@ class NodeRef {
     } else {
       this._element = undefined;
     }
-    // this._nodes = undefined;
-    // this.isList = false;
   }
 
   /** @param {Array<Node>} nodes */
@@ -3381,7 +3464,7 @@ class SceDelegateProvider {
       "$exceptionHandler",
       /**
        *
-       * @param {import("../../core/di/internal-injector").InjectorService} $injector
+       * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
        * @param {*} $$sanitizeUri
        * @param {ErrorHandler} $exceptionHandler
        * @returns
@@ -3608,14 +3691,11 @@ class SceDelegateProvider {
             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();
@@ -3656,8 +3736,7 @@ function SceProvider() {
   this.$get = [
     "$parse",
     "$sceDelegate",
-    "$exceptionHandler",
-    function ($parse, $sceDelegate, $exceptionHandler) {
+    function ($parse, $sceDelegate) {
       const sce = shallowCopy(SCE_CONTEXTS);
 
       /**
@@ -3901,11 +3980,7 @@ function SceProvider() {
           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);
@@ -3984,6 +4059,9 @@ const $compileMinErr$1 = minErr("$compile");
 const SIMPLE_ATTR_NAME = /^\w/;
 const specialAttrHolder = document.createElement("div");
 
+/**
+ * @implements {Record<string, any>}
+ */
 class Attributes {
   static $nonscope = true;
 
@@ -3993,7 +4071,7 @@ class Attributes {
    * @param {import("../exception-handler.js").ErrorHandler} $exceptionHandler
    * @param {*} $sce
    * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
-   * @param {*} [attributesToCopy]
+   * @param {Object} [attributesToCopy]
    */
   constructor(
     $rootScope,
@@ -4440,7 +4518,7 @@ class CompileProvider {
 
   /**
    * @param {import('../../interface.js').Provider} $provide
-   * @param $$sanitizeUriProvider
+   * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $$sanitizeUriProvider
    */
   constructor($provide, $$sanitizeUriProvider) {
     const hasDirectives = {};
@@ -4452,7 +4530,7 @@ class CompileProvider {
      * @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$]*)$/;
@@ -4748,13 +4826,13 @@ class CompileProvider {
      * 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();
     };
@@ -4771,13 +4849,13 @@ class CompileProvider {
      * 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();
     };
@@ -5591,6 +5669,7 @@ class CompileProvider {
             let controllerScope;
             let elementControllers;
             let transcludeFn;
+            let scopeToChild = scope;
 
             /** @type {NodeRef} */
             let $element;
@@ -5762,7 +5841,7 @@ class CompileProvider {
             // 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 ||
@@ -6767,6 +6846,8 @@ class CompileProvider {
             .catch((error) => {
               if (isError(error)) {
                 $exceptionHandler(error);
+              } else {
+                $exceptionHandler(new Error(error));
               }
             });
 
@@ -6874,11 +6955,12 @@ class CompileProvider {
           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;
           }
@@ -6954,21 +7036,22 @@ class CompileProvider {
           // 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
@@ -6976,7 +7059,7 @@ class CompileProvider {
           }
 
           // 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]));
@@ -7280,7 +7363,7 @@ class CompileProvider {
                   removeWatchCollection.push(removeWatch);
                   break;
 
-                case "=":
+                case "=": {
                   if (!hasOwn(attrs, attrName)) {
                     if (optional) {
                       break;
@@ -7293,7 +7376,6 @@ class CompileProvider {
                   }
 
                   parentGet = $parse(attrs[attrName]);
-                  var complexExpression = !!parentGet.inputs;
                   if (parentGet.literal) {
                     compare = equals$1;
                   } else {
@@ -7318,7 +7400,7 @@ class CompileProvider {
                   lastValue = destination.$target[scopeName] = parentGet(
                     scope.$target,
                   );
-                  var parentValueWatch = function parentValueWatch(
+                  const parentValueWatch = function parentValueWatch(
                     parentValue,
                   ) {
                     if (!compare(parentValue, destination[scopeName])) {
@@ -7350,7 +7432,7 @@ class CompileProvider {
                       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;
@@ -7376,7 +7458,7 @@ class CompileProvider {
                           return;
                         }
                         if (
-                          (complexExpression && !parentGet.literal) ||
+                          (!!parentGet.inputs && !parentGet.literal) ||
                           (isUndefined(attrs[attrName]) && isDefined(val))
                         ) {
                           destination.$target[attrName] = lastValue;
@@ -7408,6 +7490,7 @@ class CompileProvider {
                   }
                   removeWatchCollection.push(removeWatch);
                   break;
+                }
 
                 case "<":
                   if (!hasOwn(attrs, attrName)) {
@@ -10357,13 +10440,19 @@ function radioInputType(scope, element, attr, ctrl) {
   };
 
   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);
@@ -11158,7 +11247,6 @@ function optionDirective($interpolate) {
  */
 function ngBindDirective() {
   return {
-    restrict: "EA",
     /**
      * @param {import('../../core/scope/scope.js').Scope} scope
      * @param {Element} element
@@ -11177,7 +11265,6 @@ function ngBindDirective() {
  */
 function ngBindTemplateDirective() {
   return {
-    restrict: "EA",
     /**
      * @param {import('../../core/scope/scope.js').Scope} _scope
      * @param {Element} element
@@ -11191,7 +11278,7 @@ function ngBindTemplateDirective() {
   };
 }
 
-ngBindHtmlDirective.$inject = ["$parse"];
+ngBindHtmlDirective.$inject = [$injectTokens.$parse];
 /**
  * @returns {import('../../interface.ts').Directive}
  */
@@ -11226,7 +11313,6 @@ function classDirective(name, selector) {
 
   return function () {
     return {
-      restrict: "EA",
       /**
        * @param {import("../../core/scope/scope.js").Scope} scope
        * @param {Element} element
@@ -11390,7 +11476,6 @@ const ngClassEvenDirective = classDirective("Even", 1);
  */
 function ngCloakDirective() {
   return {
-    restrict: "EA",
     compile(element, attr) {
       attr.$set("ngCloak", undefined);
       element.classList.remove("ng-cloak");
@@ -11546,26 +11631,36 @@ function ngIfDirective($animate) {
   };
 }
 
-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() {
@@ -11618,7 +11713,7 @@ function ngIncludeDirective($templateRequest, $anchorScroll, $animate) {
                 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.
@@ -11641,19 +11736,20 @@ function ngIncludeDirective($templateRequest, $anchorScroll, $animate) {
                 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;
           }
         });
       };
@@ -11674,7 +11770,6 @@ ngIncludeFillContentDirective.$inject = ["$compile"];
  */
 function ngIncludeFillContentDirective($compile) {
   return {
-    restrict: "EA",
     priority: -400,
     require: "ngInclude",
     link(scope, $element, _$attr, ctrl) {
@@ -11710,7 +11805,6 @@ function ngInitDirective() {
  */
 function ngNonBindableDirective() {
   return {
-    restrict: "EA",
     terminal: true,
     priority: 1000,
   };
@@ -11820,7 +11914,7 @@ const ngRepeatMinErr = minErr("ngRepeat");
 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
@@ -11932,15 +12026,15 @@ function ngRepeatDirective($animate) {
         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,
@@ -12006,7 +12100,7 @@ function ngRepeatDirective($animate) {
           }
 
           // remove leftover items
-          for (var blockKey in lastBlockMap) {
+          for (let blockKey in lastBlockMap) {
             block = lastBlockMap[blockKey];
             elementsToRemove = block.clone;
             if (hasAnimate) {
@@ -12224,7 +12318,7 @@ function ngSwitchWhenDirective() {
     transclude: "element",
     terminal: true,
     priority: 1200,
-    restrict: "EA",
+
     require: "^ngSwitch",
     link(scope, element, attrs, ctrl, $transclude) {
       const cases = attrs["ngSwitchWhen"]
@@ -12251,7 +12345,6 @@ function ngSwitchWhenDirective() {
  */
 function ngSwitchDefaultDirective() {
   return {
-    restrict: "EA",
     transclude: "element",
     terminal: true,
     priority: 1200,
@@ -12265,6 +12358,12 @@ function ngSwitchDefaultDirective() {
 
 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)
@@ -12287,6 +12386,12 @@ const ngOptionsDirective = [
    * @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) {
@@ -12413,7 +12518,9 @@ const ngOptionsDirective = [
         }),
 
         getOptions() {
+          /** @type {Option[]} */
           const optionItems = [];
+          /** @type {Object.<string, Option>} */
           const selectValueMap = {};
 
           // The option values were already computed in the `getWatchables` fn,
@@ -12464,23 +12571,17 @@ const ngOptionsDirective = [
       };
     }
 
-    // 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.
@@ -12507,7 +12608,7 @@ const ngOptionsDirective = [
 
       let options;
       const ngOptions = parseOptionsExpression(
-        attr.ngOptions,
+        attr["ngOptions"],
         selectElement,
         scope,
       );
@@ -12566,14 +12667,14 @@ const ngOptionsDirective = [
         // 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
@@ -12626,11 +12727,10 @@ const ngOptionsDirective = [
         // 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;
@@ -12672,7 +12772,12 @@ const ngOptionsDirective = [
       // ------------------------------------------------------------------ //
 
       function addOptionElement(option, parent) {
-        const optionElement = optionTemplate.cloneNode(false);
+        /**
+         * @type {HTMLOptionElement}
+         */
+        const optionElement = /** @type {HTMLOptionElement} */ (
+          optionTemplate.cloneNode(false)
+        );
         parent.appendChild(optionElement);
         updateOptionElement(option, optionElement);
       }
@@ -12817,7 +12922,6 @@ const ngTranscludeDirective = [
    */
   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);
@@ -12978,7 +13082,7 @@ Object.entries(ALIASED_ATTR).forEach(([ngAttr]) => {
 ["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
@@ -13129,8 +13233,8 @@ const patternDirective = [
       restrict: "A",
       require: "?ngModel",
       compile: (_Elm, tAttr) => {
-        var patternExp;
-        var parseFn;
+        let patternExp;
+        let parseFn;
 
         if (tAttr["ngPattern"]) {
           patternExp = tAttr["ngPattern"];
@@ -13153,7 +13257,7 @@ const patternDirective = [
         return function (scope, elm, attr, ctrl) {
           if (!ctrl) return;
 
-          var attrVal = attr["pattern"];
+          let attrVal = attr["pattern"];
 
           if (attr["ngPattern"]) {
             attrVal = parseFn(scope);
@@ -13161,9 +13265,9 @@ const patternDirective = [
             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);
 
@@ -13368,10 +13472,6 @@ class AnchorScrollProvider {
     this.autoScrollingEnabled = true;
   }
 
-  disableAutoScrolling() {
-    this.autoScrollingEnabled = false;
-  }
-
   $get = [
     "$location",
     "$rootScope",
@@ -13758,7 +13858,7 @@ function resolveElementClasses(existing, toAdd, toRemove) {
   };
 
   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];
@@ -13885,6 +13985,8 @@ function prepareAnimateOptions(options) {
 }
 
 AnimateProvider.$inject = ["$provide"];
+
+/** @param {import('../interface.ts').Provider} $provide */
 function AnimateProvider($provide) {
   const provider = this;
   let classNameFilter = null;
@@ -13924,7 +14026,7 @@ function AnimateProvider($provide) {
    * ```
    *
    * @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) {
@@ -14606,13 +14708,13 @@ class BrowserProvider {
 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 = [];
@@ -14620,7 +14722,7 @@ function AnimateAsyncRunFactoryProvider() {
       }
 
       return function () {
-        var passed = false;
+        let passed = false;
         waitForTick(function () {
           passed = true;
         });
@@ -14863,7 +14965,7 @@ class TemplateCacheProvider {
 
 /** @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.
@@ -15157,7 +15259,7 @@ function sliceFn(input, begin, end) {
   return [].slice.call(input, begin, end);
 }
 
-orderByFilter.$inject = ["$parse"];
+orderByFilter.$inject = [$injectTokens.$parse];
 
 /**
  * @returns {import('../interface.ts').FilterFn}
@@ -15399,7 +15501,6 @@ function FilterProvider($provide) {
   this.$get = [
     "$injector",
     /**
-     *
      * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
      * @returns
      */
@@ -17290,10 +17391,10 @@ function ParseProvider() {
   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
@@ -17330,7 +17431,7 @@ function ParseProvider() {
      */
     function ($filter) {
       /** @type {import("./lexer/lexer.js").LexerOptions} */
-      var $lexerOptions = {
+      const $lexerOptions = {
         isIdentifierStart: isFunction(identStart) && identStart,
         isIdentifierContinue: isFunction(identContinue) && identContinue,
       };
@@ -17342,7 +17443,7 @@ function ParseProvider() {
        * @returns any
        */
       function $parse(exp, interceptorFn) {
-        var parsedExpression, cacheKey;
+        let parsedExpression, cacheKey;
 
         switch (typeof exp) {
           case "string":
@@ -17352,8 +17453,8 @@ function ParseProvider() {
             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);
@@ -20421,6 +20522,7 @@ class Scope {
    * @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) {
@@ -20457,13 +20559,13 @@ class Scope {
           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);
           }
         }
 
@@ -20488,16 +20590,16 @@ class Scope {
           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);
@@ -20518,7 +20620,7 @@ class Scope {
           let listeners = this.watchers.get(property);
 
           if (listeners) {
-            this.scheduleListener(listeners);
+            this.#scheduleListener(listeners);
           }
         }
 
@@ -20530,7 +20632,7 @@ class Scope {
         let listeners = this.watchers.get(property);
 
         if (listeners) {
-          this.scheduleListener(listeners);
+          this.#scheduleListener(listeners);
         }
 
         if (Array.isArray(target)) {
@@ -20539,7 +20641,7 @@ class Scope {
             keys.forEach((key) => {
               const listeners = this.watchers.get(key);
               if (listeners) {
-                this.scheduleListener(listeners);
+                this.#scheduleListener(listeners);
               }
             });
           }
@@ -20552,9 +20654,10 @@ class Scope {
       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 {
@@ -20583,7 +20686,7 @@ class Scope {
         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`
@@ -20611,7 +20714,7 @@ class Scope {
             );
           }
 
-          this.scheduleListener(foreignListeners);
+          this.#scheduleListener(foreignListeners);
         }
       }
 
@@ -20621,7 +20724,7 @@ class Scope {
           const listeners = this.watchers.get(key);
           if (listeners) {
             if (this.scheduled !== listeners) {
-              this.scheduleListener(listeners);
+              this.#scheduleListener(listeners);
             }
           }
         });
@@ -20631,22 +20734,6 @@ class Scope {
     }
   }
 
-  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,
@@ -20669,8 +20756,6 @@ class Scope {
 
     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),
@@ -20678,7 +20763,7 @@ class Scope {
       $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),
@@ -20690,8 +20775,6 @@ class Scope {
       $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),
     };
@@ -20712,7 +20795,7 @@ class Scope {
 
       // TODO aditional testing
       if (property === "unshift") {
-        this.scheduleListener(this.scheduled);
+        this.#scheduleListener(this.scheduled);
       }
     }
 
@@ -20725,26 +20808,6 @@ class Scope {
     }
   }
 
-  /**
-   * @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]) {
@@ -20752,20 +20815,20 @@ class Scope {
 
       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;
@@ -20778,19 +20841,54 @@ class Scope {
       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.
@@ -20808,7 +20906,6 @@ class Scope {
     if (get.constant) {
       if (listenerFn) {
         Promise.resolve().then(() => {
-          // @ts-ignore
           let res = get();
           while (isFunction(res)) {
             res = res();
@@ -20867,11 +20964,11 @@ class Scope {
         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);
           });
         };
       }
@@ -20904,13 +21001,13 @@ class Scope {
           }
         });
         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);
           });
         };
       }
@@ -20933,10 +21030,10 @@ class Scope {
             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);
             };
           }
         }
@@ -20967,12 +21064,12 @@ class Scope {
           })
           .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);
           });
         };
       }
@@ -21034,39 +21131,31 @@ class Scope {
 
     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) {
@@ -21096,7 +21185,6 @@ class Scope {
 
   $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;
@@ -21109,7 +21197,7 @@ class Scope {
     return proxy;
   }
 
-  registerKey(key, listener) {
+  #registerKey(key, listener) {
     if (this.watchers.has(key)) {
       this.watchers.get(key).push(listener);
     } else {
@@ -21117,7 +21205,7 @@ class Scope {
     }
   }
 
-  registerForeignKey(key, listener) {
+  #registerForeignKey(key, listener) {
     if (this.foreignListeners.has(key)) {
       this.foreignListeners.get(key).push(listener);
     } else {
@@ -21125,7 +21213,7 @@ class Scope {
     }
   }
 
-  deregisterKey(key, id) {
+  #deregisterKey(key, id) {
     const listenerList = this.watchers.get(key);
     if (!listenerList) return false;
 
@@ -21141,21 +21229,21 @@ class Scope {
     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);
@@ -21183,12 +21271,19 @@ class Scope {
     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);
@@ -21197,6 +21292,11 @@ class Scope {
     }
   }
 
+  /**
+   * @param {string} name
+   * @param {Function} listener
+   * @returns {(function(): void)|*}
+   */
   $on(name, listener) {
     let namedListeners = this.$$listeners.get(name);
     if (!namedListeners) {
@@ -21219,10 +21319,10 @@ class Scope {
   /**
    * @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,
     );
@@ -21234,21 +21334,20 @@ class Scope {
    * @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,
           );
@@ -21303,7 +21402,7 @@ class Scope {
     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,
           );
@@ -21312,7 +21411,7 @@ class Scope {
       return event;
     } else {
       if (this.$parent) {
-        return this.$parent?.eventHelper(
+        return this.$parent.#eventHelper(
           { name: name, event: event, broadcast: broadcast },
           ...args,
         );
@@ -21323,10 +21422,9 @@ class Scope {
   }
 
   /**
-   * @private
    * @returns {boolean}
    */
-  isRoot() {
+  #isRoot() {
     return this.$root == /** @type {Scope} */ (this);
   }
 
@@ -21345,7 +21443,7 @@ class Scope {
       );
     });
 
-    if (this.isRoot()) {
+    if (this.#isRoot()) {
       this.watchers.clear();
     } else {
       let i = this.$parent.$children.filter((x) => x.$id == this.$id)[0];
@@ -21358,11 +21456,9 @@ class Scope {
   }
 
   /**
-   * 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);
@@ -21421,6 +21517,8 @@ class Scope {
   }
 }
 
+/*------------- Private helpers -------------*/
+
 /**
  * @param {Scope} model
  * @returns {number}
@@ -21454,7 +21552,14 @@ 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",
     /**
@@ -21593,7 +21698,7 @@ class TaskTracker {
   }
 }
 
-var $templateRequestMinErr = minErr("$templateRequest");
+const $templateRequestMinErr = minErr("$templateRequest");
 
 /**
  * Used to configure the options passed to the {@link $http} service when making a template request.
@@ -21602,7 +21707,7 @@ var $templateRequestMinErr = minErr("$templateRequest");
  * requesting a template.
  */
 function TemplateRequestProvider() {
-  var httpOptions;
+  let httpOptions;
 
   /**
    * The options to be passed to the {@link $http} service when making the request.
@@ -21668,13 +21773,17 @@ function TemplateRequestProvider() {
         // 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)) {
@@ -21786,6 +21895,7 @@ class SanitizeUriProvider {
     return (uri, isMediaUrl) => {
       if (!uri) return uri;
 
+      /** @type {RegExp} */
       const regex = isMediaUrl
         ? this._imgSrcSanitizationTrustedUrlList
         : this._aHrefSanitizationTrustedUrlList;
@@ -21825,7 +21935,7 @@ class NgMessageCtrl {
     this.head = undefined;
     this.default = undefined;
 
-    this.$scope.$watchCollection(
+    this.$scope.$watch(
       this.$attrs["ngMessages"] || this.$attrs["for"],
       this.render.bind(this),
     );
@@ -22067,7 +22177,7 @@ function ngMessageDirectiveFactory(isDefault) {
 
           if (dynamicExp) {
             assignRecords(scope.$eval(dynamicExp));
-            scope.$watchCollection(dynamicExp, assignRecords);
+            scope.$watch(dynamicExp, assignRecords);
           } else {
             assignRecords(staticExp);
           }
@@ -22226,7 +22336,7 @@ function AriaProvider() {
   };
 }
 
-ngDisabledAriaDirective.$inject = ["$aria"];
+ngDisabledAriaDirective.$inject = [$injectTokens.$aria];
 function ngDisabledAriaDirective($aria) {
   return $aria.$$watchExpr(
     "ngDisabled",
@@ -22236,7 +22346,7 @@ function ngDisabledAriaDirective($aria) {
   );
 }
 
-ngShowAriaDirective.$inject = ["$aria"];
+ngShowAriaDirective.$inject = [$injectTokens.$aria];
 function ngShowAriaDirective($aria) {
   return $aria.$$watchExpr("ngShow", "aria-hidden", [], true);
 }
@@ -22255,11 +22365,11 @@ function ngMessagesAriaDirective() {
   };
 }
 
-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);
@@ -22319,7 +22429,7 @@ function ngClickAriaDirective($aria, $parse) {
   };
 }
 
-ngRequiredAriaDirective.$inject = ["$aria"];
+ngRequiredAriaDirective.$inject = [$injectTokens.$aria];
 function ngRequiredAriaDirective($aria) {
   return $aria.$$watchExpr(
     "ngRequired",
@@ -22339,7 +22449,7 @@ function ngCheckedAriaDirective($aria) {
   );
 }
 
-ngValueAriaDirective.$inject = ["$aria"];
+ngValueAriaDirective.$inject = [$injectTokens.$aria];
 function ngValueAriaDirective($aria) {
   return $aria.$$watchExpr(
     "ngValue",
@@ -22349,12 +22459,12 @@ function ngValueAriaDirective($aria) {
   );
 }
 
-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",
@@ -22364,7 +22474,7 @@ function ngReadonlyAriaDirective($aria) {
   );
 }
 
-ngModelAriaDirective.$inject = ["$aria"];
+ngModelAriaDirective.$inject = [$injectTokens.$aria];
 function ngModelAriaDirective($aria) {
   function shouldAttachAttr(attr, normalizedAttr, elem, allowNonAriaNodes) {
     return (
@@ -22507,7 +22617,7 @@ function ngModelAriaDirective($aria) {
   };
 }
 
-ngDblclickAriaDirective.$inject = ["$aria"];
+ngDblclickAriaDirective.$inject = [$injectTokens.$aria];
 function ngDblclickAriaDirective($aria) {
   return function (scope, elem, attr) {
     if (hasOwn(attr, ARIA_DISABLE_ATTR)) return;
@@ -22759,6 +22869,7 @@ function AnimateCssProvider() {
         // 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) {
@@ -22971,13 +23082,12 @@ function AnimateCssProvider() {
           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
@@ -25640,30 +25750,27 @@ function ngAnimateSwapDirective($animate) {
     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
@@ -27573,7 +27680,7 @@ const isShorthand = (cfg) =>
     Object.prototype.hasOwnProperty.bind(cfg || {}),
   ).length === 0;
 
-var DefType;
+let DefType;
 (function (DefType) {
   DefType[(DefType["PATH"] = 0)] = "PATH";
   DefType[(DefType["SEARCH"] = 1)] = "SEARCH";
@@ -28860,6 +28967,26 @@ class Rejection {
   }
 }
 
+/** @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
@@ -30987,6 +31114,7 @@ class TransitionProvider {
 
   /**
    * @param {import('../globals.js').RouterGlobals} globals
+   * @param viewService
    */
   constructor(globals, viewService) {
     this._transitionCount = 0;
@@ -34127,6 +34255,10 @@ function resolvablesBuilder(state) {
  * using the [[builder]] method.
  */
 class StateBuilder {
+  /**
+   * @param {import('./state-matcher.js').StateMatcher} matcher
+   * @param urlService
+   */
   constructor(matcher, urlService) {
     this.matcher = matcher;
     this.$injector = undefined;
@@ -34334,12 +34466,12 @@ class StateQueueManager {
  * @implements {ServiceProvider}
  */
 class StateRegistryProvider {
-  static $inject = [
-    "$urlServiceProvider",
-    "$stateProvider",
-    "$routerGlobalsProvider",
-    "$viewProvider",
-  ];
+  static $inject = provider([
+    $injectTokens.$urlService,
+    $injectTokens.$state,
+    $injectTokens.$routerGlobals,
+    $injectTokens.$view,
+  ]);
 
   /**
    * @param urlService
@@ -34637,7 +34769,7 @@ function clickHook(el, $state, type, getDef, scope) {
       // 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,
@@ -35132,7 +35264,7 @@ let ngView = [
     };
     const directive = {
       count: 0,
-      restrict: "EA",
+
       terminal: true,
       priority: 400,
       transclude: "element",
@@ -35267,7 +35399,6 @@ function $ViewDirectiveFill($compile, $controller, $transitions) {
   const getControllerAs = parse("viewDecl.controllerAs");
   const getResolveAs = parse("viewDecl.resolveAs");
   return {
-    restrict: "EA",
     priority: -400,
     compile: function (tElement) {
       const initial = tElement.innerHTML;
@@ -35463,7 +35594,6 @@ function registerControllerCallbacks(
  */
 function ngChannelDirective() {
   return {
-    restrict: "EA",
     link: (scope, element, attrs) => {
       const hasTemplate = element.childNodes.length > 0;
       const channel = attrs["ngChannel"];
@@ -35537,7 +35667,7 @@ function ngSetterDirective($parse, $log) {
           characterData: true,
         });
       } else {
-        console.warn("ngSetter: Element is not a valid DOM node.");
+        $log.warn("ngSetter: Element is not a valid DOM node.");
         return;
       }
 
@@ -35547,13 +35677,14 @@ function ngSetterDirective($parse, $log) {
   };
 }
 
-//injected by Rollup plugin
-const VERSION = "0.7.0-beta.1";
+// @private
+
+const VERSION = "0.7.0";
 
 /**
- * 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
@@ -35562,6 +35693,7 @@ function publishExternalAPI(angular) {
       [],
       [
         "$provide",
+        /** @type {import('./interface.js').Provider} */
         ($provide) => {
           // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
           $provide.provider({
@@ -35685,12 +35817,17 @@ function publishExternalAPI(angular) {
             $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;
       },
@@ -35738,6 +35875,7 @@ class Angular {
     this.errorHandlingConfig = errorHandlingConfig;
 
     window["angular"] = this;
+    this.$injectTokens = $injectTokens;
     publishExternalAPI(this);
   }
 
@@ -35984,5 +36122,3 @@ const angular = new Angular();
 document.addEventListener("DOMContentLoaded", () => angular.init(document), {
   once: true,
 });
-
-export { angular };