@angular-wave/angular.ts 0.9.9 → 0.11.0

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.9.9 - October 28, 2025 22:08:29 */
+/* Version: 0.11.0 - November 11, 2025 21:55:57 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -906,7 +906,7 @@ function assertArgFn(arg, name, acceptArrayAnnotation) {
   return arg;
 }
 
-/** @type {import("./interface.js").ErrorHandlingConfig} */
+/** @type {import("./interface.ts").ErrorHandlingConfig} */
 const minErrConfig = {
   objectMaxDepth: 5,
   urlErrorParamsEnabled: true,
@@ -1198,6 +1198,382 @@ function startsWith(str, search) {
  */
 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;
 
@@ -1521,7 +1897,7 @@ function setIsolateScope(element, scope) {
  * 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) {
@@ -1671,7 +2047,7 @@ function cleanElementData(nodes) {
 /**
  * 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");
@@ -1719,12 +2095,8 @@ function domInsert(element, parentElement, afterElement) {
   // 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;
     }
   }
@@ -1735,14 +2107,24 @@ function domInsert(element, parentElement, afterElement) {
   }
 }
 
-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;
+  });
 }
 
 /**
@@ -1776,8 +2158,6 @@ const $injectTokens = Object.freeze({
   $attrs: "$attrs",
   $scope: "$scope",
   $element: "$element",
-  $$AnimateRunner: "$$AnimateRunner",
-  $$animateAsyncRun: "$$animateAsyncRun",
   $$animateCache: "$$animateCache",
   $$animateCssDriver: "$$animateCssDriver",
   $$animateJs: "$$animateJs",
@@ -1863,7 +2243,7 @@ class NgModule {
   /**
    * @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");
@@ -1889,7 +2269,7 @@ class NgModule {
     /** @type {!Array<Array<*>>} */
     this.configBlocks = [];
 
-    /** @type {!Array.<import("../../interface.js").Injectable<any>>} */
+    /** @type {!Array.<import("../../interface.ts").Injectable<any>>} */
     this.runBlocks = [];
 
     if (configFn) {
@@ -1993,7 +2373,7 @@ class NgModule {
 
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} decorFn
+   * @param {import("../../interface.ts").Injectable<any>} decorFn
    * @returns {NgModule}
    */
   decorator(name, decorFn) {
@@ -2006,7 +2386,7 @@ class NgModule {
 
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} directiveFactory
+   * @param {import("../../interface.ts").Injectable<any>} directiveFactory
    * @returns {NgModule}
    */
   directive(name, directiveFactory) {
@@ -2023,7 +2403,7 @@ class NgModule {
 
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} animationFactory
+   * @param {import("../../interface.ts").Injectable<any>} animationFactory
    * @returns {NgModule}
    */
   animation(name, animationFactory) {
@@ -2040,7 +2420,7 @@ class NgModule {
 
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} filterFn
+   * @param {import("../../interface.ts").Injectable<any>} filterFn
    * @return {NgModule}
    */
   filter(name, filterFn) {
@@ -2053,7 +2433,7 @@ class NgModule {
 
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} ctlFn
+   * @param {import("../../interface.ts").Injectable<any>} ctlFn
    * @returns {NgModule}
    */
   controller(name, ctlFn) {
@@ -2280,6 +2660,8 @@ class InjectorService extends AbstractInjector {
     const hasCache = hasOwn(this.cache, name);
     return hasProvider || hasCache;
   }
+
+  loadNewModules() {}
 }
 
 // Helpers
@@ -2438,7 +2820,7 @@ function createInjector(modulesToLoad, strictDi = false) {
    * 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, {
@@ -2460,7 +2842,7 @@ function createInjector(modulesToLoad, strictDi = false) {
    * 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, [
@@ -2929,7 +3311,7 @@ class ControllerProvider {
 
     /**
      * @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) => {
@@ -3047,18 +3429,19 @@ class ControllerProvider {
       );
     }
     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),
@@ -3090,7 +3473,7 @@ function urlResolve(url) {
  * 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.
  */
@@ -3104,7 +3487,7 @@ function urlIsSameOrigin(requestUrl) {
  * Note: The base URL is usually the same as the document location (`location.href`) but can
  * be overriden by using the `<base>` tag.
  *
- * @param {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.
  */
@@ -3118,7 +3501,7 @@ function urlIsSameOriginAsBaseUrl(requestUrl) {
  *
  * @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) {
@@ -3131,7 +3514,7 @@ function urlIsAllowedOriginFactory(trustedOriginUrls) {
    * 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.
@@ -3147,9 +3530,9 @@ function urlIsAllowedOriginFactory(trustedOriginUrls) {
 /**
  * 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.
@@ -3783,7 +4166,7 @@ function SceProvider() {
        *
        * @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).
@@ -4015,26 +4398,23 @@ function SceProvider() {
  */
 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,
         );
@@ -4046,7 +4426,6 @@ const ngEventDirectives = {};
  *
  * @param {ng.ParseService} $parse
  * @param {ng.ExceptionHandlerService} $exceptionHandler
- * @param {ng.WindowService} $window
  * @param {string} directiveName
  * @param {string} eventName
  * @returns {ng.Directive}
@@ -4054,7 +4433,6 @@ const ngEventDirectives = {};
 function createEventDirective(
   $parse,
   $exceptionHandler,
-  $window,
   directiveName,
   eventName,
 ) {
@@ -4123,16 +4501,13 @@ const $compileMinErr$1 = minErr("$compile");
 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]
@@ -4445,19 +4820,18 @@ function tokenDifference(str1, str2) {
 /**
  * @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) => {
@@ -4470,7 +4844,7 @@ function ngObserveDirective(source, prop) {
         }
       });
 
-      observer.observe(targetElement, {
+      observer.observe(element, {
         attributes: true,
         attributeFilter: [source],
       });
@@ -4496,7 +4870,7 @@ class CompileProvider {
   /* @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) {
@@ -4686,7 +5060,7 @@ class CompileProvider {
     /**
      * @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):
      *
@@ -5472,12 +5846,12 @@ class CompileProvider {
                       createEventDirective(
                         $parse,
                         $exceptionHandler,
-                        window,
                         nName,
                         name,
                       ),
                     );
                   } else {
+                    // isWindow
                     directives.push(
                       createWindowEventDirective(
                         $parse,
@@ -7467,7 +7841,7 @@ class CompileProvider {
                             scope.$handler.watchers
                               .get(attrs[attrName])
                               ?.forEach((watchFn) => {
-                                watchFn.listenerFn(val);
+                                watchFn.listenerFn(val, scope.$target);
                               });
                           }
                         }
@@ -7880,8 +8254,14 @@ class FormController {
    * 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();
@@ -7900,11 +8280,18 @@ class FormController {
    * 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;
@@ -7942,7 +8329,11 @@ class FormController {
   }
 
   $$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) {
@@ -10497,9 +10888,9 @@ function checkboxInputType(scope, element, attr, ctrl, $filter, $parse) {
 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 {
@@ -10523,7 +10914,7 @@ function inputDirective($filter, $parse) {
 }
 
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
 function hiddenInputBrowserCacheDirective() {
   const valueProperty = {
@@ -10569,7 +10960,7 @@ function hiddenInputBrowserCacheDirective() {
 const CONSTANT_VALUE_REGEXP = /^(true|false|\d+)$/;
 
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
 function ngValueDirective() {
   /**
@@ -10593,15 +10984,15 @@ function ngValueDirective() {
   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);
         });
       };
@@ -11282,17 +11673,20 @@ function ngBindHtmlDirective($parse) {
 /**
  * @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");
@@ -11466,9 +11860,8 @@ const ngClassEvenDirective = classDirective("Even", 1);
  */
 function ngCloakDirective() {
   return {
-    compile(element, attr) {
+    compile(_, attr) {
       attr.$set("ngCloak", undefined);
-      element.classList.remove("ng-cloak");
     },
   };
 }
@@ -11552,7 +11945,7 @@ function ngHideDirective($animate) {
 ngIfDirective.$inject = ["$animate"];
 /**
  * @param {*}  $animate
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
 function ngIfDirective($animate) {
   return {
@@ -11562,22 +11955,22 @@ function ngIfDirective($animate) {
     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) => {
@@ -11632,7 +12025,7 @@ ngIncludeDirective.$inject = [
  * @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,
@@ -13014,7 +13407,7 @@ function ngTranscludeDirective($compile) {
 const REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
 
 /**
- * @type {Record<string, import("../../interface.js").DirectiveFactory>}
+ * @type {Record<string, import("../../interface.ts").DirectiveFactory>}
  */
 const ngAttributeAliasDirectives = {};
 
@@ -13587,364 +13980,6 @@ class AnchorScrollProvider {
   ];
 }
 
-/**
- * @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 */
 
 /**
@@ -13979,7 +14014,7 @@ function prepareAnimateOptions(options) {
 
 AnimateProvider.$inject = ["$provide"];
 
-/** @param {import('../interface.ts').Provider} $provide */
+/** @param {ng.ProvideService} $provide */
 function AnimateProvider($provide) {
   const provider = this;
   let classNameFilter = null;
@@ -14254,7 +14289,7 @@ function AnimateProvider($provide) {
        * 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">
@@ -14332,13 +14367,13 @@ function AnimateProvider($provide) {
          *
          * @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",
@@ -14356,11 +14391,11 @@ function AnimateProvider($provide) {
          * @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",
@@ -14375,7 +14410,7 @@ function AnimateProvider($provide) {
          *
          * @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(
@@ -14404,7 +14439,7 @@ function AnimateProvider($provide) {
          * @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);
@@ -14423,7 +14458,7 @@ function AnimateProvider($provide) {
          * @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);
@@ -14444,7 +14479,7 @@ function AnimateProvider($provide) {
          * @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);
@@ -14472,7 +14507,7 @@ function AnimateProvider($provide) {
          *   }
          * });
          * ```
-         *  @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);
@@ -14488,200 +14523,6 @@ function AnimateProvider($provide) {
   ];
 }
 
-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.
  */
@@ -15261,7 +15102,7 @@ class FilterProvider {
   /* @ignore */ static $inject = [$injectTokens.$provide];
 
   /**
-   * @param {import('../../interface.ts').Provider} $provide
+   * @param {ng.ProvideService} $provide
    */
   constructor($provide) {
     this.$provide = $provide;
@@ -17810,7 +17651,7 @@ class InterpolateProvider {
             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;
@@ -19478,7 +19319,7 @@ class LocationProvider {
   /**
    * 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) {
@@ -19506,8 +19347,6 @@ class LocationProvider {
      * @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;
@@ -19525,7 +19364,7 @@ class LocationProvider {
       }
       const appBaseNoFile = stripFile(appBase);
 
-      $location = new Location(
+      const $location = new Location(
         appBase,
         appBaseNoFile,
         this.html5ModeConf.enabled,
@@ -20071,16 +19910,9 @@ function nextId() {
  */
 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 {
@@ -20089,11 +19921,11 @@ class RootScopeProvider {
   }
 
   $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;
@@ -20122,6 +19954,9 @@ function createScope(target = {}, context) {
   }
 
   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)) {
@@ -20139,7 +19974,7 @@ function createScope(target = {}, context) {
             target[key] = createScope(target[key], proxy.$handler);
           }
         } catch {
-          // convert only what we can
+          /* empty */
         }
       }
     }
@@ -20151,25 +19986,43 @@ function createScope(target = {}, context) {
 }
 
 /**
- * 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
@@ -20196,13 +20049,13 @@ class Scope {
         : 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>} */
@@ -20247,7 +20100,7 @@ class Scope {
         ? null
         : context;
 
-    /** @type {AsyncQueueTask[]} */
+    /** @type {import('./interface.ts').AsyncQueueTask[]} */
     this.$$asyncQueue = [];
 
     this.filters = [];
@@ -20256,6 +20109,31 @@ class Scope {
     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),
+    };
   }
 
   /**
@@ -20451,8 +20329,8 @@ class Scope {
           // 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,
             );
           }
@@ -20497,29 +20375,8 @@ class Scope {
       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) &&
@@ -20614,7 +20471,7 @@ class Scope {
   }
 
   /**
-   * @param {Listener[]} listeners
+   * @param {import('./interface.ts').Listener[]} listeners
    * @param {Function} filter
    */
   #scheduleListener(listeners, filter = (val) => val) {
@@ -20638,7 +20495,7 @@ class Scope {
    * 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) {
@@ -20660,7 +20517,7 @@ class Scope {
       return () => {};
     }
 
-    /** @type {Listener} */
+    /** @type {import('./interface.ts').Listener} */
     const listener = {
       originalTarget: this.$target,
       listenerFn: listenerFn,
@@ -20772,7 +20629,7 @@ class Scope {
 
           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]);
@@ -20970,21 +20827,21 @@ class Scope {
     return true;
   }
 
-  // deregisterForeignKey(key, id) {
-  //   const listenerList = this.foreignListeners.get(key);
-  //   if (!listenerList) return false;
+  deregisterForeignKey(key, id) {
+    const listenerList = this.foreignListeners.get(key);
+    if (!listenerList) return false;
 
-  //   const index = listenerList.findIndex((x) => x.id === id);
-  //   if (index === -1) return false;
+    const index = listenerList.findIndex((x) => x.id === id);
+    if (index === -1) return false;
 
-  //   listenerList.splice(index, 1);
-  //   if (listenerList.length) {
-  //     this.foreignListeners.set(key, listenerList);
-  //   } else {
-  //     this.foreignListeners.delete(key);
-  //   }
-  //   return true;
-  // }
+    listenerList.splice(index, 1);
+    if (listenerList.length) {
+      this.foreignListeners.set(key, listenerList);
+    } else {
+      this.foreignListeners.delete(key);
+    }
+    return true;
+  }
 
   $eval(expr, locals) {
     const fn = $parse(expr);
@@ -21017,7 +20874,7 @@ class Scope {
   }
 
   /**
-   * @param {import('../../interface.js').Expression} expr
+   * @param {import('../../interface.ts').Expression} expr
    * @returns {any}
    */
   $apply(expr) {
@@ -21198,12 +21055,12 @@ class Scope {
 
   /**
    * @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);
       }
@@ -21233,6 +21090,13 @@ class Scope {
     }
   }
 
+  /* @ignore */
+  $flushQueue() {
+    while ($postUpdateQueue.length) {
+      $postUpdateQueue.shift()();
+    }
+  }
+
   /**
    * Searches the scope instance
    *
@@ -21743,7 +21607,7 @@ const ngMessageDefaultDirective = ngMessageDirectiveFactory(true);
 
 /**
  * @param {boolean} isDefault
- * @returns {(any) => import("../../interface.js").Directive}
+ * @returns {(any) => import("../../interface.ts").Directive}
  */
 function ngMessageDirectiveFactory(isDefault) {
   ngMessageDirective.$inject = ["$animate"];
@@ -21950,6 +21814,9 @@ function ngShowAriaDirective($aria) {
   return $aria.$$watchExpr("ngShow", "aria-hidden", [], true);
 }
 
+/**
+ * @return {ng.Directive}
+ */
 function ngMessagesAriaDirective() {
   return {
     restrict: "A",
@@ -21965,18 +21832,21 @@ function ngMessagesAriaDirective() {
 }
 
 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");
@@ -22013,10 +21883,6 @@ function ngClickAriaDirective($aria, $parse) {
                     // See https://github.com/angular/angular.js/issues/16664
                     event.preventDefault();
                   }
-                  scope.$apply(callback);
-                }
-
-                function callback() {
                   fn(scope, { $event: event });
                 }
               },
@@ -22231,6 +22097,231 @@ function ngDblclickAriaDirective($aria) {
   };
 }
 
+/**
+ * @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;
@@ -22338,19 +22429,18 @@ function registerRestorableStyles(backup, node, properties) {
 }
 
 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(
@@ -22681,10 +22771,7 @@ function AnimateCssProvider() {
           return closeAndReturnNoopAnimator();
         }
 
-        let activeClasses = pendClasses(
-          preparationClasses,
-          ACTIVE_CLASS_SUFFIX,
-        );
+        activeClasses = pendClasses(preparationClasses, ACTIVE_CLASS_SUFFIX);
 
         if (options.delay != null) {
           if (typeof options.delay !== "boolean") {
@@ -22751,7 +22838,7 @@ function AnimateCssProvider() {
               pause: null,
             };
 
-            runner = new $$AnimateRunner(runnerHost);
+            runner = new AnimateRunner(runnerHost);
 
             waitUntilQuiet(start);
 
@@ -22821,7 +22908,9 @@ function AnimateCssProvider() {
 
           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
@@ -22848,7 +22937,7 @@ function AnimateCssProvider() {
         }
 
         function closeAndReturnNoopAnimator() {
-          runner = new $$AnimateRunner({
+          runner = new AnimateRunner({
             end: endFn,
             cancel: cancelFn,
           });
@@ -23236,31 +23325,18 @@ function AnimateQueueProvider($animateProvider) {
     $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;
@@ -23300,11 +23376,6 @@ function AnimateQueueProvider($animateProvider) {
             // 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;
-                }
               });
             });
           }
@@ -23443,47 +23514,6 @@ function AnimateQueueProvider($animateProvider) {
           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;
@@ -23512,7 +23542,7 @@ function AnimateQueueProvider($animateProvider) {
 
         // 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();
@@ -23540,6 +23570,7 @@ function AnimateQueueProvider($animateProvider) {
         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.
@@ -23552,7 +23583,6 @@ function AnimateQueueProvider($animateProvider) {
           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
@@ -23788,6 +23818,8 @@ function AnimateQueueProvider($animateProvider) {
           });
         });
 
+        // Since we don't have digest any more - trigger queue here
+        setTimeout($rootScope.$flushQueue, 0);
         return runner;
 
         function notifyProgress(runner, event, phase, data) {
@@ -23951,18 +23983,16 @@ function AnimateQueueProvider($animateProvider) {
 // 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) {
@@ -24049,7 +24079,7 @@ function AnimateJsProvider($animateProvider) {
               runner.end();
             } else {
               close();
-              runner = new $$AnimateRunner();
+              runner = new AnimateRunner();
               runner.complete(true);
             }
             return runner;
@@ -24059,31 +24089,53 @@ function AnimateJsProvider($animateProvider) {
               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();
@@ -24093,7 +24145,7 @@ function AnimateJsProvider($animateProvider) {
               },
             });
 
-            $$AnimateRunner.chain(chain, onComplete);
+            AnimateRunner.chain(chain, onComplete);
             return runner;
 
             function onComplete(success) {
@@ -24103,7 +24155,6 @@ function AnimateJsProvider($animateProvider) {
 
             function endAnimations(cancelled) {
               if (!animationClosed) {
-                (closeActiveAnimations || (() => {}))(cancelled);
                 onComplete(cancelled);
               }
             }
@@ -24142,7 +24193,7 @@ function AnimateJsProvider($animateProvider) {
               value = value.start();
             }
 
-            if (value instanceof $$AnimateRunner) {
+            if (value instanceof AnimateRunner) {
               value.done(onDone);
             } else if (isFunction(value)) {
               // optional onEnd / onCancel callback
@@ -24179,7 +24230,7 @@ function AnimateJsProvider($animateProvider) {
                 }
               };
 
-              runner = new $$AnimateRunner({
+              runner = new AnimateRunner({
                 end() {
                   onAnimationComplete();
                 },
@@ -24275,7 +24326,7 @@ function AnimateJsProvider($animateProvider) {
             }
 
             if (runners.length) {
-              $$AnimateRunner.all(runners, callback);
+              AnimateRunner.all(runners, callback);
             } else {
               callback();
             }
@@ -24335,25 +24386,17 @@ function AnimationProvider() {
   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();
 
@@ -24454,7 +24497,7 @@ function AnimationProvider() {
         // 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();
           },
@@ -24817,8 +24860,8 @@ function AnimationProvider() {
 }
 
 /**
- * @typedef {import('./interface.js').RafScheduler} RafScheduler
- * @typedef {import('../interface.js').ServiceProvider} ServiceProvider
+ * @typedef {import('./interface.ts').RafScheduler} RafScheduler
+ * @typedef {import('../interface.ts').ServiceProvider} ServiceProvider
  */
 
 /**
@@ -25009,16 +25052,14 @@ function AnimateCssDriverProvider($$animationProvider) {
    */
   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;
 
@@ -25091,7 +25132,7 @@ function AnimateCssDriverProvider($$animationProvider) {
               runner.complete();
             });
 
-            runner = new $$AnimateRunner({
+            runner = new AnimateRunner({
               end: endFn,
               cancel: endFn,
             });
@@ -25202,12 +25243,12 @@ function AnimateCssDriverProvider($$animationProvider) {
               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);
             });
 
@@ -25277,8 +25318,11 @@ function AnimateJsDriverProvider($$animationProvider) {
   $$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);
@@ -25297,9 +25341,9 @@ function AnimateJsDriverProvider($$animationProvider) {
                 animationRunners.push(toAnimation.start());
               }
 
-              $$AnimateRunner.all(animationRunners, done);
+              AnimateRunner.all(animationRunners, done);
 
-              const runner = new $$AnimateRunner({
+              const runner = new AnimateRunner({
                 end: endFnFactory(),
                 cancel: endFnFactory(),
               });
@@ -25333,9 +25377,9 @@ function AnimateJsDriverProvider($$animationProvider) {
   ];
 }
 
-ngAnimateSwapDirective.$inject = ["$animate"];
+ngAnimateSwapDirective.$inject = [$injectTokens.$animate];
 /**
- * @returns {import('../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
 function ngAnimateSwapDirective($animate) {
   return {
@@ -25344,10 +25388,10 @@ function ngAnimateSwapDirective($animate) {
     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);
         }
@@ -27574,7 +27618,7 @@ class PathUtils {
    * @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);
@@ -28309,25 +28353,6 @@ ViewService.matches = (ngViewsByFqn, ngView) => (viewConfig) => {
   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}
@@ -28447,7 +28472,7 @@ class Rejection {
   }
 }
 
-/** @typedef {import('../../interface.js').ServiceProvider} ServiceProvider
+/** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider
 
 /**
  * Configurable provider for an injectable event bus
@@ -28804,6 +28829,31 @@ const defaultOptions = {
   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.
@@ -30622,7 +30672,6 @@ class TransitionProvider {
   }
 
   _defineCoreEvents() {
-    const Phase = TransitionHookPhase;
     const TH = TransitionHook;
     const paths = this._criteriaPaths;
     const NORMAL_SORT = false,
@@ -30630,7 +30679,7 @@ class TransitionProvider {
     const SYNCHRONOUS = true;
     this._defineEvent(
       "onCreate",
-      Phase.CREATE,
+      TransitionHookPhase.CREATE,
       0,
       paths.to,
       NORMAL_SORT,
@@ -30638,15 +30687,21 @@ class TransitionProvider {
       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,
@@ -30656,7 +30711,7 @@ class TransitionProvider {
     );
     this._defineEvent(
       "onError",
-      Phase.ERROR,
+      TransitionHookPhase.ERROR,
       0,
       paths.to,
       NORMAL_SORT,
@@ -30922,7 +30977,7 @@ class StateProvider {
 
   /**
    *
-   * @param {import("./interface.js").StateDeclaration} definition
+   * @param {import("./interface.ts").StateDeclaration} definition
    */
   state(definition) {
     if (!definition.name) {
@@ -32222,7 +32277,7 @@ function encodeDashes(str) {
   );
 }
 
-/** @typedef {import('./interface.js').StateDeclaration} StateDeclaration */
+/** @typedef {import('./interface.ts').StateDeclaration} StateDeclaration */
 
 /**
  * Internal representation of a ng-router state.
@@ -32245,7 +32300,7 @@ class StateObject {
   includes = undefined;
 
   /**
-   * @param {import('./interface.js').StateDeclaration} config
+   * @param {import('./interface.ts').StateDeclaration} config
    */
   constructor(config) {
     Object.assign(this, config);
@@ -32253,7 +32308,7 @@ class StateObject {
       return this;
     };
     /**
-     * @type {import('./interface.js').StateDeclaration}
+     * @type {import('./interface.ts').StateDeclaration}
      */
     this.self = config;
     /**
@@ -34642,7 +34697,7 @@ function $StateRefActiveDirective(
  * ```
  */
 
-/** @type {import("../../interface.js").AnnotatedDirectiveFactory} */
+/** @type {import("../../interface.ts").AnnotatedDirectiveFactory} */
 let ngView = [
   "$view",
   "$animate",
@@ -34653,7 +34708,7 @@ let ngView = [
    * @param {*} $animate
    * @param {*} $viewScroll
    * @param {*} $interpolate
-   * @returns {import("../../interface.js").Directive}
+   * @returns {import("../../interface.ts").Directive}
    */
   function $ViewDirective($view, $animate, $viewScroll, $interpolate) {
     function getRenderer() {
@@ -35079,7 +35134,8 @@ function ngSetterDirective($parse, $log) {
 }
 
 /**
- * @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) {
@@ -35093,6 +35149,7 @@ function defineDirective(method, attrOverride) {
     $injectTokens.$parse,
     $injectTokens.$state,
     $injectTokens.$sse,
+    $injectTokens.$animate,
   ];
   return directive;
 }
@@ -35112,15 +35169,11 @@ const ngPutDirective = defineDirective("put");
 /** @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();
@@ -35132,89 +35185,6 @@ function getEventNameForElement(element) {
   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.
  *
@@ -35223,6 +35193,8 @@ function handleSwapResponse(html, swap, target, scope, $compile) {
  * @returns {ng.DirectiveFactory}
  */
 function createHttpDirective(method, attrName) {
+  let content = undefined;
+
   /**
    * @param {ng.HttpService} $http
    * @param {ng.CompileService} $compile
@@ -35232,7 +35204,125 @@ function createHttpDirective(method, attrName) {
    * @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.
      *
@@ -35246,15 +35336,12 @@ function createHttpDirective(method, attrName) {
       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);
@@ -35292,13 +35379,10 @@ function createHttpDirective(method, attrName) {
     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(() =>
@@ -35314,24 +35398,14 @@ function createHttpDirective(method, attrName) {
           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`);
@@ -35339,56 +35413,57 @@ function createHttpDirective(method, attrName) {
           }
 
           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"])) {
@@ -35396,13 +35471,13 @@ function createHttpDirective(method, attrName) {
           }
 
           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"],
               };
@@ -35412,11 +35487,10 @@ function createHttpDirective(method, attrName) {
             }
             $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);
@@ -35426,9 +35500,9 @@ function createHttpDirective(method, attrName) {
                 },
                 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 };
@@ -35439,12 +35513,15 @@ function createHttpDirective(method, attrName) {
                   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();
@@ -35459,7 +35536,6 @@ function createHttpDirective(method, attrName) {
           scope.$on("$destroy", () => clearInterval(intervalId));
         }
 
-        // Eagerly execute for 'load' event
         if (eventName == "load") {
           element.dispatchEvent(new Event("load"));
         }
@@ -35473,31 +35549,26 @@ ngInjectDirective.$inject = [$injectTokens.$log, $injectTokens.$injector];
 /**
  * @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`);
+        }
+      }
     },
   };
 }
@@ -35540,38 +35611,54 @@ function ngElDirective() {
  *   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;
@@ -35582,37 +35669,81 @@ class SseProvider {
   }
 
   /**
-   * 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();
+      },
+    };
   }
 }
 
@@ -35669,10 +35800,252 @@ function ngViewportDirective() {
   };
 }
 
+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
@@ -35681,14 +36054,14 @@ function registerNgModule(angular) {
       [],
       [
         $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({
@@ -35701,6 +36074,7 @@ function registerNgModule(angular) {
               ngBind: ngBindDirective,
               ngBindHtml: ngBindHtmlDirective,
               ngBindTemplate: ngBindTemplateDirective,
+              ngChannel: ngChannelDirective,
               ngClass: ngClassDirective,
               ngClassEven: ngClassEvenDirective,
               ngClassOdd: ngClassOddDirective,
@@ -35747,11 +36121,13 @@ function registerNgModule(angular) {
               ngValue: ngValueDirective,
               ngModelOptions: ngModelOptionsDirective,
               ngViewport: ngViewportDirective,
+              ngWorker: ngWorkerDirective,
             })
             .directive({
               input: hiddenInputBrowserCacheDirective,
               ngAnimateSwap: ngAnimateSwapDirective,
               ngAnimateChildren: $$AnimateChildrenDirective,
+              // aria directives
               ngChecked: ngCheckedAriaDirective,
               ngClick: ngClickAriaDirective,
               ngDblclick: ngDblclickAriaDirective,
@@ -35763,12 +36139,12 @@ function registerNgModule(angular) {
               ngReadonly: ngReadonlyAriaDirective,
               ngRequired: ngRequiredAriaDirective,
               ngValue: ngValueAriaDirective,
+              // router directives
               ngSref: $StateRefDirective,
               ngSrefActive: $StateRefActiveDirective,
               ngSrefActiveEq: $StateRefActiveDirective,
               ngState: $StateRefDynamicDirective,
               ngView: ngView,
-              ngChannel: ngChannelDirective,
             })
             .directive({
               ngView: $ViewDirectiveFill,
@@ -35786,8 +36162,6 @@ function registerNgModule(angular) {
             $$animateJsDriver: AnimateJsDriverProvider,
             $$animateCache: AnimateCacheProvider,
             $$animateQueue: AnimateQueueProvider,
-            $$AnimateRunner: AnimateRunnerFactoryProvider,
-            $$animateAsyncRun: AnimateAsyncRunFactoryProvider,
             $controller: ControllerProvider,
             $exceptionHandler: ExceptionHandlerProvider,
             $filter: FilterProvider,
@@ -35814,6 +36188,7 @@ function registerNgModule(angular) {
             $url: UrlService,
             $stateRegistry: StateRegistryProvider,
             $eventBus: PubSubProvider,
+            $worker: WorkerProvider,
           });
         },
       ],
@@ -35839,20 +36214,36 @@ class Angular {
   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;
 
@@ -35945,7 +36336,8 @@ class Angular {
        */
       (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);
@@ -36068,7 +36460,7 @@ class Angular {
    * @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.
    */