@angular-wave/angular.ts 0.10.0 → 0.11.0

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.10.0 - November 8, 2025 10:37:14 */
+/* 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";
@@ -1897,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) {
@@ -2047,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");
@@ -2107,6 +2107,26 @@ function domInsert(element, parentElement, afterElement) {
   }
 }
 
+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;
+  });
+}
+
 /**
  * Returns the base href of the document.
  *
@@ -2138,8 +2158,6 @@ const $injectTokens = Object.freeze({
   $attrs: "$attrs",
   $scope: "$scope",
   $element: "$element",
-  $$AnimateRunner: "$$AnimateRunner",
-  $$animateAsyncRun: "$$animateAsyncRun",
   $$animateCache: "$$animateCache",
   $$animateCssDriver: "$$animateCssDriver",
   $$animateJs: "$$animateJs",
@@ -2642,6 +2660,8 @@ class InjectorService extends AbstractInjector {
     const hasCache = hasOwn(this.cache, name);
     return hasProvider || hasCache;
   }
+
+  loadNewModules() {}
 }
 
 // Helpers
@@ -10868,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 {
@@ -10894,7 +10914,7 @@ function inputDirective($filter, $parse) {
 }
 
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
 function hiddenInputBrowserCacheDirective() {
   const valueProperty = {
@@ -10940,7 +10960,7 @@ function hiddenInputBrowserCacheDirective() {
 const CONSTANT_VALUE_REGEXP = /^(true|false|\d+)$/;
 
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
 function ngValueDirective() {
   /**
@@ -10964,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);
         });
       };
@@ -11653,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");
@@ -11837,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");
     },
   };
 }
@@ -11943,7 +11965,7 @@ function ngIfDirective($animate) {
       /** @type {Element} */
       let block;
 
-      /** @type {import('../../core/scope/scope.js').Scope} */
+      /** @type {ng.Scope} */
       let childScope;
 
       let previousElements;
@@ -13992,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;
@@ -14267,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">
@@ -14347,11 +14369,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
          */
         enter(element, parent, after, options) {
           parent = parent || after.parentElement;
-          domInsert(element, parent, after);
+          animatedomInsert(element, parent, after);
           return $$animateQueue.push(
             element,
             "enter",
@@ -14369,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",
@@ -14388,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(
@@ -14417,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);
@@ -14436,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);
@@ -14457,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);
@@ -14485,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);
@@ -14501,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.
  */
@@ -15274,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;
@@ -19519,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;
@@ -19538,7 +19364,7 @@ class LocationProvider {
       }
       const appBaseNoFile = stripFile(appBase);
 
-      $location = new Location(
+      const $location = new Location(
         appBase,
         appBaseNoFile,
         this.html5ModeConf.enabled,
@@ -20128,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)) {
@@ -20145,7 +19974,7 @@ function createScope(target = {}, context) {
             target[key] = createScope(target[key], proxy.$handler);
           }
         } catch {
-          // convert only what we can
+          /* empty */
         }
       }
     }
@@ -20156,6 +19985,45 @@ function createScope(target = {}, context) {
   }
 }
 
