@angular-wave/angular.ts 0.9.3 → 0.9.5

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.9.3 - October 9, 2025 19:24:11 */
+/* Version: 0.9.5 - October 23, 2025 19:32:46 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -1798,11 +1798,11 @@
     $aria: "$aria",
     $compile: "$compile",
     $controller: "$controller",
+    $document: "$document",
     $eventBus: "$eventBus",
     $exceptionHandler: "$exceptionHandler",
     $filter: "$filter",
     $http: "$http",
-    $httpBackend: "$httpBackend",
     $httpParamSerializer: "$httpParamSerializer",
     $interpolate: "$interpolate",
     $location: "$location",
@@ -1816,6 +1816,8 @@
     $sceDelegate: "$sceDelegate",
     $state: "$state",
     $stateRegistry: "$stateRegistry",
+    $$sanitizeUri: "$$sanitizeUri",
+    $$sanitizeUriProvider: "$$sanitizeUriProvider",
     $templateCache: "$templateCache",
     $templateFactory: "$templateFactory",
     $templateRequest: "$templateRequest",
@@ -1823,6 +1825,7 @@
     $urlConfig: "$urlConfig",
     $url: "$url",
     $view: "$view",
+    $window: "$window",
     // provide literals
     $provide: "$provide",
     $injector: "$injector",
@@ -1865,7 +1868,7 @@
     /**
      * @param {string} name - Name of the module
      * @param {Array<string>} requires - List of modules which the injector will load before the current module
-     * @param {import("../../interface.js").Injectable} [configFn]
+     * @param {import("../../interface.js").Injectable<any>} [configFn]
      */
     constructor(name, requires, configFn) {
       assert(isString(name), "name required");
@@ -1891,12 +1894,14 @@
       /** @type {!Array<Array<*>>} */
       this.configBlocks = [];
 
-      /** @type {!Array.<import("../../interface.js").Injectable>} */
+      /** @type {!Array.<import("../../interface.js").Injectable<any>>} */
       this.runBlocks = [];
 
       if (configFn) {
         this.config(configFn);
       }
+
+      this.services = [];
     }
 
     /**
@@ -1921,7 +1926,7 @@
 
     /**
      *
-     * @param {import("../../interface.js").Injectable} configFn
+     * @param {import("../../interface.ts").Injectable<any>} configFn
      * @returns {NgModule}
      */
     config(configFn) {
@@ -1930,7 +1935,7 @@
     }
 
     /**
-     * @param {import("../../interface.js").Injectable} block
+     * @param {import("../../interface.ts").Injectable<any>} block
      * @returns {NgModule}
      */
     run(block) {
@@ -1940,7 +1945,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").ComponentOptions} options
+     * @param {import("../../interface.ts").Component} options
      * @returns {NgModule}
      */
     component(name, options) {
@@ -1953,7 +1958,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable} providerFunction
+     * @param {import("../../interface.ts").Injectable<any>} providerFunction
      * @returns {NgModule}
      */
     factory(name, providerFunction) {
@@ -1966,20 +1971,21 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable} serviceFunction
+     * @param {import("../../interface.ts").Injectable<any>} serviceFunction
      * @returns {NgModule}
      */
     service(name, serviceFunction) {
       if (serviceFunction && isFunction(serviceFunction)) {
         serviceFunction["$$moduleName"] = name;
       }
+      this.services.push(name);
       this.invokeQueue.push([$injectTokens.$provide, "service", [name, serviceFunction]]);
       return this;
     }
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable} providerType
+     * @param {import("../../interface.ts").Injectable<any>} providerType
      * @returns {NgModule}
      */
     provider(name, providerType) {
@@ -1992,7 +1998,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable} decorFn
+     * @param {import("../../interface.js").Injectable<any>} decorFn
      * @returns {NgModule}
      */
     decorator(name, decorFn) {
@@ -2005,7 +2011,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable} directiveFactory
+     * @param {import("../../interface.js").Injectable<any>} directiveFactory
      * @returns {NgModule}
      */
     directive(name, directiveFactory) {
@@ -2022,7 +2028,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable} animationFactory
+     * @param {import("../../interface.js").Injectable<any>} animationFactory
      * @returns {NgModule}
      */
     animation(name, animationFactory) {
@@ -2039,7 +2045,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable} filterFn
+     * @param {import("../../interface.js").Injectable<any>} filterFn
      * @return {NgModule}
      */
     filter(name, filterFn) {
@@ -2052,7 +2058,7 @@
 
     /**
      * @param {string} name
-     * @param {import("../../interface.js").Injectable} ctlFn
+     * @param {import("../../interface.js").Injectable<any>} ctlFn
      * @returns {NgModule}
      */
     controller(name, ctlFn) {
@@ -2236,6 +2242,8 @@
         this.path.join(" <- "),
       );
     }
+
+    loadNewModules() {}
   }
 
   /**
@@ -2407,7 +2415,7 @@
     /**
      * Registers a provider.
      * @param {string} name
-     * @param {import('../../interface.ts').ServiceProvider | import('../../interface.ts').InjectableFactory} provider
+     * @param {import('../../interface.ts').ServiceProvider | import('../../interface.ts').Injectable<any>} provider
      * @returns {import('../../interface.ts').ServiceProvider}
      */
     function provider(name, provider) {
@@ -2926,7 +2934,7 @@
 
       /**
        * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
-       * @returns {Function} A service function that creates controllers.
+       * @returns {import("./interface.js").ControllerService} A service function that creates controllers.
        */
       ($injector) => {
         return (expression, locals, later, ident) => {
@@ -2937,7 +2945,7 @@
           later = later === true;
 
           if (isString(expression)) {
-            match = expression.match(CNTRL_REG);
+            match = /** @type {string} */ (expression).match(CNTRL_REG);
             if (!match) {
               throw $controllerMinErr(
                 "ctrlfmt",
@@ -2974,7 +2982,7 @@
                 locals,
                 identifier,
                 instance,
-                constructor || expression.name,
+                constructor || /** @type {any} */ (expression).name,
               );
             }
 
@@ -2997,7 +3005,7 @@
                     locals,
                     identifier,
                     instance,
-                    constructor || expression.name,
+                    constructor || /** @type {any} */ (expression).name,
                   );
                 }
               }
@@ -3006,14 +3014,18 @@
             }.bind(this, { instance, identifier });
           }
 
-          instance = $injector.instantiate(expression, locals, constructor);
+          instance = $injector.instantiate(
+            /** @type {any} */ (expression),
+            locals,
+            constructor,
+          );
 
           if (identifier) {
             this.addIdentifier(
               locals,
               identifier,
               instance,
-              constructor || expression.name,
+              constructor || /** @type {any} */ (expression).name,
             );
           }
 
@@ -3164,8 +3176,6 @@
     return url.replace(/#$/, "");
   }
 
