@angular-wave/angular.ts 0.9.9 → 0.11.0

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.9.9 - October 28, 2025 22:08:28 */
+/* Version: 0.11.0 - November 11, 2025 21:55:55 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -912,7 +912,7 @@
     return arg;
   }
 
-  /** @type {import("./interface.js").ErrorHandlingConfig} */
+  /** @type {import("./interface.ts").ErrorHandlingConfig} */
   const minErrConfig = {
     objectMaxDepth: 5,
     urlErrorParamsEnabled: true,
@@ -1204,6 +1204,382 @@
    */
   const Cache = new Map();
 
+  /**
+   * @readonly
+   * @enum {number}
+   */
+  const ASTType = {
+    Program: 1,
+    ExpressionStatement: 2,
+    AssignmentExpression: 3,
+    ConditionalExpression: 4,
+    LogicalExpression: 5,
+    BinaryExpression: 6,
+    UnaryExpression: 7,
+    CallExpression: 8,
+    MemberExpression: 9,
+    Identifier: 10,
+    Literal: 11,
+    ArrayExpression: 12,
+    Property: 13,
+    ObjectExpression: 14,
+    ThisExpression: 15,
+    LocalsExpression: 16,
+    NGValueParameter: 17,
+  };
+
+  const ADD_CLASS_SUFFIX = "-add";
+  const REMOVE_CLASS_SUFFIX = "-remove";
+  const EVENT_CLASS_PREFIX = "ng-";
+  const ACTIVE_CLASS_SUFFIX = "-active";
+  const PREPARE_CLASS_SUFFIX = "-prepare";
+
+  const NG_ANIMATE_CLASSNAME = "ng-animate";
+  const NG_ANIMATE_CHILDREN_DATA = "$$ngAnimateChildren";
+  let TRANSITION_PROP;
+  let TRANSITIONEND_EVENT;
+  let ANIMATION_PROP;
+  let ANIMATIONEND_EVENT;
+
+  // If unprefixed events are not supported but webkit-prefixed are, use the latter.
+  // Otherwise, just use W3C names, browsers not supporting them at all will just ignore them.
+  // Note: Chrome implements `window.onwebkitanimationend` and doesn't implement `window.onanimationend`
+  // but at the same time dispatches the `animationend` event and not `webkitAnimationEnd`.
+  // Register both events in case `window.onanimationend` is not supported because of that,
+  // do the same for `transitionend` as Safari is likely to exhibit similar behavior.
+  // Also, the only modern browser that uses vendor prefixes for transitions/keyframes is webkit
+  // therefore there is no reason to test anymore for other vendor prefixes:
+  // http://caniuse.com/#search=transition
+  if (
+    window.ontransitionend === undefined &&
+    window.onwebkittransitionend !== undefined
+  ) {
+    TRANSITION_PROP = "WebkitTransition";
+    TRANSITIONEND_EVENT = "webkitTransitionEnd transitionend";
+  } else {
+    TRANSITION_PROP = "transition";
+    TRANSITIONEND_EVENT = "transitionend";
+  }
+
+  if (
+    window.onanimationend === undefined &&
+    window.onwebkitanimationend !== undefined
+  ) {
+    ANIMATION_PROP = "WebkitAnimation";
+    ANIMATIONEND_EVENT = "webkitAnimationEnd animationend";
+  } else {
+    ANIMATION_PROP = "animation";
+    ANIMATIONEND_EVENT = "animationend";
+  }
+
+  const DURATION_KEY = "Duration";
+  const PROPERTY_KEY = ASTType.Property;
+  const DELAY_KEY = "Delay";
+  const TIMING_KEY = "TimingFunction";
+  const ANIMATION_ITERATION_COUNT_KEY = "IterationCount";
+  const ANIMATION_PLAYSTATE_KEY = "PlayState";
+  const SAFE_FAST_FORWARD_DURATION_VALUE = 9999;
+
+  const ANIMATION_DELAY_PROP = ANIMATION_PROP + DELAY_KEY;
+  const ANIMATION_DURATION_PROP = ANIMATION_PROP + DURATION_KEY;
+  const TRANSITION_DELAY_PROP = TRANSITION_PROP + DELAY_KEY;
+  const TRANSITION_DURATION_PROP = TRANSITION_PROP + DURATION_KEY;
+
+  const ngMinErr$1 = minErr("ng");
+  function assertArg(arg, name, reason) {
+    if (!arg) {
+      throw ngMinErr$1(
+        "areq",
+        "Argument '{0}' is {1}",
+        name || "?",
+        reason,
+      );
+    }
+    return arg;
+  }
+
+  function packageStyles(options) {
+    const styles = {};
+    if (options && (options.to || options.from)) {
+      styles.to = options.to;
+      styles.from = options.from;
+    }
+    return styles;
+  }
+
+  function pendClasses(classes, fix, isPrefix) {
+    let className = "";
+
+    classes = Array.isArray(classes)
+      ? classes
+      : classes && isString(classes) && classes.length
+        ? classes.split(/\s+/)
+        : [];
+    classes.forEach((klass, i) => {
+      if (klass && klass.length > 0) {
+        className += i > 0 ? " " : "";
+        className += isPrefix ? fix + klass : klass + fix;
+      }
+    });
+    return className;
+  }
+
+  function removeFromArray(arr, val) {
+    const index = arr.indexOf(val);
+    if (val >= 0) {
+      arr.splice(index, 1);
+    }
+  }
+
+  /**
+   *
+   * @param {NodeList|Node} element
+   * @returns {Node[]|Node|undefined}
+   */
+  function stripCommentsFromElement(element) {
+    if (element instanceof NodeList) {
+      return Array.from(element).filter((x) => x.nodeType == Node.ELEMENT_NODE);
+    } else if (element.nodeType === Node.ELEMENT_NODE) {
+      return /** @type {Node} */ (element);
+    } else {
+      return undefined;
+    }
+  }
+
+  /**
+   * @param {NodeList|Node} element
+   * @returns {Node}
+   */
+  function extractElementNode(element) {
+    if (!element || !Array.isArray(element)) return /** @type {Node} */ (element);
+    for (let i = 0; i < /** @type {NodeList} */ (element).length; i++) {
+      const elm = element[i];
+      if (elm.nodeType === Node.ELEMENT_NODE) {
+        return elm;
+      }
+    }
+  }
+
+  function applyAnimationClassesFactory() {
+    return function (element, options) {
+      if (options.addClass) {
+        element.classList.add(...options.addClass.trim().split(" "));
+        options.addClass = null;
+      }
+      if (options.removeClass) {
+        element.classList.remove(...options.removeClass.trim().split(" "));
+        options.removeClass = null;
+      }
+    };
+  }
+
+  function prepareAnimationOptions(options) {
+    options = options || {};
+    if (!options.$$prepared) {
+      let domOperation = options.domOperation || (() => {});
+      options.domOperation = function () {
+        options.$$domOperationFired = true;
+        domOperation();
+        domOperation = () => {};
+      };
+      options.$$prepared = true;
+    }
+    return options;
+  }
+
+  function applyAnimationStyles(element, options) {
+    applyAnimationFromStyles(element, options);
+    applyAnimationToStyles(element, options);
+  }
+
+  /**
+   * Applies initial animation styles to a DOM element.
+   *
+   * This function sets the element's inline styles using the properties
+   * defined in `options.from`, then clears the property to prevent reuse.
+   *
+   * @param {HTMLElement} element - The target DOM element to apply styles to.
+   * @param {{ from?: Partial<CSSStyleDeclaration> | null }} options - options containing a `from` object with CSS property–value pairs.
+   */
+  function applyAnimationFromStyles(element, options) {
+    if (options.from) {
+      Object.assign(element.style, options.from);
+      options.from = null;
+    }
+  }
+
+  /**
+   * Applies final animation styles to a DOM element.
+   *
+   * This function sets the element's inline styles using the properties
+   * defined in `options.to`, then clears the property to prevent reuse.
+   *
+   * @param {HTMLElement} element - The target DOM element to apply styles to.
+   * @param {{ to?: Partial<CSSStyleDeclaration> | null }} options - options containing a `from` object with CSS property–value pairs.
+   */
+  function applyAnimationToStyles(element, options) {
+    if (options.to) {
+      Object.assign(element.style, options.to);
+      options.to = null;
+    }
+  }
+
+  function mergeAnimationDetails(element, oldAnimation, newAnimation) {
+    const target = oldAnimation.options || {};
+    const newOptions = newAnimation.options || {};
+
+    const toAdd = `${target.addClass || ""} ${newOptions.addClass || ""}`;
+    const toRemove = `${target.removeClass || ""} ${newOptions.removeClass || ""}`;
+    const classes = resolveElementClasses(
+      element.getAttribute("class"),
+      toAdd,
+      toRemove,
+    );
+
+    if (newOptions.preparationClasses) {
+      target.preparationClasses = concatWithSpace(
+        newOptions.preparationClasses,
+        target.preparationClasses,
+      );
+      delete newOptions.preparationClasses;
+    }
+
+    extend(target, newOptions);
+
+    if (classes.addClass) {
+      target.addClass = classes.addClass;
+    } else {
+      target.addClass = null;
+    }
+
+    if (classes.removeClass) {
+      target.removeClass = classes.removeClass;
+    } else {
+      target.removeClass = null;
+    }
+
+    oldAnimation.addClass = target.addClass;
+    oldAnimation.removeClass = target.removeClass;
+
+    return target;
+  }
+
+  function resolveElementClasses(existing, toAdd, toRemove) {
+    const ADD_CLASS = 1;
+    const REMOVE_CLASS = -1;
+
+    const flags = {};
+    existing = splitClassesToLookup(existing);
+
+    toAdd = splitClassesToLookup(toAdd);
+    Object.keys(toAdd).forEach((key) => {
+      flags[key] = ADD_CLASS;
+    });
+
+    toRemove = splitClassesToLookup(toRemove);
+    Object.keys(toRemove).forEach((key) => {
+      flags[key] = flags[key] === ADD_CLASS ? null : REMOVE_CLASS;
+    });
+
+    const classes = {
+      addClass: "",
+      removeClass: "",
+    };
+
+    Object.entries(flags).forEach(([klass, val]) => {
+      let prop, allow;
+      if (val === ADD_CLASS) {
+        prop = "addClass";
+        allow = !existing[klass] || existing[klass + REMOVE_CLASS_SUFFIX];
+      } else if (val === REMOVE_CLASS) {
+        prop = "removeClass";
+        allow = existing[klass] || existing[klass + ADD_CLASS_SUFFIX];
+      }
+      if (allow) {
+        if (classes[prop].length) {
+          classes[prop] += " ";
+        }
+        classes[prop] += klass;
+      }
+    });
+
+    function splitClassesToLookup(classes) {
+      if (isString(classes)) {
+        classes = classes.trim().split(" ");
+      }
+
+      const obj = {};
+      if (classes) {
+        classes.forEach((klass) => {
+          // sometimes the split leaves empty string values
+          // incase extra spaces were applied to the options
+          if (klass.length) {
+            obj[klass] = true;
+          }
+        });
+      }
+      return obj;
+    }
+
+    return classes;
+  }
+
+  function applyGeneratedPreparationClasses(element, event, options) {
+    let classes = "";
+    if (event) {
+      classes = pendClasses(event, EVENT_CLASS_PREFIX, true);
+    }
+    if (options.addClass) {
+      classes = concatWithSpace(
+        classes,
+        pendClasses(options.addClass, ADD_CLASS_SUFFIX),
+      );
+    }
+    if (options.removeClass) {
+      classes = concatWithSpace(
+        classes,
+        pendClasses(options.removeClass, REMOVE_CLASS_SUFFIX),
+      );
+    }
+    if (classes.length) {
+      options.preparationClasses = classes;
+      element.className += ` ${classes}`;
+    }
+  }
+
+  function clearGeneratedClasses(element, options) {
+    if (options.preparationClasses) {
+      options.preparationClasses
+        .split(" ")
+        .forEach((cls) => element.classList.remove(cls));
+      options.preparationClasses = null;
+    }
+    if (options.activeClasses) {
+      options.activeClasses
+        .split(" ")
+        .forEach((cls) => element.classList.remove(cls));
+      options.activeClasses = null;
+    }
+  }
+
+  function blockKeyframeAnimations(node, applyBlock) {
+    const value = applyBlock ? "paused" : "";
+    const key = ANIMATION_PROP + ANIMATION_PLAYSTATE_KEY;
+    applyInlineStyle(node, [key, value]);
+    return [key, value];
+  }
+
+  function applyInlineStyle(node, styleTuple) {
+    const prop = styleTuple[0];
+    node.style[prop] = styleTuple[1];
+  }
+
+  function concatWithSpace(a, b) {
+    if (!a) return b;
+    if (!b) return a;
+    return `${a} ${b}`;
+  }
+
   /** @type {number} */
   let jqId = 1;
 
@@ -1527,7 +1903,7 @@
    * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
    *
    * @param {Element} element - The DOM element to get data from.
-   * @param {string} [name] - The DOM element to get data from.
+   * @param {string} [name] - Controller name.
    * @returns {import("../core/scope/scope.js").Scope|undefined} - The retrieved data
    */
   function getController(element, name) {
@@ -1677,7 +2053,7 @@
   /**
    * Return instance of InjectorService attached to element
    * @param {Element} element
-   * @returns {import('../core/di/internal-injector.js').InjectorService}
+   * @returns {ng.InjectorService}
    */
   function getInjector(element) {
     return getInheritedData(element, "$injector");
@@ -1725,12 +2101,8 @@
     // from the dom sometime before this code runs then let's
     // just stick to using the parent element as the anchor
     if (afterElement) {
-      const afterNode = extractElementNode$1(afterElement);
-      if (
-        afterNode &&
-        !afterNode.parentNode &&
-        !afterNode.previousElementSibling
-      ) {
+      const afterNode = extractElementNode(afterElement);
+      if (afterNode && !afterNode.parentNode && !afterNode.previousSibling) {
         afterElement = null;
       }
     }
@@ -1741,14 +2113,24 @@
     }
   }
 
-  function extractElementNode$1(element) {
-    const { length } = element;
-    for (let i = 0; i < length; i++) {
-      const elm = element[i];
-      if (elm.nodeType === Node.ELEMENT_NODE) {
-        return elm;
-      }
-    }
+  function animatedomInsert(element, parent, after) {
+    const originalVisibility = element.style.visibility;
+    const originalPosition = element.style.position;
+    const originalPointerEvents = element.style.pointerEvents;
+
+    Object.assign(element.style, {
+      visibility: "hidden",
+      position: "absolute",
+      pointerEvents: "none",
+    });
+
+    domInsert(element, parent, after);
+
+    requestAnimationFrame(() => {
+      element.style.visibility = originalVisibility;
+      element.style.position = originalPosition;
+      element.style.pointerEvents = originalPointerEvents;
+    });
   }
 
   /**
@@ -1782,8 +2164,6 @@
     $attrs: "$attrs",
     $scope: "$scope",
     $element: "$element",
-    $$AnimateRunner: "$$AnimateRunner",
-    $$animateAsyncRun: "$$animateAsyncRun",
     $$animateCache: "$$animateCache",
     $$animateCssDriver: "$$animateCssDriver",
     $$animateJs: "$$animateJs",
@@ -1869,7 +2249,7 @@
     /**
      * @param {string} name - Name of the module
      * @param {Array<string>} requires - List of modules which the injector will load before the current module
-     * @param {import("../../interface.js").Injectable<any>} [configFn]
+     * @param {import("../../interface.ts").Injectable<any>} [configFn]
      */
     constructor(name, requires, configFn) {
       assert(isString(name), "name required");
@@ -1895,7 +2275,7 @@
       /** @type {!Array<Array<*>>} */
       this.configBlocks = [];
 
-      /** @type {!Array.<import("../../interface.js").Injectable<any>>} */
+      /** @type {!Array.<import("../../interface.ts").Injectable<any>>} */
       this.runBlocks = [];
 
       if (configFn) {
@@ -1999,7 +2379,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable<any>} decorFn
+     * @param {import("../../interface.ts").Injectable<any>} decorFn
      * @returns {NgModule}
      */
     decorator(name, decorFn) {
@@ -2012,7 +2392,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable<any>} directiveFactory
+     * @param {import("../../interface.ts").Injectable<any>} directiveFactory
      * @returns {NgModule}
      */
     directive(name, directiveFactory) {
@@ -2029,7 +2409,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable<any>} animationFactory
+     * @param {import("../../interface.ts").Injectable<any>} animationFactory
      * @returns {NgModule}
      */
     animation(name, animationFactory) {
@@ -2046,7 +2426,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable<any>} filterFn
+     * @param {import("../../interface.ts").Injectable<any>} filterFn
      * @return {NgModule}
      */
     filter(name, filterFn) {
@@ -2059,7 +2439,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable<any>} ctlFn
+     * @param {import("../../interface.ts").Injectable<any>} ctlFn
      * @returns {NgModule}
      */
     controller(name, ctlFn) {
@@ -2286,6 +2666,8 @@
       const hasCache = hasOwn(this.cache, name);
       return hasProvider || hasCache;
     }
+
+    loadNewModules() {}
   }
 
   // Helpers
@@ -2444,7 +2826,7 @@
      * Registers a factory.
      * @param {string} name
      * @param {(string|(function(*): *))[]} factoryFn
-     * @returns {import('../../interface.js').ServiceProvider}
+     * @returns {import('../../interface.ts').ServiceProvider}
      */
     function factory(name, factoryFn) {
       return provider(name, {
@@ -2466,7 +2848,7 @@
      * Registers a service constructor.
      * @param {string} name
      * @param {Function} constructor
-     * @returns {import('../../interface.js').ServiceProvider}
+     * @returns {import('../../interface.ts').ServiceProvider}
      */
     function service(name, constructor) {
       return factory(name, [
@@ -2935,7 +3317,7 @@
 
       /**
        * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
-       * @returns {import("./interface.js").ControllerService} A service function that creates controllers.
+       * @returns {import("./interface.ts").ControllerService} A service function that creates controllers.
        */
       ($injector) => {
         return (expression, locals, later, ident) => {
@@ -3053,18 +3435,19 @@
         );
       }
       locals.$scope[identifier] = instance;
+      locals.$scope["$controllerIdentifier"] = identifier;
     }
   }
 
   const originUrl = urlResolve(window.location.href);
 
   /**
-   * @param {import("./interface.js").ResolvableUrl} url
-   * @return {import("./interface.js").ParsedUrl}
+   * @param {import("./interface.ts").ResolvableUrl} url
+   * @return {import("./interface.ts").ParsedUrl}
    */
   function urlResolve(url) {
     if (!isString(url))
-      return /** @type {import("./interface.js").ParsedUrl} */ (url);
+      return /** @type {import("./interface.ts").ParsedUrl} */ (url);
 
     const urlParsingNode = new URL(
       /** @type {string} */ (url),
@@ -3096,7 +3479,7 @@
    * Parse a request URL and determine whether this is a same-origin request as the application
    * document.
    *
-   * @param {import("./interface.js").ResolvableUrl} requestUrl The url of the request as a string that will be resolved
+   * @param {import("./interface.ts").ResolvableUrl} requestUrl The url of the request as a string that will be resolved
    * or a parsed URL object.
    * @returns {boolean} Whether the request is for the same origin as the application document.
    */
@@ -3110,7 +3493,7 @@
    * Note: The base URL is usually the same as the document location (`location.href`) but can
    * be overriden by using the `<base>` tag.
    *
-   * @param {import("./interface.js").ResolvableUrl} requestUrl The url of the request as a string that will be resolved
+   * @param {import("./interface.ts").ResolvableUrl} requestUrl The url of the request as a string that will be resolved
    * or a parsed URL object.
    * @returns {boolean} Whether the URL is same-origin as the document base URL.
    */
@@ -3124,7 +3507,7 @@
    *
    * @param {string[]} trustedOriginUrls - A list of URLs (strings), whose origins are trusted.
    *
-   * @returns {(url: import("./interface.js").ResolvableUrl) => boolean } - A function that receives a URL (string or parsed URL object) and returns
+   * @returns {(url: import("./interface.ts").ResolvableUrl) => boolean } - A function that receives a URL (string or parsed URL object) and returns
    *     whether it is of an allowed origin.
    */
   function urlIsAllowedOriginFactory(trustedOriginUrls) {
@@ -3137,7 +3520,7 @@
      * based on a list of trusted-origin URLs. The current location's origin is implicitly
      * trusted.
      *
-     * @param {import("./interface.js").ResolvableUrl} requestUrl - The URL to be checked (provided as a string that will be
+     * @param {import("./interface.ts").ResolvableUrl} requestUrl - The URL to be checked (provided as a string that will be
      *     resolved or a parsed URL object).
      *
      * @returns {boolean} - Whether the specified URL is of an allowed origin.
@@ -3153,9 +3536,9 @@
   /**
    * Determine if two URLs share the same origin.
    *
-   * @param {import("./interface.js").ResolvableUrl} url1 - First URL to compare as a string or a normalized URL in the form of
+   * @param {import("./interface.ts").ResolvableUrl} url1 - First URL to compare as a string or a normalized URL in the form of
    *     a dictionary object returned by `urlResolve()`.
-   * @param {import("./interface.js").ResolvableUrl} url2 - Second URL to compare as a string or a normalized URL in the form
+   * @param {import("./interface.ts").ResolvableUrl} url2 - Second URL to compare as a string or a normalized URL in the form
    *     of a dictionary object returned by `urlResolve()`.
    *
    * @returns {boolean} - True if both URLs have the same origin, and false otherwise.
@@ -3789,7 +4172,7 @@
          *
          * @param {string} type The SCE context in which this result will be used.
          * @param {string} expr String expression to compile.
-         * @return {import("../../core/parse/interface.js").CompiledExpression} A function which represents the compiled expression:
+         * @return {import("../../core/parse/interface.ts").CompiledExpression} A function which represents the compiled expression:
          *
          *    * `context` – `{object}` – an object against which any expressions embedded in the
          *      strings are evaluated against (typically a scope object).
@@ -4021,26 +4404,23 @@
    */
   const ngEventDirectives = {};
 
-  "click copy cut dblclick focus blur keydown keyup load mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup paste submit touchstart touchend touchmove offline online"
+  "click copy cut dblclick focus blur keydown keyup load mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup paste submit touchstart touchend touchmove"
     .split(" ")
     .forEach((eventName) => {
       const directiveName = directiveNormalize(`ng-${eventName}`);
       ngEventDirectives[directiveName] = [
         $injectTokens.$parse,
         $injectTokens.$exceptionHandler,
-        $injectTokens.$window,
 
         /**
-         * @param {import("../../core/parse/interface.ts").ParseService} $parse
+         * @param {ng.ParseService} $parse
          * @param {ng.ExceptionHandlerService} $exceptionHandler
-         * @param {ng.WindowService} $window
          * @returns
          */
-        ($parse, $exceptionHandler, $window) => {
+        ($parse, $exceptionHandler) => {
           return createEventDirective(
             $parse,
             $exceptionHandler,
-            $window,
             directiveName,
             eventName,
           );
@@ -4052,7 +4432,6 @@
    *
    * @param {ng.ParseService} $parse
    * @param {ng.ExceptionHandlerService} $exceptionHandler
-   * @param {ng.WindowService} $window
    * @param {string} directiveName
    * @param {string} eventName
    * @returns {ng.Directive}
@@ -4060,7 +4439,6 @@
   function createEventDirective(
     $parse,
     $exceptionHandler,
-    $window,
     directiveName,
     eventName,
   ) {
@@ -4129,16 +4507,13 @@
   const SIMPLE_ATTR_NAME = /^\w/;
   const specialAttrHolder = document.createElement("div");
 
-  /**
-   * @implements {Record<string, any>}
-   */
   class Attributes {
     static $nonscope = true;
 
     /**
-     * @param {import('../scope/scope.js').Scope} $rootScope
+     * @param {ng.Scope} $rootScope
      * @param {*} $animate
-     * @param {import("../../services/exception/exception-handler.js").ErrorHandler} $exceptionHandler
+     * @param {ng.ExceptionHandlerService} $exceptionHandler
      * @param {*} $sce
      * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
      * @param {Object} [attributesToCopy]
@@ -4451,19 +4826,18 @@
   /**
    * @param {string} source - the name of the attribute to be observed
    * @param {string} prop - the scope property to be updated with attribute value
-   * @returns {import("../../interface.ts").Directive}
+   * @returns {ng.Directive}
    */
   function ngObserveDirective(source, prop) {
     return {
       restrict: "A",
       compile: () => (scope, element) => {
-        const targetElement = element;
         if (prop === "") {
           prop = source;
         }
         const normalized = kebabToCamel(prop);
         if (!scope[normalized]) {
-          scope[normalized] = targetElement.getAttribute(source);
+          scope[normalized] = element.getAttribute(source);
         }
 
         const observer = new MutationObserver((mutations) => {
@@ -4476,7 +4850,7 @@
           }
         });
 
-        observer.observe(targetElement, {
+        observer.observe(element, {
           attributes: true,
           attributeFilter: [source],
         });
@@ -4502,7 +4876,7 @@
     /* @ignore */ static $inject = [$injectTokens.$provide, $injectTokens.$$sanitizeUriProvider];
 
     /**
-     * @param {import('../../interface.js').Provider} $provide
+     * @param {import('../../interface.ts').Provider} $provide
      * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $$sanitizeUriProvider
      */
     constructor($provide, $$sanitizeUriProvider) {
@@ -4692,7 +5066,7 @@
       /**
        * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
        *    or an object map of components where the keys are the names and the values are the component definition objects.
-       * @param {import("../../interface.js").Component} options Component definition object (a simplified
+       * @param {import("../../interface.ts").Component} options Component definition object (a simplified
        *    {directive definition object}),
        *    with the following properties (all optional):
        *
@@ -5478,12 +5852,12 @@
                         createEventDirective(
                           $parse,
                           $exceptionHandler,
-                          window,
                           nName,
                           name,
                         ),
                       );
                     } else {
+                      // isWindow
                       directives.push(
                         createWindowEventDirective(
                           $parse,
@@ -7473,7 +7847,7 @@
                               scope.$handler.watchers
                                 .get(attrs[attrName])
                                 ?.forEach((watchFn) => {
-                                  watchFn.listenerFn(val);
+                                  watchFn.listenerFn(val, scope.$target);
                                 });
                             }
                           }
@@ -7886,8 +8260,14 @@
      * state (ng-dirty class). This method will also propagate to parent forms.
      */
     $setDirty() {
-      this.$$animate.removeClass(this.$$element, PRISTINE_CLASS);
-      this.$$animate.addClass(this.$$element, DIRTY_CLASS);
+      if (hasAnimate(this.$$element)) {
+        this.$$animate.removeClass(this.$$element, PRISTINE_CLASS);
+        this.$$animate.addClass(this.$$element, DIRTY_CLASS);
+      } else {
+        // Fallback for non-animated environments
+        this.$$element.classList.remove(PRISTINE_CLASS);
+        this.$$element.classList.add(DIRTY_CLASS);
+      }
       this.$dirty = true;
       this.$pristine = false;
       this.$$parentForm.$setDirty();
@@ -7906,11 +8286,18 @@
      * saving or resetting it.
      */
     $setPristine() {
-      this.$$animate.setClass(
-        this.$$element,
-        PRISTINE_CLASS,
-        `${DIRTY_CLASS} ${SUBMITTED_CLASS}`,
-      );
+      if (hasAnimate(this.$$element)) {
+        this.$$animate.setClass(
+          this.$$element,
+          PRISTINE_CLASS,
+          `${DIRTY_CLASS} ${SUBMITTED_CLASS}`,
+        );
+      } else {
+        // Fallback for non-animated environments
+        this.$$element.classList.remove(DIRTY_CLASS, SUBMITTED_CLASS);
+        this.$$element.classList.add(PRISTINE_CLASS);
+      }
+
       this.$dirty = false;
       this.$pristine = true;
       this.$submitted = false;
@@ -7948,7 +8335,11 @@
     }
 
     $$setSubmitted() {
-      this.$$animate.addClass(this.$$element, SUBMITTED_CLASS);
+      if (hasAnimate(this.$$element)) {
+        this.$$animate.addClass(this.$$element, SUBMITTED_CLASS);
+      } else {
+        this.$$element.classList.add(SUBMITTED_CLASS);
+      }
       this.$submitted = true;
       this.$$controls.forEach((control) => {
         if (control.$$setSubmitted) {
@@ -10503,9 +10894,9 @@
   inputDirective.$inject = ["$filter", "$parse"];
 
   /**
-   * @param {*} $filter
-   * @param {*} $parse
-   * @returns {import('../../interface.ts').Directive}
+   * @param {ng.FilterService} $filter
+   * @param {ng.ParseService} $parse
+   * @returns {ng.Directive}
    */
   function inputDirective($filter, $parse) {
     return {
@@ -10529,7 +10920,7 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function hiddenInputBrowserCacheDirective() {
     const valueProperty = {
@@ -10575,7 +10966,7 @@
   const CONSTANT_VALUE_REGEXP = /^(true|false|\d+)$/;
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngValueDirective() {
     /**
@@ -10599,15 +10990,15 @@
     return {
       restrict: "A",
       priority: 100,
-      compile(tpl, tplAttr) {
-        if (CONSTANT_VALUE_REGEXP.test(tplAttr["ngValue"])) {
-          return function ngValueConstantLink(scope, elm, attr) {
-            const value = scope.$eval(attr["ngValue"]);
+      compile(_, tplAttr) {
+        if (CONSTANT_VALUE_REGEXP.test(tplAttr.ngValue)) {
+          return function (scope, elm, attr) {
+            const value = scope.$eval(attr.ngValue);
             updateElementValue(elm, attr, value);
           };
         }
-        return function ngValueLink(scope, elm, attr) {
-          scope.$watch(attr["ngValue"], (value) => {
+        return function (scope, elm, attr) {
+          scope.$watch(attr.ngValue, (value) => {
             updateElementValue(elm, attr, value);
           });
         };
@@ -11288,17 +11679,20 @@
   /**
    * @param {string} name
    * @param {boolean|number} selector
-   * @returns {() => import("../../interface.ts").Directive}
+   * @returns {ng.DirectiveFactory}
    */
   function classDirective(name, selector) {
     name = `ngClass${name}`;
 
+    /**
+     * @returns {ng.Directive}
+     */
     return function () {
       return {
         /**
-         * @param {import("../../core/scope/scope.js").Scope} scope
-         * @param {Element} element
-         * @param {import("../../core/compile/attributes").Attributes} attr
+         * @param {ng.Scope} scope
+         * @param {HTMLElement} element
+         * @param {ng.Attributes} attr
          */
         link(scope, element, attr) {
           let classCounts = getCacheData(element, "$classCounts");
@@ -11472,9 +11866,8 @@
    */
   function ngCloakDirective() {
     return {
-      compile(element, attr) {
+      compile(_, attr) {
         attr.$set("ngCloak", undefined);
-        element.classList.remove("ng-cloak");
       },
     };
   }
@@ -11558,7 +11951,7 @@
   ngIfDirective.$inject = ["$animate"];
   /**
    * @param {*}  $animate
-   * @returns {import("../../interface.ts").Directive}
+   * @returns {ng.Directive}
    */
   function ngIfDirective($animate) {
     return {
@@ -11568,22 +11961,22 @@
       restrict: "A",
       /**
        *
-       * @param {import("../../core/scope/scope.js").Scope} $scope
+       * @param {ng.Scope} $scope
        * @param {Element} $element
-       * @param {import("../../core/compile/attributes.js").Attributes} $attr
-       * @param {Object} _ctrl
+       * @param {ng.Attributes} $attr
+       * @param {*} _ctrl
        * @param {*} $transclude
        */
       link($scope, $element, $attr, _ctrl, $transclude) {
         /** @type {Element} */
         let block;
 
-        /** @type {import('../../core/scope/scope.js').Scope} */
+        /** @type {ng.Scope} */
         let childScope;
 
         let previousElements;
 
-        $scope.$watch($attr["ngIf"], (value) => {
+        $scope.$watch($attr.ngIf, (value) => {
           if (value) {
             if (!childScope) {
               $transclude((clone, newScope) => {
@@ -11638,7 +12031,7 @@
    * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
    * @param {*} $animate
    * @param {import('../../services/exception/interface.ts').ErrorHandler} $exceptionHandler
-   * @returns {import('../../interface.js').Directive}
+   * @returns {import('../../interface.ts').Directive}
    */
   function ngIncludeDirective(
     $templateRequest,
@@ -13020,7 +13413,7 @@
   const REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
 
   /**
-   * @type {Record<string, import("../../interface.js").DirectiveFactory>}
+   * @type {Record<string, import("../../interface.ts").DirectiveFactory>}
    */
   const ngAttributeAliasDirectives = {};
 
@@ -13593,364 +13986,6 @@
     ];
   }
 
-  /**
-   * @readonly
-   * @enum {number}
-   */
-  const ASTType = {
-    Program: 1,
-    ExpressionStatement: 2,
-    AssignmentExpression: 3,
-    ConditionalExpression: 4,
-    LogicalExpression: 5,
-    BinaryExpression: 6,
-    UnaryExpression: 7,
-    CallExpression: 8,
-    MemberExpression: 9,
-    Identifier: 10,
-    Literal: 11,
-    ArrayExpression: 12,
-    Property: 13,
-    ObjectExpression: 14,
-    ThisExpression: 15,
-    LocalsExpression: 16,
-    NGValueParameter: 17,
-  };
-
-  const ADD_CLASS_SUFFIX = "-add";
-  const REMOVE_CLASS_SUFFIX = "-remove";
-  const EVENT_CLASS_PREFIX = "ng-";
-  const ACTIVE_CLASS_SUFFIX = "-active";
-  const PREPARE_CLASS_SUFFIX = "-prepare";
-
-  const NG_ANIMATE_CLASSNAME = "ng-animate";
-  const NG_ANIMATE_CHILDREN_DATA = "$$ngAnimateChildren";
-  let TRANSITION_PROP;
-  let TRANSITIONEND_EVENT;
-  let ANIMATION_PROP;
-  let ANIMATIONEND_EVENT;
-
-  // If unprefixed events are not supported but webkit-prefixed are, use the latter.
-  // Otherwise, just use W3C names, browsers not supporting them at all will just ignore them.
-  // Note: Chrome implements `window.onwebkitanimationend` and doesn't implement `window.onanimationend`
-  // but at the same time dispatches the `animationend` event and not `webkitAnimationEnd`.
-  // Register both events in case `window.onanimationend` is not supported because of that,
-  // do the same for `transitionend` as Safari is likely to exhibit similar behavior.
-  // Also, the only modern browser that uses vendor prefixes for transitions/keyframes is webkit
-  // therefore there is no reason to test anymore for other vendor prefixes:
-  // http://caniuse.com/#search=transition
-  if (
-    window.ontransitionend === undefined &&
-    window.onwebkittransitionend !== undefined
-  ) {
-    TRANSITION_PROP = "WebkitTransition";
-    TRANSITIONEND_EVENT = "webkitTransitionEnd transitionend";
-  } else {
-    TRANSITION_PROP = "transition";
-    TRANSITIONEND_EVENT = "transitionend";
-  }
-
-  if (
-    window.onanimationend === undefined &&
-    window.onwebkitanimationend !== undefined
-  ) {
-    ANIMATION_PROP = "WebkitAnimation";
-    ANIMATIONEND_EVENT = "webkitAnimationEnd animationend";
-  } else {
-    ANIMATION_PROP = "animation";
-    ANIMATIONEND_EVENT = "animationend";
-  }
-
-  const DURATION_KEY = "Duration";
-  const PROPERTY_KEY = ASTType.Property;
-  const DELAY_KEY = "Delay";
-  const TIMING_KEY = "TimingFunction";
-  const ANIMATION_ITERATION_COUNT_KEY = "IterationCount";
-  const ANIMATION_PLAYSTATE_KEY = "PlayState";
-  const SAFE_FAST_FORWARD_DURATION_VALUE = 9999;
-
-  const ANIMATION_DELAY_PROP = ANIMATION_PROP + DELAY_KEY;
-  const ANIMATION_DURATION_PROP = ANIMATION_PROP + DURATION_KEY;
-  const TRANSITION_DELAY_PROP = TRANSITION_PROP + DELAY_KEY;
-  const TRANSITION_DURATION_PROP = TRANSITION_PROP + DURATION_KEY;
-
-  const ngMinErr$1 = minErr("ng");
-  function assertArg(arg, name, reason) {
-    if (!arg) {
-      throw ngMinErr$1(
-        "areq",
-        "Argument '{0}' is {1}",
-        name || "?",
-        reason,
-      );
-    }
-    return arg;
-  }
-
-  function packageStyles(options) {
-    const styles = {};
-    if (options && (options.to || options.from)) {
-      styles.to = options.to;
-      styles.from = options.from;
-    }
-    return styles;
-  }
-
-  function pendClasses(classes, fix, isPrefix) {
-    let className = "";
-
-    classes = Array.isArray(classes)
-      ? classes
-      : classes && isString(classes) && classes.length
-        ? classes.split(/\s+/)
-        : [];
-    classes.forEach((klass, i) => {
-      if (klass && klass.length > 0) {
-        className += i > 0 ? " " : "";
-        className += isPrefix ? fix + klass : klass + fix;
-      }
-    });
-    return className;
-  }
-
-  function removeFromArray(arr, val) {
-    const index = arr.indexOf(val);
-    if (val >= 0) {
-      arr.splice(index, 1);
-    }
-  }
-
-  /**
-   *
-   * @param {NodeList|Node} element
-   * @returns {Node[]|Node|undefined}
-   */
-  function stripCommentsFromElement(element) {
-    if (element instanceof NodeList) {
-      return Array.from(element).filter((x) => x.nodeType == Node.ELEMENT_NODE);
-    } else if (element.nodeType === Node.ELEMENT_NODE) {
-      return /** @type {Node} */ (element);
-    } else {
-      return undefined;
-    }
-  }
-
-  /**
-   * @param {NodeList|Node} element
-   * @returns {Node}
-   */
-  function extractElementNode(element) {
-    if (!element) return /** @type {Node} */ (element);
-    for (let i = 0; i < /** @type {NodeList} */ (element).length; i++) {
-      const elm = element[i];
-      if (elm.nodeType === Node.ELEMENT_NODE) {
-        return elm;
-      }
-    }
-  }
-
-  function applyAnimationClassesFactory() {
-    return function (element, options) {
-      if (options.addClass) {
-        element.classList.add(...options.addClass.trim().split(" "));
-        options.addClass = null;
-      }
-      if (options.removeClass) {
-        element.classList.remove(...options.removeClass.trim().split(" "));
-        options.removeClass = null;
-      }
-    };
-  }
-
-  function prepareAnimationOptions(options) {
-    options = options || {};
-    if (!options.$$prepared) {
-      let domOperation = options.domOperation || (() => {});
-      options.domOperation = function () {
-        options.$$domOperationFired = true;
-        domOperation();
-        domOperation = () => {};
-      };
-      options.$$prepared = true;
-    }
-    return options;
-  }
-
-  function applyAnimationStyles(element, options) {
-    applyAnimationFromStyles(element, options);
-    applyAnimationToStyles(element, options);
-  }
-
-  function applyAnimationFromStyles(element, options) {
-    if (options.from) {
-      //element.css(options.from);
-      options.from = null;
-    }
-  }
-
-  function applyAnimationToStyles(element, options) {
-    if (options.to) {
-      //element.css(options.to);
-      options.to = null;
-    }
-  }
-
-  function mergeAnimationDetails(element, oldAnimation, newAnimation) {
-    const target = oldAnimation.options || {};
-    const newOptions = newAnimation.options || {};
-
-    const toAdd = `${target.addClass || ""} ${newOptions.addClass || ""}`;
-    const toRemove = `${target.removeClass || ""} ${newOptions.removeClass || ""}`;
-    const classes = resolveElementClasses(
-      element.getAttribute("class"),
-      toAdd,
-      toRemove,
-    );
-
-    if (newOptions.preparationClasses) {
-      target.preparationClasses = concatWithSpace(
-        newOptions.preparationClasses,
-        target.preparationClasses,
-      );
-      delete newOptions.preparationClasses;
-    }
-
-    extend(target, newOptions);
-
-    if (classes.addClass) {
-      target.addClass = classes.addClass;
-    } else {
-      target.addClass = null;
-    }
-
-    if (classes.removeClass) {
-      target.removeClass = classes.removeClass;
-    } else {
-      target.removeClass = null;
-    }
-
-    oldAnimation.addClass = target.addClass;
-    oldAnimation.removeClass = target.removeClass;
-
-    return target;
-  }
-
-  function resolveElementClasses(existing, toAdd, toRemove) {
-    const ADD_CLASS = 1;
-    const REMOVE_CLASS = -1;
-
-    const flags = {};
-    existing = splitClassesToLookup(existing);
-
-    toAdd = splitClassesToLookup(toAdd);
-    Object.keys(toAdd).forEach((key) => {
-      flags[key] = ADD_CLASS;
-    });
-
-    toRemove = splitClassesToLookup(toRemove);
-    Object.keys(toRemove).forEach((key) => {
-      flags[key] = flags[key] === ADD_CLASS ? null : REMOVE_CLASS;
-    });
-
-    const classes = {
-      addClass: "",
-      removeClass: "",
-    };
-
-    Object.entries(flags).forEach(([klass, val]) => {
-      let prop, allow;
-      if (val === ADD_CLASS) {
-        prop = "addClass";
-        allow = !existing[klass] || existing[klass + REMOVE_CLASS_SUFFIX];
-      } else if (val === REMOVE_CLASS) {
-        prop = "removeClass";
-        allow = existing[klass] || existing[klass + ADD_CLASS_SUFFIX];
-      }
-      if (allow) {
-        if (classes[prop].length) {
-          classes[prop] += " ";
-        }
-        classes[prop] += klass;
-      }
-    });
-
-    function splitClassesToLookup(classes) {
-      if (isString(classes)) {
-        classes = classes.trim().split(" ");
-      }
-
-      const obj = {};
-      if (classes) {
-        classes.forEach((klass) => {
-          // sometimes the split leaves empty string values
-          // incase extra spaces were applied to the options
-          if (klass.length) {
-            obj[klass] = true;
-          }
-        });
-      }
-      return obj;
-    }
-
-    return classes;
-  }
-
-  function applyGeneratedPreparationClasses(element, event, options) {
-    let classes = "";
-    if (event) {
-      classes = pendClasses(event, EVENT_CLASS_PREFIX, true);
-    }
-    if (options.addClass) {
-      classes = concatWithSpace(
-        classes,
-        pendClasses(options.addClass, ADD_CLASS_SUFFIX),
-      );
-    }
-    if (options.removeClass) {
-      classes = concatWithSpace(
-        classes,
-        pendClasses(options.removeClass, REMOVE_CLASS_SUFFIX),
-      );
-    }
-    if (classes.length) {
-      options.preparationClasses = classes;
-      element.className += ` ${classes}`;
-    }
-  }
-
-  function clearGeneratedClasses(element, options) {
-    if (options.preparationClasses) {
-      options.preparationClasses
-        .split(" ")
-        .forEach((cls) => element.classList.remove(cls));
-      options.preparationClasses = null;
-    }
-    if (options.activeClasses) {
-      options.activeClasses
-        .split(" ")
-        .forEach((cls) => element.classList.remove(cls));
-      options.activeClasses = null;
-    }
-  }
-
-  function blockKeyframeAnimations(node, applyBlock) {
-    const value = applyBlock ? "paused" : "";
-    const key = ANIMATION_PROP + ANIMATION_PLAYSTATE_KEY;
-    applyInlineStyle(node, [key, value]);
-    return [key, value];
-  }
-
-  function applyInlineStyle(node, styleTuple) {
-    const prop = styleTuple[0];
-    node.style[prop] = styleTuple[1];
-  }
-
-  function concatWithSpace(a, b) {
-    if (!a) return b;
-    if (!b) return a;
-    return `${a} ${b}`;
-  }
-
   /** @typedef {"enter"|"leave"|"move"|"addClass"|"setClass"|"removeClass"} AnimationMethod */
 
   /**
@@ -13985,7 +14020,7 @@
 
   AnimateProvider.$inject = ["$provide"];
 
-  /** @param {import('../interface.ts').Provider} $provide */
+  /** @param {ng.ProvideService} $provide */
   function AnimateProvider($provide) {
     const provider = this;
     let classNameFilter = null;
@@ -14260,7 +14295,7 @@
          * Note that this does not cancel the underlying operation, e.g. the setting of classes or
          * adding the element to the DOM.
          *
-         * @param {import('./animate-runner.js').AnimateRunner} runner An animation runner returned by an $animate function.
+         * @param {import('./runner/animate-runner.js').AnimateRunner} runner An animation runner returned by an $animate function.
          *
          * @example
           <example module="animationExample" deps="angular-animate.js" animations="true" name="animate-cancel">
@@ -14338,13 +14373,13 @@
            *
            * @param {Element} element - the element which will be inserted into the DOM
            * @param {Element} parent - the parent element which will append the element as a child (so long as the after element is not present)
-           * @param {Element} after - after the sibling element after which the element will be appended
+           * @param {Element} [after] - after the sibling element after which the element will be appended
            * @param {AnimationOptions} [options] - an optional collection of options/styles that will be applied to the element.
-           * @returns {import('./animate-runner.js').AnimateRunner} the animation runner
+           * @returns {import('./runner/animate-runner.js').AnimateRunner} the animation runner
            */
           enter(element, parent, after, options) {
             parent = parent || after.parentElement;
-            domInsert(element, parent, after);
+            animatedomInsert(element, parent, after);
             return $$animateQueue.push(
               element,
               "enter",
@@ -14362,11 +14397,11 @@
            * @param {Element} parent - the parent element which will append the element as a child (so long as the after element is not present)
            * @param {Element} after - after the sibling element after which the element will be appended
            * @param {AnimationOptions} [options] - an optional collection of options/styles that will be applied to the element.
-           * @returns {import('./animate-runner.js').AnimateRunner} the animation runner
+           * @returns {import('./runner/animate-runner.js').AnimateRunner} the animation runner
            */
           move(element, parent, after, options) {
             parent = parent || after.parentElement;
-            domInsert(element, parent, after);
+            animatedomInsert(element, parent, after);
             return $$animateQueue.push(
               element,
               "move",
@@ -14381,7 +14416,7 @@
            *
            * @param {Element} element the element which will be removed from the DOM
            * @param {AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.
-           * @returns {import('./animate-runner.js').AnimateRunner} the animation runner
+           * @returns {import('./runner/animate-runner.js').AnimateRunner} the animation runner
            */
           leave(element, options) {
             return $$animateQueue.push(
@@ -14410,7 +14445,7 @@
            * @param {Element} element the element which the CSS classes will be applied to
            * @param {string} className the CSS class(es) that will be added (multiple classes are separated via spaces)
            * @param {AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.
-           * @return {import('./animate-runner.js').AnimateRunner}} animationRunner the animation runner
+           * @return {import('./runner/animate-runner.js').AnimateRunner}} animationRunner the animation runner
            */
           addClass(element, className, options) {
             options = prepareAnimateOptions(options);
@@ -14429,7 +14464,7 @@
            * @param {Element} element the element which the CSS classes will be applied to
            * @param {string} className the CSS class(es) that will be removed (multiple classes are separated via spaces)
            * @param {AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.         *
-           * @return {import('./animate-runner.js').AnimateRunner} animationRunner the animation runner
+           * @return {import('./runner/animate-runner.js').AnimateRunner} animationRunner the animation runner
            */
           removeClass(element, className, options) {
             options = prepareAnimateOptions(options);
@@ -14450,7 +14485,7 @@
            * @param {string} remove the CSS class(es) that will be removed (multiple classes are separated via spaces)
            * @param {object=} options an optional collection of options/styles that will be applied to the element.
            *
-           * @return {import('./animate-runner.js').AnimateRunner} the animation runner
+           * @return {import('./runner/animate-runner.js').AnimateRunner} the animation runner
            */
           setClass(element, add, remove, options) {
             options = prepareAnimateOptions(options);
@@ -14478,7 +14513,7 @@
            *   }
            * });
            * ```
-           *  @return {import('./animate-runner.js').AnimateRunner} the animation runner
+           *  @return {import('./runner/animate-runner.js').AnimateRunner} the animation runner
            */
           animate(element, from, to, className, options) {
             options = prepareAnimateOptions(options);
@@ -14494,200 +14529,6 @@
     ];
   }
 
-  function AnimateAsyncRunFactoryProvider() {
-    this.$get = [
-      function () {
-        let waitQueue = [];
-
-        function waitForTick(fn) {
-          waitQueue.push(fn);
-          if (waitQueue.length > 1) return;
-          window.requestAnimationFrame(function () {
-            for (let i = 0; i < waitQueue.length; i++) {
-              waitQueue[i]();
-            }
-            waitQueue = [];
-          });
-        }
-
-        return function () {
-          let passed = false;
-          waitForTick(function () {
-            passed = true;
-          });
-          return function (callback) {
-            if (passed) {
-              callback();
-            } else {
-              waitForTick(callback);
-            }
-          };
-        };
-      },
-    ];
-  }
-
-  const INITIAL_STATE = 0;
-  const DONE_PENDING_STATE = 1;
-  const DONE_COMPLETE_STATE = 2;
-  let $$animateAsyncRun;
-
-  function AnimateRunnerFactoryProvider() {
-    this.$get = [
-      "$$animateAsyncRun",
-      function (animateAsyncRun) {
-        $$animateAsyncRun = animateAsyncRun;
-        return AnimateRunner;
-      },
-    ];
-  }
-
-  class AnimateRunner {
-    static chain(chain, callback) {
-      let index = 0;
-
-      function next() {
-        if (index === chain.length) {
-          callback(true);
-          return;
-        }
-
-        chain[index]((response) => {
-          if (response === false) {
-            callback(false);
-            return;
-          }
-          index++;
-          next();
-        });
-      }
-
-      next();
-    }
-
-    static all(runners, callback) {
-      let count = 0;
-      let status = true;
-
-      runners.forEach((runner) => {
-        runner.done(onProgress);
-      });
-
-      function onProgress(response) {
-        status = status && response;
-        if (++count === runners.length) {
-          callback(status);
-        }
-      }
-    }
-
-    constructor(host) {
-      this.setHost(host);
-
-      const rafTick = $$animateAsyncRun();
-      const timeoutTick = (fn) => {
-        setTimeout(fn, 0, false);
-      };
-
-      this._doneCallbacks = [];
-      this._tick = (fn) => {
-        if (document.hidden) {
-          timeoutTick(fn);
-        } else {
-          rafTick(fn);
-        }
-      };
-      this._state = 0;
-    }
-
-    setHost(host) {
-      this.host = host || {};
-    }
-
-    done(fn) {
-      if (this._state === DONE_COMPLETE_STATE) {
-        fn();
-      } else {
-        this._doneCallbacks.push(fn);
-      }
-    }
-
-    progress() {}
-
-    getPromise() {
-      if (!this.promise) {
-        const self = this;
-        this.promise = new Promise((resolve, reject) => {
-          self.done((status) => {
-            if (status === false) {
-              reject();
-            } else {
-              resolve();
-            }
-          });
-        });
-      }
-      return this.promise;
-    }
-
-    then(resolveHandler, rejectHandler) {
-      return this.getPromise().then(resolveHandler, rejectHandler);
-    }
-
-    catch(handler) {
-      return this.getPromise().catch(handler);
-    }
-
-    finally(handler) {
-      return this.getPromise().finally(handler);
-    }
-
-    pause() {
-      if (this.host.pause) {
-        this.host.pause();
-      }
-    }
-
-    resume() {
-      if (this.host.resume) {
-        this.host.resume();
-      }
-    }
-
-    end() {
-      if (this.host.end) {
-        this.host.end();
-      }
-      this._resolve(true);
-    }
-
-    cancel() {
-      if (this.host.cancel) {
-        this.host.cancel();
-      }
-      this._resolve(false);
-    }
-
-    complete(response) {
-      if (this._state === INITIAL_STATE) {
-        this._state = DONE_PENDING_STATE;
-        this._tick(() => {
-          this._resolve(response);
-        });
-      }
-    }
-
-    _resolve(response) {
-      if (this._state !== DONE_COMPLETE_STATE) {
-        this._doneCallbacks.forEach((fn) => {
-          fn(response);
-        });
-        this._doneCallbacks.length = 0;
-        this._state = DONE_COMPLETE_STATE;
-      }
-    }
-  }
-
   /**
    * Provides an instance of a cache that can be used to store and retrieve template content.
    */
@@ -15267,7 +15108,7 @@
     /* @ignore */ static $inject = [$injectTokens.$provide];
 
     /**
-     * @param {import('../../interface.ts').Provider} $provide
+     * @param {ng.ProvideService} $provide
      */
     constructor($provide) {
       this.$provide = $provide;
@@ -17816,7 +17657,7 @@
               return concat.join("");
             };
 
-            return /**@type {import("./interface.js").InterpolationFunction}  */ extend(
+            return /**@type {import("./interface.ts").InterpolationFunction}  */ extend(
               (context, cb) => {
                 let i = 0;
                 const ii = expressions.length;
@@ -19484,7 +19325,7 @@
     /**
      * Registers a callback to be called when the URL changes.
      *
-     * @param {import("./interface.js").UrlChangeListener} callback - The callback function to register.
+     * @param {import("./interface.ts").UrlChangeListener} callback - The callback function to register.
      * @returns void
      */
     #onUrlChange(callback) {
@@ -19512,8 +19353,6 @@
        * @returns {Location}
        */
       ($rootScope, $rootElement) => {
-        /** @type {Location} */
-        let $location;
         const baseHref = getBaseHref(); // if base[href] is undefined, it defaults to ''
         const initialUrl = trimEmptyHash(window.location.href);
         let appBase;
@@ -19531,7 +19370,7 @@
         }
         const appBaseNoFile = stripFile(appBase);
 
-        $location = new Location(
+        const $location = new Location(
           appBase,
           appBaseNoFile,
           this.html5ModeConf.enabled,
@@ -20077,16 +19916,9 @@
    */
   let $parse;
 
-  /**@type {import('../../services/exception/exception-handler.js').ErrorHandler} */
+  /**@type {ng.ExceptionHandlerService} */
   let $exceptionHandler;
 
-  /**
-   * @typedef {Object} AsyncQueueTask
-   * @property {Scope} handler
-   * @property {Function} fn
-   * @property {Object} locals
-   */
-
   const $postUpdateQueue = [];
 
   class RootScopeProvider {
@@ -20095,11 +19927,11 @@
     }
 
     $get = [
-      "$exceptionHandler",
-      "$parse",
+      $injectTokens.$exceptionHandler,
+      $injectTokens.$parse,
       /**
-       * @param {import('../../services/exception/exception-handler.js').ErrorHandler} exceptionHandler
-       * @param {import('../parse/interface.ts').ParseService} parse
+       * @param {ng.ExceptionHandlerService} exceptionHandler
+       * @param {ng.ParseService} parse
        */
       (exceptionHandler, parse) => {
         $exceptionHandler = exceptionHandler;
@@ -20128,6 +19960,9 @@
     }
 
     if (typeof target === "object") {
+      if (isUnsafeGlobal(target)) {
+        return target;
+      }
       const proxy = new Proxy(target, context || new Scope());
       for (const key in target) {
         if (hasOwn(target, key)) {
@@ -20145,7 +19980,7 @@
               target[key] = createScope(target[key], proxy.$handler);
             }
           } catch {
-            // convert only what we can
+            /* empty */
           }
         }
       }
@@ -20157,25 +19992,43 @@
   }
 
   /**
-   * Listener function definition.
-   * @typedef {Object} Listener
-   * @property {Object} originalTarget - The original target object.
-   * @property {ListenerFunction} listenerFn - The function invoked when changes are detected.
-   * @property {import("../parse/interface.ts").CompiledExpression} watchFn
-   * @property {number} id - Deregistration id
-   * @property {number} scopeId - The scope that created the Listener
-   * @property {string[]} property
-   * @property {string} [watchProp] - The original property to watch if different from observed key
-   * @property {Proxy} [foreignListener]
-   *
+   * @param {any} target
+   * @returns {boolean}
    */
+  function isUnsafeGlobal(target) {
+    if (target == null) return false;
+    const t = typeof target;
+    if (t !== "object" && t !== "function") return false;
 
-  /**
-   * Listener function type.
-   * @callback ListenerFunction
-   * @param {*} newValue - The new value of the changed property.
-   * @param {Object} originalTarget - The original target object.
-   */
+    const g = globalThis;
+    if (
+      target === g ||
+      target === g.window ||
+      target === g.document ||
+      target === g.self ||
+      target === g.frames
+    ) {
+      return true;
+    }
+
+    // DOM / browser host object checks
+    if (
+      (typeof Window !== "undefined" && target instanceof Window) ||
+      (typeof Document !== "undefined" && target instanceof Document) ||
+      (typeof Element !== "undefined" && target instanceof Element) ||
+      (typeof Node !== "undefined" && target instanceof Node) ||
+      (typeof EventTarget !== "undefined" && target instanceof EventTarget)
+    ) {
+      return true;
+    }
+
+    // Cross-origin or non-enumerable window objects
+    try {
+      return Object.prototype.toString.call(target) === "[object Window]";
+    } catch {
+      return true;
+    }
+  }
 
   /**
    * Decorator for excluding objects from scope observability
@@ -20202,13 +20055,13 @@
           : context
         : undefined;
 
-      /** @type {Map<string, Array<Listener>>} Watch listeners */
+      /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners */
       this.watchers = context ? context.watchers : new Map();
 
       /** @type {Map<String, Function[]>} Event listeners */
       this.$$listeners = new Map();
 
-      /** @type {Map<string, Array<Listener>>} Watch listeners from other proxies */
+      /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
       this.foreignListeners = context ? context.foreignListeners : new Map();
 
       /** @type {Set<ProxyConstructor>} */
@@ -20253,7 +20106,7 @@
           ? null
           : context;
 
-      /** @type {AsyncQueueTask[]} */
+      /** @type {import('./interface.ts').AsyncQueueTask[]} */
       this.$$asyncQueue = [];
 
       this.filters = [];
@@ -20262,6 +20115,31 @@
       this.$$destroyed = false;
 
       this.scheduled = [];
+
+      /** @private */
+      this.propertyMap = {
+        $watch: this.$watch.bind(this),
+        $new: this.$new.bind(this),
+        $newIsolate: this.$newIsolate.bind(this),
+        $destroy: this.$destroy.bind(this),
+        $flushQueue: this.$flushQueue.bind(this),
+        $eval: this.$eval.bind(this),
+        $apply: this.$apply.bind(this),
+        $postUpdate: this.$postUpdate.bind(this),
+        $isRoot: this.#isRoot.bind(this),
+        $proxy: this.$proxy,
+        $on: this.$on.bind(this),
+        $emit: this.$emit.bind(this),
+        $broadcast: this.$broadcast.bind(this),
+        $transcluded: this.$transcluded.bind(this),
+        $handler: /** @type {Scope} */ (this),
+        $parent: this.$parent,
+        $root: this.$root,
+        $children: this.$children,
+        $id: this.$id,
+        $merge: this.$merge.bind(this),
+        $getById: this.$getById.bind(this),
+      };
     }
 
     /**
@@ -20457,8 +20335,8 @@
             // filter for repeaters
             if (this.$target.$$hashKey) {
               foreignListeners = foreignListeners.filter((x) =>
-                x.originalTarget.$$hashKey
-                  ? x.originalTarget.$$hashKey == this.$target.$$hashKey
+                x.originalTarget["$$hashKey"]
+                  ? x.originalTarget["$$hashKey"] === this.$target.$$hashKey
                   : false,
               );
             }
@@ -20503,29 +20381,8 @@
         this.$proxy = proxy;
       }
 
-      this.propertyMap = {
-        $watch: this.$watch.bind(this),
-        $new: this.$new.bind(this),
-        $newIsolate: this.$newIsolate.bind(this),
-        $destroy: this.$destroy.bind(this),
-        $eval: this.$eval.bind(this),
-        $apply: this.$apply.bind(this),
-        $postUpdate: this.$postUpdate.bind(this),
-        $isRoot: this.#isRoot.bind(this),
-        $target: target,
-        $proxy: this.$proxy,
-        $on: this.$on.bind(this),
-        $emit: this.$emit.bind(this),
-        $broadcast: this.$broadcast.bind(this),
-        $transcluded: this.$transcluded.bind(this),
-        $handler: /** @type {Scope} */ (this),
-        $parent: this.$parent,
-        $root: this.$root,
-        $children: this.$children,
-        $id: this.$id,
-        $merge: this.$merge.bind(this),
-        $getById: this.$getById.bind(this),
-      };
+      this.propertyMap.$target = target;
+      this.propertyMap.$proxy = proxy;
 
       if (
         Array.isArray(target) &&
@@ -20620,7 +20477,7 @@
     }
 
     /**
-     * @param {Listener[]} listeners
+     * @param {import('./interface.ts').Listener[]} listeners
      * @param {Function} filter
      */
     #scheduleListener(listeners, filter = (val) => val) {
@@ -20644,7 +20501,7 @@
      * function is invoked when changes to that property are detected.
      *
      * @param {string} watchProp - An expression to be watched in the context of this model.
-     * @param {ListenerFunction} [listenerFn] - A function to execute when changes are detected on watched context.
+     * @param {import('./interface.ts').ListenerFunction} [listenerFn] - A function to execute when changes are detected on watched context.
      * @param {boolean} [lazy] - A flag to indicate if the listener should be invoked immediately. Defaults to false.
      */
     $watch(watchProp, listenerFn, lazy = false) {
@@ -20666,7 +20523,7 @@
         return () => {};
       }
 
-      /** @type {Listener} */
+      /** @type {import('./interface.ts').Listener} */
       const listener = {
         originalTarget: this.$target,
         listenerFn: listenerFn,
@@ -20778,7 +20635,7 @@
 
             let potentialProxy = $parse(
               watchProp.split(".").slice(0, -1).join("."),
-            )(listener.originalTarget);
+            )(/** @type {Scope} */ (listener.originalTarget));
             if (potentialProxy && this.foreignProxies.has(potentialProxy)) {
               potentialProxy.$handler.#registerForeignKey(key, listener);
               potentialProxy.$handler.#scheduleListener([listener]);
@@ -20976,21 +20833,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);
@@ -21023,7 +20880,7 @@
     }
 
     /**
-     * @param {import('../../interface.js').Expression} expr
+     * @param {import('../../interface.ts').Expression} expr
      * @returns {any}
      */
     $apply(expr) {
@@ -21204,12 +21061,12 @@
 
     /**
      * @internal
-     * @param {Listener} listener - The property path that was changed.
+     * @param {import('./interface.ts').Listener} listener - The property path that was changed.
      */
     #notifyListener(listener, target) {
       const { originalTarget, listenerFn, watchFn } = listener;
       try {
-        let newVal = watchFn(originalTarget);
+        let newVal = watchFn(/** @type {Scope} */ (originalTarget));
         if (isUndefined(newVal)) {
           newVal = watchFn(target);
         }
@@ -21239,6 +21096,13 @@
       }
     }
 
+    /* @ignore */
+    $flushQueue() {
+      while ($postUpdateQueue.length) {
+        $postUpdateQueue.shift()();
+      }
+    }
+
     /**
      * Searches the scope instance
      *
@@ -21749,7 +21613,7 @@
 
   /**
    * @param {boolean} isDefault
-   * @returns {(any) => import("../../interface.js").Directive}
+   * @returns {(any) => import("../../interface.ts").Directive}
    */
   function ngMessageDirectiveFactory(isDefault) {
     ngMessageDirective.$inject = ["$animate"];
@@ -21956,6 +21820,9 @@
     return $aria.$$watchExpr("ngShow", "aria-hidden", [], true);
   }
 
+  /**
+   * @return {ng.Directive}
+   */
   function ngMessagesAriaDirective() {
     return {
       restrict: "A",
@@ -21971,18 +21838,21 @@
   }
 
   ngClickAriaDirective.$inject = [$injectTokens.$aria, $injectTokens.$parse];
+
+  /**
+   * @param $aria
+   * @param {ng.ParseService} $parse
+   * @return {ng.Directive}
+   */
   function ngClickAriaDirective($aria, $parse) {
     return {
       restrict: "A",
       compile(_elem, attr) {
         if (hasOwn(attr, ARIA_DISABLE_ATTR)) return;
 
-        const fn = $parse(attr.ngClick);
+        const fn = $parse(attr["ngClick"]);
 
-        /**
-         * @param {Element} elem
-         */
-        return function (scope, elem, attr) {
+        return (scope, elem, attr) => {
           if (!isNodeOneOf(elem, nativeAriaNodeNames)) {
             if ($aria.config("bindRoleForClick") && !elem.hasAttribute("role")) {
               elem.setAttribute("role", "button");
@@ -22019,10 +21889,6 @@
                       // See https://github.com/angular/angular.js/issues/16664
                       event.preventDefault();
                     }
-                    scope.$apply(callback);
-                  }
-
-                  function callback() {
                     fn(scope, { $event: event });
                   }
                 },
@@ -22237,6 +22103,231 @@
     };
   }
 
+  /**
+   * @fileoverview
+   * Frame-synchronized animation runner and scheduler.
+   * Provides async batching of animation callbacks using requestAnimationFrame.
+   * In AngularJS, this user to be implemented as `$$AnimateRunner`
+   */
+
+  /**
+   * Internal runner states.
+   * @readonly
+   * @enum {number}
+   */
+  const RunnerState = {
+    INITIAL: 0,
+    PENDING: 1,
+    DONE: 2,
+  };
+
+  /** @type {VoidFunction[]} */
+  let queue = [];
+
+  /** @type {boolean} */
+  let scheduled = false;
+
+  /**
+   * Flush all queued callbacks.
+   * @private
+   */
+  function flush() {
+    const tasks = queue;
+    queue = [];
+    scheduled = false;
+    for (let i = 0; i < tasks.length; i++) {
+      tasks[i]();
+    }
+  }
+
+  /**
+   * Schedule a callback to run on the next animation frame.
+   * Multiple calls within the same frame are batched together.
+   *
+   * @param {VoidFunction} fn - The callback to execute.
+   */
+  function schedule(fn) {
+    queue.push(fn);
+    if (!scheduled) {
+      scheduled = true;
+      (typeof requestAnimationFrame === "function"
+        ? requestAnimationFrame
+        : setTimeout)(flush, 0);
+    }
+  }
+
+  /**
+   * Represents an asynchronous animation operation.
+   * Provides both callback-based and promise-based completion APIs.
+   */
+  class AnimateRunner {
+    /**
+     * Run an array of animation runners in sequence.
+     * Each runner waits for the previous one to complete.
+     *
+     * @param {AnimateRunner[]} runners - Runners to execute in order.
+     * @param {(ok: boolean) => void} callback - Invoked when all complete or one fails.
+     */
+    static chain(runners, callback) {
+      let i = 0;
+      const next = (ok = true) => {
+        if (!ok || i >= runners.length) {
+          callback(ok);
+          return;
+        }
+        runners[i++].done(next);
+      };
+      next();
+    }
+
+    /**
+     * Waits for all animation runners to complete before invoking the callback.
+     *
+     * @param {AnimateRunner[]} runners - Active runners to wait for.
+     * @param {(ok: boolean) => void} callback - Called when all runners complete.
+     */
+    static all(runners, callback) {
+      let remaining = runners.length;
+      let status = true;
+      for (const r of runners) {
+        r.done((result) => {
+          status = status && result !== false;
+          if (--remaining === 0) callback(status);
+        });
+      }
+    }
+
+    /**
+     * @param {import("../interface.ts").AnimationHost} [host] - Optional animation host.
+     */
+    constructor(host) {
+      /** @type {import("../interface.ts").AnimationHost} */
+      this.host = host || {};
+
+      /** @type {Array<(ok: boolean) => void>} */
+      this._doneCallbacks = [];
+
+      /** @type {RunnerState} */
+      this._state = RunnerState.INITIAL;
+
+      /** @type {Promise<void>|null} */
+      this._promise = null;
+
+      /** @type {(fn: VoidFunction) => void} */
+      this._schedule = schedule;
+    }
+
+    /**
+     * Sets or updates the animation host.
+     * @param {import("../interface.ts").AnimationHost} host - The host object.
+     */
+    setHost(host) {
+      this.host = host || {};
+    }
+
+    /**
+     * Registers a callback to be called once the animation completes.
+     * If the animation is already complete, it's called immediately.
+     *
+     * @param {(ok: boolean) => void} fn - Completion callback.
+     */
+    done(fn) {
+      if (this._state === RunnerState.DONE) {
+        fn(true);
+      } else {
+        this._doneCallbacks.push(fn);
+      }
+    }
+
+    /**
+     * Notifies the host of animation progress.
+     * @param {...any} args - Progress arguments.
+     */
+    progress(...args) {
+      this.host.progress?.(...args);
+    }
+
+    /** Pauses the animation, if supported by the host. */
+    pause() {
+      this.host.pause?.();
+    }
+
+    /** Resumes the animation, if supported by the host. */
+    resume() {
+      this.host.resume?.();
+    }
+
+    /** Ends the animation successfully. */
+    end() {
+      this.host.end?.();
+      this._finish(true);
+    }
+
+    /** Cancels the animation. */
+    cancel() {
+      this.host.cancel?.();
+      this._finish(false);
+    }
+
+    /**
+     * Marks the animation as complete on the next animation frame.
+     * @param {boolean} [status=true] - True if successful, false if canceled.
+     */
+    complete(status = true) {
+      if (this._state === RunnerState.INITIAL) {
+        this._state = RunnerState.PENDING;
+        this._schedule(() => this._finish(status));
+      }
+    }
+
+    /**
+     * Returns a promise that resolves or rejects when the animation completes.
+     * @returns {Promise<void>} Promise resolved on success or rejected on cancel.
+     */
+    getPromise() {
+      if (!this._promise) {
+        this._promise = new Promise((resolve, reject) => {
+          this.done((success) => {
+            if (success === false) reject();
+            else resolve();
+          });
+        });
+      }
+      return this._promise;
+    }
+
+    /** @inheritdoc */
+    then(onFulfilled, onRejected) {
+      return this.getPromise().then(onFulfilled, onRejected);
+    }
+
+    /** @inheritdoc */
+    catch(onRejected) {
+      return this.getPromise().catch(onRejected);
+    }
+
+    /** @inheritdoc */
+    finally(onFinally) {
+      return this.getPromise().finally(onFinally);
+    }
+
+    /**
+     * Completes the animation and invokes all done callbacks.
+     * @private
+     * @param {boolean} status - True if completed successfully, false if canceled.
+     */
+    _finish(status) {
+      if (this._state === RunnerState.DONE) return;
+      this._state = RunnerState.DONE;
+
+      const callbacks = this._doneCallbacks;
+      for (let i = 0; i < callbacks.length; i++) {
+        callbacks[i](status);
+      }
+      callbacks.length = 0;
+    }
+  }
+
   const ANIMATE_TIMER_KEY = "$$animateCss";
 
   const ONE_SECOND = 1000;
@@ -22344,19 +22435,18 @@
   }
 
   function AnimateCssProvider() {
+    let activeClasses;
     this.$get = [
-      "$$AnimateRunner",
       "$$animateCache",
       "$$rAFScheduler",
 
       /**
        *
-       * @param {*} $$AnimateRunner
        * @param {*} $$animateCache
        * @param {import("./raf-scheduler").RafScheduler} $$rAFScheduler
        * @returns
        */
-      function ($$AnimateRunner, $$animateCache, $$rAFScheduler) {
+      function ($$animateCache, $$rAFScheduler) {
         const applyAnimationClasses = applyAnimationClassesFactory();
 
         function computeCachedCssStyles(
@@ -22687,10 +22777,7 @@
             return closeAndReturnNoopAnimator();
           }
 
-          let activeClasses = pendClasses(
-            preparationClasses,
-            ACTIVE_CLASS_SUFFIX,
-          );
+          activeClasses = pendClasses(preparationClasses, ACTIVE_CLASS_SUFFIX);
 
           if (options.delay != null) {
             if (typeof options.delay !== "boolean") {
@@ -22757,7 +22844,7 @@
                 pause: null,
               };
 
-              runner = new $$AnimateRunner(runnerHost);
+              runner = new AnimateRunner(runnerHost);
 
               waitUntilQuiet(start);
 
@@ -22827,7 +22914,9 @@
 
             if (events && events.length) {
               // Remove the transitionend / animationend listener(s)
-              element.off(events.join(" "), onAnimationProgress);
+              events.forEach((i) =>
+                element.removeEventListener(i, onAnimationProgress),
+              );
             }
 
             // Cancel the fallback closing timeout and remove the timer data
@@ -22854,7 +22943,7 @@
           }
 
           function closeAndReturnNoopAnimator() {
-            runner = new $$AnimateRunner({
+            runner = new AnimateRunner({
               end: endFn,
               cancel: cancelFn,
             });
@@ -23242,31 +23331,18 @@
       $injectTokens.$rootScope,
       $injectTokens.$injector,
       $injectTokens.$$animation,
-      $injectTokens.$$AnimateRunner,
       $injectTokens.$templateRequest,
       /**
        *
-       * @param {import('../core/scope/scope.js').Scope} $rootScope
-       * @param {import('../core/di/internal-injector.js').InjectorService} $injector
+       * @param {ng.RootScopeService} $rootScope
+       * @param {ng.InjectorService} $injector
        * @param {*} $$animation
-       * @param {*} $$AnimateRunner
        * @param {*} $templateRequest
        * @returns
        */
-      function (
-        $rootScope,
-        $injector,
-        $$animation,
-        $$AnimateRunner,
-        $templateRequest,
-      ) {
+      function ($rootScope, $injector, $$animation, $templateRequest) {
         const activeAnimationsLookup = new Map();
         const disabledElementsLookup = new Map();
-        let animationsEnabled = null;
-
-        function removeFromDisabledElementsLookup(evt) {
-          disabledElementsLookup.delete(evt.target);
-        }
 
         function postDigestTaskFactory() {
           let postDigestCalled = false;
@@ -23306,11 +23382,6 @@
               // any animations are triggered.
               $rootScope.$postUpdate(() => {
                 $rootScope.$postUpdate(() => {
-                  // we check for null directly in the event that the application already called
-                  // .enabled() with whatever arguments that it provided it with
-                  if (animationsEnabled === null) {
-                    animationsEnabled = true;
-                  }
                 });
               });
             }
@@ -23449,47 +23520,6 @@
             options.domOperation = domOperation;
             return queueAnimation(element, event, options);
           },
-
-          // this method has four signatures:
-          //  () - global getter
-          //  (bool) - global setter
-          //  (element) - element getter
-          //  (element, bool) - element setter<F37>
-          enabled(element, bool) {
-            const argCount = arguments.length;
-
-            if (argCount === 0) {
-              // () - Global getter
-              bool = !!animationsEnabled;
-            } else {
-              const hasElement = isElement(element);
-
-              if (!hasElement) {
-                // (bool) - Global setter
-                bool = animationsEnabled = !!element;
-              } else {
-                const node = element;
-
-                if (argCount === 1) {
-                  // (element) - Element getter
-                  bool = !disabledElementsLookup.get(node);
-                } else {
-                  // (element, bool) - Element setter
-                  if (!disabledElementsLookup.has(node)) {
-                    // The element is added to the map for the first time.
-                    // Create a listener to remove it on `$destroy` (to avoid memory leak).
-                    element.addEventListener(
-                      "$destroy",
-                      removeFromDisabledElementsLookup,
-                    );
-                  }
-                  disabledElementsLookup.set(node, !bool);
-                }
-              }
-            }
-
-            return bool;
-          },
         };
 
         return $animate;
@@ -23518,7 +23548,7 @@
 
           // we create a fake runner with a working promise.
           // These methods will become available after the digest has passed
-          const runner = new $$AnimateRunner();
+          const runner = new AnimateRunner();
 
           // this is used to trigger callbacks in postDigest mode
           const runInNextPostDigestOrNow = postDigestTaskFactory();
@@ -23546,6 +23576,7 @@
           if (options.to && !isObject(options.to)) {
             options.to = null;
           }
+
           // If animations are hard-disabled for the whole application there is no need to continue.
           // There are also situations where a directive issues an animation for a JQLite wrapper that
           // contains only comment nodes. In this case, there is no way we can perform an animation.
@@ -23558,7 +23589,6 @@
             close();
             return runner;
           }
-
           const isStructural = ["enter", "move", "leave"].indexOf(event) >= 0;
 
           // This is a hard disable of all animations the element itself, therefore  there is no need to
@@ -23794,6 +23824,8 @@
             });
           });
 
+          // Since we don't have digest any more - trigger queue here
+          setTimeout($rootScope.$flushQueue, 0);
           return runner;
 
           function notifyProgress(runner, event, phase, data) {
@@ -23957,18 +23989,16 @@
   // TODO: use caching here to speed things up for detection
   // TODO: add documentation
 
-  AnimateJsProvider.$inject = ["$animateProvider"];
+  AnimateJsProvider.$inject = [$injectTokens.$animate + "Provider"];
   function AnimateJsProvider($animateProvider) {
     this.$get = [
       $injectTokens.$injector,
-      "$$AnimateRunner",
       /**
        *
-       * @param {import("../core/di/internal-injector").InjectorService} $injector
-       * @param {*} $$AnimateRunner
+       * @param {ng.InjectorService} $injector
        * @returns
        */
-      function ($injector, $$AnimateRunner) {
+      function ($injector) {
         const applyAnimationClasses = applyAnimationClassesFactory();
         // $animateJs(element, 'enter');
         return function (element, event, classes, options) {
@@ -24055,7 +24085,7 @@
                 runner.end();
               } else {
                 close();
-                runner = new $$AnimateRunner();
+                runner = new AnimateRunner();
                 runner.complete(true);
               }
               return runner;
@@ -24065,31 +24095,53 @@
                 return runner;
               }
 
-              runner = new $$AnimateRunner();
-              let closeActiveAnimations;
+              runner = new AnimateRunner();
+
               const chain = [];
 
               if (before) {
-                chain.push((fn) => {
-                  closeActiveAnimations = before(fn);
+                const runnerBefore = new AnimateRunner({
+                  end(fn) {
+                    // call the before animation function, then mark runner done
+                    const endFn = before(fn) || (() => {});
+                    endFn();
+                  },
+                  cancel() {
+                    (before(true) || (() => {}))();
+                  },
                 });
+                chain.push(runnerBefore);
               }
 
               if (chain.length) {
-                chain.push((fn) => {
-                  applyOptions();
-                  fn(true);
+                const runnerApplyOptions = new AnimateRunner({
+                  end(fn) {
+                    applyOptions();
+                    fn(true);
+                  },
+                  cancel() {
+                    applyOptions();
+                  },
                 });
+                chain.push(runnerApplyOptions);
               } else {
                 applyOptions();
               }
 
               if (after) {
-                chain.push((fn) => {
-                  closeActiveAnimations = after(fn);
+                const runnerAfter = new AnimateRunner({
+                  end(fn) {
+                    const endFn = after(fn) || (() => {});
+                    endFn();
+                  },
+                  cancel() {
+                    (after(true) || (() => {}))();
+                  },
                 });
+                chain.push(runnerAfter);
               }
 
+              // finally, set host for overall runner
               runner.setHost({
                 end() {
                   endAnimations();
@@ -24099,7 +24151,7 @@
                 },
               });
 
-              $$AnimateRunner.chain(chain, onComplete);
+              AnimateRunner.chain(chain, onComplete);
               return runner;
 
               function onComplete(success) {
@@ -24109,7 +24161,6 @@
 
               function endAnimations(cancelled) {
                 if (!animationClosed) {
-                  (closeActiveAnimations || (() => {}))(cancelled);
                   onComplete(cancelled);
                 }
               }
@@ -24148,7 +24199,7 @@
                 value = value.start();
               }
 
-              if (value instanceof $$AnimateRunner) {
+              if (value instanceof AnimateRunner) {
                 value.done(onDone);
               } else if (isFunction(value)) {
                 // optional onEnd / onCancel callback
@@ -24185,7 +24236,7 @@
                   }
                 };
 
-                runner = new $$AnimateRunner({
+                runner = new AnimateRunner({
                   end() {
                     onAnimationComplete();
                   },
@@ -24281,7 +24332,7 @@
               }
 
               if (runners.length) {
-                $$AnimateRunner.all(runners, callback);
+                AnimateRunner.all(runners, callback);
               } else {
                 callback();
               }
@@ -24341,25 +24392,17 @@
     this.$get = [
       $injectTokens.$rootScope,
       $injectTokens.$injector,
-      $injectTokens.$$AnimateRunner,
       $injectTokens.$$rAFScheduler,
       $injectTokens.$$animateCache,
       /**
        *
        * @param {ng.RootScopeService} $rootScope
        * @param {import("../core/di/internal-injector").InjectorService} $injector
-       * @param {*} $$AnimateRunner
        * @param {import("./raf-scheduler").RafScheduler} $$rAFScheduler
        * @param {*} $$animateCache
        * @returns
        */
-      function (
-        $rootScope,
-        $injector,
-        $$AnimateRunner,
-        $$rAFScheduler,
-        $$animateCache,
-      ) {
+      function ($rootScope, $injector, $$rAFScheduler, $$animateCache) {
         const animationQueue = [];
         const applyAnimationClasses = applyAnimationClassesFactory();
 
@@ -24460,7 +24503,7 @@
           // these runner methods will get later updated with the
           // methods leading into the driver's end/cancel methods
           // for now they just stop the animation from starting
-          const runner = new $$AnimateRunner({
+          const runner = new AnimateRunner({
             end() {
               close();
             },
@@ -24823,8 +24866,8 @@
   }
 
   /**
-   * @typedef {import('./interface.js').RafScheduler} RafScheduler
-   * @typedef {import('../interface.js').ServiceProvider} ServiceProvider
+   * @typedef {import('./interface.ts').RafScheduler} RafScheduler
+   * @typedef {import('../interface.ts').ServiceProvider} ServiceProvider
    */
 
   /**
@@ -25015,16 +25058,14 @@
      */
     this.$get = [
       "$animateCss",
-      "$$AnimateRunner",
       "$rootElement",
       /**
        *
        * @param {*} $animateCss
-       * @param {typeof import('./animate-runner.js').AnimateRunner} $$AnimateRunner
        * @param {Element} $rootElement
        * @returns
        */
-      function ($animateCss, $$AnimateRunner, $rootElement) {
+      function ($animateCss, $rootElement) {
         const bodyNode = document.body;
         const rootNode = $rootElement;
 
@@ -25097,7 +25138,7 @@
                 runner.complete();
               });
 
-              runner = new $$AnimateRunner({
+              runner = new AnimateRunner({
                 end: endFn,
                 cancel: endFn,
               });
@@ -25208,12 +25249,12 @@
                 animationRunners.push(animation.start());
               });
 
-              const runner = new $$AnimateRunner({
+              const runner = new AnimateRunner({
                 end: endFn,
                 cancel: endFn, // CSS-driven animations cannot be cancelled, only ended
               });
 
-              $$AnimateRunner.all(animationRunners, (status) => {
+              AnimateRunner.all(animationRunners, (status) => {
                 runner.complete(status);
               });
 
@@ -25283,8 +25324,11 @@
     $$animationProvider.drivers.push("$$animateJsDriver");
     this.$get = [
       "$$animateJs",
-      "$$AnimateRunner",
-      function ($$animateJs, $$AnimateRunner) {
+      /**
+       *
+       * @param {*} $$animateJs
+       */
+      function ($$animateJs) {
         return function initDriverFn(animationDetails) {
           if (animationDetails.from && animationDetails.to) {
             const fromAnimation = prepareAnimation(animationDetails.from);
@@ -25303,9 +25347,9 @@
                   animationRunners.push(toAnimation.start());
                 }
 
-                $$AnimateRunner.all(animationRunners, done);
+                AnimateRunner.all(animationRunners, done);
 
-                const runner = new $$AnimateRunner({
+                const runner = new AnimateRunner({
                   end: endFnFactory(),
                   cancel: endFnFactory(),
                 });
@@ -25339,9 +25383,9 @@
     ];
   }
 
-  ngAnimateSwapDirective.$inject = ["$animate"];
+  ngAnimateSwapDirective.$inject = [$injectTokens.$animate];
   /**
-   * @returns {import('../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngAnimateSwapDirective($animate) {
     return {
@@ -25350,10 +25394,10 @@
       terminal: true,
       priority: 550, // We use 550 here to ensure that the directive is caught before others,
       // but after `ngIf` (at priority 600).
-      link(scope, $element, attrs, ctrl, $transclude) {
+      link(scope, $element, attrs, _ctrl, $transclude) {
         let previousElement;
         let previousScope;
-        scope.$watch(attrs["ngAnimateSwap"] || attrs["for"], (value) => {
+        scope.$watch(attrs.ngAnimateSwap || attrs.for, (value) => {
           if (previousElement) {
             $animate.leave(previousElement);
           }
@@ -27580,7 +27624,7 @@
      * @param {PathNode[]} fromPath
      * @param {PathNode[]} toPath
      * @param {boolean} [reloadState]
-     * @returns {import("../transition/interface.js").TreeChanges}
+     * @returns {import("../transition/interface.ts").TreeChanges}
      */
     static treeChanges(fromPath, toPath, reloadState) {
       const max = Math.min(fromPath.length, toPath.length);
@@ -28315,25 +28359,6 @@
     return vc.$ngViewContextAnchor === (ngViewContext && ngViewContext.name);
   };
 
-  /**
-   * An object for Transition Hook Phases
-   * @enum {number}
-   * @readonly
-   */
-  const TransitionHookPhase = {
-    CREATE: 0,
-    BEFORE: 1,
-    RUN: 2,
-    SUCCESS: 3,
-    ERROR: 4,
-  };
-
-  /** An object for Transition Hook Scopes */
-  const TransitionHookScope = {
-    TRANSITION: 0,
-    STATE: 1,
-  };
-
   /**
    * An object for Transition Rejection reasons.
    * @enum {number}
@@ -28453,7 +28478,7 @@
     }
   }
 
-  /** @typedef {import('../../interface.js').ServiceProvider} ServiceProvider
+  /** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider
 
   /**
    * Configurable provider for an injectable event bus
@@ -28810,6 +28835,31 @@
     bind: null,
   };
 
+  /**
+   * Enum representing the different phases of a transition hook.
+   *
+   * @readonly
+   * @enum {number}
+   */
+  const TransitionHookPhase = Object.freeze({
+    CREATE: 0,
+    BEFORE: 1,
+    RUN: 2,
+    SUCCESS: 3,
+    ERROR: 4,
+  });
+
+  /**
+   * Enum representing the scope in which a transition hook operates.
+   *
+   * @readonly
+   * @enum {number}
+   */
+  const TransitionHookScope = Object.freeze({
+    TRANSITION: 0,
+    STATE: 1,
+  });
+
   class TransitionHook {
     /**
      * Chains together an array of TransitionHooks.
@@ -30628,7 +30678,6 @@
     }
 
     _defineCoreEvents() {
-      const Phase = TransitionHookPhase;
       const TH = TransitionHook;
       const paths = this._criteriaPaths;
       const NORMAL_SORT = false,
@@ -30636,7 +30685,7 @@
       const SYNCHRONOUS = true;
       this._defineEvent(
         "onCreate",
-        Phase.CREATE,
+        TransitionHookPhase.CREATE,
         0,
         paths.to,
         NORMAL_SORT,
@@ -30644,15 +30693,21 @@
         TH.THROW_ERROR,
         SYNCHRONOUS,
       );
-      this._defineEvent("onBefore", Phase.BEFORE, 0, paths.to);
-      this._defineEvent("onStart", Phase.RUN, 0, paths.to);
-      this._defineEvent("onExit", Phase.RUN, 100, paths.exiting, REVERSE_SORT);
-      this._defineEvent("onRetain", Phase.RUN, 200, paths.retained);
-      this._defineEvent("onEnter", Phase.RUN, 300, paths.entering);
-      this._defineEvent("onFinish", Phase.RUN, 400, paths.to);
+      this._defineEvent("onBefore", TransitionHookPhase.BEFORE, 0, paths.to);
+      this._defineEvent("onStart", TransitionHookPhase.RUN, 0, paths.to);
+      this._defineEvent(
+        "onExit",
+        TransitionHookPhase.RUN,
+        100,
+        paths.exiting,
+        REVERSE_SORT,
+      );
+      this._defineEvent("onRetain", TransitionHookPhase.RUN, 200, paths.retained);
+      this._defineEvent("onEnter", TransitionHookPhase.RUN, 300, paths.entering);
+      this._defineEvent("onFinish", TransitionHookPhase.RUN, 400, paths.to);
       this._defineEvent(
         "onSuccess",
-        Phase.SUCCESS,
+        TransitionHookPhase.SUCCESS,
         0,
         paths.to,
         NORMAL_SORT,
@@ -30662,7 +30717,7 @@
       );
       this._defineEvent(
         "onError",
-        Phase.ERROR,
+        TransitionHookPhase.ERROR,
         0,
         paths.to,
         NORMAL_SORT,
@@ -30928,7 +30983,7 @@
 
     /**
      *
-     * @param {import("./interface.js").StateDeclaration} definition
+     * @param {import("./interface.ts").StateDeclaration} definition
      */
     state(definition) {
       if (!definition.name) {
@@ -32228,7 +32283,7 @@
     );
   }
 
-  /** @typedef {import('./interface.js').StateDeclaration} StateDeclaration */
+  /** @typedef {import('./interface.ts').StateDeclaration} StateDeclaration */
 
   /**
    * Internal representation of a ng-router state.
@@ -32251,7 +32306,7 @@
     includes = undefined;
 
     /**
-     * @param {import('./interface.js').StateDeclaration} config
+     * @param {import('./interface.ts').StateDeclaration} config
      */
     constructor(config) {
       Object.assign(this, config);
@@ -32259,7 +32314,7 @@
         return this;
       };
       /**
-       * @type {import('./interface.js').StateDeclaration}
+       * @type {import('./interface.ts').StateDeclaration}
        */
       this.self = config;
       /**
@@ -34648,7 +34703,7 @@
    * ```
    */
 
-  /** @type {import("../../interface.js").AnnotatedDirectiveFactory} */
+  /** @type {import("../../interface.ts").AnnotatedDirectiveFactory} */
   let ngView = [
     "$view",
     "$animate",
@@ -34659,7 +34714,7 @@
      * @param {*} $animate
      * @param {*} $viewScroll
      * @param {*} $interpolate
-     * @returns {import("../../interface.js").Directive}
+     * @returns {import("../../interface.ts").Directive}
      */
     function $ViewDirective($view, $animate, $viewScroll, $interpolate) {
       function getRenderer() {
@@ -35085,7 +35140,8 @@
   }
 
   /**
-   * @param {"get" | "delete" | "post" | "put"} method
+   * @param {"get" | "delete" | "post" | "put"} method - HTTP method applied to request
+   * @param {string} [attrOverride] - Custom name to use for the attribute
    * @returns {ng.DirectiveFactory}
    */
   function defineDirective(method, attrOverride) {
@@ -35099,6 +35155,7 @@
       $injectTokens.$parse,
       $injectTokens.$state,
       $injectTokens.$sse,
+      $injectTokens.$animate,
     ];
     return directive;
   }
@@ -35118,15 +35175,11 @@
   /** @type {ng.DirectiveFactory} */
   const ngSseDirective = defineDirective("get", "ngSse");
 
-  /**
-   * @typedef {"click" | "change" | "submit"} EventType
-   */
-
   /**
    * Selects DOM event to listen for based on the element type.
    *
    * @param {Element} element - The DOM element to inspect.
-   * @returns {EventType} The name of the event to listen for.
+   * @returns {"click" | "change" | "submit"} The name of the event to listen for.
    */
   function getEventNameForElement(element) {
     const tag = element.tagName.toLowerCase();
@@ -35138,89 +35191,6 @@
     return "click";
   }
 
-  /**
-   * Handles DOM manipulation based on a swap strategy and server-rendered HTML.
-   *
-   * @param {string} html - The HTML string returned from the server.
-   * @param {import("./interface.ts").SwapModeType} swap
-   * @param {Element} target - The target DOM element to apply the swap to.
-   * @param {ng.Scope} scope
-   * @param {ng.CompileService} $compile
-   */
-  function handleSwapResponse(html, swap, target, scope, $compile) {
-    let nodes = [];
-    if (!["textcontent", "delete", "none"].includes(swap)) {
-      if (!html) {
-        return;
-      }
-
-      if (isObject(html)) {
-        scope.$merge(html);
-        return;
-      }
-
-      const compiled = $compile(html)(scope);
-      nodes =
-        compiled instanceof DocumentFragment
-          ? Array.from(compiled.childNodes)
-          : [compiled];
-    }
-
-    switch (swap) {
-      case "innerHTML":
-        target.replaceChildren(...nodes);
-        break;
-
-      case "outerHTML": {
-        const parent = target.parentNode;
-        if (!parent) return;
-        const frag = document.createDocumentFragment();
-        nodes.forEach((n) => frag.appendChild(n));
-        parent.replaceChild(frag, target);
-        break;
-      }
-
-      case "textContent":
-        target.textContent = html;
-        break;
-
-      case "beforebegin":
-        nodes.forEach((node) => target.parentNode.insertBefore(node, target));
-        break;
-
-      case "afterbegin":
-        nodes
-          .slice()
-          .reverse()
-          .forEach((node) => target.insertBefore(node, target.firstChild));
-        break;
-
-      case "beforeend":
-        nodes.forEach((node) => target.appendChild(node));
-        break;
-
-      case "afterend":
-        nodes
-          .slice()
-          .reverse()
-          .forEach((node) =>
-            target.parentNode.insertBefore(node, target.nextSibling),
-          );
-        break;
-
-      case "delete":
-        target.remove();
-        break;
-
-      case "none":
-        break;
-
-      default:
-        target.replaceChildren(...nodes);
-        break;
-    }
-  }
-
   /**
    * Creates an HTTP directive factory that supports GET, DELETE, POST, PUT.
    *
@@ -35229,6 +35199,8 @@
    * @returns {ng.DirectiveFactory}
    */
   function createHttpDirective(method, attrName) {
+    let content = undefined;
+
     /**
      * @param {ng.HttpService} $http
      * @param {ng.CompileService} $compile
@@ -35238,7 +35210,125 @@
      * @param {ng.SseService} $sse
      * @returns {ng.Directive}
      */
-    return function ($http, $compile, $log, $parse, $state, $sse) {
+    return function ($http, $compile, $log, $parse, $state, $sse, $animate) {
+      /**
+       * Handles DOM manipulation based on a swap strategy and server-rendered HTML.
+       *
+       * @param {string | Object} html - The HTML string or object returned from the server.
+       * @param {import("./interface.ts").SwapModeType} swap
+       * @param {ng.Scope} scope
+       * @param {ng.Attributes} attrs
+       * @param {Element} element
+       */
+      function handleSwapResponse(html, swap, scope, attrs, element) {
+        let animationEnabled = false;
+        if (attrs.animate) {
+          animationEnabled = true;
+        }
+        let nodes = [];
+        if (!["textcontent", "delete", "none"].includes(swap)) {
+          if (!html) return;
+          const compiled = $compile(html)(scope);
+          nodes =
+            compiled instanceof DocumentFragment
+              ? Array.from(compiled.childNodes)
+              : [compiled];
+        }
+
+        const targetSelector = attrs["target"];
+        const target = targetSelector
+          ? document.querySelector(targetSelector)
+          : element;
+
+        if (!target) {
+          $log.warn(`${attrName}: target "${targetSelector}" not found`);
+          return;
+        }
+
+        switch (swap) {
+          case "innerHTML":
+            if (animationEnabled) {
+              if (content) {
+                $animate.leave(content).done(() => {
+                  content = nodes[0];
+                  $animate.enter(nodes[0], target);
+                  scope.$flushQueue();
+                });
+                scope.$flushQueue();
+              } else {
+                content = nodes[0];
+                $animate.enter(nodes[0], target);
+                scope.$flushQueue();
+              }
+            } else {
+              target.replaceChildren(...nodes);
+            }
+            break;
+
+          case "outerHTML": {
+            const parent = target.parentNode;
+            if (!parent) return;
+            const frag = document.createDocumentFragment();
+            nodes.forEach((n) => frag.appendChild(n));
+            if (animationEnabled) {
+              const placeholder = document.createComment("placeholder");
+              target.parentNode.insertBefore(placeholder, target.nextSibling);
+              $animate.leave(target).done(() => {
+                const insertedNodes = Array.from(frag.childNodes);
+                insertedNodes.forEach((n) =>
+                  $animate.enter(n, parent, placeholder),
+                );
+                content = insertedNodes;
+                scope.$flushQueue();
+              });
+              scope.$flushQueue();
+            } else {
+              parent.replaceChild(frag, target);
+            }
+            break;
+          }
+
+          case "textContent":
+            target.textContent = html;
+            break;
+
+          case "beforebegin":
+            nodes.forEach((node) => target.parentNode.insertBefore(node, target));
+            break;
+
+          case "afterbegin":
+            nodes
+              .slice()
+              .reverse()
+              .forEach((node) => target.insertBefore(node, target.firstChild));
+            break;
+
+          case "beforeend":
+            nodes.forEach((node) => target.appendChild(node));
+            break;
+
+          case "afterend":
+            nodes
+              .slice()
+              .reverse()
+              .forEach((node) =>
+                target.parentNode.insertBefore(node, target.nextSibling),
+              );
+            break;
+
+          case "delete":
+            target.remove();
+            break;
+
+          case "none":
+            break;
+
+          default:
+            target.replaceChildren(...nodes);
+            break;
+        }
+      }
+
       /**
        * Collects form data from the element or its associated form.
        *
@@ -35252,15 +35342,12 @@
         const tag = element.tagName.toLowerCase();
 
         if (tag === "form") {
-          /** @type {HTMLFormElement} */
           form = /** @type {HTMLFormElement} */ (element);
         } else if ("form" in element && element.form) {
-          /** @type {HTMLFormElement} */
           form = /** @type {HTMLFormElement} */ (element.form);
         } else if (element.hasAttribute("form")) {
           const formId = element.getAttribute("form");
           if (formId) {
-            /** @type {HTMLElement | null} */
             const maybeForm = document.getElementById(formId);
             if (maybeForm && maybeForm.tagName.toLowerCase() === "form") {
               form = /** @type {HTMLFormElement} */ (maybeForm);
@@ -35298,13 +35385,10 @@
       return {
         restrict: "A",
         link(scope, element, attrs) {
-          const eventName =
-            attrs["trigger"] ||
-            /** @type {EventType} */ getEventNameForElement(element);
-
+          const eventName = attrs.trigger || getEventNameForElement(element);
           const tag = element.tagName.toLowerCase();
 
-          if (isDefined(attrs["latch"])) {
+          if (isDefined(attrs.latch)) {
             attrs.$observe(
               "latch",
               callBackAfterFirst(() =>
@@ -35320,24 +35404,14 @@
             element.dispatchEvent(new Event(eventName));
             intervalId = setInterval(
               () => element.dispatchEvent(new Event(eventName)),
-              parseInt(attrs["interval"]) || 1000,
+              parseInt(attrs.interval) || 1000,
             );
           }
 
           element.addEventListener(eventName, async (event) => {
             if (/** @type {HTMLButtonElement} */ (element).disabled) return;
             if (tag === "form") event.preventDefault();
-            const swap = attrs["swap"] || "innerHTML";
-            const targetSelector = attrs["target"];
-            const target = targetSelector
-              ? document.querySelector(targetSelector)
-              : element;
-
-            if (!target) {
-              $log.warn(`${attrName}: target "${targetSelector}" not found`);
-              return;
-            }
-
+            const swap = attrs.swap || "innerHTML";
             const url = attrs[attrName];
             if (!url) {
               $log.warn(`${attrName}: no URL specified`);
@@ -35345,56 +35419,57 @@
             }
 
             const handler = (res) => {
-              if (isDefined(attrs["loading"])) {
+              if (isDefined(attrs.loading)) {
                 attrs.$set("loading", false);
               }
 
-              if (isDefined(attrs["loadingClass"])) {
-                attrs.$removeClass(attrs["loadingClass"]);
+              if (isDefined(attrs.loadingClass)) {
+                attrs.$removeClass(attrs.loadingClass);
               }
 
               const html = res.data;
               if (200 <= res.status && res.status <= 299) {
-                if (isDefined(attrs["success"])) {
-                  $parse(attrs["success"])(scope, { $res: html });
+                if (isDefined(attrs.success)) {
+                  $parse(attrs.success)(scope, { $res: html });
                 }
 
-                if (isDefined(attrs["stateSuccess"])) {
-                  $state.go(attrs["stateSuccess"]);
+                if (isDefined(attrs.stateSuccess)) {
+                  $state.go(attrs.stateSuccess);
                 }
               } else if (400 <= res.status && res.status <= 599) {
-                if (isDefined(attrs["error"])) {
-                  $parse(attrs["error"])(scope, { $res: html });
+                if (isDefined(attrs.error)) {
+                  $parse(attrs.error)(scope, { $res: html });
                 }
 
-                if (isDefined(attrs["stateError"])) {
-                  $state.go(attrs["stateError"]);
+                if (isDefined(attrs.stateError)) {
+                  $state.go(attrs.stateError);
                 }
               }
 
-              handleSwapResponse(
-                html,
-                /** @type {import("./interface.ts").SwapModeType} */ (swap),
-                target,
-                scope,
-                $compile,
-              );
+              if (isObject(html)) {
+                if (attrs.target) {
+                  scope.$eval(`${attrs.target} = ${JSON.stringify(html)}`);
+                } else {
+                  scope.$merge(html);
+                }
+              } else if (isString(html)) {
+                handleSwapResponse(html, swap, scope, attrs, element);
+              }
             };
-            if (isDefined(attrs["delay"])) {
-              await wait(parseInt(attrs["delay"]) | 0);
-            }
 
-            if (throttled) {
-              return;
+            if (isDefined(attrs.delay)) {
+              await wait(parseInt(attrs.delay) | 0);
             }
 
-            if (isDefined(attrs["throttle"])) {
+            if (throttled) return;
+
+            if (isDefined(attrs.throttle)) {
               throttled = true;
               attrs.$set("throttled", true);
               setTimeout(() => {
                 attrs.$set("throttled", false);
                 throttled = false;
-              }, parseInt(attrs["throttle"]));
+              }, parseInt(attrs.throttle));
             }
 
             if (isDefined(attrs["loading"])) {
@@ -35402,13 +35477,13 @@
             }
 
             if (isDefined(attrs["loadingClass"])) {
-              attrs.$addClass(attrs["loadingClass"]);
+              attrs.$addClass(attrs.loadingClass);
             }
 
             if (method === "post" || method === "put") {
               let data;
               const config = {};
-              if (attrs["enctype"]) {
+              if (attrs.enctype) {
                 config.headers = {
                   "Content-Type": attrs["enctype"],
                 };
@@ -35418,11 +35493,10 @@
               }
               $http[method](url, data, config).then(handler).catch(handler);
             } else {
-              // If SSE mode is enabled
-              if (method === "get" && attrs["ngSse"]) {
+              if (method === "get" && attrs.ngSse) {
                 const sseUrl = url;
                 const config = {
-                  withCredentials: attrs["withCredentials"] === "true",
+                  withCredentials: attrs.withCredentials === "true",
                   transformMessage: (data) => {
                     try {
                       return JSON.parse(data);
@@ -35432,9 +35506,9 @@
                   },
                   onOpen: () => {
                     $log.info(`${attrName}: SSE connection opened to ${sseUrl}`);
-                    if (isDefined(attrs["loading"])) attrs.$set("loading", false);
-                    if (isDefined(attrs["loadingClass"]))
-                      attrs.$removeClass(attrs["loadingClass"]);
+                    if (isDefined(attrs.loading)) attrs.$set("loading", false);
+                    if (isDefined(attrs.loadingClass))
+                      attrs.$removeClass(attrs.loadingClass);
                   },
                   onMessage: (data) => {
                     const res = { status: 200, data };
@@ -35445,12 +35519,15 @@
                     const res = { status: 500, data: err };
                     handler(res);
                   },
+                  onReconnect: (count) => {
+                    $log.info(`ngSse: reconnected ${count} time(s)`);
+                    if (attrs.onReconnect)
+                      $parse(attrs.onReconnect)(scope, { $count: count });
+                  },
                 };
 
-                // Open the SSE connection using the injected service
                 const source = $sse(sseUrl, config);
 
-                // Cleanup on scope destroy
                 scope.$on("$destroy", () => {
                   $log.info(`${attrName}: closing SSE connection`);
                   source.close();
@@ -35465,7 +35542,6 @@
             scope.$on("$destroy", () => clearInterval(intervalId));
           }
 
-          // Eagerly execute for 'load' event
           if (eventName == "load") {
             element.dispatchEvent(new Event("load"));
           }
@@ -35479,31 +35555,26 @@
   /**
    * @param {ng.LogService} $log
    * @param {ng.InjectorService} $injector
-   * @returns {import('interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngInjectDirective($log, $injector) {
     return {
       restrict: "A",
       link(scope, _element, attrs) {
-        const expr = attrs["ngInject"];
-
+        const expr = attrs.ngInject;
         if (!expr) return;
-        // Match any identifier that starts with $, or ends with Service/Factory
-        // Example matches: $http, userService, authFactory
-        const replacedExpr = expr.replace(
-          /(\$[\w]+|[\w]+(?:Service|Factory))/g,
-          (match, name) => {
-            try {
-              const service = $injector.get(name);
-              scope.$target[name] = service;
-              return name;
-            } catch {
-              $log.warn(`Injectable ${name} not found in $injector`);
-              return match;
-            }
-          },
-        );
-        scope.$apply(replacedExpr);
+        const tokens = expr
+          .split(";")
+          .map((s) => s.trim())
+          .filter(Boolean);
+
+        for (const name of tokens) {
+          if ($injector.has(name)) {
+            scope[name] = $injector.get(name);
+          } else {
+            $log.warn(`Injectable ${name} not found in $injector`);
+          }
+        }
       },
     };
   }
@@ -35546,38 +35617,54 @@
    *   const source = $sse('/events', {
    *     onMessage: (data) => console.log(data),
    *     onError: (err) => console.error(err),
-   *     withCredentials: true
+   *     retryDelay: 2000,
+   *     heartbeatTimeout: 10000,
    *   });
    *
-   *   // later:
    *   source.close();
    */
-
   class SseProvider {
     constructor() {
       /**
        * Optional provider-level defaults
        * @type {ng.SseConfig}
        */
-      this.defaults = {};
+      this.defaults = {
+        retryDelay: 1000,
+        maxRetries: Infinity,
+        heartbeatTimeout: 15000, // 15 seconds
+        transformMessage(data) {
+          try {
+            return JSON.parse(data);
+          } catch {
+            return data;
+          }
+        },
+      };
     }
 
     /**
      * Returns the $sse service function
      * @returns {ng.SseService}
      */
-    $get =
-      () =>
-      (url, config = {}) => {
-        const finalUrl = this.#buildUrl(url, config.params);
-        return this.#createEventSource(finalUrl, config);
-      };
+    $get = [
+      $injectTokens.$log,
+      /** @param {ng.LogService} log */
+      (log) => {
+        this.$log = log;
+        return (url, config = {}) => {
+          const mergedConfig = { ...this.defaults, ...config };
+          const finalUrl = this.#buildUrl(url, mergedConfig.params);
+          return this.#createConnection(finalUrl, mergedConfig);
+        };
+      },
+    ];
 
     /**
      * Build URL with query parameters
-     * @param {string} url - Base URL
-     * @param {Record<string, any>=} params - Query parameters
-     * @returns {string} URL with serialized query string
+     * @param {string} url
+     * @param {Record<string, any>=} params
+     * @returns {string}
      */
     #buildUrl(url, params) {
       if (!params) return url;
@@ -35588,37 +35675,81 @@
     }
 
     /**
-     * Create and manage an EventSource
-     * @param {string} url - URL for SSE connection
-     * @param {ng.SseConfig} config - Configuration object
-     * @returns {EventSource} The EventSource instance wrapped as SseService
+     * Creates a managed SSE connection with reconnect and heartbeat
+     * @param {string} url
+     * @param {ng.SseConfig} config
+     * @returns {import("./interface.ts").SseConnection}
      */
-    #createEventSource(url, config) {
-      const es = new EventSource(url, {
-        withCredentials: !!config.withCredentials,
-      });
+    #createConnection(url, config) {
+      let es;
+      let retryCount = 0;
+      let closed = false;
+      let heartbeatTimer;
 
-      if (config.onOpen) {
-        es.addEventListener("open", (e) => config.onOpen(e));
-      }
+      const connect = () => {
+        if (closed) return;
 
-      es.addEventListener("message", (e) => {
-        let data = e.data;
-        try {
-          data = config.transformMessage
-            ? config.transformMessage(data)
-            : JSON.parse(data);
-        } catch {
-          // leave as raw string if not JSON
-        }
-        config.onMessage?.(data, e);
-      });
+        es = new EventSource(url, {
+          withCredentials: !!config.withCredentials,
+        });
 
-      if (config.onError) {
-        es.addEventListener("error", (e) => config.onError(e));
-      }
+        es.addEventListener("open", (e) => {
+          retryCount = 0;
+          config.onOpen?.(e);
+          if (config.heartbeatTimeout) resetHeartbeat();
+        });
 
-      return es;
+        es.addEventListener("message", (e) => {
+          let data = e.data;
+          try {
+            data = config.transformMessage ? config.transformMessage(data) : data;
+          } catch {
+            /* empty */
+          }
+          config.onMessage?.(data, e);
+          if (config.heartbeatTimeout) resetHeartbeat();
+        });
+
+        es.addEventListener("error", (err) => {
+          config.onError?.(err);
+          if (closed) return;
+          es.close();
+
+          if (retryCount < config.maxRetries) {
+            retryCount++;
+            config.onReconnect?.(retryCount);
+            setTimeout(connect, config.retryDelay);
+          } else {
+            this.$log.warn("SSE: Max retries reached");
+          }
+        });
+      };
+
+      const resetHeartbeat = () => {
+        clearTimeout(heartbeatTimer);
+        heartbeatTimer = setTimeout(() => {
+          this.$log.warn("SSE: heartbeat timeout, reconnecting...");
+          es.close();
+          config.onReconnect?.(++retryCount);
+          connect();
+        }, config.heartbeatTimeout);
+      };
+
+      connect();
+
+      return {
+        close() {
+          closed = true;
+          clearTimeout(heartbeatTimer);
+          es.close();
+        },
+        connect() {
+          if (closed == false) {
+            close();
+          }
+          connect();
+        },
+      };
     }
   }
 
@@ -35675,10 +35806,252 @@
     };
   }
 
+  ngWorkerDirective.$inject = ["$worker", $injectTokens.$parse, $injectTokens.$log];
+  /**
+   * ngWorker directive factory
+   * Usage: <div ng-worker="workerName" data-params="{{ expression }}" data-on-result="callback($result)"></div>
+   */
+  function ngWorkerDirective($worker, $parse, $log) {
+    return {
+      restrict: "A",
+      link(scope, element, attrs) {
+        const workerName = attrs.ngWorker;
+        if (!workerName) {
+          $log.warn("ngWorker: missing worker name");
+          return;
+        }
+
+        const eventName = attrs.trigger || getEventNameForElement(element);
+
+        let throttled = false;
+        let intervalId;
+
+        if (isDefined(attrs.latch)) {
+          attrs.$observe(
+            "latch",
+            callBackAfterFirst(() => element.dispatchEvent(new Event(eventName))),
+          );
+        }
+
+        if (isDefined(attrs.interval)) {
+          element.dispatchEvent(new Event(eventName));
+          intervalId = setInterval(
+            () => element.dispatchEvent(new Event(eventName)),
+            parseInt(attrs.interval) || 1000,
+          );
+        }
+
+        const worker = $worker(workerName, {
+          onMessage: (result) => {
+            if (isDefined(attrs.dataOnResult)) {
+              $parse(attrs.dataOnResult)(scope, { $result: result });
+            } else {
+              const swap = attrs.swap || "innerHTML";
+              handleSwap(result, swap, element);
+            }
+          },
+          onError: (err) => {
+            $log.error(`[ng-worker:${workerName}]`, err);
+            if (isDefined(attrs.dataOnError)) {
+              $parse(attrs.dataOnError)(scope, { $error: err });
+            } else {
+              element.textContent = "Error";
+            }
+          },
+        });
+
+        element.addEventListener(eventName, async () => {
+          if (element.disabled) return;
+
+          if (isDefined(attrs.delay)) {
+            await wait(parseInt(attrs.delay) || 0);
+          }
+
+          if (throttled) return;
+
+          if (isDefined(attrs.throttle)) {
+            throttled = true;
+            attrs.$set("throttled", true);
+            setTimeout(() => {
+              attrs.$set("throttled", false);
+              throttled = false;
+            }, parseInt(attrs.throttle));
+          }
+
+          let params;
+          try {
+            params = attrs.params ? scope.$eval(attrs.params) : undefined;
+          } catch (err) {
+            $log.error("ngWorker: failed to evaluate data-params", err);
+            params = undefined;
+          }
+
+          worker.post(params);
+        });
+
+        if (intervalId) {
+          scope.$on("$destroy", () => clearInterval(intervalId));
+        }
+
+        if (eventName === "load") {
+          element.dispatchEvent(new Event("load"));
+        }
+      },
+    };
+  }
+
+  /**
+   * Swap result into DOM based on strategy
+   */
+  function handleSwap(result, swap, element) {
+    switch (swap) {
+      case "outerHTML": {
+        const parent = element.parentNode;
+        if (!parent) return;
+        const temp = document.createElement("div");
+        temp.innerHTML = result;
+        parent.replaceChild(temp.firstChild, element);
+        break;
+      }
+      case "textContent":
+        element.textContent = result;
+        break;
+      case "beforebegin":
+        element.insertAdjacentHTML("beforebegin", result);
+        break;
+      case "afterbegin":
+        element.insertAdjacentHTML("afterbegin", result);
+        break;
+      case "beforeend":
+        element.insertAdjacentHTML("beforeend", result);
+        break;
+      case "afterend":
+        element.insertAdjacentHTML("afterend", result);
+        break;
+      case "innerHTML":
+      default:
+        element.innerHTML = result;
+        break;
+    }
+  }
+
+  /**
+   * Worker Provider
+   *
+   * Usage:
+   *   const worker = $worker('./math.worker.js', {
+   *     onMessage: (data) => console.log('Result:', data),
+   *     onError: (err) => console.error('Worker error:', err),
+   *     autoTerminate: false,
+   *     transformMessage: (d) => d,
+   *   });
+   *
+   *   worker.post({ action: 'fib', n: 20 });
+   *   worker.terminate();
+   */
+  class WorkerProvider {
+    /**
+     * @type {ng.LogService}
+     */
+    $log;
+    constructor() {
+      /**
+       * Optional provider-level defaults
+       * @type {ng.WorkerConfig}
+       */
+      this.defaults = {
+        autoTerminate: false,
+        transformMessage(data) {
+          try {
+            return JSON.parse(data);
+          } catch {
+            return data;
+          }
+        },
+      };
+    }
+
+    /**
+     * Returns the $worker service function
+     * @returns {ng.WorkerService}
+     */
+    $get = [
+      $injectTokens.$log,
+      /** @param {ng.LogService} log */
+      (log) => {
+        this.$log = log;
+        return (scriptPath, config = {}) => {
+          const merged = { ...this.defaults, ...config };
+          return this.#createWorker(scriptPath, merged);
+        };
+      },
+    ];
+
+    /**
+     * Creates a managed Web Worker instance
+     * @param {string | URL} scriptPath
+     * @param {ng.WorkerConfig} config
+     * @returns {import("./interface.ts").WorkerConnection}
+     */
+    #createWorker(scriptPath, config) {
+      if (!scriptPath) throw new Error("Worker script path required");
+
+      let worker = new Worker(scriptPath, { type: "module" });
+      let terminated = false;
+
+      const reconnect = () => {
+        if (terminated) return;
+        this.$log.info("Worker: restarting...");
+        worker.terminate();
+        worker = new Worker(scriptPath, { type: "module" });
+        wire(worker);
+      };
+
+      const wire = (w) => {
+        w.onmessage = (e) => {
+          let data = e.data;
+          try {
+            data = config.transformMessage ? config.transformMessage(data) : data;
+          } catch {
+            /* no-op */
+          }
+          config.onMessage?.(data, e);
+        };
+
+        w.onerror = (err) => {
+          config.onError?.(err);
+          if (config.autoRestart) reconnect();
+        };
+      };
+
+      wire(worker);
+      let that = this;
+      return {
+        post(data) {
+          if (terminated) return that.$log.warn("Worker already terminated");
+          try {
+            worker.postMessage(data);
+          } catch (err) {
+            that.$log.error("Worker post failed", err);
+          }
+        },
+        terminate() {
+          terminated = true;
+          worker.terminate();
+        },
+        restart() {
+          if (terminated)
+            return that.$log.warn("Worker cannot restart after terminate");
+          reconnect();
+        },
+      };
+    }
+  }
+
   /**
    * Initializes core `ng` module.
-   * @param {import('./angular.js').Angular} angular
-   * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
+   * @param {ng.Angular} angular
+   * @returns {ng.NgModule} `ng` module
    */
   function registerNgModule(angular) {
     return angular
@@ -35687,14 +36060,14 @@
         [],
         [
           $injectTokens.$provide,
-          /** @param {import("./interface.js").Provider} $provide */
+          /** @param {ng.ProvideService} $provide */
           ($provide) => {
             // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
             $provide.provider({
               $$sanitizeUri: SanitizeUriProvider,
             });
-            $provide.value("$window", window);
-            $provide.value("$document", document);
+            $provide.value($injectTokens.$window, window);
+            $provide.value($injectTokens.$document, document);
             $provide
               .provider($injectTokens.$compile, CompileProvider)
               .directive({
@@ -35707,6 +36080,7 @@
                 ngBind: ngBindDirective,
                 ngBindHtml: ngBindHtmlDirective,
                 ngBindTemplate: ngBindTemplateDirective,
+                ngChannel: ngChannelDirective,
                 ngClass: ngClassDirective,
                 ngClassEven: ngClassEvenDirective,
                 ngClassOdd: ngClassOddDirective,
@@ -35753,11 +36127,13 @@
                 ngValue: ngValueDirective,
                 ngModelOptions: ngModelOptionsDirective,
                 ngViewport: ngViewportDirective,
+                ngWorker: ngWorkerDirective,
               })
               .directive({
                 input: hiddenInputBrowserCacheDirective,
                 ngAnimateSwap: ngAnimateSwapDirective,
                 ngAnimateChildren: $$AnimateChildrenDirective,
+                // aria directives
                 ngChecked: ngCheckedAriaDirective,
                 ngClick: ngClickAriaDirective,
                 ngDblclick: ngDblclickAriaDirective,
@@ -35769,12 +36145,12 @@
                 ngReadonly: ngReadonlyAriaDirective,
                 ngRequired: ngRequiredAriaDirective,
                 ngValue: ngValueAriaDirective,
+                // router directives
                 ngSref: $StateRefDirective,
                 ngSrefActive: $StateRefActiveDirective,
                 ngSrefActiveEq: $StateRefActiveDirective,
                 ngState: $StateRefDynamicDirective,
                 ngView: ngView,
-                ngChannel: ngChannelDirective,
               })
               .directive({
                 ngView: $ViewDirectiveFill,
@@ -35792,8 +36168,6 @@
               $$animateJsDriver: AnimateJsDriverProvider,
               $$animateCache: AnimateCacheProvider,
               $$animateQueue: AnimateQueueProvider,
-              $$AnimateRunner: AnimateRunnerFactoryProvider,
-              $$animateAsyncRun: AnimateAsyncRunFactoryProvider,
               $controller: ControllerProvider,
               $exceptionHandler: ExceptionHandlerProvider,
               $filter: FilterProvider,
@@ -35820,6 +36194,7 @@
               $url: UrlService,
               $stateRegistry: StateRegistryProvider,
               $eventBus: PubSubProvider,
+              $worker: WorkerProvider,
             });
           },
         ],
@@ -35845,20 +36220,36 @@
     constructor() {
       this.$cache = Cache;
 
-      /** @type {import('./services/pubsub/pubsub.js').PubSub} */
+      /** @type {ng.PubSubService} */
       this.$eventBus = EventBus;
 
       /**
        * @type {string} `version` from `package.json`
        */
-      this.version = "0.9.9"; //inserted via rollup plugin
+      this.version = "0.11.0"; //inserted via rollup plugin
 
       /** @type {!Array<string|any>} */
       this.bootsrappedModules = [];
 
+      /**
+       * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
+       *
+       * @type {(element: Element, name: string?) => ng.Scope|undefined}
+       */
       this.getController = getController;
+
+      /**
+       * Return instance of InjectorService attached to element
+       * @type {(Element) => ng.InjectorService}
+       */
       this.getInjector = getInjector;
+
+      /**
+       * Gets scope for a given element.
+       * @type {(Element) => *}
+       */
       this.getScope = getScope;
+
       this.errorHandlingConfig = errorHandlingConfig;
       this.$t = $injectTokens;
 
@@ -35951,7 +36342,8 @@
          */
         (scope, el, compile, $injector) => {
           // ng-route deps
-          this.$injector = $injector;
+          this.$injector = $injector; // TODO refactor away as this as this prevents multiple apps from being used
+
           setCacheData(el, "$injector", $injector);
 
           const compileFn = compile(el);
@@ -36074,7 +36466,7 @@
      * @param {string} name The name of the module to create or retrieve.
      * @param {Array.<string>} [requires] If specified then new module is being created. If
      *        unspecified then the module is being retrieved for further configuration.
-     * @param {import("./interface.js").Injectable<any>} [configFn] Optional configuration function for the module that gets
+     * @param {import("./interface.ts").Injectable<any>} [configFn] Optional configuration function for the module that gets
      *        passed to {@link NgModule.config NgModule.config()}.
      * @returns {NgModule} A newly registered module.
      */