+/**
+ * @param {any} target
+ * @returns {boolean}
+ */
+function isUnsafeGlobal(target) {
+  if (target == null) return false;
+  const t = typeof target;
+  if (t !== "object" && t !== "function") return false;
+
+  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
  */
@@ -22229,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,18 +22431,16 @@ 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(
@@ -22747,7 +22838,7 @@ function AnimateCssProvider() {
               pause: null,
             };
 
-            runner = new $$AnimateRunner(runnerHost);
+            runner = new AnimateRunner(runnerHost);
 
             waitUntilQuiet(start);
 
@@ -22846,7 +22937,7 @@ function AnimateCssProvider() {
         }
 
         function closeAndReturnNoopAnimator() {
-          runner = new $$AnimateRunner({
+          runner = new AnimateRunner({
             end: endFn,
             cancel: cancelFn,
           });
@@ -23234,24 +23325,16 @@ 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();
 
@@ -23459,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();
@@ -23904,14 +23987,12 @@ AnimateJsProvider.$inject = [$injectTokens.$animate + "Provider"];
 function AnimateJsProvider($animateProvider) {
   this.$get = [
     $injectTokens.$injector,
-    "$$AnimateRunner",
     /**
      *
      * @param {ng.InjectorService} $injector
-     * @param {*} $$AnimateRunner
      * @returns
      */
-    function ($injector, $$AnimateRunner) {
+    function ($injector) {
       const applyAnimationClasses = applyAnimationClassesFactory();
       // $animateJs(element, 'enter');
       return function (element, event, classes, options) {
@@ -23998,7 +24079,7 @@ function AnimateJsProvider($animateProvider) {
               runner.end();
             } else {
               close();
-              runner = new $$AnimateRunner();
+              runner = new AnimateRunner();
               runner.complete(true);
             }
             return runner;
@@ -24008,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();
@@ -24042,7 +24145,7 @@ function AnimateJsProvider($animateProvider) {
               },
             });
 
-            $$AnimateRunner.chain(chain, onComplete);
+            AnimateRunner.chain(chain, onComplete);
             return runner;
 
             function onComplete(success) {
@@ -24052,7 +24155,6 @@ function AnimateJsProvider($animateProvider) {
 
             function endAnimations(cancelled) {
               if (!animationClosed) {
-                (closeActiveAnimations || (() => {}))(cancelled);
                 onComplete(cancelled);
               }
             }
@@ -24091,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
@@ -24128,7 +24230,7 @@ function AnimateJsProvider($animateProvider) {
                 }
               };
 
-              runner = new $$AnimateRunner({
+              runner = new AnimateRunner({
                 end() {
                   onAnimationComplete();
                 },
@@ -24224,7 +24326,7 @@ function AnimateJsProvider($animateProvider) {
             }
 
             if (runners.length) {
-              $$AnimateRunner.all(runners, callback);
+              AnimateRunner.all(runners, callback);
             } else {
               callback();
             }
@@ -24284,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();
 
@@ -24403,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();
           },
@@ -24958,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;
 
@@ -25040,7 +25132,7 @@ function AnimateCssDriverProvider($$animationProvider) {
               runner.complete();
             });
 
-            runner = new $$AnimateRunner({
+            runner = new AnimateRunner({
               end: endFn,
               cancel: endFn,
             });
@@ -25151,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);
             });
 
@@ -25226,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);
@@ -25246,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(),
               });
@@ -35454,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`);
+        }
+      }
     },
   };
 }
@@ -35954,8 +36044,8 @@ class WorkerProvider {
 
 /**
  * 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
@@ -35964,14 +36054,14 @@ function registerNgModule(angular) {
       [],
       [
         $injectTokens.$provide,
-        /** @param {import("./interface.ts").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({
@@ -35984,6 +36074,7 @@ function registerNgModule(angular) {
               ngBind: ngBindDirective,
               ngBindHtml: ngBindHtmlDirective,
               ngBindTemplate: ngBindTemplateDirective,
+              ngChannel: ngChannelDirective,
               ngClass: ngClassDirective,
               ngClassEven: ngClassEvenDirective,
               ngClassOdd: ngClassOddDirective,
@@ -36036,6 +36127,7 @@ function registerNgModule(angular) {
               input: hiddenInputBrowserCacheDirective,
               ngAnimateSwap: ngAnimateSwapDirective,
               ngAnimateChildren: $$AnimateChildrenDirective,
+              // aria directives
               ngChecked: ngCheckedAriaDirective,
               ngClick: ngClickAriaDirective,
               ngDblclick: ngDblclickAriaDirective,
@@ -36047,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,
@@ -36070,8 +36162,6 @@ function registerNgModule(angular) {
             $$animateJsDriver: AnimateJsDriverProvider,
             $$animateCache: AnimateCacheProvider,
             $$animateQueue: AnimateQueueProvider,
-            $$AnimateRunner: AnimateRunnerFactoryProvider,
-            $$animateAsyncRun: AnimateAsyncRunFactoryProvider,
             $controller: ControllerProvider,
             $exceptionHandler: ExceptionHandlerProvider,
             $filter: FilterProvider,
@@ -36124,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.10.0"; //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;
 
@@ -36230,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);