-  /** @typedef {import("../exception/interface.ts").Interface }  ErrorHandler */
-
   const $sceMinErr = minErr("$sce");
 
   const SCE_CONTEXTS = {
@@ -3455,14 +3465,14 @@
       };
 
       this.$get = [
-        "$injector",
-        "$$sanitizeUri",
-        "$exceptionHandler",
+        $injectTokens.$injector,
+        $injectTokens.$$sanitizeUri,
+        $injectTokens.$exceptionHandler,
         /**
          *
-         * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
+         * @param {ng.InjectorService} $injector
          * @param {*} $$sanitizeUri
-         * @param {ErrorHandler} $exceptionHandler
+         * @param {ng.ExceptionHandlerService} $exceptionHandler
          * @returns
          */
         function ($injector, $$sanitizeUri, $exceptionHandler) {
@@ -3481,7 +3491,7 @@
 
           /**
            * @param {string|RegExp} matcher
-           * @param {import("../../shared/url-utils/interface").ParsedUrl} parsedUrl
+           * @param {import("../../shared/url-utils/interface.ts").ParsedUrl} parsedUrl
            * @return {boolean}
            */
           function matchUrl(matcher, parsedUrl) {
@@ -3736,9 +3746,15 @@
     };
 
     this.$get = [
-      "$parse",
-      "$sceDelegate",
-      function ($parse, $sceDelegate) {
+      $injectTokens.$parse,
+      $injectTokens.$sceDelegate,
+      /**
+       *
+       * @param {ng.ParseService} $parse
+       * @param $sceDelegate
+       * @return {*}
+       */
+      ($parse, $sceDelegate) => {
         const sce = shallowCopy(SCE_CONTEXTS);
 
         /**
@@ -3772,14 +3788,14 @@
          *
          * @param {string} type The SCE context in which this result will be used.
          * @param {string} expr String expression to compile.
-         * @return {function(context, locals)} A function which represents the compiled expression:
+         * @return {import("../../core/parse/interface.js").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).
          *    * `locals` – `{object=}` – local variables context object, useful for overriding values
          *      in `context`.
          */
-        sce.parseAs = function sceParseAs(type, expr) {
+        sce.parseAs = (type, expr) => {
           const parsed = $parse(expr);
           if (parsed.literal && parsed.constant) {
             return parsed;
@@ -4517,7 +4533,7 @@
   const DirectiveSuffix = "Directive";
 
   class CompileProvider {
-    /* @ignore */ static $inject = ["$provide", "$$sanitizeUriProvider"];
+    /* @ignore */ static $inject = [$injectTokens.$provide, $injectTokens.$$sanitizeUriProvider];
 
     /**
      * @param {import('../../interface.js').Provider} $provide
@@ -4711,7 +4727,7 @@
       /**
        * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
        *    or an object map of components where the keys are the names and the values are the component definition objects.
-       * @param {import("../../interface.js").ComponentOptions} options Component definition object (a simplified
+       * @param {import("../../interface.js").Component} options Component definition object (a simplified
        *    {directive definition object}),
        *    with the following properties (all optional):
        *
@@ -10625,7 +10641,7 @@
   scriptDirective.$inject = ["$templateCache"];
 
   /**
-   * @param {import('../../services/template-cache/interface.ts').TemplateCache} $templateCache
+   * @param {ng.TemplateCacheService} $templateCache
    * @returns {import('../../interface.ts').Directive}
    */
   function scriptDirective($templateCache) {
@@ -11642,9 +11658,9 @@
   /**
    *
    * @param {*} $templateRequest
-   * @param {import("../../services/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
+   * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
    * @param {*} $animate
-   * @param {import('../../services/exception/interface.ts').Interface} $exceptionHandler
+   * @param {import('../../services/exception/interface.ts').ErrorHandler} $exceptionHandler
    * @returns {import('../../interface.js').Directive}
    */
   function ngIncludeDirective(
@@ -13484,8 +13500,8 @@
       $injectTokens.$rootScope,
       /**
        *
-       * @param {import('../services/location/location.js').Location} $location
-       * @param {import('../core/scope/scope.js').Scope} $rootScope
+       * @param {import('../../services/location/location.js').Location} $location
+       * @param {import('../../core/scope/scope.js').Scope} $rootScope
        * @returns
        */
       function ($location, $rootScope) {
@@ -14032,7 +14048,7 @@
      * ```
      *
      * @param {string} name The name of the animation (this is what the class-based CSS value will be compared to).
-     * @param {import("../interface.ts").Injectable} factory The factory function that will be executed to return the animation
+     * @param {import("../interface.ts").Injectable<any>} factory The factory function that will be executed to return the animation
      *                           object.
      */
     this.register = function (name, factory) {
@@ -14700,11 +14716,11 @@
    */
   class TemplateCacheProvider {
     constructor() {
-      /** @type {import('./interface.ts').TemplateCache} */
+      /** @type {ng.TemplateCacheService} */
       this.cache = new Map();
     }
     /**
-     * @returns {import('./interface.ts').TemplateCache}
+     * @returns {ng.TemplateCacheService}
      */
     $get() {
       return this.cache;
@@ -14757,7 +14773,7 @@
 
   /** @typedef {import('../log/interface.ts').LogService} LogService */
 
-  /** @typedef {import("./interface.ts").Interface}  ErrorHandler */
+  /** @typedef {import("./interface.ts").ErrorHandler}  ErrorHandler */
 
   /**
    * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.
@@ -14788,7 +14804,7 @@
   }
 
   /**
-   * @returns {import('../interface.ts').FilterFn}
+   * @returns {ng.FilterFn}
    */
   function filterFilter() {
     /**
@@ -14992,7 +15008,7 @@
   }
 
   /**
-   * @returns {import('../interface.ts').FilterFn}
+   * @returns {ng.FilterFn}
    */
   function jsonFilter() {
     return function (object, spacing) {
@@ -15004,7 +15020,7 @@
   }
 
   /**
-   * @returns {import('../interface.ts').FilterFn}
+   * @returns {ng.FilterFn}
    */
   function limitToFilter() {
     /**
@@ -15054,7 +15070,7 @@
   orderByFilter.$inject = [$injectTokens.$parse];
 
   /**
-   * @returns {import('../interface.ts').FilterFn}
+   * @returns {ng.FilterFn}
    */
   function orderByFilter($parse) {
     return function (array, sortPredicate, reverseOrder, compareFn) {
@@ -15236,7 +15252,7 @@
    * ```
    *
    * @param {import('./state/state-service.js').StateProvider} $state
-   * @returns {import('../interface.ts').FilterFn}
+   * @returns {ng.FilterFn}
    */
   function $IsStateFilter($state) {
     const isFilter = (state, params, options) =>
@@ -15258,7 +15274,7 @@
    * ```
    *
    * @param {import('./state/state-service.js').StateProvider} $state
-   * @returns {import('../interface.ts').FilterFn}
+   * @returns {ng.FilterFn}
    */
   function $IncludedByStateFilter($state) {
     const includesFilter = function (state, params, options) {
@@ -15289,8 +15305,8 @@
     }
 
     /**
-     * @param {string|Record<string, import('../../interface.ts').FilterFactory>} name
-     * @param {import('../../interface.ts').FilterFactory} [factory]
+     * @param {string|Record<string, ng.FilterFn>} name
+     * @param {ng.FilterService} [factory]
      * @return {import('../../interface.ts').Provider}
      */
     register(name, factory) {
@@ -15306,7 +15322,7 @@
       $injectTokens.$injector,
       /**
        * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
-       * @returns {import('../../interface.ts').FilterFn}
+       * @returns {ng.FilterService}
        */
       ($injector) => (/** @type {string} */ name) => $injector.get(name + SUFFIX),
     ];
@@ -17568,13 +17584,13 @@
     }
 
     $get = [
-      "$parse",
-      "$sce",
+      $injectTokens.$parse,
+      $injectTokens.$sce,
       /**
        *
-       * @param {import("../parse/interface.ts").ParseService} $parse
+       * @param {ng.ParseService} $parse
        * @param {*} $sce
-       * @returns
+       * @returns {ng.InterpolateService}
        */
       function ($parse, $sce) {
         /** @type {InterpolateProvider} */
@@ -17823,7 +17839,7 @@
               return concat.join("");
             };
 
-            return extend(
+            return /**@type {import("./interface.js").InterpolationFunction}  */ extend(
               (context, cb) => {
                 let i = 0;
                 const ii = expressions.length;
@@ -17917,6 +17933,7 @@
           return provider.endSymbol;
         };
 
+        // @ts-ignore
         return $interpolate;
       },
     ];
@@ -17924,51 +17941,6 @@
 
   let lastCookies = {};
   let lastCookieString = "";
-
-  /**
-   * @returns {Object<String, String>} List of all cookies
-   */
-  function getCookies() {
-    let cookieArray;
-    let cookie;
-    let i;
-    let index;
-    let name;
-    const currentCookieString = document.cookie;
-
-    if (currentCookieString !== lastCookieString) {
-      lastCookieString = currentCookieString;
-      cookieArray = lastCookieString.split("; ");
-      lastCookies = {};
-
-      for (i = 0; i < cookieArray.length; i++) {
-        cookie = cookieArray[i];
-        index = cookie.indexOf("=");
-        if (index > 0) {
-          // ignore nameless cookies
-          name = safeDecodeURIComponent(cookie.substring(0, index));
-          // the first value that is seen for a cookie is the most
-          // specific one.  values for the same cookie name that
-          // follow are for less specific paths.
-          if (isUndefined(lastCookies[name])) {
-            lastCookies[name] = safeDecodeURIComponent(
-              cookie.substring(index + 1),
-            );
-          }
-        }
-      }
-    }
-    return lastCookies;
-  }
-
-  function safeDecodeURIComponent(str) {
-    try {
-      return decodeURIComponent(str);
-    } catch {
-      return str;
-    }
-  }
-
   const APPLICATION_JSON = "application/json";
   const CONTENT_TYPE_APPLICATION_JSON = {
     "Content-Type": `${APPLICATION_JSON};charset=utf-8`,
@@ -18000,8 +17972,12 @@
    * Note that serializer will sort the request parameters alphabetically.
    */
   function HttpParamSerializerProvider() {
-    this.$get = function () {
-      return function ngParamSerializer(params) {
+    /**
+     * @returns {import('./interface.ts').HttpParamSerializer}
+     * A function that serializes parameters into a query string.
+     */
+    this.$get = () => {
+      return (params) => {
         if (!params) return "";
         const parts = [];
         Object.keys(params)
@@ -18327,17 +18303,15 @@
     });
 
     this.$get = [
-      "$httpBackend",
-      "$injector",
-      "$sce",
+      $injectTokens.$injector,
+      $injectTokens.$sce,
       /**
        *
-       * @param {*} $httpBackend
        * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
        * @param {*} $sce
        * @returns
        */
-      function ($httpBackend, $injector, $sce) {
+      function ($injector, $sce) {
         /**
          * @type {Map<string, string>}
          */
@@ -18673,7 +18647,7 @@
          * Makes the request.
          *
          * !!! ACCESSES CLOSURE VARS:
-         * $httpBackend, defaults, $log, $rootScope, defaultCache, $http.pendingRequests
+         * defaults, $log, $rootScope, defaultCache, $http.pendingRequests
          */
         function sendReq(config, reqData) {
           const { promise, resolve, reject } = Promise.withResolvers();
@@ -18744,7 +18718,7 @@
                 xsrfValue;
             }
 
-            $httpBackend(
+            http(
               config.method,
               url,
               reqData,
@@ -18760,6 +18734,10 @@
 
           return promise;
 
+          /**
+           * @param eventHandlers
+           * @return {Record<string, EventListener>}
+           */
           function createApplyHandlers(eventHandlers) {
             if (eventHandlers) {
               const applyHandlers = {};
@@ -18776,12 +18754,14 @@
                   }
                 };
               });
-              return applyHandlers;
+              return /** @type {Record<string, EventListener>} */ (applyHandlers);
+            } else {
+              return {};
             }
           }
 
           /**
-           * Callback registered to $httpBackend():
+           * Callback registered to http():
            *  - caches the response if desired
            *  - resolves the raw $http promise
            *  - calls $apply
@@ -18869,159 +18849,177 @@
   }
 
   /**
-   * HTTP backend used by the `$http` that delegates to
-   * XMLHttpRequest object and deals with browser incompatibilities.
-   * You should never need to use this service directly.
-   */
-  class HttpBackendProvider {
-    constructor() {
-      this.$get = () => createHttpBackend();
-    }
-  }
-
-  /**
-   * @returns
+   * Makes an HTTP request using XMLHttpRequest with flexible options.
+   *
+   * @param {string} method - The HTTP method (e.g., "GET", "POST").
+   * @param {string} [url] - The URL to send the request to. Defaults to the current page URL.
+   * @param {*} [post] - The body to send with the request, if any.
+   * @param {function(number, any, string|null, string, string): void} [callback] - Callback invoked when the request completes.
+   * @param {Object<string, string|undefined>} [headers] - Headers to set on the request.
+   * @param {number|Promise<any>} [timeout] - Timeout in ms or a cancellable promise.
+   * @param {boolean} [withCredentials] - Whether to send credentials with the request.
+   * @param {XMLHttpRequestResponseType} [responseType] - The type of data expected in the response.
+   * @param {Record<string, EventListener>} [eventHandlers] - Event listeners for the XMLHttpRequest object.
+   * @param {Record<string, EventListener>} [uploadEventHandlers] - Event listeners for the XMLHttpRequest.upload object.
+   * @returns {void}
    */
-  function createHttpBackend() {
-    /**
-     * Makes an HTTP request using XMLHttpRequest with flexible options.
-     *
-     * @param {string} method - The HTTP method (e.g., "GET", "POST").
-     * @param {string} [url] - The URL to send the request to. Defaults to the current page URL.
-     * @param {*} [post] - The body to send with the request, if any.
-     * @param {function(number, any, string|null, string, string): void} [callback] - Callback invoked when the request completes.
-     * @param {Object<string, string|undefined>} [headers] - Headers to set on the request.
-     * @param {number|Promise<any>} [timeout] - Timeout in ms or a cancellable promise.
-     * @param {boolean} [withCredentials] - Whether to send credentials with the request.
-     * @param {XMLHttpRequestResponseType} [responseType] - The type of data expected in the response.
-     * @param {Object<string, EventListener>} [eventHandlers] - Event listeners for the XMLHttpRequest object.
-     * @param {Object<string, EventListener>} [uploadEventHandlers] - Event listeners for the XMLHttpRequest.upload object.
-     * @returns {void}
-     */
-    return function (
-      method,
-      url,
-      post,
-      callback,
-      headers,
-      timeout,
-      withCredentials,
-      responseType,
-      eventHandlers,
-      uploadEventHandlers,
-    ) {
-      url = url || trimEmptyHash(window.location.href);
+  function http(
+    method,
+    url,
+    post,
+    callback,
+    headers,
+    timeout,
+    withCredentials,
+    responseType,
+    eventHandlers,
+    uploadEventHandlers,
+  ) {
+    url = url || trimEmptyHash(window.location.href);
 
-      const xhr = new XMLHttpRequest();
-      let abortedByTimeout = false;
-      let timeoutId;
+    const xhr = new XMLHttpRequest();
+    let abortedByTimeout = false;
+    let timeoutId;
 
-      xhr.open(method, url, true);
+    xhr.open(method, url, true);
 
-      if (headers) {
-        for (const [key, value] of Object.entries(headers)) {
-          if (isDefined(value)) {
-            xhr.setRequestHeader(key, value);
-          }
+    if (headers) {
+      for (const [key, value] of Object.entries(headers)) {
+        if (isDefined(value)) {
+          xhr.setRequestHeader(key, value);
         }
       }
+    }
 
-      xhr.onload = () => {
-        let status = xhr.status || 0;
-        const statusText = xhr.statusText || "";
+    xhr.onload = () => {
+      let status = xhr.status || 0;
+      const statusText = xhr.statusText || "";
 
-        if (status === 0) {
-          status = xhr.response
-            ? 200
-            : new URL(url).protocol === "file:"
-              ? 404
-              : 0;
-        }
+      if (status === 0) {
+        status = xhr.response ? 200 : new URL(url).protocol === "file:" ? 404 : 0;
+      }
 
-        completeRequest(
-          status,
-          xhr.response,
-          xhr.getAllResponseHeaders(),
-          statusText,
-          "complete",
-        );
-      };
+      completeRequest(
+        status,
+        xhr.response,
+        xhr.getAllResponseHeaders(),
+        statusText,
+        "complete",
+      );
+    };
 
-      xhr.onerror = () => completeRequest(-1, null, null, "", "error");
-      xhr.ontimeout = () => completeRequest(-1, null, null, "", "timeout");
+    xhr.onerror = () => completeRequest(-1, null, null, "", "error");
+    xhr.ontimeout = () => completeRequest(-1, null, null, "", "timeout");
 
-      xhr.onabort = () => {
-        completeRequest(
-          -1,
-          null,
-          null,
-          "",
-          abortedByTimeout ? "timeout" : "abort",
-        );
-      };
+    xhr.onabort = () => {
+      completeRequest(-1, null, null, "", abortedByTimeout ? "timeout" : "abort");
+    };
 
-      if (eventHandlers) {
-        for (const [key, handler] of Object.entries(eventHandlers)) {
-          xhr.addEventListener(key, handler);
-        }
+    if (eventHandlers) {
+      for (const [key, handler] of Object.entries(eventHandlers)) {
+        xhr.addEventListener(key, handler);
       }
+    }
 
-      if (uploadEventHandlers) {
-        for (const [key, handler] of Object.entries(uploadEventHandlers)) {
-          xhr.upload.addEventListener(key, handler);
-        }
+    if (uploadEventHandlers) {
+      for (const [key, handler] of Object.entries(uploadEventHandlers)) {
+        xhr.upload.addEventListener(key, handler);
       }
+    }
 
-      if (withCredentials) {
-        xhr.withCredentials = true;
-      }
+    if (withCredentials) {
+      xhr.withCredentials = true;
+    }
 
-      if (responseType) {
-        try {
-          xhr.responseType = responseType;
-        } catch (e) {
-          if (responseType !== "json") throw e;
-        }
+    if (responseType) {
+      try {
+        xhr.responseType = responseType;
+      } catch (e) {
+        if (responseType !== "json") throw e;
       }
+    }
 
-      xhr.send(isUndefined(post) ? null : post);
+    xhr.send(isUndefined(post) ? null : post);
 
-      if (typeof timeout === "number" && timeout > 0) {
-        timeoutId = setTimeout(() => timeoutRequest("timeout"), timeout);
-      } else if (isPromiseLike(timeout)) {
-        /** @type {Promise} */ (timeout).then(() => {
-          timeoutRequest(isDefined(timeout["$$timeoutId"]) ? "timeout" : "abort");
-        });
-      }
+    if (typeof timeout === "number" && timeout > 0) {
+      timeoutId = setTimeout(() => timeoutRequest("timeout"), timeout);
+    } else if (isPromiseLike(timeout)) {
+      /** @type {Promise} */ (timeout).then(() => {
+        timeoutRequest(isDefined(timeout["$$timeoutId"]) ? "timeout" : "abort");
+      });
+    }
 
-      /**
-       * @param {"timeout"|"abort"} reason
-       */
-      function timeoutRequest(reason) {
-        abortedByTimeout = reason === "timeout";
-        if (xhr) xhr.abort();
+    /**
+     * @param {"timeout"|"abort"} reason
+     */
+    function timeoutRequest(reason) {
+      abortedByTimeout = reason === "timeout";
+      if (xhr) xhr.abort();
+    }
+
+    /**
+     * @param {number} status - HTTP status code or -1 for network errors.
+     * @param {*} response - The parsed or raw response from the server.
+     * @param {string|null} headersString - The raw response headers as a string.
+     * @param {string} statusText - The status text returned by the server.
+     * @param {"complete"|"error"|"timeout"|"abort"} xhrStatus - Final status of the request.
+     */
+    function completeRequest(
+      status,
+      response,
+      headersString,
+      statusText,
+      xhrStatus,
+    ) {
+      if (isDefined(timeoutId)) {
+        clearTimeout(timeoutId);
       }
+      callback(status, response, headersString, statusText, xhrStatus);
+    }
+  }
 
-      /**
-       * @param {number} status - HTTP status code or -1 for network errors.
-       * @param {*} response - The parsed or raw response from the server.
-       * @param {string|null} headersString - The raw response headers as a string.
-       * @param {string} statusText - The status text returned by the server.
-       * @param {"complete"|"error"|"timeout"|"abort"} xhrStatus - Final status of the request.
-       */
-      function completeRequest(
-        status,
-        response,
-        headersString,
-        statusText,
-        xhrStatus,
-      ) {
-        if (isDefined(timeoutId)) {
-          clearTimeout(timeoutId);
+  /**
+   * @returns {Object<String, String>} List of all cookies
+   */
+  function getCookies() {
+    let cookieArray;
+    let cookie;
+    let i;
+    let index;
+    let name;
+    const currentCookieString = document.cookie;
+
+    if (currentCookieString !== lastCookieString) {
+      lastCookieString = currentCookieString;
+      cookieArray = lastCookieString.split("; ");
+      lastCookies = {};
+
+      for (i = 0; i < cookieArray.length; i++) {
+        cookie = cookieArray[i];
+        index = cookie.indexOf("=");
+        if (index > 0) {
+          // ignore nameless cookies
+          name = safeDecodeURIComponent(cookie.substring(0, index));
+          // the first value that is seen for a cookie is the most
+          // specific one.  values for the same cookie name that
+          // follow are for less specific paths.
+          if (isUndefined(lastCookies[name])) {
+            lastCookies[name] = safeDecodeURIComponent(
+              cookie.substring(index + 1),
+            );
+          }
         }
-        callback(status, response, headersString, statusText, xhrStatus);
       }
-    };
+    }
+    return lastCookies;
+  }
+
+  function safeDecodeURIComponent(str) {
+    try {
+      return decodeURIComponent(str);
+    } catch {
+      return str;
+    }
   }
 
   const PATH_MATCH = /^([^?#]*)(\?([^#]*))?(#(.*))?$/;
@@ -19532,7 +19530,7 @@
       $injectTokens.$rootElement,
       /**
        *
-       * @param {import('../../core/scope/scope.js').Scope} $rootScope
+       * @param {ng.Scope} $rootScope
        * @param {Element} $rootElement
        * @returns {Location}
        */
@@ -20098,7 +20096,7 @@
   }
 
   /**
-   * @type {import('../parse/interface.ts').ParseService}
+   * @type {ng.ParseService}
    */
   let $parse;
 
@@ -21197,6 +21195,9 @@
       return this.$root == /** @type {Scope} */ (this);
     }
 
+    /**
+     * @param {Function} fn
+     */
     $postUpdate(fn) {
       $postUpdateQueue.push(fn);
     }
@@ -21379,11 +21380,11 @@
       "$sce",
       /**
        *
-       * @param {import('./exception/exception-handler.js').ErrorHandler} $exceptionHandler
-       * @param {import('../services/template-cache/interface.ts').TemplateCache} $templateCache
-       * @param {import("interface.ts").HttpService} $http
+       * @param {ng.ExceptionHandlerService} $exceptionHandler
+       * @param {ng.TemplateCacheService} $templateCache
+       * @param {ng.HttpService} $http
        * @param {*} $sce
-       * @returns
+       * @returns {ng.TemplateRequestService}
        */
       function ($exceptionHandler, $templateCache, $http, $sce) {
         function handleRequestFn(tpl, ignoreRequestError) {
@@ -24361,14 +24362,14 @@
     }
 
     this.$get = [
-      "$rootScope",
-      "$injector",
-      "$$AnimateRunner",
-      "$$rAFScheduler",
-      "$$animateCache",
+      $injectTokens.$rootScope,
+      $injectTokens.$injector,
+      $injectTokens.$$AnimateRunner,
+      $injectTokens.$$rAFScheduler,
+      $injectTokens.$$animateCache,
       /**
        *
-       * @param {*} $rootScope
+       * @param {ng.RootScopeService} $rootScope
        * @param {import("../core/di/internal-injector").InjectorService} $injector
        * @param {*} $$AnimateRunner
        * @param {import("./raf-scheduler").RafScheduler} $$rAFScheduler
@@ -24534,7 +24535,6 @@
           // block. This way we can group animations for all the animations that
           // were apart of the same postDigest flush call.
           if (animationQueue.length > 1) return runner;
-
           $rootScope.$postUpdate(() => {
             const animations = [];
             animationQueue.forEach((entry) => {
@@ -25424,158 +25424,6 @@
     };
   }
 
-  /**
-   * Returns a new function for [Partial Application](https://en.wikipedia.org/wiki/Partial_application) of the original function.
-   *
-   * Given a function with N parameters, returns a new function that supports partial application.
-   * The new function accepts anywhere from 1 to N parameters.  When that function is called with M parameters,
-   * where M is less than N, it returns a new function that accepts the remaining parameters.  It continues to
-   * accept more parameters until all N parameters have been supplied.
-   *
-   *
-   * This contrived example uses a partially applied function as an predicate, which returns true
-   * if an object is found in both arrays.
-   * @example
-   * ```
-   * // returns true if an object is in both of the two arrays
-   * function inBoth(array1, array2, object) {
-   *   return array1.indexOf(object) !== -1 &&
-   *          array2.indexOf(object) !== 1;
-   * }
-   * let obj1, obj2, obj3, obj4, obj5, obj6, obj7
-   * let foos = [obj1, obj3]
-   * let bars = [obj3, obj4, obj5]
-   *
-   * // A curried "copy" of inBoth
-   * let curriedInBoth = curry(inBoth);
-   * // Partially apply both the array1 and array2
-   * let inFoosAndBars = curriedInBoth(foos, bars);
-   *
-   * // Supply the final argument; since all arguments are
-   * // supplied, the original inBoth function is then called.
-   * let obj1InBoth = inFoosAndBars(obj1); // false
-   *
-   * // Use the inFoosAndBars as a predicate.
-   * // Filter, on each iteration, supplies the final argument
-   * let allObjs = [ obj1, obj2, obj3, obj4, obj5, obj6, obj7 ];
-   * let foundInBoth = allObjs.filter(inFoosAndBars); // [ obj3 ]
-   *
-   * ```
-   *
-   * @param fn
-   * @returns {*|function(): (*|any)}
-   */
-  function curry(fn) {
-    return function curried() {
-      if (arguments.length >= fn.length) {
-        return fn.apply(this, arguments);
-      }
-      const args = Array.prototype.slice.call(arguments);
-      return curried.bind(this, ...args);
-    };
-  }
-  /**
-   * Given a varargs list of functions, returns a function that composes the argument functions, right-to-left
-   * given: f(x), g(x), h(x)
-   * let composed = compose(f,g,h)
-   * then, composed is: f(g(h(x)))
-   */
-  function compose() {
-    const args = arguments;
-    const start = args.length - 1;
-    return function () {
-      let i = start,
-        result = args[start].apply(this, arguments);
-      while (i--) result = args[i].call(this, result);
-      return result;
-    };
-  }
-  /**
-   * Given a varargs list of functions, returns a function that is composes the argument functions, left-to-right
-   * given: f(x), g(x), h(x)
-   * let piped = pipe(f,g,h);
-   * then, piped is: h(g(f(x)))
-   */
-  function pipe() {
-    return compose.apply(null, [].slice.call(arguments).reverse());
-  }
-
-  /**
-   * Given a property name and a value, returns a function that returns a boolean based on whether
-   * the passed object has a property that matches the value
-   * let obj = { foo: 1, name: "blarg" };
-   * let getName = propEq("name", "blarg");
-   * getName(obj) === true
-   */
-  const propEq = curry((name, _val, obj) => obj && obj[name] === _val);
-  /**
-   * Given a dotted property name, returns a function that returns a nested property from an object, or undefined
-   * let obj = { id: 1, nestedObj: { foo: 1, name: "blarg" }, };
-   * let getName = prop("nestedObj.name");
-   * getName(obj) === "blarg"
-   * let propNotFound = prop("this.property.doesnt.exist");
-   * propNotFound(obj) === undefined
-   */
-  const parse = (name) =>
-    pipe.apply(
-      null,
-      name.split(".").map((name) => (obj) => obj && obj[name]),
-    );
-
-  /** Given a class, returns a Predicate function that returns true if the object is of that class */
-  const is = (ctor) => (obj) =>
-    (obj != null && obj.constructor === ctor) || obj instanceof ctor;
-
-  /** Given a value, returns a function which returns the value */
-  const val = (v) => () => v;
-  /**
-   * Sorta like Pattern Matching (a functional programming conditional construct)
-   *
-   * See http://c2.com/cgi/wiki?PatternMatching
-   *
-   * This is a conditional construct which allows a series of predicates and output functions
-   * to be checked and then applied.  Each predicate receives the input.  If the predicate
-   * returns truthy, then its matching output function (mapping function) is provided with
-   * the input and, then the result is returned.
-   *
-   * Each combination (2-tuple) of predicate + output function should be placed in an array
-   * of size 2: [ predicate, mapFn ]
-   *
-   * These 2-tuples should be put in an outer array.
-   *
-   * @example
-   * ```
-   *
-   * // Here's a 2-tuple where the first element is the isString predicate
-   * // and the second element is a function that returns a description of the input
-   * let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];
-   *
-   * // Second tuple: predicate "isNumber", mapfn returns a description
-   * let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];
-   *
-   * let third = [ (input) => input === null,  (input) => `Oh, null...` ];
-   *
-   * let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];
-   *
-   * let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);
-   *
-   * console.log(descriptionOf(undefined)); // 'notdefined'
-   * console.log(descriptionOf(55)); // '(55) That's a number!'
-   * console.log(descriptionOf("foo")); // 'Here's your string foo'
-   * ```
-   *
-   * @param struct A 2D array.  Each element of the array should be an array, a 2-tuple,
-   * with a Predicate and a mapping/output function
-   * @returns {function(any): *}
-   */
-  function pattern(struct) {
-    return function (x) {
-      for (let i = 0; i < struct.length; i++) {
-        if (struct[i][0](x)) return struct[i][1](x);
-      }
-    };
-  }
-
   function equals(o1, o2) {
     if (o1 === o2) return true;
     if (o1 === null || o2 === null) return false;
@@ -25602,81 +25450,7 @@
     }
     return true;
   }
-  /**
-   * Builds proxy functions on the `to` object which pass through to the `from` object.
-   *
-   * For each key in `fnNames`, creates a proxy function on the `to` object.
-   * The proxy function calls the real function on the `from` object.
-   *
-   *
-   * #### Example:
-   * This example creates an new class instance whose functions are prebound to the new'd object.
-   * ```js
-   * class Foo {
-   *   constructor(data) {
-   *     // Binds all functions from Foo.prototype to 'this',
-   *     // then copies them to 'this'
-   *     bindFunctions(Foo.prototype, this, this);
-   *     this.data = data;
-   *   }
-   *
-   *   log() {
-   *     console.log(this.data);
-   *   }
-   * }
-   *
-   * let myFoo = new Foo([1,2,3]);
-   * var logit = myFoo.log;
-   * logit(); // logs [1, 2, 3] from the myFoo 'this' instance
-   * ```
-   *
-   * #### Example:
-   * This example creates a bound version of a service function, and copies it to another object
-   * ```
-   *
-   * var SomeService = {
-   *   this.data = [3, 4, 5];
-   *   this.log = function() {
-   *     console.log(this.data);
-   *   }
-   * }
-   *
-   * // Constructor fn
-   * function OtherThing() {
-   *   // Binds all functions from SomeService to SomeService,
-   *   // then copies them to 'this'
-   *   bindFunctions(SomeService, this, SomeService);
-   * }
-   *
-   * let myOtherThing = new OtherThing();
-   * myOtherThing.log(); // logs [3, 4, 5] from SomeService's 'this'
-   * ```
-   *
-   * @param source A function that returns the source object which contains the original functions to be bound
-   * @param target A function that returns the target object which will receive the bound functions
-   * @param bind A function that returns the object which the functions will be bound to
-   * @param fnNames The function names which will be bound (Defaults to all the functions found on the 'from' object)
-   * @param latebind If true, the binding of the function is delayed until the first time it's invoked
-   */
-  function createProxyFunctions(
-    source,
-    target,
-    bind,
-    fnNames,
-    latebind = false,
-  ) {
-    const bindFunction = (fnName) => source()[fnName].bind(bind());
-    const makeLateRebindFn = (fnName) =>
-      function lateRebindFunction() {
-        target[fnName] = bindFunction(fnName);
-        return target[fnName].apply(null, arguments);
-      };
-    fnNames = fnNames || Object.keys(source());
-    return fnNames.reduce((acc, name) => {
-      acc[name] = latebind ? makeLateRebindFn(name) : bindFunction(name);
-      return acc;
-    }, target);
-  }
+
   /**
    * prototypal inheritance helper.
    * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it
@@ -25701,11 +25475,13 @@
   /**
    * Given an array, and an item, if the item is found in the array, it removes it (in-place).
    * The same array is returned
+   * @param {Array} array
+   * @param {any} obj
+   * @returns {Array}
    */
-  const removeFrom = curry(_removeFrom);
-  function _removeFrom(array, obj) {
-    const idx = array.indexOf(obj);
-    if (idx >= 0) array.splice(idx, 1);
+  function removeFrom(array, obj) {
+    const i = array.indexOf(obj);
+    if (i !== -1) array.splice(i, 1);
     return array;
   }
 
@@ -25988,6 +25764,148 @@
   const silentRejection = (error) =>
     silenceUncaughtInPromise(Promise.reject(error));
 
+  /**
+   * Returns a new function for [Partial Application](https://en.wikipedia.org/wiki/Partial_application) of the original function.
+   *
+   * Given a function with N parameters, returns a new function that supports partial application.
+   * The new function accepts anywhere from 1 to N parameters.  When that function is called with M parameters,
+   * where M is less than N, it returns a new function that accepts the remaining parameters.  It continues to
+   * accept more parameters until all N parameters have been supplied.
+   *
+   *
+   * This contrived example uses a partially applied function as an predicate, which returns true
+   * if an object is found in both arrays.
+   * @example
+   * ```
+   * // returns true if an object is in both of the two arrays
+   * function inBoth(array1, array2, object) {
+   *   return array1.indexOf(object) !== -1 &&
+   *          array2.indexOf(object) !== 1;
+   * }
+   * let obj1, obj2, obj3, obj4, obj5, obj6, obj7
+   * let foos = [obj1, obj3]
+   * let bars = [obj3, obj4, obj5]
+   *
+   * // A curried "copy" of inBoth
+   * let curriedInBoth = curry(inBoth);
+   * // Partially apply both the array1 and array2
+   * let inFoosAndBars = curriedInBoth(foos, bars);
+   *
+   * // Supply the final argument; since all arguments are
+   * // supplied, the original inBoth function is then called.
+   * let obj1InBoth = inFoosAndBars(obj1); // false
+   *
+   * // Use the inFoosAndBars as a predicate.
+   * // Filter, on each iteration, supplies the final argument
+   * let allObjs = [ obj1, obj2, obj3, obj4, obj5, obj6, obj7 ];
+   * let foundInBoth = allObjs.filter(inFoosAndBars); // [ obj3 ]
+   *
+   * ```
+   *
+   * @param fn
+   * @returns {*|function(): (*|any)}
+   */
+  function curry(fn) {
+    return function curried() {
+      if (arguments.length >= fn.length) {
+        return fn.apply(this, arguments);
+      }
+      const args = Array.prototype.slice.call(arguments);
+      return curried.bind(this, ...args);
+    };
+  }
+
+  /**
+   * Given a property name and a value, returns a function that returns a boolean based on whether
+   * the passed object has a property that matches the value
+   * let obj = { foo: 1, name: "blarg" };
+   * let getName = propEq("name", "blarg");
+   * getName(obj) === true
+   */
+  const propEq = curry((name, _val, obj) => obj && obj[name] === _val);
+  /**
+   * Given a dotted property name, returns a function that returns a nested property from an object, or undefined
+   * let obj = { id: 1, nestedObj: { foo: 1, name: "blarg" }, };
+   * let getName = prop("nestedObj.name");
+   * getName(obj) === "blarg"
+   * let propNotFound = prop("this.property.doesnt.exist");
+   * propNotFound(obj) === undefined
+   */
+  const parse = (path) => {
+    const parts = path.split(".");
+    return (obj) => parts.reduce((acc, key) => acc && acc[key], obj);
+  };
+
+  /**
+   * Given a class constructor, returns a predicate function that checks
+   * whether a given object is an instance of that class.
+   *
+   * @param {new (...args: any[]) => any} ctor - The class constructor to check against.
+   * @returns {(obj: any) => boolean} A predicate function that returns true if the object is of the given class.
+   */
+  function is(ctor) {
+    /**
+     * Checks if the provided object is an instance of the given constructor.
+     *
+     * @param {any} obj - The object to test.
+     * @returns {boolean} True if the object is an instance of the given class.
+     */
+    return function (obj) {
+      return (obj != null && obj.constructor === ctor) || obj instanceof ctor;
+    };
+  }
+
+  /** Given a value, returns a function which returns the value */
+  const val = (v) => () => v;
+
+  /**
+   * Sorta like Pattern Matching (a functional programming conditional construct)
+   *
+   * See http://c2.com/cgi/wiki?PatternMatching
+   *
+   * This is a conditional construct which allows a series of predicates and output functions
+   * to be checked and then applied.  Each predicate receives the input.  If the predicate
+   * returns truthy, then its matching output function (mapping function) is provided with
+   * the input and, then the result is returned.
+   *
+   * Each combination (2-tuple) of predicate + output function should be placed in an array
+   * of size 2: [ predicate, mapFn ]
+   *
+   * These 2-tuples should be put in an outer array.
+   *
+   * @example
+   * ```
+   *
+   * // Here's a 2-tuple where the first element is the isString predicate
+   * // and the second element is a function that returns a description of the input
+   * let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];
+   *
+   * // Second tuple: predicate "isNumber", mapfn returns a description
+   * let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];
+   *
+   * let third = [ (input) => input === null,  (input) => `Oh, null...` ];
+   *
+   * let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];
+   *
+   * let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);
+   *
+   * console.log(descriptionOf(undefined)); // 'notdefined'
+   * console.log(descriptionOf(55)); // '(55) That's a number!'
+   * console.log(descriptionOf("foo")); // 'Here's your string foo'
+   * ```
+   *
+   * @param struct A 2D array.  Each element of the array should be an array, a 2-tuple,
+   * with a Predicate and a mapping/output function
+   * @returns {function(any): *}
+   */
+  function pattern(struct) {
+    return function (x) {
+      for (let i = 0; i < struct.length; i++) {
+        if (struct[i][0](x)) return struct[i][1](x);
+      }
+    };
+  }
+
   /**
    * An internal class which implements [[ParamTypeDefinition]].
    *
@@ -28182,23 +28100,11 @@
     constructor() {
       this._ngViews = [];
       this._viewConfigs = [];
-      this._viewConfigFactories = {};
       this._listeners = [];
-      this._pluginapi = {
-        _registeredUIView: (id) => {
-          return find(this._ngViews, (view) => view.id === id);
-        },
-        _registeredUIViews: () => this._ngViews,
-        _activeViewConfigs: () => this._viewConfigs,
-        _onSync: (listener) => {
-          this._listeners.push(listener);
-          return () => removeFrom(this._listeners, listener);
-        },
-      };
       this.viewConfigFactory(getViewConfigFactory());
     }
 
-    $get = [() => this];
+    $get = () => this;
 
     /**
      * @param {?import('../state/state-object.js').StateObject} context
@@ -28336,7 +28242,7 @@
           return;
         }
         trace.traceViewServiceUIViewEvent("<- Deregistering", ngView);
-        removeFrom(ngViews)(ngView);
+        removeFrom(ngViews, ngView);
       };
     }
     /**
@@ -29248,6 +29154,14 @@
    * The registration data for a registered transition hook
    */
   class RegisteredHook {
+    /**
+     * @param {import("./transition-service.js").TransitionProvider} tranSvc
+     * @param eventType
+     * @param callback
+     * @param matchCriteria
+     * @param removeHookFromRegistry
+     * @param options
+     */
     constructor(
       tranSvc,
       eventType,
@@ -29256,6 +29170,7 @@
       removeHookFromRegistry,
       options = {},
     ) {
+      /** @type {import("./transition-service.js").TransitionProvider} */
       this.tranSvc = tranSvc;
       this.eventType = eventType;
       this.callback = callback;
@@ -29304,7 +29219,7 @@
      * }
      */
     _getDefaultMatchCriteria() {
-      return map(this.tranSvc._pluginapi._getPathTypes(), () => true);
+      return map(this.tranSvc._getPathTypes(), () => true);
     }
     /**
      * Gets matching nodes as [[IMatchingNodes]]
@@ -29326,7 +29241,7 @@
         this._getDefaultMatchCriteria(),
         this.matchCriteria,
       );
-      const paths = Object.values(this.tranSvc._pluginapi._getPathTypes());
+      const paths = Object.values(this.tranSvc._getPathTypes());
       return paths.reduce((mn, pathtype) => {
         // STATE scope criteria matches against every node in the path.
         // TRANSITION scope criteria matches against only the last node in the path
@@ -29364,7 +29279,7 @@
     const _registeredHooks = (registry._registeredHooks =
       registry._registeredHooks || {});
     const hooks = (_registeredHooks[eventType.name] = []);
-    const removeHookFn = removeFrom(hooks);
+    const removeHookFn = (x) => removeFrom(hooks, x);
     // Create hook registration function on the IHookRegistry for the event
     registry[eventType.name] = hookRegistrationFn;
     function hookRegistrationFn(matchObject, callback, options = {}) {
@@ -29396,6 +29311,9 @@
    * in the Transition class, so we must also provide the Transition's _treeChanges)
    */
   class HookBuilder {
+    /**
+     * @param {import("./transition.js").Transition} transition
+     */
     constructor(transition) {
       this.transition = transition;
     }
@@ -29405,7 +29323,7 @@
      * @returns
      */
     buildHooksForPhase(phase) {
-      return this.transition.transitionService._pluginapi
+      return this.transition.transitionService
         ._getEvents(phase)
         .map((type) => this.buildHooks(type))
         .reduce(unnestR, [])
@@ -29593,7 +29511,7 @@
      * (which can then be used to register hooks)
      */
     createTransitionHookRegFns() {
-      this.transitionService._pluginapi
+      this.transitionService
         ._getEvents()
         .filter((type) => type.hookPhase !== TransitionHookPhase.CREATE)
         .forEach((type) => makeEvent(this, this.transitionService, type));
@@ -30008,6 +29926,7 @@
       )
         return "SameAsCurrent";
     }
+
     /**
      * Runs the transition
      *
@@ -30015,7 +29934,7 @@
      *
      * @internal
      *
-     * @returns a promise for a successful transition.
+     * @returns {Promise} a promise for a successful transition.
      */
     run() {
       // Gets transition hooks array for the given phase
@@ -30652,13 +30571,6 @@
       this.globals = globals;
       this.$view = viewService;
       this._deregisterHookFns = {};
-      this._pluginapi = createProxyFunctions(val(this), {}, val(this), [
-        "_definePathType",
-        "_defineEvent",
-        "_getPathTypes",
-        "_getEvents",
-        "getHooks",
-      ]);
       this._defineCorePaths();
       this._defineCoreEvents();
       this._registerCoreTransitionHooks();
@@ -30816,6 +30728,10 @@
       makeEvent(this, this, eventType);
     }
 
+    /**
+     * @param {TransitionHookPhase} [phase]
+     * @return {any[]}
+     */
     _getEvents(phase) {
       const transitionHookTypes = isDefined(phase)
         ? this._eventTypes.filter((type) => type.hookPhase === phase)
@@ -30907,7 +30823,7 @@
       return this.globals.$current;
     }
 
-    static $inject = ["$routerProvider", "$transitionsProvider"];
+    /* @ignore */ static $inject = ["$routerProvider", "$transitionsProvider"];
 
     /**
      *
@@ -30932,16 +30848,6 @@
           throw new Error($error$);
         }
       };
-      const getters = ["current", "$current", "params", "transition"];
-      const boundFns = Object.keys(StateProvider.prototype).filter(
-        (x) => !getters.includes(x),
-      );
-      createProxyFunctions(
-        val(StateProvider.prototype),
-        this,
-        val(this),
-        boundFns,
-      );
 
       EventBus.subscribe("$stateService:defaultErrorHandler", (err) =>
         this.defaultErrorHandler()(err),
@@ -31141,7 +31047,7 @@
     onInvalid(callback) {
       this.invalidCallbacks.push(callback);
       return function deregisterListener() {
-        removeFrom(this.invalidCallbacks)(callback);
+        removeFrom(this.invalidCallbacks, callback);
       }.bind(this);
     }
     /**
@@ -31566,8 +31472,8 @@
     $get = [
       $injectTokens.$anchorScroll,
       /**
-       * @param {import('../services/anchor-scroll.js').AnchorScrollObject} $anchorScroll
-       * @returns {import('../services/anchor-scroll.js').AnchorScrollObject|Function}
+       * @param {import('../services/anchor-scroll/anchor-scroll.js').AnchorScrollObject} $anchorScroll
+       * @returns {import('../services/anchor-scroll/anchor-scroll.js').AnchorScrollObject|Function}
        */
       ($anchorScroll) => {
         if (this.enabled) {
@@ -31607,8 +31513,8 @@
       $injectTokens.$templateRequest,
       $injectTokens.$injector,
       /**
-       * @param {import("interface.ts").HttpService} $http
-       * @param {import("../services/template-cache/interface.ts").TemplateCache} $templateCache
+       * @param {ng.HttpService} $http
+       * @param {ng.TemplateCacheService} $templateCache
        * @param {any} $templateRequest
        * @param {import("../core/di/internal-injector.js").InjectorService} $injector
        * @returns
@@ -31720,7 +31626,7 @@
     /**
      * Creates a template by invoking an injectable provider function.
      *
-     * @param {import('../interface.ts').Injectable} provider Function to invoke via `locals`
+     * @param {import('../interface.ts').Injectable<any>} provider Function to invoke via `locals`
      * @param {Function} params a function used to invoke the template provider
      * @param {import("./resolve/resolve-context.js").ResolveContext} context
      * @return {string|Promise.<string>} The template html as a string, or a promise
@@ -31735,7 +31641,7 @@
     /**
      * Creates a component's template by invoking an injectable provider function.
      *
-     * @param {import('../interface.ts').Injectable} provider Function to invoke via `locals`
+     * @param {import('../interface.ts').Injectable<any>} provider Function to invoke via `locals`
      * @return {Promise<any>} The template html as a string: "<component-name input1='::$resolve.foo'></component-name>".
      */
     fromComponentProvider(provider, context) {
@@ -33051,7 +32957,7 @@
    * API for URL management
    */
   class UrlService {
-    static $inject = provider([
+    /* @ignore */ static $inject = provider([
       $injectTokens.$location,
       $injectTokens.$state,
       $injectTokens.$router,
@@ -33232,7 +33138,7 @@
      */
     onChange(callback) {
       this._urlListeners.push(callback);
-      return () => removeFrom(this._urlListeners)(callback);
+      return () => removeFrom(this._urlListeners, callback);
     }
 
     /**
@@ -33738,12 +33644,12 @@
     ]);
     const tuple2Resolvable = pattern([
       [
-        pipe((x) => x.val, isString),
+        (x) => isString(x.val),
         (tuple) =>
           new Resolvable(tuple.token, (x) => x, [tuple.val], tuple.policy),
       ],
       [
-        pipe((x) => x.val, Array.isArray),
+        (x) => Array.isArray(x.val),
         (tuple) =>
           new Resolvable(
             tuple.token,
@@ -33753,7 +33659,7 @@
           ),
       ],
       [
-        pipe((x) => x.val, isFunction),
+        (x) => isFunction(x.val),
         (tuple) =>
           new Resolvable(
             tuple.token,
@@ -34005,7 +33911,12 @@
    *
    */
   class StateRegistryProvider {
-    static $inject = provider([$injectTokens.$url, $injectTokens.$state, $injectTokens.$router, $injectTokens.$view]);
+    /* @ignore */ static $inject = provider([
+      $injectTokens.$url,
+      $injectTokens.$state,
+      $injectTokens.$router,
+      $injectTokens.$view,
+    ]);
 
     /**
      * @param urlService
@@ -34134,7 +34045,7 @@
     onStatesChanged(listener) {
       this.listeners.push(listener);
       return function deregisterListener() {
-        removeFrom(this.listeners)(listener);
+        removeFrom(this.listeners, listener);
       }.bind(this);
     }
     /**
@@ -34597,7 +34508,7 @@
           };
           states.push(stateInfo);
           return function removeState() {
-            removeFrom(states)(stateInfo);
+            removeFrom(states, stateInfo);
           };
         }
         // Update route state
@@ -35141,8 +35052,8 @@
   ngSetterDirective.$inject = [$injectTokens.$parse, $injectTokens.$log];
 
   /**
-   * @param {import('../../core/parse/interface.ts').ParseService} $parse
-   * @param {import('../../services/log/interface.ts').LogService} $log
+   * @param {ng.ParseService} $parse
+   * @param {ng.LogService} $log
    * @returns {import('interface.ts').Directive}
    */
   function ngSetterDirective($parse, $log) {
@@ -35198,7 +35109,7 @@
 
   /**
    * @param {"get" | "delete" | "post" | "put"} method
-   * @returns {import('../../interface.ts').DirectiveFactory}
+   * @returns {ng.DirectiveFactory}
    */
   function defineDirective(method) {
     const attrName = "ng" + method.charAt(0).toUpperCase() + method.slice(1);
@@ -35207,16 +35118,16 @@
     return directive;
   }
 
-  /** @type {import('../../interface.ts').DirectiveFactory} */
+  /** @type {ng.DirectiveFactory} */
   const ngGetDirective = defineDirective("get");
 
-  /** @type {import('../../interface.ts').DirectiveFactory} */
+  /** @type {ng.DirectiveFactory} */
   const ngDeleteDirective = defineDirective("delete");
 
-  /** @type {import('../../interface.ts').DirectiveFactory} */
+  /** @type {ng.DirectiveFactory} */
   const ngPostDirective = defineDirective("post");
 
-  /** @type {import('../../interface.ts').DirectiveFactory} */
+  /** @type {ng.DirectiveFactory} */
   const ngPutDirective = defineDirective("put");
 
   /**
@@ -35243,10 +35154,10 @@
    * 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 {import("./interface.ts").SwapModeType} swap
    * @param {Element} target - The target DOM element to apply the swap to.
-   * @param {import('../../core/scope/scope.js').Scope} scope
-   * @param {import('../../core/compile/compile.js').CompileFn} $compile
+   * @param {ng.Scope} scope
+   * @param {ng.CompileService} $compile
    */
   function handleSwapResponse(html, swap, target, scope, $compile) {
     let nodes = [];
@@ -35327,16 +35238,16 @@
    *
    * @param {"get" | "delete" | "post" | "put"} method - HTTP method to use.
    * @param {string} attrName - Attribute name containing the URL.
-   * @returns {import('../../interface.ts').DirectiveFactory}
+   * @returns {ng.DirectiveFactory}
    */
   function createHttpDirective(method, attrName) {
     /**
-     * @param {import("interface.ts").HttpService} $http
-     * @param {import("../../core/compile/compile.js").CompileFn} $compile
-     * @param {import("../../services/log/interface.ts").LogService} $log
-     * @param {import("../../core/parse/interface.ts").ParseService} $parse
-     * @param {import("../../router/state/state-service.js").StateProvider} $state
-     * @returns {import('../../interface.ts').Directive}
+     * @param {ng.HttpService} $http
+     * @param {ng.CompileService} $compile
+     * @param {ng.LogService} $log
+     * @param {ng.ParseService} $parse
+     * @param {ng.StateService} $state
+     * @returns {ng.Directive}
      */
     return function ($http, $compile, $log, $parse, $state) {
       /**
@@ -35475,7 +35386,7 @@
 
               handleSwapResponse(
                 html,
-                /** @type {import("../../interface.ts").SwapModeType} */ (swap),
+                /** @type {import("./interface.ts").SwapModeType} */ (swap),
                 target,
                 scope,
                 $compile,
@@ -35530,6 +35441,40 @@
     };
   }
 
+  ngInjectDirective.$inject = [$injectTokens.$log, $injectTokens.$injector];
+
+  /**
+   * @param {ng.LogService} $log
+   * @param {ng.InjectorService} $injector
+   * @returns {import('interface.ts').Directive}
+   */
+  function ngInjectDirective($log, $injector) {
+    return {
+      restrict: "A",
+      link(scope, _element, attrs) {
+        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);
+      },
+    };
+  }
+
   /**
    * Initializes core `ng` module.
    * @param {import('./angular.js').Angular} angular
@@ -35548,6 +35493,8 @@
             $provide.provider({
               $$sanitizeUri: SanitizeUriProvider,
             });
+            $provide.value("$window", window);
+            $provide.value("$document", document);
             $provide
               .provider($injectTokens.$compile, CompileProvider)
               .directive({
@@ -35572,6 +35519,7 @@
                 ngHide: ngHideDirective,
                 ngIf: ngIfDirective,
                 ngInclude: ngIncludeDirective,
+                ngInject: ngInjectDirective,
                 ngInit: ngInitDirective,
                 ngMessages: ngMessagesDirective,
                 ngMessage: ngMessageDirective,
@@ -35649,7 +35597,6 @@
               $interpolate: InterpolateProvider,
               $http: HttpProvider,
               $httpParamSerializer: HttpParamSerializerProvider,
-              $httpBackend: HttpBackendProvider,
               $location: LocationProvider,
               $log: LogProvider,
               $parse: ParseProvider,
@@ -35690,13 +35637,6 @@
   /** @type {Object.<string, NgModule>} */
   const modules = {};
 
-  /**
-   * Configuration option for AngularTS bootstrap process.
-   *
-   * @typedef {Object} AngularBootstrapConfig
-   * @property {boolean} [strictDi] - Disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. Defaults to `false`.
-   */
-
   class Angular {
     constructor() {
       this.$cache = Cache;
@@ -35707,7 +35647,7 @@
       /**
        * @type {string} `version` from `package.json`
        */
-      this.version = "0.9.3"; //inserted via rollup plugin
+      this.version = "0.9.5"; //inserted via rollup plugin
 
       /** @type {!Array<string|any>} */
       this.bootsrappedModules = [];
@@ -35762,7 +35702,7 @@
      *     Each item in the array should be the name of a predefined module or a (DI annotated)
      *     function that will be invoked by the injector as a `config` block.
      *     See: {@link angular.module modules}
-     * @param {AngularBootstrapConfig} [config]
+     * @param {import("./interface.ts").AngularBootstrapConfig} [config]
      * @returns {import('./core/di/internal-injector.js').InjectorService} The created injector instance for this application.
      */
     bootstrap(element, modules, config) {
@@ -35930,7 +35870,7 @@
      * @param {string} name The name of the module to create or retrieve.
      * @param {Array.<string>} [requires] If specified then new module is being created. If
      *        unspecified then the module is being retrieved for further configuration.
-     * @param {import("./interface.js").Injectable} [configFn] Optional configuration function for the module that gets
+     * @param {import("./interface.js").Injectable<any>} [configFn] Optional configuration function for the module that gets
      *        passed to {@link NgModule.config NgModule.config()}.
      * @returns {NgModule} A newly registered module.
      */