@angular-wave/angular.ts 0.15.0 → 0.15.2

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.15.0 - December 14, 2025 04:42:34 */
+/* Version: 0.15.2 - December 24, 2025 03:47:35 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -108,14 +108,14 @@
     //   via the forEach method when constructing the JQLite object in the first place
     if (isArray(obj) || obj instanceof Array || isString(obj)) return true;
 
-    const len = /** @type {Object} */ (obj).length;
+    const len = /** @type {ArrayLike<any>} */ (obj).length;
 
     // NodeList objects (with `item` method) and
     // other objects with suitable length characteristics are array-like
     return (
       isNumber(len) &&
       ((len >= 0 && len - 1 in /** @type {Object} */ (obj)) ||
-        typeof (/** @type {Object} */ (obj).item) === "function")
+        typeof (/** @type {NodeList} */ (obj).item) === "function")
     );
   }
 
@@ -155,7 +155,7 @@
    * @param {new (...args: any[]) => T} type  The constructor to test against
    * @returns {val is T}
    */
-  function isIntanceOf(val, type) {
+  function isInstanceOf(val, type) {
     return val instanceof type;
   }
 
@@ -174,8 +174,7 @@
 
   /**
    * Determines if a reference is a `string`.
-   *
-   * @param value - The value to check.
+   * @param {unknown} value - The value to check.
    * @returns {value is string} True if `value` is a string.
    */
   function isString(value) {
@@ -288,7 +287,7 @@
    * @returns {obj is Window} True if `obj` is a window obj.
    */
   function isWindow(obj) {
-    return obj && isIntanceOf(obj, Window);
+    return isInstanceOf(obj, Window);
   }
 
   /**
@@ -347,25 +346,30 @@
     return isString(value) ? value.trim() : value;
   }
 
+  /**
+   * @param {string} name
+   * @param {string} separator
+   */
   function snakeCase(name, separator) {
     const modseparator = separator;
 
     return name.replace(
       /[A-Z]/g,
-      (letter, pos) => (pos ? modseparator : "") + letter.toLowerCase(),
+      (/** @type {string} */ letter, /** @type {any} */ pos) =>
+        (pos ? modseparator : "") + letter.toLowerCase(),
     );
   }
 
   /**
    * Set or clear the hashkey for an object.
-   * @param obj object
-   * @param hashkey the hashkey (!truthy to delete the hashkey)
+   * @param {{ [x: string]: any; _hashKey?: any; }} obj object
+   * @param {any} hashkey the hashkey (!truthy to delete the hashkey)
    */
   function setHashKey(obj, hashkey) {
     if (hashkey) {
-      obj.$$hashKey = hashkey;
+      obj._hashKey = hashkey;
     } else {
-      delete obj.$$hashKey;
+      delete obj._hashKey;
     }
   }
 
@@ -380,7 +384,7 @@
    * @returns {Object<string, any>} The extended destination object.
    */
   function baseExtend(dst, objs, deep = false) {
-    const hasKey = dst.$$hashKey;
+    const hasKey = dst._hashKey;
 
     for (let i = 0, ii = objs.length; i < ii; ++i) {
       const obj = objs[i];
@@ -447,6 +451,10 @@
     return extend(Object.create(parent), extra);
   }
 
+  /**
+   * @param {{ toString: () => string; }} obj
+   * @returns {boolean}
+   */
   function hasCustomToString(obj) {
     return isFunction(obj.toString) && obj.toString !== toString;
   }
@@ -457,12 +465,16 @@
    * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/nodeName)
    *
    * @param {Element} element
-   * @returns
+   * @returns {string}
    */
   function getNodeName(element) {
     return lowercase(element.nodeName);
   }
 
+  /**
+   * @param {any} array
+   * @param {string} obj
+   */
   function includes(array, obj) {
     return Array.prototype.indexOf.call(array, obj) !== -1;
   }
@@ -485,6 +497,10 @@
     return index;
   }
 
+  /**
+   * @param {unknown} val1
+   * @param {unknown} val2
+   */
   function simpleCompare(val1, val2) {
     return val1 === val2 || (Number.isNaN(val1) && Number.isNaN(val2));
   }
@@ -639,6 +655,10 @@
     }
   }
 
+  /**
+   * @param {unknown} value
+   * @returns {string | unknown}
+   */
   function stringify$1(value) {
     if (isNull(value) || isUndefined(value)) {
       return "";
@@ -650,10 +670,14 @@
         value = `${value}`;
         break;
       default:
-        if (hasCustomToString(value) && !isArray(value) && !isDate(value)) {
-          value = value.toString();
+        if (
+          hasCustomToString(/** @type {Object} */ (value)) &&
+          !isArray(value) &&
+          !isDate(value)
+        ) {
+          value = /** @type {Object} */ (value).toString();
         } else {
-          value = toJson(value);
+          value = toJson(/** @type {any[]} */ (value));
         }
     }
 
@@ -668,10 +692,19 @@
     return isNumber(maxDepth) && maxDepth > 0;
   }
 
+  /**
+   * @param {any[]} array1
+   * @param {IArguments | any[] | NodeListOf<ChildNode>} array2
+   * @param {number | undefined} [index]
+   */
   function concat(array1, array2, index) {
     return array1.concat(Array.prototype.slice.call(array2, index));
   }
 
+  /**
+   * @param {IArguments | [string, ...any[]]} args
+   * @param {number} startIndex
+   */
   function sliceArgs(args, startIndex) {
     return Array.prototype.slice.call(args, startIndex);
   }
@@ -707,6 +740,10 @@
     return fn;
   }
 
+  /**
+   * @param {string} key
+   * @param {unknown} value
+   */
   function toJsonReplacer(key, value) {
     let val = value;
 
@@ -728,93 +765,44 @@
   }
 
   /**
-   * Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
-   * stripped since AngularTS uses this notation internally.
-   *
-   * @param {Object|Array|Date|string|number|boolean} obj Input to be serialized into JSON.
-   * @param {boolean|number} [pretty=2] If set to true, the JSON output will contain newlines and whitespace.
-   *    If set to an integer, the JSON output will contain that many spaces per indentation.
-   * @returns {string|undefined} JSON-ified string representing `obj`.
-   * @knownIssue
+   * Serializes input into a JSON-formatted string. Properties with leading `$$` characters
+   * will be stripped since AngularTS uses this notation internally.
    *
-   * The Safari browser throws a `RangeError` instead of returning `null` when it tries to stringify a `Date`
-   * object with an invalid date value. The only reliable way to prevent this is to monkeypatch the
-   * `Date.prototype.toJSON` method as follows:
-   *
-   * ```
-   * let _DatetoJSON = Date.prototype.toJSON;
-   * Date.prototype.toJSON = function() {
-   *   try {
-   *     return _DatetoJSON.call(this);
-   *   } catch(e) {
-   *     if (e instanceof RangeError) {
-   *       return null;
-   *     }
-   *     throw e;
-   *   }
-   * };
-   * ```
-   *
-   * See https://github.com/angular/angular.js/pull/14221 for more information.
+   * @param {Object|Array<any>|Date|string|number|boolean} obj
+   *   Input to be serialized into JSON.
+   * @param {boolean|number} [pretty=2]
+   *   If `true`, the JSON output will contain newlines and whitespace (2 spaces).
+   *   If a number, the JSON output will contain that many spaces per indentation.
+   * @returns {string|undefined}
+   *   JSON-ified string representing `obj`, or `undefined` if `obj` is undefined.
    */
   function toJson(obj, pretty) {
     if (isUndefined(obj)) return undefined;
 
     if (!isNumber(pretty)) {
-      pretty = pretty ? 2 : null;
+      pretty = pretty ? 2 : undefined;
     }
 
-    return JSON.stringify(obj, toJsonReplacer, /** @type {Number} */ (pretty));
+    return JSON.stringify(obj, toJsonReplacer, /** @type {number} */ (pretty));
   }
 
   /**
    * Deserializes a JSON string.
    *
    * @param {string} json JSON string to deserialize.
-   * @returns {Object|Array|string|number} Deserialized JSON string.
+   * @returns {Object|Array<any>|string|number} Deserialized JSON string.
    */
   function fromJson(json) {
     return isString(json) ? JSON.parse(json) : json;
   }
 
-  const MS_PER_MINUTE = 60_000; // 60,000 ms in a minute
-
-  function timezoneToOffset(timezone, fallback) {
-    const requestedTimezoneOffset =
-      Date.parse(`Jan 01, 1970 00:00:00 ${timezone}`) / MS_PER_MINUTE;
-
-    return isNumberNaN(requestedTimezoneOffset)
-      ? fallback
-      : requestedTimezoneOffset;
-  }
-
-  function addDateMinutes(date, minutes) {
-    const newDate = new Date(date.getTime());
-
-    newDate.setMinutes(newDate.getMinutes() + minutes);
-
-    return newDate;
-  }
-
-  function convertTimezoneToLocal(date, timezone, reverse) {
-    const doReverse = 1;
-
-    const dateTimezoneOffset = date.getTimezoneOffset();
-
-    const timezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
-
-    return addDateMinutes(
-      date,
-      doReverse * (timezoneOffset - dateTimezoneOffset),
-    );
-  }
-
   /**
    * Parses an escaped url query string into key-value pairs.
    * @param {string} keyValue
-   * @returns {Object.<string,boolean|Array>}
+   * @returns {Object.<string,boolean|Array<any>>}
    */
   function parseKeyValue(keyValue) {
+    /** @type {Record<string, boolean | string | Array<any>>} */
     const obj = {};
 
     (keyValue || "").split("&").forEach((item) => {
@@ -838,9 +826,9 @@
           val = isDefined(val) ? tryDecodeURIComponent(val) : true;
 
           if (!hasOwn(obj, /** @type {string} */ (key))) {
-            obj[key] = val;
+            obj[key] = /** @type {string } */ (val);
           } else if (isArray(obj[key])) {
-            obj[key].push(val);
+            /** @type {Array<any>} */ (obj[key]).push(val);
           } else {
             obj[key] = [obj[key], val];
           }
@@ -848,10 +836,16 @@
       }
     });
 
-    return /** @type {Object.<string,boolean|Array>} */ (obj);
+    return /** @type {Object.<string,boolean|Array<any>>} */ (obj);
   }
 
+  /**
+   * @param {string | { [s: string]: any; } | ArrayLike<any> | null} obj
+   */
   function toKeyValue(obj) {
+    /**
+     * @type {string[]}
+     */
     const parts = [];
 
     obj &&
@@ -919,6 +913,8 @@
    *    pct-encoded   = "%" HEXDIG HEXDIG
    *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
    *                     / "*" / "+" / "," / ";" / "="
+   * @param {string | number | boolean} val
+   * @param {boolean | undefined} [pctEncodeSpaces]
    */
   function encodeUriQuery(val, pctEncodeSpaces) {
     return encodeURIComponent(val)
@@ -933,28 +929,39 @@
   const ngAttrPrefixes = ["ng-", "data-ng-"];
 
   /**
-   * Creates a shallow copy of an object, an array or a primitive.
+   * Creates a shallow copy of an object, an array, or returns primitives as-is.
+   *
+   * Assumes there are no proto properties.
    *
-   * Assumes that there are no proto properties for objects.
+   * @template T
+   * @param {T} src
+   * @param {T extends any[] ? T : Record<string, unknown>} [dst]
+   * @returns {T}
    */
   function shallowCopy(src, dst) {
     if (isArray(src)) {
-      dst = dst || [];
+      /** @type {any[]} */
+      const out = /** @type {any[]} */ (dst) || [];
 
-      for (let i = 0, ii = src.length; i < ii; i++) {
-        dst[i] = src[i];
-      }
-    } else if (isObject(src)) {
-      dst = dst || {};
+      out.push(...src);
+
+      return /** @type {T} */ (out);
+    }
+
+    if (isObject(src)) {
+      const out = /** @type {Record<string, unknown>} */ (dst) || {};
 
       for (const key in src) {
-        if (!(key.startsWith("$") && key.charAt(1) === "$")) {
-          dst[key] = src[key];
+        // Copy all properties except $$-prefixed
+        if (!key.startsWith("$$")) {
+          out[key] = src[key];
         }
       }
+
+      return /** @type {T} */ (out);
     }
 
-    return dst || src;
+    return src;
   }
 
   /**
@@ -970,6 +977,9 @@
 
   /**
    * Throw error if the argument is falsy.
+   * @param {string | boolean | Object} arg
+   * @param {string} name
+   * @param {string | undefined} [reason]
    */
   function assertArg(arg, name, reason) {
     if (!arg) {
@@ -984,6 +994,11 @@
     return arg;
   }
 
+  /**
+   * @param {string | Function | any[]} arg
+   * @param {string} name
+   * @param {boolean | undefined} [acceptArrayAnnotation]
+   */
   function assertArgFn(arg, name, acceptArrayAnnotation) {
     if (acceptArrayAnnotation && isArray(arg)) {
       arg = arg[arg.length - 1];
@@ -1071,7 +1086,7 @@
 
       const templateArgs = sliceArgs(args, 2).map((arg) => toDebugString(arg));
 
-      message += template.replace(/\{\d+\}/g, (match) => {
+      message += template.replace(/\{\d+\}/g, (/** @type {string} */ match) => {
         const index = +match.slice(1, -1);
 
         if (index < templateArgs.length) {
@@ -1130,19 +1145,19 @@
    * Hash of a:
    *  string is string
    *  number is number as string
-   *  object is either result of calling $$hashKey function on the object or uniquely generated id,
-   *         that is also assigned to the $$hashKey property of the object.
+   *  object is either result of calling _hashKey function on the object or uniquely generated id,
+   *         that is also assigned to the _hashKey property of the object.
    *
    * @param {*} obj
    * @returns {string} hash string such that the same input will have the same hash string.
    *         The resulting string key is in 'type:hashKey' format.
    */
   function hashKey(obj) {
-    const key = obj && obj.$$hashKey;
+    const key = obj && obj._hashKey;
 
     if (key) {
       if (typeof key === "function") {
-        return obj.$$hashKey();
+        return obj._hashKey();
       }
 
       return key;
@@ -1151,9 +1166,9 @@
     const objType = typeof obj;
 
     if (objType === "function" || (objType === "object" && obj !== null)) {
-      obj.$$hashKey = `${objType}:${nextUid()}`;
+      obj._hashKey = `${objType}:${nextUid()}`;
 
-      return obj.$$hashKey;
+      return obj._hashKey;
     }
 
     if (objType === "undefined") {
@@ -1415,14 +1430,6 @@
     return typeof fn === "function" && !fn.prototype;
   }
 
-  /**
-   * Expando cache for adding properties to DOM nodes with JavaScript.
-   * This used to be an Object in JQLite decorator, but swapped out for a Map
-   *
-   * @type {Map<number, import('../interface.ts').ExpandoStore>}
-   */
-  const Cache = new Map();
-
   const ADD_CLASS_SUFFIX = "-add";
   const REMOVE_CLASS_SUFFIX = "-remove";
   const EVENT_CLASS_PREFIX = "ng-";
@@ -1849,10 +1856,18 @@
 
   const EXPANDO = "ng";
 
+  /**
+   * Expando cache for adding properties to DOM nodes with JavaScript.
+   * This used to be an Object in JQLite decorator, but swapped out for a Map
+   *
+   * @type {Map<number, import('../interface.ts').ExpandoStore>}
+   */
+  const Cache = new Map();
+
   /**
    * Key for storing scope data, attached to an element
    */
-  const SCOPE_KEY = "$scope";
+  const SCOPE_KEY = $injectTokens._scope;
 
   const DASH_LOWERCASE_REGEXP = /-([a-z])/g;
 
@@ -2295,7 +2310,7 @@
   /**
    * Return the DOM siblings between the first and last node in the given array.
    * @param {Array<Node>} nodes An array-like object
-   * @returns {Element} the inputted object or a JQLite collection containing the nodes
+   * @returns {*[]|Array<Node>} the inputted object or a JQLite collection containing the nodes
    */
   function getBlockNodes(nodes) {
     // TODO(perf): update `nodes` instead of creating a new object?
@@ -2405,7 +2420,7 @@
    * @param {HTMLElement | Element} parentElement
    *   The parent element that will receive the inserted element.
    *
-   * @param {HTMLElement | Element | null} [afterElement]
+   * @param {ChildNode | Element | null} [afterElement]
    *   An optional sibling element — if present and valid, `element`
    *   will be inserted after it. If omitted or invalid, `element`
    *   is prepended to `parentElement`.
@@ -2431,6 +2446,11 @@
     }
   }
 
+  /**
+   * @param {HTMLElement} element
+   * @param {HTMLElement} parent
+   * @param {ChildNode | null | undefined} after
+   */
   function animatedomInsert(element, parent, after) {
     const originalVisibility = element.style.visibility;
 
@@ -2798,11 +2818,11 @@
    * Creates a proxy that automatically persists an object's state
    * into a storage backend whenever a property is set.
    *
-   * @param {object} target - The object to wrap
+   * @param {Record<PropertyKey, any>} target - The object to wrap
    * @param {string} key - The storage key
-   * @param {object} storage - Any storage-like object with getItem/setItem/removeItem
+   * @param {import("../../core/di/inteface").StorageLike & import("../../core/di/inteface").PersistentStoreConfig} storage - Any storage-like object with getItem/setItem/removeItem
    * @param {{serialize?: function, deserialize?: function}} [options] - Optional custom (de)serialization
-   * @returns {Proxy}
+   * @returns {Record<PropertyKey, any>}
    */
   function createPersistentProxy(target, key, storage, options = {}) {
     const serialize = options.serialize || JSON.stringify;
@@ -2868,7 +2888,6 @@
   }
 
   const BADARG = "badarg";
-  const BADARGVALUE = "badarg: value";
 
   /** @type {Map<ng.Validator, string>} */
   const reasons = new Map([
@@ -2971,6 +2990,25 @@
     /** @type {Map<String|Function, boolean>} */
     const loadedModules = new Map(); // Keep track of loaded modules to avoid circular dependencies
 
+    /**
+     * @typedef {{
+     *   $provide: {
+     *     provider: Function,
+     *     factory: Function,
+     *     service: Function,
+     *     value: Function,
+     *     constant: Function,
+     *     store: Function,
+     *     decorator: Function,
+     *   },
+     *   $injectorProvider?: {
+     *     $get: () => unknown
+     *   },
+     *   $injector?: ProviderInjector
+     * }} ProviderCache
+     */
+
+    /** @type {ProviderCache} */
     const providerCache = {
       $provide: {
         provider: supportObject(provider),
@@ -3127,12 +3165,11 @@
      * Registers a service persisted in a storage
      *
      * @param {string} name - Service name
-     * @param {Function} ctor - Constructor for the service
+     * @param {import("../../interface.ts").Constructor} ctor - Constructor for the service
      * @param {ng.StorageType} type - Type of storage to be instantiated
-     * @param {Storage|Object} backendOrConfig - Either a Storage-like object (getItem/setItem) or a config object
-     *                                           with { backend, serialize, deserialize }
+     * @param {import("./inteface.ts").StorageLike & import("./inteface.ts").PersistentStoreConfig} [backendOrConfig]
      */
-    function store(name, ctor, type, backendOrConfig = {}) {
+    function store(name, ctor, type, backendOrConfig) {
       return provider(name, {
         $get: /** @param {ng.InjectorService} $injector */ ($injector) => {
           switch (type) {
@@ -3151,11 +3188,11 @@
 
               const $cookie = $injector.get($injectTokens._cookie);
 
-              const serialize = backendOrConfig.serialize ?? JSON.stringify;
+              const serialize = backendOrConfig?.serialize ?? JSON.stringify;
 
-              const deserialize = backendOrConfig.deserialize ?? JSON.parse;
+              const deserialize = backendOrConfig?.deserialize ?? JSON.parse;
 
-              const cookieOpts = backendOrConfig.cookie ?? {};
+              const cookieOpts = backendOrConfig?.cookie ?? {};
 
               return createPersistentProxy(instance, name, {
                 getItem(key) {
@@ -3205,10 +3242,15 @@
                 backend = localStorage;
               }
 
-              return createPersistentProxy(instance, name, backend, {
-                serialize,
-                deserialize,
-              });
+              return createPersistentProxy(
+                instance,
+                name,
+                /** @type {import("./inteface.ts").StorageLike} */ (backend),
+                {
+                  serialize,
+                  deserialize,
+                },
+              );
             }
           }
 
@@ -3685,7 +3727,7 @@
      *
      * - **`defaults.xsrfHeaderName`** - {string} - Name of HTTP header to populate with the
      * XSRF token. Defaults value is `'X-XSRF-TOKEN'`.
-     *
+     * @type {import("./interface.ts").HttpProviderDefaults}
      */
     const defaults = (this.defaults = {
       // transform incoming response data
@@ -3754,6 +3796,7 @@
      * array, on request, but reverse order, on response.
      *
      * {@link ng.$http#interceptors Interceptors detailed info}
+     * @type {Array<string | ng.Injectable<import("./interface.ts").HttpInterceptorFactory>>}
      */
     this.interceptors = [];
 
@@ -3797,19 +3840,6 @@
      */
     this.xsrfTrustedOrigins = [];
 
-    /**
-     * This property is deprecated. Use {@link $httpProvider#xsrfTrustedOrigins xsrfTrustedOrigins}
-     * instead.
-     */
-    Object.defineProperty(this, "xsrfWhitelistedOrigins", {
-      get() {
-        return this.xsrfTrustedOrigins;
-      },
-      set(origins) {
-        this.xsrfTrustedOrigins = origins;
-      },
-    });
-
     const that = this;
 
     this.$get = [
@@ -4694,14 +4724,14 @@
            * @param {import("./interface.ts").SwapModeType} swap
            * @param {ng.Scope} scopeParam
            * @param {ng.Attributes} attrsParam
-           * @param {Element} elmenetParam
+           * @param {Element} elementParam
            */
           function handleSwapResponse(
             html,
             swap,
             scopeParam,
             attrsParam,
-            elmenetParam,
+            elementParam,
           ) {
             let animationEnabled = false;
 
@@ -4724,7 +4754,7 @@
 
             const target = targetSelector
               ? document.querySelector(targetSelector)
-              : elmenetParam;
+              : elementParam;
 
             if (!target) {
               $log.warn(`${attrName}: target "${targetSelector}" not found`);
@@ -5685,14 +5715,14 @@
      * @throws {Error} If the argument is invalid or cannot be wrapped properly.
      */
     constructor(element) {
-      /** @private @type {Node | ChildNode | null} */
-      this._node = null;
+      /** @private @type {Node | ChildNode | undefined} */
+      this._node = undefined;
 
       /** @type {Element | undefined} */
       this._element = undefined;
 
-      /** @private @type {Array<Node> | undefined} a stable list on nodes */
-      this._nodes = undefined;
+      /** @private @type {Array<Node>} a stable list on nodes */
+      this._nodes = [];
 
       /** @type {boolean} */
       this._isList = false;
@@ -5810,7 +5840,9 @@
       if (this._isList) {
         return this._nodes[0];
       } else {
-        return this._element || this._node;
+        return /** @type {Element | Node | ChildNode} */ (
+          this._element || this._node
+        );
       }
     }
 
@@ -5819,7 +5851,9 @@
       if (this._isList) {
         return this._nodes;
       } else {
-        return this._element || this._node;
+        return /** @type {Element | Node | ChildNode} */ (
+          this._element || this._node
+        );
       }
     }
 
@@ -5828,7 +5862,9 @@
       if (this._isList) {
         return Array.from(this._nodes);
       } else {
-        return [this._element || this._node];
+        return [
+          /** @type {Element | Node | ChildNode} */ (this._element || this._node),
+        ];
       }
     }
 
@@ -6984,10 +7020,29 @@
 
   const specialAttrHolder = document.createElement("div");
 
+  /**
+   * @extends {Record<string, any>}
+   */
   class Attributes {
     static $nonscope = true;
 
     /**
+     * Creates an Attributes instance.
+     *
+     * There are two construction modes:
+     *
+     * 1. **Fresh instance** (no `attributesToCopy`):
+     *    - Used when compiling a DOM element for the first time.
+     *    - Initializes a new `$attr` map to track normalized → DOM attribute names.
+     *
+     * 2. **Clone instance** (`attributesToCopy` provided):
+     *    - Used when cloning attributes for directive linking / child scopes.
+     *    - Performs a shallow copy of all properties from the source Attributes object,
+     *      including `$attr`, normalized attribute values, and internal fields
+     *      (e.g. `$$observers`).
+     *    - `$attr` is intentionally **not reinitialized** in this case, because the
+     *      source object already contains the correct normalized → DOM attribute mapping.
+     *
      * @param {ng.AnimateService} $animate
      * @param {ng.ExceptionHandlerService} $exceptionHandler
      * @param {*} $sce
@@ -7008,16 +7063,20 @@
           this[key] = attributesToCopy[key];
         }
       } else {
+        /**
+         * A map of DOM element attribute names to the normalized name. This is needed
+         * to do reverse lookup from normalized name back to actual name.
+         */
         this.$attr = {};
       }
 
       /** @type {import("../../shared/noderef.js").NodeRef} */
-      this.$nodeRef = nodeRef;
+      this._nodeRef = nodeRef;
     }
 
     /** @type {Node|Element} */
     get $$element() {
-      return this.$nodeRef.node;
+      return this._nodeRef.node;
     }
 
     /**
@@ -7046,7 +7105,7 @@
             classVal,
           );
         } else {
-          this.$nodeRef.element.classList.add(classVal);
+          this._nodeRef.element.classList.add(classVal);
         }
       }
     }
@@ -7065,7 +7124,7 @@
             classVal,
           );
         } else {
-          this.$nodeRef.element.classList.remove(classVal);
+          this._nodeRef.element.classList.remove(classVal);
         }
       }
     }
@@ -7084,7 +7143,7 @@
         if (hasAnimate(this.$$element)) {
           this._$animate.addClass(/** @type {Element }*/ (this.$$element), toAdd);
         } else {
-          this.$nodeRef.element.classList.add(...toAdd.trim().split(/\s+/));
+          this._nodeRef.element.classList.add(...toAdd.trim().split(/\s+/));
         }
       }
       const toRemove = tokenDifference(oldClasses, newClasses);
@@ -7096,7 +7155,7 @@
             toRemove,
           );
         } else {
-          this.$nodeRef.element.classList.remove(...toRemove.trim().split(/\s+/));
+          this._nodeRef.element.classList.remove(...toRemove.trim().split(/\s+/));
         }
       }
     }
@@ -7144,7 +7203,7 @@
         }
       }
 
-      const nodeName = this.$nodeRef.node.nodeName.toLowerCase();
+      const nodeName = this._nodeRef.node.nodeName.toLowerCase();
 
       let maybeSanitizedValue;
 
@@ -7205,6 +7264,7 @@
     }
 
     /**
+     * @template T
      * Observes an interpolated attribute.
      * 
      * The observer function will be invoked once during the next `$digest` following
@@ -7212,11 +7272,11 @@
      * changes.
      *
      * @param {string} key Normalized key. (ie ngAttribute) .
-     * @param {any} fn Function that will be called whenever
+     * @param {(value?: T) => any} fn Function that will be called whenever
               the interpolated value of the attribute changes.
     *        See the {@link guide/interpolation#how-text-and-attribute-bindings-work Interpolation
     *        guide} for more info.
-    * @returns {function()} Returns a deregistration function for this observer.
+    * @returns {Function} Returns a deregistration function for this observer.
     */
     $observe(key, fn) {
       const $$observers =
@@ -8370,7 +8430,7 @@
            * @param {Attributes|any} attrs The shared attrs object which is used to populate the normalized attributes.
            * @param {number=} maxPriority Max directive priority.
            * @param {string} [ignoreDirective]
-           * @return {import('../../interface.ts').Directive[]} An array to which the directives are added to. This array is sorted before the function returns.
+           * @return {ng.Directive[]} An array to which the directives are added to. This array is sorted before the function returns.
            */
           function collectDirectives(node, attrs, maxPriority, ignoreDirective) {
             /**
@@ -8621,7 +8681,7 @@
 
             const { index } = previousCompileContext;
 
-            templateAttrs.$nodeRef = compileNodeRef;
+            templateAttrs._nodeRef = compileNodeRef;
             let directive;
 
             let directiveName;
@@ -8672,7 +8732,7 @@
 
               if (compileNode === linkNode) {
                 attrs = templateAttrs;
-                $element = templateAttrs.$nodeRef;
+                $element = templateAttrs._nodeRef;
               } else {
                 $element = new NodeRef(linkNode);
                 attrs = new Attributes(
@@ -9098,7 +9158,7 @@
                   terminalPriority = directive.priority;
                   $template = compileNodeRef;
                   compileNodeRef = new NodeRef(document.createComment(""));
-                  templateAttrs.$nodeRef = compileNodeRef;
+                  templateAttrs._nodeRef = compileNodeRef;
                   compileNode = compileNodeRef.node;
                   ctxNodeRef.node = compileNode;
                   replaceWith(
@@ -9869,7 +9929,7 @@
 
                   let linkNode = $compileNode._getAny();
 
-                  if (scope.$$destroyed) {
+                  if (scope._destroyed) {
                     continue;
                   }
 
@@ -9936,7 +9996,7 @@
             ) {
               let childBoundTranscludeFn = boundTranscludeFn;
 
-              if (scope.$$destroyed) {
+              if (scope._destroyed) {
                 return;
               }
 
@@ -10797,13 +10857,13 @@
    *   $nonscope: boolean,
    *   $addControl: Function,
    *   $getControls: () => any[],
-   *   $$renameControl: Function,
+   *   _renameControl: Function,
    *   $removeControl: Function,
    *   $setValidity: Function | ((key: any, isValid: boolean, control: any) => any),
    *   $setDirty: Function,
    *   $setPristine: Function,
    *   $setSubmitted: Function,
-   *   $$setSubmitted: Function
+   *   _setSubmitted: Function
    * }}
    */
   const nullFormCtrl = {
@@ -10812,7 +10872,7 @@
       /* empty */
     },
     $getControls: () => [],
-    $$renameControl: (control, name) => {
+    _renameControl: (control, name) => {
       control.$name = name;
     },
     $removeControl: () => {
@@ -10830,7 +10890,7 @@
     $setSubmitted: () => {
       /* empty */
     },
-    $$setSubmitted: () => {
+    _setSubmitted: () => {
       /* empty */
     },
   };
@@ -10887,11 +10947,11 @@
   class FormController {
     static $nonscope = true;
     /* @ignore */ static $inject = [
-      "$element",
-      "$attrs",
-      "$scope",
-      "$animate",
-      "$interpolate",
+      $injectTokens._element,
+      $injectTokens._attrs,
+      $injectTokens._scope,
+      $injectTokens._animate,
+      $injectTokens._interpolate,
     ];
 
     /**
@@ -10902,7 +10962,7 @@
      * @param {ng.InterpolateService} $interpolate
      */
     constructor($element, $attrs, $scope, $animate, $interpolate) {
-      this.$$controls = [];
+      this._controls = [];
 
       this.$name = $interpolate($attrs.name || $attrs.ngForm || "")($scope);
 
@@ -10931,6 +10991,7 @@
 
       this.$$classCache[VALID_CLASS] = isValid;
       this.$$classCache[INVALID_CLASS] = !isValid;
+      this.$target = {};
     }
 
     /**
@@ -10941,7 +11002,7 @@
      * a form that uses `ng-model-options` to pend updates.
      */
     $rollbackViewValue() {
-      this.$$controls.forEach((control) => {
+      this._controls.forEach((control) => {
         control.$rollbackViewValue();
       });
     }
@@ -10954,7 +11015,7 @@
      * usually handles calling this in response to input events.
      */
     $commitViewValue() {
-      this.$$controls.forEach((control) => {
+      this._controls.forEach((control) => {
         control.$commitViewValue();
       });
     }
@@ -10978,7 +11039,7 @@
       // Breaking change - before, inputs whose name was "hasOwnProperty" were quietly ignored
       // and not added to the scope.  Now we throw an error.
       assertNotHasOwnProperty(control.$name, "input");
-      this.$$controls.push(control);
+      this._controls.push(control);
 
       if (control.$name) {
         this[control.$name] = control;
@@ -11000,13 +11061,14 @@
      * Likewise, adding a control to, or removing a control from the form is not reflected
      * in the shallow copy. That means you should get a fresh copy from `$getControls()` every time
      * you need access to the controls.
+     * @returns {ReadonlyArray<FormController>}
      */
     $getControls() {
-      return shallowCopy(this.$$controls);
+      return shallowCopy(this._controls);
     }
 
     // Private API: rename a form control
-    $$renameControl(control, newName) {
+    _renameControl(control, newName) {
       const oldName = control.$name;
 
       if (this[oldName] === control) {
@@ -11025,6 +11087,7 @@
      * form. `$dirty`, `$submitted` states will not be changed, because the expected behavior can be
      * different from case to case. For example, removing the only `$dirty` control from a form may or
      * may not mean that the form is still `$dirty`.
+     * @param {FormController } control
      */
     $removeControl(control) {
       if (control.$name && this[control.$name] === control) {
@@ -11043,7 +11106,7 @@
           this.$setValidity(name, null, control);
         });
 
-      arrayRemove(this.$$controls, control);
+      arrayRemove(this._controls, control);
 
       control.$target.$$parentForm = nullFormCtrl;
     }
@@ -11096,7 +11159,7 @@
       this.$dirty = false;
       this.$pristine = true;
       this.$submitted = false;
-      this.$$controls.forEach((control) => {
+      this._controls.forEach((control) => {
         control.$setPristine();
       });
     }
@@ -11111,7 +11174,7 @@
      * back to its pristine state.
      */
     $setUntouched() {
-      this.$$controls.forEach((control) => {
+      this._controls.forEach((control) => {
         control.$setUntouched();
       });
     }
@@ -11127,19 +11190,19 @@
       while (rootForm.$$parentForm && rootForm.$$parentForm !== nullFormCtrl) {
         rootForm = rootForm.$$parentForm;
       }
-      rootForm.$$setSubmitted();
+      rootForm._setSubmitted();
     }
 
-    $$setSubmitted() {
+    _setSubmitted() {
       if (hasAnimate(this.$$element)) {
         this.$$animate.addClass(this.$$element, SUBMITTED_CLASS);
       } else {
         this.$$element.classList.add(SUBMITTED_CLASS);
       }
       this.$submitted = true;
-      this.$$controls.forEach((control) => {
-        if (control.$$setSubmitted) {
-          control.$$setSubmitted();
+      this._controls.forEach((control) => {
+        if (control._setSubmitted) {
+          control._setSubmitted();
         }
       });
     }
@@ -11457,7 +11520,7 @@
                   attrParam.$observe(nameAttr, (newValue) => {
                     if (controller.$name === newValue) return;
                     scope.$target[controller.$name] = undefined;
-                    controller.$$parentForm.$$renameControl(controller, newValue);
+                    controller.$$parentForm._renameControl(controller, newValue);
 
                     if (
                       scope.$target !== controller.$$parentForm &&
@@ -11680,12 +11743,12 @@
    */
 
   class NgModelController {
-    static $nonscope = true;
+    /* @ignore */ static $nonscope = true;
     /* @ignore */ static $inject = [
-      "$scope",
+      $injectTokens._scope,
       $injectTokens._exceptionHandler,
-      "$attrs",
-      "$element",
+      $injectTokens._attrs,
+      $injectTokens._element,
       $injectTokens._parse,
       $injectTokens._animate,
       $injectTokens._interpolate,
@@ -11717,19 +11780,19 @@
       /** @type {any} */
       this.$$rawModelValue = undefined; // stores the parsed modelValue / model set from scope regardless of validity.
 
-      /** @type {any} */
+      /** @type {import("./interface.ts").ModelValidators} */
       this.$validators = {};
 
-      /** @type {any} */
+      /** @type {import("./interface.ts").AsyncModelValidators} */
       this.$asyncValidators = {};
 
-      /** @type {Array<any>} */
+      /** @type {Array<import("./interface.ts").ModelParser>} */
       this.$parsers = [];
 
-      /** @type {Array<any>} */
+      /** @type {Array<import("./interface.ts").ModelFormatter>} */
       this.$formatters = [];
 
-      /** @type {Array<any>} */
+      /** @type {Array<import("./interface.ts").ModelViewChangeListener>} */
       this.$viewChangeListeners = [];
 
       /** @type {boolean} */
@@ -11760,15 +11823,15 @@
       // Attach the correct context to the event handler function for updateOn
       this.$$updateEventHandler = this.$$updateEventHandler.bind(this);
 
-      this.$$parsedNgModel = $parse($attr.ngModel);
-      this.$$parsedNgModelAssign = this.$$parsedNgModel.assign;
+      this._parsedNgModel = $parse($attr.ngModel);
+      this._parsedNgModelAssign = this._parsedNgModel.assign;
 
       /**
        * @type {import("../../core/parse/interface.ts").CompiledExpression |
        *        (function(ng.Scope): any)}
        */
-      this.$$ngModelGet = this.$$parsedNgModel;
-      this.$$ngModelSet = this.$$parsedNgModelAssign;
+      this._ngModelGet = this._parsedNgModel;
+      this._ngModelSet = this._parsedNgModelAssign;
       this.$$pendingDebounce = null;
       this.$$parserValid = undefined;
 
@@ -11917,8 +11980,8 @@
 
         const invokeModelSetter = this.$$parse(`${this.$$attr.ngModel}($$$p)`);
 
-        this.$$ngModelGet = ($scope) => {
-          let modelValue = this.$$parsedNgModel($scope);
+        this._ngModelGet = ($scope) => {
+          let modelValue = this._parsedNgModel($scope);
 
           if (isFunction(modelValue)) {
             modelValue = invokeModelGetter($scope);
@@ -11926,14 +11989,14 @@
 
           return modelValue;
         };
-        this.$$ngModelSet = ($scope, newValue) => {
-          if (isFunction(this.$$parsedNgModel($scope))) {
+        this._ngModelSet = ($scope, newValue) => {
+          if (isFunction(this._parsedNgModel($scope))) {
             invokeModelSetter($scope, { $$$p: newValue });
           } else {
-            this.$$parsedNgModelAssign($scope, newValue);
+            this._parsedNgModelAssign($scope, newValue);
           }
         };
-      } else if (!this.$$parsedNgModel.assign) {
+      } else if (!this._parsedNgModel.assign) {
         throw ngModelMinErr(
           "nonassign",
           "Expression '{0}' is non-assignable. Element: {1}",
@@ -12409,7 +12472,7 @@
       if (isNumberNaN(this.$modelValue)) {
         // this.$modelValue has not been touched yet...
         // @ts-ignore
-        this.$modelValue = this.$$ngModelGet(this.$$scope);
+        this.$modelValue = this._ngModelGet(this.$$scope);
       }
       const prevModelValue = this.$modelValue;
 
@@ -12446,13 +12509,15 @@
         // intentional loose equality
         // eslint-disable-next-line eqeqeq
         if (that.$modelValue != prevModelValue) {
+          if (isNull(that.$modelValue) && prevModelValue === "") return;
+
           that.$$writeModelToScope();
         }
       }
     }
 
     $$writeModelToScope() {
-      this.$$ngModelSet(this.$$scope, this.$modelValue);
+      this._ngModelSet(this.$$scope, this.$modelValue);
       Object.values(this.$viewChangeListeners).forEach((listener) => {
         try {
           listener();
@@ -12570,7 +12635,7 @@
      * **Note:** it is not possible to override the `getterSetter` option.
      * </div>
      *
-     * @param {Object} options a hash of settings to override the previous options
+     * @param {import("../../interface.ts").NgModelOptions} options a hash of settings to override the previous options
      *
      */
     $overrideModelOptions(options) {
@@ -12769,7 +12834,7 @@
     //       ng-change executes in apply phase
     // 4. view should be changed back to 'a'
     ctrl.$$scope.$watch("value", () => {
-      const modelValue = ctrl.$$ngModelGet(ctrl.$$scope);
+      const modelValue = ctrl._ngModelGet(ctrl.$$scope);
 
       // if scope model value and ngModel value are out of sync
       // This cannot be moved to the action function, because it would not catch the
@@ -12818,7 +12883,7 @@
 
               attr.$observe("name", (newValue) => {
                 if (modelCtrl.$name !== newValue) {
-                  modelCtrl.$$parentForm.$$renameControl(modelCtrl, newValue);
+                  modelCtrl.$$parentForm._renameControl(modelCtrl, newValue);
                 }
               });
               const deregisterWatch = scope.$watch(attr.ngModel, (val) => {
@@ -12853,9 +12918,6 @@
     };
   }
 
-  // Regex code was initially obtained from SO prior to modification: https://stackoverflow.com/questions/3143070/javascript-regex-iso-datetime#answer-3143231
-  const ISO_DATE_REGEXP =
-    /^\d{4,}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+(?:[+-][0-2]\d:[0-5]\d|Z)$/;
   // See valid URLs in RFC3987 (http://tools.ietf.org/html/rfc3987)
   // Note: We are being more lenient, because browsers are too.
   //   1. Scheme
@@ -12903,35 +12965,14 @@
 
   const inputType = {
     text: textInputType,
-    date: createDateInputType(
-      "date",
-      DATE_REGEXP,
-      createDateParser(DATE_REGEXP, ["yyyy", "MM", "dd"]),
-    ),
-    "datetime-local": createDateInputType(
+    date: createStringDateInputType("date", DATE_REGEXP),
+    "datetime-local": createStringDateInputType(
       "datetimelocal",
       DATETIMELOCAL_REGEXP,
-      createDateParser(DATETIMELOCAL_REGEXP, [
-        "yyyy",
-        "MM",
-        "dd",
-        "HH",
-        "mm",
-        "ss",
-        "sss",
-      ]),
-    ),
-    time: createDateInputType(
-      "time",
-      TIME_REGEXP,
-      createDateParser(TIME_REGEXP, ["HH", "mm", "ss", "sss"]),
-    ),
-    week: createDateInputType("week", WEEK_REGEXP, weekParser),
-    month: createDateInputType(
-      "month",
-      MONTH_REGEXP,
-      createDateParser(MONTH_REGEXP, ["yyyy", "MM"]),
     ),
+    time: createStringDateInputType("time", TIME_REGEXP),
+    week: createStringDateInputType("week", WEEK_REGEXP),
+    month: createStringDateInputType("month", MONTH_REGEXP),
     number: numberInputType,
     url: urlInputType,
     email: emailInputType,
@@ -13060,318 +13101,56 @@
     };
   }
 
-  function weekParser(isoWeek, existingDate) {
-    if (isDate(isoWeek)) {
-      return isoWeek;
-    }
-
-    function getFirstThursdayOfYear(year) {
-      // 0 = index of January
-      const dayOfWeekOnFirst = new Date(year, 0, 1).getDay();
-
-      // 4 = index of Thursday (+1 to account for 1st = 5)
-      // 11 = index of *next* Thursday (+1 account for 1st = 12)
-      return new Date(
-        year,
-        0,
-        // eslint-disable-next-line no-magic-numbers
-        (dayOfWeekOnFirst <= 4 ? 5 : 12) - dayOfWeekOnFirst,
-      );
-    }
-
-    if (isString(isoWeek)) {
-      WEEK_REGEXP.lastIndex = 0;
-      const parts = WEEK_REGEXP.exec(isoWeek);
-
-      if (parts) {
-        const year = +parts[1];
-
-        const week = +parts[2];
-
-        let hours = 0;
-
-        let minutes = 0;
-
-        let seconds = 0;
-
-        let milliseconds = 0;
-
-        const firstThurs = getFirstThursdayOfYear(year);
-
-        const DAYS = 7;
-
-        const addDays = (week - 1) * DAYS;
-
-        if (existingDate) {
-          hours = existingDate.getHours();
-          minutes = existingDate.getMinutes();
-          seconds = existingDate.getSeconds();
-          milliseconds = existingDate.getMilliseconds();
-        }
-
-        return new Date(
-          year,
-          0,
-          firstThurs.getDate() + addDays,
-          hours,
-          minutes,
-          seconds,
-          milliseconds,
-        );
-      }
-    }
-
-    return NaN;
-  }
-
-  function createDateParser(regexp, mapping) {
-    return function (iso, previousDate) {
-      let parts;
-
-      let map;
-
-      if (isDate(iso)) {
-        return iso;
-      }
-
-      if (isString(iso)) {
-        // When a date is JSON'ified to wraps itself inside of an extra
-        // set of double quotes. This makes the date parsing code unable
-        // to match the date string and parse it as a date.
-        if (iso.charAt(0) === '"' && iso.charAt(iso.length - 1) === '"') {
-          iso = iso.substring(1, iso.length - 1);
-        }
-
-        if (ISO_DATE_REGEXP.test(iso)) {
-          return new Date(iso);
-        }
-        regexp.lastIndex = 0;
-        parts = regexp.exec(iso);
-
-        if (parts) {
-          parts.shift();
-
-          if (previousDate) {
-            map = {
-              yyyy: previousDate.getFullYear(),
-              MM: previousDate.getMonth() + 1,
-              dd: previousDate.getDate(),
-              HH: previousDate.getHours(),
-              mm: previousDate.getMinutes(),
-              ss: previousDate.getSeconds(),
-              sss: previousDate.getMilliseconds() / 1000,
-            };
-          } else {
-            map = { yyyy: 1970, MM: 1, dd: 1, HH: 0, mm: 0, ss: 0, sss: 0 };
-          }
-
-          Object.entries(parts).forEach(([index, part]) => {
-            if (index < mapping.length) {
-              map[mapping[index]] = +part;
-            }
-          });
-
-          const date = new Date(
-            map.yyyy,
-            map.MM - 1,
-            map.dd,
-            map.HH,
-            map.mm,
-            map.ss || 0,
-            map.sss * 1000 || 0,
-          );
-
-          if (map.yyyy < 100) {
-            // In the constructor, 2-digit years map to 1900-1999.
-            // Use `setFullYear()` to set the correct year.
-            date.setFullYear(map.yyyy);
-          }
-
-          return date;
-        }
-      }
-
-      return NaN;
-    };
-  }
-
-  const MONTH_INPUT_FORMAT = /\b\d{4}-(0[1-9]|1[0-2])\b/;
-
-  function createDateInputType(type, regexp, parseDate) {
-    return function dynamicDateInputType(
-      scope,
-      element,
-      attr,
-      ctrl,
-      $filter,
-      $parse,
-    ) {
-      badInputChecker(scope, element, attr, ctrl, type);
+  /**
+   * @param {string} type
+   * @param {RegExp} regexp
+   * @returns {*}
+   */
+  function createStringDateInputType(type, regexp) {
+    return function stringDateInputType(scope, element, attr, ctrl, $parse) {
       baseInputType(scope, element, attr, ctrl);
-      let previousDate;
-
       ctrl.$parsers.push((value) => {
         if (ctrl.$isEmpty(value)) return null;
 
-        if (regexp.test(value)) {
-          // Do not convert for native HTML
-          if (["month", "week", "datetimelocal", "time", "date"].includes(type)) {
-            return value;
-          }
+        if (regexp.test(value)) return value;
 
-          // Note: We cannot read ctrl.$modelValue, as there might be a different
-          // parser/formatter in the processing chain so that the model
-          // contains some different data format!
-          return parseDateAndConvertTimeZoneToLocal(value, previousDate);
-        }
         ctrl.$$parserName = type;
 
         return undefined;
       });
 
-      ctrl.$formatters.push(function (value) {
-        if (value && !isString(value)) {
-          throw ngModelMinErr("datefmt", "Expected `{0}` to be a String", value);
-        }
-
-        if (type === "month") {
-          if (isNullOrUndefined(value)) {
-            return "";
-          }
-
-          if (!MONTH_INPUT_FORMAT.test(value)) {
-            throw ngModelMinErr(
-              "datefmt",
-              "Expected month `{0}` to be a 'YYYY-DD'",
-              value,
-            );
-          }
-        }
-
-        if (type === "week") {
-          if (isNullOrUndefined(value)) {
-            return "";
-          }
-
-          if (!WEEK_REGEXP.test(value)) {
-            throw ngModelMinErr(
-              "datefmt",
-              "Expected week `{0}` to be a 'yyyy-Www'",
-              value,
-            );
-          }
-        }
-
-        if (type === "datetimelocal") {
-          if (isNullOrUndefined(value)) {
-            return "";
-          }
+      ctrl.$formatters.push((value) => {
+        if (ctrl.$isEmpty(value)) return "";
 
-          if (!DATETIMELOCAL_REGEXP.test(value)) {
-            throw ngModelMinErr(
-              "datefmt",
-              "Expected week `{0}` to be a in date time format. See: https://developer.mozilla.org/en-US/docs/Web/HTML/Date_and_time_formats#local_date_and_time_strings",
-              value,
-            );
-          }
+        if (!isString(value)) {
+          throw ngModelMinErr("datefmt", "Expected `{0}` to be a string", value);
         }
 
         return value;
-
-        // if (isValidDate(value)) {
-        //   previousDate = value;
-        //   const timezone = ctrl.$options.getOption("timezone");
-
-        //   if (timezone) {
-        //     previousTimezone = timezone;
-        //     previousDate = convertTimezoneToLocal(previousDate, timezone, true);
-        //   }
-
-        //   return value;
-        // }
-        // previousDate = null;
-        // previousTimezone = null;
-        // return "";
       });
 
+      // Optional min/max
       if (isDefined(attr.min) || attr.ngMin) {
-        let minVal = attr.min || $parse(attr.ngMin)(scope);
+        let minVal = attr.min || $parse?.(attr.ngMin)(scope);
 
-        let parsedMinVal = parseObservedDateValue(deProxy(minVal));
-
-        ctrl.$validators.min = function (value) {
-          if (type === "month") {
-            return (
-              isUndefined(parsedMinVal) ||
-              parseDate(value) >= parseDate(parsedMinVal)
-            );
-          }
-
-          return (
-            !isValidDate(value) ||
-            isUndefined(parsedMinVal) ||
-            parseDate(value) >= parsedMinVal
-          );
-        };
+        ctrl.$validators.min = (_modelValue, viewValue) =>
+          ctrl.$isEmpty(viewValue) || viewValue >= minVal;
         attr.$observe("min", (val) => {
-          if (val !== minVal) {
-            parsedMinVal = parseObservedDateValue(val);
-            minVal = val;
-            ctrl.$validate();
-          }
+          minVal = val;
+          ctrl.$validate();
         });
       }
 
       if (isDefined(attr.max) || attr.ngMax) {
-        let maxVal = attr.max || $parse(attr.ngMax)(scope);
-
-        let parsedMaxVal = parseObservedDateValue(deProxy(maxVal));
-
-        ctrl.$validators.max = function (value) {
-          if (type === "month") {
-            return (
-              isUndefined(parsedMaxVal) ||
-              parseDate(value) <= parseDate(parsedMaxVal)
-            );
-          }
+        let maxVal = attr.max || $parse?.(attr.ngMax)(scope);
 
-          return (
-            !isValidDate(value) ||
-            isUndefined(parsedMaxVal) ||
-            parseDate(value) <= parsedMaxVal
-          );
-        };
+        ctrl.$validators.max = (_modelValue, viewValue) =>
+          ctrl.$isEmpty(viewValue) || viewValue <= maxVal;
         attr.$observe("max", (val) => {
-          if (val !== maxVal) {
-            parsedMaxVal = parseObservedDateValue(val);
-            maxVal = val;
-            ctrl.$validate();
-          }
+          maxVal = val;
+          ctrl.$validate();
         });
       }
-
-      function isValidDate(value) {
-        // Invalid Date: getTime() returns NaN
-        return value && !(value.getTime && Number.isNaN(value.getTime()));
-      }
-
-      function parseObservedDateValue(val) {
-        return isDefined(val) && !isDate(val)
-          ? parseDateAndConvertTimeZoneToLocal(val) || undefined
-          : val;
-      }
-
-      function parseDateAndConvertTimeZoneToLocal(value, previousDateParam) {
-        const timezone = ctrl.$options.getOption("timezone");
-
-        let parsedDate = parseDate(value, previousDateParam);
-
-        if (!Number.isNaN(parsedDate) && timezone) {
-          parsedDate = convertTimezoneToLocal(parsedDate, timezone);
-        }
-
-        return parsedDate;
-      }
     };
   }
 
@@ -13496,7 +13275,7 @@
     return (value - stepBase) % step === 0;
   }
 
-  function numberInputType(scope, element, attr, ctrl, $filter, $parse) {
+  function numberInputType(scope, element, attr, ctrl, $parse) {
     badInputChecker(scope, element, attr, ctrl, "number");
     numberFormatterParser(ctrl);
     baseInputType(scope, element, attr, ctrl);
@@ -13835,7 +13614,7 @@
     return fallback;
   }
 
-  function checkboxInputType(scope, element, attr, ctrl, $filter, $parse) {
+  function checkboxInputType(scope, element, attr, ctrl, $parse) {
     const trueValue = parseConstantExpr(
       $parse,
       scope,
@@ -13874,14 +13653,13 @@
     ctrl.$parsers.push((value) => (value ? trueValue : falseValue));
   }
 
-  inputDirective.$inject = [$injectTokens._filter, $injectTokens._parse];
+  inputDirective.$inject = [$injectTokens._parse];
 
   /**
-   * @param {ng.FilterFactory} $filter
    * @param {ng.ParseService} $parse
    * @returns {ng.Directive}
    */
-  function inputDirective($filter, $parse) {
+  function inputDirective($parse) {
     return {
       restrict: "E",
       require: ["?ngModel"],
@@ -13893,7 +13671,6 @@
               element,
               attr,
               ctrls[0],
-              $filter,
               $parse,
             );
           }
@@ -13905,47 +13682,18 @@
   /**
    * @returns {ng.Directive}
    */
-  function hiddenInputBrowserCacheDirective() {
-    const valueProperty = {
-      configurable: true,
-      enumerable: false,
-      get() {
-        return this.getAttribute("value") || "";
-      },
-      set(val) {
-        this.setAttribute("value", val);
-      },
-    };
-
+  function hiddenInputDirective() {
     return {
       restrict: "E",
-      priority: 200,
       compile(_, attr) {
-        if (attr.type?.toLowerCase() !== "hidden") {
-          return undefined;
-        }
+        if (attr.type?.toLowerCase() !== "hidden") return undefined;
 
-        const res = {
+        return {
           pre(_scope, element) {
-            const node = element;
-
-            // Support: Edge
-            // Moving the DOM around prevents autofillling
-            if (node.parentNode) {
-              node.parentNode.insertBefore(node, node.nextSibling);
-            }
-
-            // Support: FF, IE
-            // Avoiding direct assignment to .value prevents autofillling
-            if (Object.defineProperty) {
-              Object.defineProperty(node, "value", valueProperty);
-            }
-
-            return undefined;
+            /** @type {HTMLInputElement} */ (element).value =
+              element.getAttribute("value") ?? "";
           },
         };
-
-        return res;
       },
     };
   }
@@ -14017,8 +13765,6 @@
       "selectValueMap",
       "emptyOption",
       "optionsMap",
-      "$scope",
-      "$element",
     ];
 
     /**
@@ -14046,8 +13792,8 @@
       /** @type {boolean} */
       this.multiple = false;
 
-      /** @type {HTMLOptionElement} */
-      this.unknownOption = document.createElement("option");
+      /** @private @type {HTMLOptionElement} */
+      this._unknownOption = document.createElement("option");
 
       /** @type {boolean} */
       this.hasEmptyOption = false;
@@ -14079,10 +13825,10 @@
     renderUnknownOption(val) {
       const unknownVal = this.generateUnknownOptionValue(val);
 
-      this.unknownOption.value = unknownVal;
-      this.$element.prepend(this.unknownOption);
-      this.unknownOption.selected = true;
-      this.unknownOption.setAttribute("selected", "selected");
+      this._unknownOption.value = unknownVal;
+      this.$element.prepend(this._unknownOption);
+      this._unknownOption.selected = true;
+      this._unknownOption.setAttribute("selected", "selected");
       this.$element.value = unknownVal;
     }
 
@@ -14093,9 +13839,9 @@
     updateUnknownOption(val) {
       const unknownVal = this.generateUnknownOptionValue(val);
 
-      this.unknownOption.value = unknownVal;
-      this.unknownOption.selected = true;
-      this.unknownOption.setAttribute("selected", "selected");
+      this._unknownOption.value = unknownVal;
+      this._unknownOption.selected = true;
+      this._unknownOption.setAttribute("selected", "selected");
       this.$element.value = unknownVal;
     }
 
@@ -14116,7 +13862,7 @@
      * Remove the unknown option from the select element if it exists.
      */
     removeUnknownOption() {
-      if (this.unknownOption.parentElement) this.unknownOption.remove();
+      if (this._unknownOption.parentElement) this._unknownOption.remove();
     }
 
     /**
@@ -14241,7 +13987,7 @@
      * @returns {boolean} Whether the unknown option is currently selected.
      */
     $isUnknownOptionSelected() {
-      return this.$element.options[0] === this.unknownOption;
+      return this.$element.options[0] === this._unknownOption;
     }
 
     /**
@@ -14262,7 +14008,7 @@
       if (isNullOrUndefined(value) && this.emptyOption) {
         this.removeUnknownOption();
         this.selectEmptyOption();
-      } else if (this.unknownOption.parentElement) {
+      } else if (this._unknownOption.parentElement) {
         this.updateUnknownOption(value);
       } else {
         this.renderUnknownOption(value);
@@ -14421,7 +14167,7 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function selectDirective() {
     return {
@@ -14644,7 +14390,9 @@
         scope.$watch(
           attr.ngBind,
           (value) => {
-            element.textContent = stringify$1(deProxy(value));
+            element.textContent = /** @type {string} */ (
+              stringify$1(deProxy(value))
+            );
           },
           isDefined(attr.lazy),
         );
@@ -14653,17 +14401,17 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngBindTemplateDirective() {
     return {
       /**
        * @param {ng.Scope} _scope
        * @param {Element} element
-       * @param {import('../../core/compile/attributes.js').Attributes} attr
+       * @param {ng.Attributes} attr
        */
       link(_scope, element, attr) {
-        attr.$observe("ngBindTemplate", (value) => {
+        attr.$observe("ngBindTemplate", (/** @type {string | null} */ value) => {
           element.textContent = isUndefined(value) ? "" : value;
         });
       },
@@ -14672,8 +14420,8 @@
 
   ngBindHtmlDirective.$inject = [$injectTokens._parse];
   /**
-   * @param {import('../../core/parse/interface.ts').ParseService} $parse
-   * @returns {import('../../interface.ts').Directive}
+   * @param {ng.ParseService} $parse
+   * @returns {ng.Directive}
    */
   function ngBindHtmlDirective($parse) {
     return {
@@ -14962,7 +14710,8 @@
 
   ngHideDirective.$inject = [$injectTokens._animate];
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @param {ng.AnimateService} $animate
+   * @returns {ng.Directive}
    */
   function ngHideDirective($animate) {
     return {
@@ -15004,7 +14753,7 @@
        * @param {Element} $element
        * @param {ng.Attributes} $attr
        * @param {*} _ctrl
-       * @param {*} $transclude
+       * @param {ng.TranscludeFn} $transclude
        */
       link($scope, $element, $attr, _ctrl, $transclude) {
         /** @type {Element | null | undefined} */
@@ -15019,23 +14768,28 @@
         $scope.$watch($attr.ngIf, (value) => {
           if (value) {
             if (!childScope) {
-              $transclude((clone, newScope) => {
-                childScope = newScope;
-                // Note: We only need the first/last node of the cloned nodes.
-                // However, we need to keep the reference to the dom wrapper as it might be changed later
-                // by a directive with templateUrl when its template arrives.
-                block = clone;
-
-                if (hasAnimate(clone)) {
-                  $animate.enter(
-                    clone,
-                    /** @type {Element} */ ($element.parentElement),
-                    $element,
-                  );
-                } else {
-                  $element.after(clone);
-                }
-              });
+              $transclude(
+                (
+                  /** @type {Element} */ clone,
+                  /** @type {ng.Scope} */ newScope,
+                ) => {
+                  childScope = newScope;
+                  // Note: We only need the first/last node of the cloned nodes.
+                  // However, we need to keep the reference to the dom wrapper as it might be changed later
+                  // by a directive with templateUrl when its template arrives.
+                  block = clone;
+
+                  if (hasAnimate(/** @type {Node} */ (clone))) {
+                    $animate.enter(
+                      /** @type {Element} */ (clone),
+                      /** @type {Element} */ ($element.parentElement),
+                      $element,
+                    );
+                  } else {
+                    $element.after(/** @type {Node} */ (clone));
+                  }
+                },
+              );
             }
           } else {
             if (previousElements) {
@@ -15154,9 +14908,9 @@
             if (src) {
               // set the 2nd param to true to ignore the template request error so that the inner
               // contents and scope can be cleaned up.
-              await $templateRequest(src, true).then(
+              await $templateRequest(src).then(
                 (response) => {
-                  if (scope.$$destroyed) return;
+                  if (scope._destroyed) return;
 
                   if (thisChangeId !== changeCounter) return;
                   const newScope = scope.$new();
@@ -15188,7 +14942,7 @@
                   scope.$eval(onloadExp);
                 },
                 (err) => {
-                  if (scope.$$destroyed) return;
+                  if (scope._destroyed) return;
 
                   if (thisChangeId === changeCounter) {
                     cleanupLastIncludeContent();
@@ -15231,7 +14985,7 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngInitDirective() {
     return {
@@ -15253,7 +15007,7 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngNonBindableDirective() {
     return {
@@ -15399,7 +15153,7 @@
       if (keyIdentifier) scope[keyIdentifier] = key;
 
       if (value) {
-        scope.$target.$$hashKey = value.$$hashKey;
+        scope.$target._hashKey = value._hashKey;
       }
       scope.$index = index;
       scope.$first = index === 0;
@@ -15727,7 +15481,7 @@
 
       // asks for $scope to fool the BC controller module
       controller: [
-        "$scope",
+        $injectTokens._scope,
         class {
           constructor() {
             this.cases = {};
@@ -15756,19 +15510,20 @@
 
           let ii;
 
+          let runner;
+
           // Start with the last, in case the array is modified during the loop
           while (previousLeaveAnimations.length) {
             $animate.cancel(previousLeaveAnimations.pop());
           }
 
           for (i = 0, ii = selectedScopes.length; i < ii; ++i) {
-            const selected = getBlockNodes(selectedElements[i].clone);
+            const selected = selectedElements[i].clone;
 
             selectedScopes[i].$destroy();
 
             if (hasAnimate(selected)) {
-              const runner = (previousLeaveAnimations[i] =
-                $animate.leave(selected));
+              runner = previousLeaveAnimations[i] = $animate.leave(selected);
 
               runner.done(spliceFactory(previousLeaveAnimations, i));
             } else {
@@ -15798,7 +15553,13 @@
                 selectedElements.push(block);
 
                 if (hasAnimate(caseElement)) {
-                  $animate.enter(caseElement, anchor.parentElement, anchor);
+                  if (runner) {
+                    requestAnimationFrame(() => {
+                      $animate.enter(caseElement, anchor.parentElement, anchor);
+                    });
+                  } else {
+                    $animate.enter(caseElement, anchor.parentElement, anchor);
+                  }
                 } else {
                   domInsert(caseElement, anchor.parentElement, anchor);
                 }
@@ -15811,7 +15572,7 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngSwitchWhenDirective() {
     return {
@@ -15841,7 +15602,7 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngSwitchDefaultDirective() {
     return {
@@ -17471,13 +17232,21 @@
            *
            * @param {Element} element - the element which will be inserted into the DOM
            * @param {Element} parent - the parent element which will append the element as a child (so long as the after element is not present)
-           * @param {Element} [after] - after the sibling element after which the element will be appended
+           * @param {ChildNode | null | undefined} [after] - after the sibling element after which the element will be appended
            * @param {import("./interface.ts").AnimationOptions} [options] - an optional collection of options/styles that will be applied to the element.
            * @returns {import('./runner/animate-runner.js').AnimateRunner} the animation runner
            */
           enter(element, parent, after, options) {
             parent = parent || after.parentElement;
-            animatedomInsert(element, parent, after);
+
+            if (
+              isInstanceOf(element, HTMLElement) &&
+              isInstanceOf(parent, HTMLElement)
+            ) {
+              animatedomInsert(element, parent, after);
+            } else {
+              domInsert(element, parent, after);
+            }
 
             return $$animateQueue.push(
               element,
@@ -17500,7 +17269,15 @@
            */
           move(element, parent, after, options) {
             parent = parent || after.parentElement;
-            animatedomInsert(element, parent, after);
+
+            if (
+              isInstanceOf(element, HTMLElement) &&
+              isInstanceOf(parent, HTMLElement)
+            ) {
+              animatedomInsert(element, parent, after);
+            } else {
+              domInsert(element, parent, after);
+            }
 
             return $$animateQueue.push(
               element,
@@ -17539,7 +17316,7 @@
            *
            * @param {Element} element the element which the CSS classes will be applied to
            * @param {string} className the CSS class(es) that will be added (multiple classes are separated via spaces)
-           * @param {import("./interface").AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.
+           * @param {import("./interface.ts").AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.
            * @return {import('./runner/animate-runner.js').AnimateRunner}} animationRunner the animation runner
            */
           addClass(element, className, options) {
@@ -17559,7 +17336,7 @@
            *
            * @param {Element} element the element which the CSS classes will be applied to
            * @param {string} className the CSS class(es) that will be removed (multiple classes are separated via spaces)
-           * @param {import("./interface").AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.         *
+           * @param {import("./interface.ts").AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.         *
            * @return {import('./runner/animate-runner.js').AnimateRunner} animationRunner the animation runner
            */
           removeClass(element, className, options) {
@@ -18181,55 +17958,6 @@
     }
   }
 
-  $IsStateFilter.$inject = [$injectTokens._state];
-
-  /**
-   * `isState` Filter: truthy if the current state is the parameter
-   *
-   * Translates to [[StateService.is]] `$state.is("stateName")`.
-   *
-   * #### Example:
-   * ```html
-   * <div ng-if="'stateName' | isState">show if state is 'stateName'</div>
-   * ```
-   *
-   * @param {import('./state/state-service.js').StateProvider} $state
-   * @returns {ng.FilterFn}
-   */
-  function $IsStateFilter($state) {
-    const isFilter = (state, params, options) =>
-      $state.is(state, params, options);
-
-    isFilter.$stateful = true;
-
-    return isFilter;
-  }
-
-  $IncludedByStateFilter.$inject = [$injectTokens._state];
-
-  /**
-   * `includedByState` Filter: truthy if the current state includes the parameter
-   *
-   * Translates to [[StateService.includes]]` $state.is("fullOrPartialStateName")`.
-   *
-   * #### Example:
-   * ```html
-   * <div ng-if="'fullOrPartialStateName' | includedByState">show if state includes 'fullOrPartialStateName'</div>
-   * ```
-   *
-   * @param {import('./state/state-service.js').StateProvider} $state
-   * @returns {ng.FilterFn}
-   */
-  function $IncludedByStateFilter($state) {
-    const includesFilter = function (state, params, options) {
-      return $state.includes(state, params, options);
-    };
-
-    includesFilter.$stateful = true;
-
-    return includesFilter;
-  }
-
   /* @ignore */
   const SUFFIX = "Filter";
 
@@ -18253,8 +17981,6 @@
         json: jsonFilter,
         limitTo: limitToFilter,
         orderBy: orderByFilter,
-        isState: $IsStateFilter,
-        includedByState: $IncludedByStateFilter,
       }).forEach(([k, v]) =>
         this.register(k, /** @type {ng.FilterFactory} */ (v)),
       );
@@ -18378,9 +18104,9 @@
             : function (scope, locals) {
                 let lastValue;
 
-                expressions.forEach((exp) => {
-                  lastValue = exp(scope, locals);
-                });
+                for (let i = 0, j = expressions.length; i < j; i++) {
+                  lastValue = expressions[i](scope, locals);
+                }
 
                 return lastValue;
               };
@@ -19027,7 +18753,7 @@
 
     let argsToWatch;
 
-    let isStatelessFilter;
+    let isFilter;
 
     const decoratedNode = /** @type  {DecoratedASTNode} */ (ast);
 
@@ -19158,10 +18884,8 @@
 
         return decoratedNode;
       case ASTType._CallExpression:
-        isStatelessFilter = ast.filter
-          ? isStateless($filter, ast.callee.name)
-          : false;
-        allConstants = isStatelessFilter;
+        isFilter = ast.filter;
+        allConstants = isFilter;
         argsToWatch = [];
         ast.arguments.forEach((expr) => {
           decorated = findConstantAndWatchExpressions(expr, $filter, astIsPure);
@@ -19169,7 +18893,7 @@
           argsToWatch.push.apply(argsToWatch, decorated.toWatch);
         });
         decoratedNode.constant = allConstants;
-        decoratedNode.toWatch = isStatelessFilter ? argsToWatch : [decoratedNode];
+        decoratedNode.toWatch = isFilter ? argsToWatch : [decoratedNode];
 
         return decoratedNode;
       case ASTType._AssignmentExpression:
@@ -19316,12 +19040,6 @@
     return undefined === parentIsPure ? PURITY_RELATIVE : parentIsPure;
   }
 
-  function isStateless($filter, filterName) {
-    const fn = $filter(filterName);
-
-    return !fn.$stateful;
-  }
-
   /**
    * Converts parameter to  strings property name for use  as keys in an object.
    * Any non-string object, including a number, is typecasted into a string via the toString method.
@@ -20363,7 +20081,7 @@
       const fn = this._astCompiler.compile(ast);
 
       fn.literal = isLiteral(ast);
-      fn.constant = isConstant(ast);
+      fn.constant = !!ast.constant;
 
       return fn;
     }
@@ -20381,18 +20099,25 @@
     }
   }
 
+  /**
+   * @param {import("../ast/ast-node.d.ts").ASTNode} ast
+   * @returns {boolean}
+   */
   function isLiteral(ast) {
-    return (
-      ast.body.length === 0 ||
-      (ast.body.length === 1 &&
-        (ast.body[0].expression.type === ASTType._Literal ||
-          ast.body[0].expression.type === ASTType._ArrayExpression ||
-          ast.body[0].expression.type === ASTType._ObjectExpression))
-    );
-  }
+    const { body } = ast;
 
-  function isConstant(ast) {
-    return ast.constant;
+    if (body && body.length === 1) {
+      switch (body[0].expression?.type) {
+        case ASTType._Literal:
+        case ASTType._ArrayExpression:
+        case ASTType._ObjectExpression:
+          return true;
+        default:
+          return false;
+      }
+    } else {
+      return true;
+    }
   }
 
   class ParseProvider {
@@ -20437,7 +20162,7 @@
         /**
          *
          * @param {(any) => any} $filter
-         * @returns {import('./interface').ParseService}
+         * @returns {import('./interface.ts').ParseService}
          */
         function ($filter) {
           /** @type {import("./lexer/lexer.js").LexerOptions} */
@@ -20488,7 +20213,7 @@
           /**
            * @param {Function} parsedExpression
            * @param interceptorFn
-           * @returns {import('./interface').CompiledExpression|*}
+           * @returns {import('./interface.ts').CompiledExpression|*}
            */
           function addInterceptor(parsedExpression, interceptorFn) {
             if (!interceptorFn) {
@@ -20617,7 +20342,7 @@
    * @param {ng.Scope} scope
    * @param {Function} listener
    * @param {*} objectEquality
-   * @param {import('./interface').CompiledExpression} parsedExpression
+   * @param {import('./interface.ts').CompiledExpression} parsedExpression
    * @returns {any}
    */
   function inputsWatchDelegate(
@@ -21184,19 +20909,19 @@
    * The pathname, beginning with "/"
    * @type {string}
    */
-  let $$path;
+  let _path;
 
   /**
-   * @type {Object.<string,boolean|Array>}
+   * @type {Object.<string,boolean|Array<any>>}
    */
-  let $$search;
+  let _search;
 
   /**
    * @ignore
    * The hash string, minus the hash symbol
    * @type {string}
    */
-  let $$hash;
+  let _hash;
 
   class Location {
     /**
@@ -21233,14 +20958,14 @@
        * Current url
        * @type {string}
        */
-      this.$$url = undefined;
+      this._url = undefined;
 
       /**
        * @ignore
        * Callback to update browser url
-       * @type {Function}
+       * @type {Function | undefined}
        */
-      this.$$updateBrowser = undefined;
+      this._updateBrowser = undefined;
     }
 
     /**
@@ -21271,7 +20996,7 @@
      * @return {string} url
      */
     getUrl() {
-      return this.$$url;
+      return this._url;
     }
 
     /**
@@ -21283,8 +21008,8 @@
     setPath(path) {
       const newPath = path !== null ? path.toString() : "";
 
-      $$path = newPath.charAt(0) === "/" ? newPath : `/${newPath}`;
-      this.$$compose();
+      _path = newPath.charAt(0) === "/" ? newPath : `/${newPath}`;
+      this._compose();
 
       return this;
     }
@@ -21296,7 +21021,7 @@
      * @return {string}
      */
     getPath() {
-      return $$path;
+      return _path;
     }
 
     /**
@@ -21305,8 +21030,8 @@
      * @return {Location} hash
      */
     setHash(hash) {
-      $$hash = hash !== null ? hash.toString() : "";
-      this.$$compose();
+      _hash = hash !== null ? hash.toString() : "";
+      this._compose();
 
       return this;
     }
@@ -21316,7 +21041,7 @@
      * @return {string} hash
      */
     getHash() {
-      return $$hash;
+      return _hash;
     }
 
     /**
@@ -21331,7 +21056,7 @@
         case 1:
           if (isString(search) || isNumber(search)) {
             search = search.toString();
-            $$search = parseKeyValue(search);
+            _search = parseKeyValue(search);
           } else if (isObject(search)) {
             search = structuredClone(search, {});
             // remove object undefined or null properties
@@ -21339,7 +21064,7 @@
               if (isNull(value)) delete search[key];
             });
 
-            $$search = search;
+            _search = search;
           } else {
             throw $locationMinErr(
               "isrcharg",
@@ -21349,14 +21074,14 @@
           break;
         default:
           if (isUndefined(paramValue) || paramValue === null) {
-            delete $$search[search];
+            delete _search[search];
           } else {
             // @ts-ignore
-            $$search[search] = paramValue;
+            _search[search] = paramValue;
           }
       }
 
-      this.$$compose();
+      this._compose();
 
       return this;
     }
@@ -21367,20 +21092,20 @@
      * @returns {Object} Search object or Location object
      */
     getSearch() {
-      return $$search;
+      return _search;
     }
 
     /**
      * @private
      * Compose url and update `url` and `absUrl` property
      */
-    $$compose() {
-      this.$$url = normalizePath($$path, $$search, $$hash);
+    _compose() {
+      this._url = normalizePath(_path, _search, _hash);
       this.absUrl = this.html5
-        ? this.appBaseNoFile + this.$$url.substring(1)
-        : this.appBase + (this.$$url ? this.hashPrefix + this.$$url : "");
+        ? this.appBaseNoFile + this._url.substring(1)
+        : this.appBase + (this._url ? this.hashPrefix + this._url : "");
       urlUpdatedByLocation = true;
-      setTimeout(() => this.$$updateBrowser && this.$$updateBrowser());
+      setTimeout(() => this._updateBrowser && this._updateBrowser());
     }
 
     /**
@@ -21491,11 +21216,11 @@
 
         parseAppUrl(pathUrl, true);
 
-        if (!$$path) {
-          $$path = "/";
+        if (!_path) {
+          _path = "/";
         }
 
-        this.$$compose();
+        this._compose();
       } else {
         const withoutBaseUrl =
           stripBaseUrl(this.appBase, url) ||
@@ -21529,9 +21254,9 @@
 
         parseAppUrl(withoutHashUrl, false);
 
-        $$path = removeWindowsDriveName($$path, withoutHashUrl, this.appBase);
+        _path = removeWindowsDriveName(_path, withoutHashUrl, this.appBase);
 
-        this.$$compose();
+        this._compose();
 
         /*
          * In Windows, on an anchor node on documents loaded from
@@ -21581,16 +21306,17 @@
         rewriteLinks: true,
       };
 
-      /** @type {Array<import("./interface.ts").UrlChangeListener>} */
-      this.urlChangeListeners = [];
-      this.urlChangeInit = false;
-
-      /** @type {History['state']} */
-      this.cachedState = null;
-      /** @type {History['state']} */
-      this.lastHistoryState = null;
-      /** @type {string} */
-      this.lastBrowserUrl = window.location.href;
+      /** @private @type {Array<import("./interface.ts").UrlChangeListener>} */
+      this._urlChangeListeners = [];
+      /** @private */
+      this._urlChangeInit = false;
+
+      /** @private @type {History['state']} */
+      this._cachedState = null;
+      /** @private @type {History['state']} */
+      this._lastHistoryState = null;
+      /** @private @type {string} */
+      this._lastBrowserUrl = window.location.href;
       this.cacheState();
     }
 
@@ -21613,12 +21339,12 @@
       if (url) {
         url = new URL(url).href;
 
-        if (this.lastBrowserUrl === url && this.lastHistoryState === state) {
+        if (this._lastBrowserUrl === url && this._lastHistoryState === state) {
           return this;
         }
 
-        this.lastBrowserUrl = url;
-        this.lastHistoryState = state;
+        this._lastBrowserUrl = url;
+        this._lastHistoryState = state;
         history.pushState(state, "", url);
         this.cacheState();
       }
@@ -21639,7 +21365,7 @@
      * @returns {History['state']} The cached state.
      */
     state() {
-      return this.cachedState;
+      return this._cachedState;
     }
 
     /**
@@ -21651,9 +21377,9 @@
       const currentState = history.state ?? null;
 
       if (!equals$1(currentState, this.lastCachedState)) {
-        this.cachedState = currentState;
+        this._cachedState = currentState;
         this.lastCachedState = currentState;
-        this.lastHistoryState = currentState;
+        this._lastHistoryState = currentState;
       }
     }
 
@@ -21661,20 +21387,20 @@
      * Fires the state or URL change event.
      */
     #fireStateOrUrlChange() {
-      const prevLastHistoryState = this.lastHistoryState;
+      const prevLastHistoryState = this._lastHistoryState;
 
       this.cacheState();
 
       if (
-        this.lastBrowserUrl === this.getBrowserUrl() &&
-        prevLastHistoryState === this.cachedState
+        this._lastBrowserUrl === this.getBrowserUrl() &&
+        prevLastHistoryState === this._cachedState
       ) {
         return;
       }
-      this.lastBrowserUrl = this.getBrowserUrl();
-      this.lastHistoryState = this.cachedState;
-      this.urlChangeListeners.forEach((listener) => {
-        listener(trimEmptyHash(window.location.href), this.cachedState);
+      this._lastBrowserUrl = this.getBrowserUrl();
+      this._lastHistoryState = this._cachedState;
+      this._urlChangeListeners.forEach((listener) => {
+        listener(trimEmptyHash(window.location.href), this._cachedState);
       });
     }
 
@@ -21685,7 +21411,7 @@
      * @returns void
      */
     #onUrlChange(callback) {
-      if (!this.urlChangeInit) {
+      if (!this._urlChangeInit) {
         window.addEventListener(
           "popstate",
           this.#fireStateOrUrlChange.bind(this),
@@ -21694,9 +21420,9 @@
           "hashchange",
           this.#fireStateOrUrlChange.bind(this),
         );
-        this.urlChangeInit = true;
+        this._urlChangeInit = true;
       }
-      this.urlChangeListeners.push(callback);
+      this._urlChangeListeners.push(callback);
     }
 
     $get = [
@@ -21932,12 +21658,16 @@
           }
         };
 
-        $location.$$updateBrowser = updateBrowser;
+        $location._updateBrowser = updateBrowser;
         updateBrowser();
         $rootScope.$on("$updateBrowser", updateBrowser);
 
         return $location;
 
+        /**
+         * @param {string} oldUrl
+         * @param {any} oldState
+         */
         function afterLocationChange(oldUrl, oldState) {
           $rootScope.$broadcast(
             "$locationChangeSuccess",
@@ -22091,13 +21821,13 @@
         ? match.pathname.substring(1)
         : match.pathname;
 
-    $$path = decodePath(path, html5Mode);
-    $$search = parseKeyValue(match.search);
-    $$hash = decodeURIComponent(match.hash);
+    _path = decodePath(path, html5Mode);
+    _search = parseKeyValue(match.search);
+    _hash = decodeURIComponent(match.hash);
 
     // make sure path starts with '/';
-    if ($$path && $$path.charAt(0) !== "/") {
-      $$path = `/${$$path}`;
+    if (_path && _path.charAt(0) !== "/") {
+      _path = `/${_path}`;
     }
   }
 
@@ -22257,7 +21987,8 @@
      * @param {string} type
      */
     _consoleLog(type) {
-      const console = window.console || {};
+      const console =
+        window.console || /** @type {Partial<Record<string, Function>>} */ ({});
 
       const logFn =
         console[type] ||
@@ -22266,7 +21997,7 @@
           /* empty */
         });
 
-      return (...args) => {
+      return (/** @type {any[]} */ ...args) => {
         const formattedArgs = args.map((arg) => this._formatError(arg));
 
         return logFn.apply(console, formattedArgs);
@@ -22349,7 +22080,7 @@
    *
    * @param {Object} target - The object to be wrapped in a proxy.
    * @param {Scope} [context] - The context for the handler, used to track listeners.
-   * @returns {Scope} - A proxy that intercepts operations on the target object,
+   * @returns {Scope|Object} - A proxy that intercepts operations on the target object,
    *                                     or the original value if the target is not an object.
    */
   function createScope(target = {}, context) {
@@ -22405,7 +22136,8 @@
       target instanceof Promise ||
       target instanceof HTMLCollection ||
       target instanceof NodeList ||
-      target instanceof Event
+      target instanceof Event ||
+      target instanceof Date
     ) {
       return true;
     }
@@ -22440,20 +22172,17 @@
       /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners */
       this.watchers = context ? context.watchers : new Map();
 
-      /** @type {Map<String, Function[]>} Event listeners */
-      this.$$listeners = new Map();
-
-      /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
-      this.foreignListeners = context ? context.foreignListeners : new Map();
+      /** @private @type {Map<String, Function[]>} Event listeners */
+      this._listeners = new Map();
 
-      /** @type {Set<Proxy<ng.Scope>>} */
-      this.foreignProxies = context ? context.foreignProxies : new Set();
+      /** @private @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
+      this._foreignListeners = context ? context._foreignListeners : new Map();
 
-      /** @type {WeakMap<Object, Array<string>>} */
-      this.objectListeners = context ? context.objectListeners : new WeakMap();
+      /** @private @type {Set<Proxy<ng.Scope>>} */
+      this._foreignProxies = context ? context._foreignProxies : new Set();
 
-      /** @type {Map<Function, {oldValue: any, fn: Function}>} */
-      this.functionListeners = context ? context.functionListeners : new Map();
+      /** @private @type {WeakMap<Object, Array<string>>} */
+      this._objectListeners = context ? context._objectListeners : new WeakMap();
 
       /** @type {Proxy<Scope>} Current proxy being operated on */
       this.$proxy = null;
@@ -22488,40 +22217,39 @@
           ? null
           : context;
 
-      this.filters = [];
-
-      /** @type {boolean} */
-      this.$$destroyed = false;
+      /** @ignore @type {boolean} */
+      this._destroyed = false;
 
-      this.scheduled = [];
+      /** @private @type {import("./interface.ts").Listener[]} A list of scheduled Event listeners */
+      this._scheduled = [];
 
       this.$scopename = undefined;
 
       /** @private */
       this.propertyMap = {
-        $watch: this.$watch.bind(this),
-        $new: this.$new.bind(this),
-        $newIsolate: this.$newIsolate.bind(this),
-        $destroy: this.$destroy.bind(this),
-        $flushQueue: this.$flushQueue.bind(this),
-        $eval: this.$eval.bind(this),
         $apply: this.$apply.bind(this),
-        $postUpdate: this.$postUpdate.bind(this),
-        $isRoot: this.#isRoot.bind(this),
-        $on: this.$on.bind(this),
-        $emit: this.$emit.bind(this),
         $broadcast: this.$broadcast.bind(this),
-        $transcluded: this.$transcluded.bind(this),
+        $children: this.$children,
+        $destroy: this.$destroy.bind(this),
+        $emit: this.$emit.bind(this),
+        $eval: this.$eval.bind(this),
+        $flushQueue: this.$flushQueue.bind(this),
+        $getById: this.$getById.bind(this),
         $handler: /** @type {Scope} */ (this),
+        $id: this.$id,
+        $isRoot: this.#isRoot.bind(this),
         $merge: this.$merge.bind(this),
-        $getById: this.$getById.bind(this),
-        $searchByName: this.$searchByName.bind(this),
-        $proxy: this.$proxy,
+        $new: this.$new.bind(this),
+        $newIsolate: this.$newIsolate.bind(this),
+        $on: this.$on.bind(this),
         $parent: this.$parent,
+        $postUpdate: this.$postUpdate.bind(this),
+        $proxy: this.$proxy,
         $root: this.$root,
-        $children: this.$children,
-        $id: this.$id,
         $scopename: this.$scopename,
+        $searchByName: this.$searchByName.bind(this),
+        $transcluded: this.$transcluded.bind(this),
+        $watch: this.$watch.bind(this),
       };
     }
 
@@ -22581,18 +22309,18 @@
               this.#scheduleListener(listeners);
             }
 
-            const foreignListeners = this.foreignListeners.get(property);
+            const _foreignListeners = this._foreignListeners.get(property);
 
-            if (foreignListeners) {
-              this.#scheduleListener(foreignListeners);
+            if (_foreignListeners) {
+              this.#scheduleListener(_foreignListeners);
             }
           }
 
-          if (this.objectListeners.get(target[property])) {
-            this.objectListeners.delete(target[property]);
+          if (this._objectListeners.get(target[property])) {
+            this._objectListeners.delete(target[property]);
           }
           target[property] = createScope(value, this);
-          this.objectListeners.set(target[property], [property]);
+          this._objectListeners.set(target[property], [property]);
 
           return true;
         }
@@ -22613,10 +22341,10 @@
               this.#scheduleListener(listeners);
             }
 
-            const foreignListeners = this.foreignListeners.get(property);
+            const _foreignListeners = this._foreignListeners.get(property);
 
-            if (foreignListeners) {
-              this.#scheduleListener(foreignListeners);
+            if (_foreignListeners) {
+              this.#scheduleListener(_foreignListeners);
             }
 
             this.#checkeListenersForAllKeys(value);
@@ -22669,8 +22397,8 @@
           }
 
           if (isArray(target)) {
-            if (this.objectListeners.has(proxy) && property !== "length") {
-              const keyList = this.objectListeners.get(proxy);
+            if (this._objectListeners.has(proxy) && property !== "length") {
+              const keyList = this._objectListeners.get(proxy);
 
               for (let i = 0, l = keyList.length; i < l; i++) {
                 const currentListeners = this.watchers.get(keyList[i]);
@@ -22686,7 +22414,7 @@
         return true;
       } else {
         if (isUndefined(target[property]) && isProxy(value)) {
-          this.foreignProxies.add(/** @type {Proxy<ng.Scope>} */ (value));
+          this._foreignProxies.add(/** @type {Proxy<ng.Scope>} */ (value));
           target[property] = value;
 
           if (!this.watchers.has(property)) {
@@ -22707,8 +22435,8 @@
 
           // Handle the case where we need to start observing object after a watcher has been set
           if (isUndefined(oldValue) && isObject(target[property])) {
-            if (!this.objectListeners.has(target[property])) {
-              this.objectListeners.set(target[property], [property]);
+            if (!this._objectListeners.has(target[property])) {
+              this._objectListeners.set(target[property], [property]);
             }
             const keyList = keys(value);
 
@@ -22771,25 +22499,25 @@
             });
           }
 
-          let foreignListeners = this.foreignListeners.get(property);
+          let _foreignListeners = this._foreignListeners.get(property);
 
-          if (!foreignListeners && this.$parent?.foreignListeners) {
-            foreignListeners = this.$parent.foreignListeners.get(property);
+          if (!_foreignListeners && this.$parent?._foreignListeners) {
+            _foreignListeners = this.$parent._foreignListeners.get(property);
           }
 
-          if (foreignListeners) {
-            let scheduled = foreignListeners;
+          if (_foreignListeners) {
+            let scheduled = _foreignListeners;
 
             // filter for repeaters
-            const hashKey = this.$target.$$hashKey;
+            const hashKey = this.$target._hashKey;
 
             if (hashKey) {
               scheduled = [];
 
-              for (let i = 0, l = foreignListeners.length; i < l; i++) {
-                const listener = foreignListeners[i];
+              for (let i = 0, l = _foreignListeners.length; i < l; i++) {
+                const listener = _foreignListeners[i];
 
-                if (listener.originalTarget.$$hashKey === hashKey) {
+                if (listener.originalTarget._hashKey === hashKey) {
                   scheduled.push(listener);
                 }
               }
@@ -22801,15 +22529,15 @@
           }
         }
 
-        if (this.objectListeners.has(proxy) && property !== "length") {
-          const keyList = this.objectListeners.get(proxy);
+        if (this._objectListeners.has(proxy) && property !== "length") {
+          const keyList = this._objectListeners.get(proxy);
 
           for (let i = 0, l = keyList.length; i < l; i++) {
             const key = keyList[i];
 
             const listeners = this.watchers.get(key);
 
-            if (listeners && this.scheduled !== listeners) {
+            if (listeners && this._scheduled !== listeners) {
               this.#scheduleListener(listeners);
             }
           }
@@ -22849,8 +22577,8 @@
         isArray(target) &&
         ["pop", "shift", "unshift"].includes(/** @type { string } */ (property))
       ) {
-        if (this.objectListeners.has(proxy)) {
-          const keyList = this.objectListeners.get(proxy);
+        if (this._objectListeners.has(proxy)) {
+          const keyList = this._objectListeners.get(proxy);
 
           for (let i = 0, l = keyList.length; i < l; i++) {
             const key = keyList[i];
@@ -22858,13 +22586,13 @@
             const listeners = this.watchers.get(key);
 
             if (listeners) {
-              this.scheduled = listeners;
+              this._scheduled = listeners;
             }
           }
         }
 
         if (property === "unshift") {
-          this.#scheduleListener(this.scheduled);
+          this.#scheduleListener(this._scheduled);
         }
       }
 
@@ -22889,8 +22617,8 @@
           this.#scheduleListener(listeners);
         }
 
-        if (this.objectListeners.has(this.$proxy)) {
-          const keyList = this.objectListeners.get(this.$proxy);
+        if (this._objectListeners.has(this.$proxy)) {
+          const keyList = this._objectListeners.get(this.$proxy);
 
           for (let i = 0, l = keyList.length; i < l; i++) {
             const key = keyList[i];
@@ -22901,9 +22629,9 @@
           }
         }
 
-        if (this.scheduled) {
-          this.#scheduleListener(this.scheduled);
-          this.scheduled = [];
+        if (this._scheduled) {
+          this.#scheduleListener(this._scheduled);
+          this._scheduled = [];
         }
 
         return true;
@@ -22911,8 +22639,8 @@
 
       delete target[property];
 
-      if (this.objectListeners.has(this.$proxy)) {
-        const keyList = this.objectListeners.get(this.$proxy);
+      if (this._objectListeners.has(this.$proxy)) {
+        const keyList = this._objectListeners.get(this.$proxy);
 
         for (let i = 0, l = keyList.length; i < l; i++) {
           const key = keyList[i];
@@ -23154,7 +22882,7 @@
               watchProp.split(".").slice(0, -1).join("."),
             )(/** @type {Scope} */ (listener.originalTarget));
 
-            if (potentialProxy && this.foreignProxies.has(potentialProxy)) {
+            if (potentialProxy && this._foreignProxies.has(potentialProxy)) {
               potentialProxy.$handler.#registerForeignKey(key, listener);
               potentialProxy.$handler.#scheduleListener([listener]);
 
@@ -23237,7 +22965,7 @@
       const listenerObject = listener.watchFn(this.$target);
 
       if (isObject(listenerObject)) {
-        this.objectListeners.set(listenerObject, [key]);
+        this._objectListeners.set(listenerObject, [key]);
       }
 
       if (keySet.length > 0) {
@@ -23331,10 +23059,10 @@
 
     /** @internal **/
     #registerForeignKey(key, listener) {
-      if (this.foreignListeners.has(key)) {
-        this.foreignListeners.get(key).push(listener);
+      if (this._foreignListeners.has(key)) {
+        this._foreignListeners.get(key).push(listener);
       } else {
-        this.foreignListeners.set(key, [listener]);
+        this._foreignListeners.set(key, [listener]);
       }
     }
 
@@ -23359,7 +23087,7 @@
     }
 
     // #deregisterForeignKey(key, id) {
-    //   const listenerList = this.foreignListeners.get(key);
+    //   const listenerList = this._foreignListeners.get(key);
     //   if (!listenerList) return false;
 
     //   const index = listenerList.findIndex((x) => x.id === id);
@@ -23367,9 +23095,9 @@
 
     //   listenerList.splice(index, 1);
     //   if (listenerList.length) {
-    //     this.foreignListeners.set(key, listenerList);
+    //     this._foreignListeners.set(key, listenerList);
     //   } else {
-    //     this.foreignListeners.delete(key);
+    //     this._foreignListeners.delete(key);
     //   }
     //   return true;
     // }
@@ -23429,11 +23157,11 @@
      * @returns {(function(): void)|*}
      */
     $on(name, listener) {
-      let namedListeners = this.$$listeners.get(name);
+      let namedListeners = this._listeners.get(name);
 
       if (!namedListeners) {
         namedListeners = [];
-        this.$$listeners.set(name, namedListeners);
+        this._listeners.set(name, namedListeners);
       }
       namedListeners.push(listener);
 
@@ -23444,7 +23172,7 @@
           namedListeners.splice(indexOfListener, 1);
 
           if (namedListeners.length === 0) {
-            this.$$listeners.delete(name);
+            this._listeners.delete(name);
           }
         }
       };
@@ -23480,7 +23208,7 @@
      */
     #eventHelper({ name, event, broadcast }, ...args) {
       if (!broadcast) {
-        if (!this.$$listeners.has(name)) {
+        if (!this._listeners.has(name)) {
           if (this.$parent) {
             return this.$parent.$handler.#eventHelper(
               { name, event, broadcast },
@@ -23512,7 +23240,7 @@
 
       const listenerArgs = concat([event], [event].concat(args), 1);
 
-      const listeners = this.$$listeners.get(name);
+      const listeners = this._listeners.get(name);
 
       if (listeners) {
         let { length } = listeners;
@@ -23579,7 +23307,7 @@
     }
 
     $destroy() {
-      if (this.$$destroyed) return;
+      if (this._destroyed) return;
 
       this.$broadcast("$destroy");
 
@@ -23610,8 +23338,8 @@
         }
       }
 
-      this.$$listeners.clear();
-      this.$$destroyed = true;
+      this._listeners.clear();
+      this._destroyed = true;
     }
 
     /**
@@ -23693,31 +23421,23 @@
      * @returns {ng.Scope|undefined}
      */
     $searchByName(name) {
-      /**
-       * @param {ng.Scope} scope
-       * @param {string} nameParam
-       * @returns {ng.Scope|undefined}
-       */
-      function getByName(scope, nameParam) {
-        if (scope.$scopename === nameParam) {
-          return scope;
-        } else {
-          let res = undefined;
+      const stack = [this.$root];
 
-          for (const child of scope.$children) {
-            const found = getByName(child, nameParam);
+      while (stack.length) {
+        const scope = stack.pop();
 
-            if (found) {
-              res = found;
-              break;
-            }
-          }
+        if (scope.$scopename === name) {
+          return scope;
+        }
 
-          return res;
+        if (scope.$children?.length) {
+          for (let i = scope.$children.length - 1; i >= 0; i--) {
+            stack.push(scope.$children[i]);
+          }
         }
       }
 
-      return getByName(this.$root, name);
+      return undefined;
     }
   }
 
@@ -23769,146 +23489,65 @@
     return ids;
   }
 
-  const $templateRequestMinErr = minErr("$templateRequest");
-
   /**
-   * Used to configure the options passed to the {@link $http} service when making a template request.
+   * Provider for the `$templateRequest` service.
    *
-   * For example, it can be used for specifying the "Accept" header that is sent to the server, when
-   * requesting a template.
+   * Fetches templates via HTTP and caches them in `$templateCache`.
+   * Templates are assumed trusted. This provider allows configuring
+   * per-request `$http` options such as headers, timeout, or transform functions.
    */
-  function TemplateRequestProvider() {
-    let httpOptions;
+  class TemplateRequestProvider {
+    /** @type {ng.RequestShortcutConfig|undefined} */
+    httpOptions;
 
-    /**
-     * The options to be passed to the {@link $http} service when making the request.
-     * You can use this to override options such as the "Accept" header for template requests.
-     * The {@link $templateRequest} will set the `cache` and the `transformResponse` properties of the
-     * options if not overridden here.
-     *
-     * @param {string=} val new value for the {@link $http} options.
-     * @returns {string|TemplateRequestProvider} Returns the {@link $http} options when used as getter and self if used as setter.
-     */
-    this.httpOptions = function (val) {
-      if (val) {
-        httpOptions = val;
-
-        return this;
-      }
-
-      return httpOptions;
-    };
-
-    /**
-     * The `$templateRequest` service runs security checks then downloads the provided template using
-     * `$http` and, upon success, stores the contents inside of `$templateCache`. If the HTTP request
-     * fails or the response data of the HTTP request is empty, a `$compile` error will be thrown (the
-     * exception can be thwarted by setting the 2nd parameter of the function to true). Note that the
-     * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted
-     * when `tpl` is of type string and `$templateCache` has the matching entry.
-     *
-     * If you want to pass custom options to the `$http` service, such as setting the Accept header you
-     * can configure this via {@link $templateRequestProvider#httpOptions}.
-     *
-     * `$templateRequest` is used internally by {@link $compile}, {@link ngRoute.$route}, and directives such
-     * as {@link ngInclude} to download and cache templates.
-     *
-     * 3rd party modules should use `$templateRequest` if their services or directives are loading
-     * templates.
-     *
-     * @param {string} tpl The HTTP request template URL
-     * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
-     *
-     * @return {Promise} a promise for the HTTP response data of the given URL.
-     *
-     * @property {number} totalPendingRequests total amount of pending template requests being downloaded.
-     */
-    this.$get = [
-      $injectTokens._exceptionHandler,
+    /** @returns {Array} DI tokens for Angular.ts injection */
+    $get = [
       $injectTokens._templateCache,
       $injectTokens._http,
-      $injectTokens._sce,
       /**
-       *
-       * @param {ng.ExceptionHandlerService} $exceptionHandler
        * @param {ng.TemplateCacheService} $templateCache
        * @param {ng.HttpService} $http
-       * @param {*} $sce
        * @returns {ng.TemplateRequestService}
        */
-      function ($exceptionHandler, $templateCache, $http, $sce) {
-        function handleRequestFn(tpl, ignoreRequestError) {
-          handleRequestFn.totalPendingRequests++;
-
-          // We consider the template cache holds only trusted templates, so
-          // there's no need to go through adding the template again to the trusted
-          // resources for keys that already are included in there. This also makes
-          // AngularTS accept any script directive, no matter its name. However, we
-          // still need to unwrap trusted types.
-
-          if (!isString(tpl) || !$templateCache.has(tpl)) {
-            try {
-              tpl = $sce.getTrustedResourceUrl(tpl);
-
-              if (!tpl) {
-                return Promise.reject("Template not found");
-              }
-            } catch (err) {
-              return Promise.reject(err.message);
-            }
-          }
-
-          let transformResponse =
-            $http.defaults && $http.defaults.transformResponse;
+      ($templateCache, $http) => {
+        /**
+         * Fetch a template via HTTP and cache it.
+         *
+         * @param {string} templateUrl URL of the template
+         * @returns {Promise<string>} Resolves with template content
+         */
+        const fetchTemplate = (templateUrl) => {
+          // Filter out default transformResponse for template requests
+          let transformResponse = $http.defaults?.transformResponse ?? null;
 
           if (isArray(transformResponse)) {
-            transformResponse = transformResponse.filter(function (transformer) {
-              return transformer !== defaultHttpResponseTransform;
-            });
+            transformResponse = transformResponse.filter(
+              (x) => x !== defaultHttpResponseTransform,
+            );
           } else if (transformResponse === defaultHttpResponseTransform) {
             transformResponse = null;
           }
 
-          return $http
-            .get(
-              tpl,
-              extend(
-                {
-                  cache: $templateCache,
-                  transformResponse,
-                },
-                httpOptions,
-              ),
-            )
-            .finally(function () {
-              handleRequestFn.totalPendingRequests--;
-            })
-            .then(function (response) {
-              $templateCache.set(tpl, response.data);
-
-              return response.data;
-            }, handleError);
-
-          function handleError(resp) {
-            if (!ignoreRequestError) {
-              resp = $templateRequestMinErr(
-                "tpload",
-                "Failed to load template: {0} (HTTP status: {1} {2})",
-                tpl,
-                resp.status,
-                resp.statusText,
-              );
-
-              $exceptionHandler(resp);
-            }
+          /** @type {ng.RequestShortcutConfig} */
+          const config = extend(
+            {
+              cache: $templateCache,
+              transformResponse,
+            },
+            this.httpOptions || {},
+          );
 
-            return Promise.reject(resp);
-          }
-        }
+          return $http.get(templateUrl, config).then(
+            (response) => {
+              $templateCache.set(templateUrl, response.data);
 
-        handleRequestFn.totalPendingRequests = 0;
+              return response.data;
+            },
+            (resp) => Promise.reject(resp),
+          );
+        };
 
-        return handleRequestFn;
+        return fetchTemplate;
       },
     ];
   }
@@ -24248,12 +23887,12 @@
         const src = attrs.ngMessagesInclude || attrs.src;
 
         $templateRequest(src).then((html) => {
-          if ($scope.$$destroyed) return;
+          if ($scope._destroyed) return;
 
           if (isString(html) && !html.trim()) ; else {
             // Non-empty template - compile and link
             $compile(html)($scope, (contents) => {
-              isIntanceOf(contents, Node) && element.after(contents);
+              isInstanceOf(contents, Node) && element.after(contents);
             });
           }
         });
@@ -24404,11 +24043,7 @@
   ];
 
   const isNodeOneOf = function (elem, nodeTypeArray) {
-    if (nodeTypeArray.indexOf(elem.nodeName) !== -1) {
-      return true;
-    }
-
-    return false;
+    return nodeTypeArray.indexOf(elem.nodeName) !== -1;
   };
 
   /**
@@ -27646,7 +27281,7 @@
     _nextTick() {
       if (!this._queue.length) return;
 
-      const items = this._queue.shift();
+      const items = /** @type{Array<() => void>} */ (this._queue.shift());
 
       items.forEach((fn) => fn());
 
@@ -28583,7 +28218,7 @@
   /**
    * Returns the last element of an array, or undefined if the array is empty.
    * @template T
-   * @param {T[]} arr - The input array.
+   * @param {any[]|string} arr - The input array.
    * @returns {T | undefined} The last element or undefined.
    */
   function tail(arr) {
@@ -28654,16 +28289,16 @@
    *
    * ```
    *
-   * @param fn
+   * @param {Function} fn
    * @returns {*|function(): (*|any)}
    */
   function curry(fn) {
-    const curried = (...args) => {
+    const curried = (/** @type {any[]} */ ...args) => {
       if (args.length >= fn.length) {
         return fn(...args);
       }
 
-      return (...nextArgs) => curried(...args, ...nextArgs);
+      return (/** @type {any} */ ...nextArgs) => curried(...args, ...nextArgs);
     };
 
     return curried;
@@ -28676,7 +28311,13 @@
    * let getName = propEq("name", "blarg");
    * getName(obj) === true
    */
-  const propEq = curry((name, _val, obj) => obj && obj[name] === _val);
+  const propEq = curry(
+    (
+      /** @type {string | number} */ name,
+      /** @type {any} */ _val,
+      /** @type {{ [x: string]: any; }} */ 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" }, };
@@ -28685,10 +28326,11 @@
    * let propNotFound = prop("this.property.doesnt.exist");
    * propNotFound(obj) === undefined
    */
-  const parse = (path) => {
+  const parse = (/** @type {string} */ path) => {
     const parts = path.split(".");
 
-    return (obj) => parts.reduce((acc, key) => acc && acc[key], obj);
+    return (/** @type {any} */ obj) =>
+      parts.reduce((acc, key) => acc && acc[key], obj);
   };
 
   /**
@@ -28713,7 +28355,12 @@
     };
   }
 
-  /** Given a value, returns a function which returns the value */
+  /**
+   * Given a value, returns a function which returns that value.
+   * @template T
+   * @param {T} value - The value to wrap in a function.
+   * @returns {() => T} A function that returns the given value.
+   */
   const val = (value) => () => value;
 
   /**
@@ -28730,31 +28377,28 @@
    * 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): *}
+   * @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 {string | any[]} 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 (item) {
@@ -29414,17 +29058,23 @@
       /**
        * @type {number}
        */
-      this.lastStartedTransitionId = -1;
+      this._lastStartedTransitionId = -1;
 
       /**
        * @type {Queue<import("./transition/transition.js").Transition>}
        */
-      this.transitionHistory = new Queue([], 1);
+      this._transitionHistory = new Queue(
+        /** @type {Array<import("./transition/transition.js").Transition>} */ ([]),
+        1,
+      );
 
       /**
        * @type {Queue<import("./transition/transition.js").Transition>}
        */
-      this.successfulTransitions = new Queue([], 1);
+      this._successfulTransitions = new Queue(
+        /** @type {Array<import("./transition/transition.js").Transition>} */ ([]),
+        1,
+      );
 
       /**
        * @type {import("./state/interface.ts").StateDeclaration|undefined}
@@ -29523,10 +29173,17 @@
     return (_fn && _fn.toString()) || "undefined";
   }
 
+  /**
+   * @param {any} value
+   * @returns {string|*|string}
+   */
   function stringify(value) {
+    /**
+     * @type {any[]}
+     */
     const seen = [];
 
-    const isRejection = (obj) => {
+    const isRejection = (/** @type {Promise<any>} */ obj) => {
       return (
         obj &&
         typeof obj.then === "function" &&
@@ -29534,7 +29191,9 @@
       );
     };
 
-    const hasToString = (obj) =>
+    const hasToString = (
+      /** @type {{ constructor: ObjectConstructor; toString: any; }} */ obj,
+    ) =>
       isObject(obj) &&
       !isArray(obj) &&
       obj.constructor !== Object &&
@@ -29544,12 +29203,23 @@
       [isUndefined, val("undefined")],
       [isNull, val("null")],
       [isPromise, val("[Promise]")],
-      [isRejection, (reg) => reg._transitionRejection.toString()],
-      [hasToString, (str) => str.toString()],
+      [
+        isRejection,
+        (
+          /** @type {{ _transitionRejection: { toString: () => any; }; }} */ reg,
+        ) => reg._transitionRejection.toString(),
+      ],
+      [
+        hasToString,
+        (/** @type {{ toString: () => any; }} */ str) => str.toString(),
+      ],
       [isInjectable, functionToString],
-      [val(true), (bool) => bool],
+      [val(true), (/** @type {any} */ bool) => bool],
     ]);
 
+    /**
+     * @param {any} item
+     */
     function format(item) {
       if (isObject(item)) {
         if (seen.indexOf(item) !== -1) return "[circular ref]";
@@ -29572,7 +29242,9 @@
     );
   }
 
-  const stripLastPathElement = (str) => str.replace(/\/[^/]*$/, "");
+  const stripLastPathElement = (/** @type {string} */ str) =>
+    str.replace(/\/[^/]*$/, "");
+
   /**
    * Splits on a delimiter, but returns the delimiters in the array
    *
@@ -29582,12 +29254,14 @@
    * splitOnSlashes("/foo"); // ["/", "foo"]
    * splitOnSlashes("/foo/"); // ["/", "foo", "/"]
    * ```
+   * @param {string} delim
    */
   function splitOnDelim(delim) {
     const re = new RegExp(`(${delim})`, "g");
 
-    return (str) => str.split(re).filter(Boolean);
+    return (/** @type {string} */ str) => str.split(re).filter(Boolean);
   }
+
   /**
    * Reduce fn that joins neighboring strings
    *
@@ -29599,10 +29273,12 @@
    * let arr = ["foo", "bar", 1, "baz", "", "qux" ];
    * arr.reduce(joinNeighborsR, []) // ["foobar", 1, "bazqux" ]
    * ```
+   * @param {string | any[]} acc
+   * @param {unknown} str
    */
   function joinNeighborsR(acc, str) {
-    if (isString(tail(acc)) && isString(str))
-      return acc.slice(0, -1).concat(tail(acc) + str);
+    if (isString(tail(/** @type {string} */ (acc))) && isString(str))
+      return acc.slice(0, -1).concat(tail(/** @type {string} */ (acc)) + str);
 
     return pushR(acc, str);
   }
@@ -32172,18 +31848,24 @@
       this._deregistered = true;
     }
   }
-  /** Return a registration function of the requested type. */
-  function makeEvent(registry, transitionService, eventType) {
+  /**
+   * Return a registration function of the requested type.
+   * @param {ng.TransitionProvider| import("./transition.js").Transition} hookSource
+   * @param {ng.TransitionProvider} transitionService
+   * @param {import("./transition-event-type.js").TransitionEventType} eventType
+   * @returns {( matchObject: any, callback: Function, options?: Record<string, any> ) => () => void }
+   */
+  function makeEvent(hookSource, transitionService, eventType) {
     // Create the object which holds the registered transition hooks.
-    const _registeredHooks = (registry._registeredHooks =
-      registry._registeredHooks || {});
+    const _registeredHooks = (hookSource._registeredHooks =
+      hookSource._registeredHooks || {});
 
     const hooks = (_registeredHooks[eventType.name] = []);
 
     const removeHookFn = (x) => removeFrom(hooks, x);
 
     // Create hook registration function on the HookRegistry for the event
-    registry[eventType.name] = hookRegistrationFn;
+    hookSource[eventType.name] = hookRegistrationFn;
     function hookRegistrationFn(matchObject, callback, options = {}) {
       const registeredHook = new RegisteredHook(
         transitionService,
@@ -32228,7 +31910,7 @@
      * @returns
      */
     buildHooksForPhase(phase) {
-      return this.transition._transitionService
+      return this.transition._transitionProvider
         ._getEvents(phase)
         .map((type) => this.buildHooks(type))
         .reduce(unnestR, [])
@@ -32289,7 +31971,7 @@
             state,
             hook,
             _options,
-            this.transition._transitionService._$exceptionHandler,
+            this.transition._transitionProvider._$exceptionHandler,
           );
 
           return { hook, node, transitionHook };
@@ -32318,7 +32000,7 @@
       const isCreate = hookType.hookPhase === TransitionHookPhase._CREATE;
 
       // Instance and Global hook registries
-      const $transitions = this.transition._transitionService;
+      const $transitions = this.transition._transitionProvider;
 
       const registries = isCreate
         ? [$transitions]
@@ -32383,7 +32065,11 @@
        * @type {import('../router.js').RouterProvider}
        */
       this._globals = globals;
-      this._transitionService = transitionService;
+
+      /** @type {ng.TransitionProvider} */
+      this._transitionProvider = transitionService;
+
+      /** @type {PromiseWithResolvers<any>} */
       this._deferred = Promise.withResolvers();
 
       /**
@@ -32439,10 +32125,12 @@
      * (which can then be used to register hooks)
      */
     createTransitionHookRegFns() {
-      this._transitionService
+      this._transitionProvider
         ._getEvents()
         .filter((type) => type.hookPhase !== TransitionHookPhase._CREATE)
-        .forEach((type) => makeEvent(this, this._transitionService, type));
+        .forEach((type) => {
+          return makeEvent(this, this._transitionProvider, type);
+        });
     }
 
     getHooks(hookName) {
@@ -32453,7 +32141,7 @@
       const enteringStates = this._treeChanges.entering.map((node) => node.state);
 
       PathUtils.applyViewConfigs(
-        this._transitionService.$view,
+        this._transitionProvider.$view,
         this._treeChanges.to,
         enteringStates,
       );
@@ -32773,7 +32461,7 @@
       );
 
       targetState = targetState.withOptions(newOptions, true);
-      const newTransition = this._transitionService.create(
+      const newTransition = this._transitionProvider.create(
         this._treeChanges.from,
         targetState,
       );
@@ -32959,9 +32647,9 @@
       const startTransition = () => {
         const { _globals } = this;
 
-        _globals.lastStartedTransitionId = this.$id;
+        _globals._lastStartedTransitionId = this.$id;
         _globals.transition = this;
-        _globals.transitionHistory.enqueue(this);
+        _globals._transitionHistory.enqueue(this);
         trace.traceTransitionStart(this);
 
         return Promise.resolve();
@@ -33302,7 +32990,7 @@
     const globals = trans._globals;
 
     const transitionSuccessful = () => {
-      globals.successfulTransitions.enqueue(trans);
+      globals._successfulTransitions.enqueue(trans);
       globals.$current = trans.$to();
       globals.current = globals.$current.self;
       copy(trans.params(), globals.params);
@@ -33351,12 +33039,19 @@
     stateRegistry,
   ) {
     return transitionService.onBefore(
-      { entering: (state) => !!state.lazyLoad },
-      (transition) => {
+      {
+        entering: (state) => {
+          return !!state.lazyLoad;
+        },
+      },
+      /** @param {import("../transition/transition.js").Transition} transition*/ (
+        transition,
+      ) => {
         function retryTransition() {
           if (transition.originalTransition().options().source !== "url") {
             // The original transition was not triggered via url sync
             // The lazy state should be loaded now, so re-try the original transition
+
             const orig = transition.targetState();
 
             return stateService.target(
@@ -33655,7 +33350,7 @@
 
       /** @type {ng.ExceptionHandlerService} */
       this._$exceptionHandler = $exceptionHandler.handler;
-      globals.successfulTransitions.onEvict(treeChangesCleanup);
+      globals._successfulTransitions.onEvict(treeChangesCleanup);
     }
 
     $get = [
@@ -33940,8 +33635,15 @@
      * @param {ng.ExceptionHandlerProvider} exceptionHandlerProvider
      */
     constructor(globals, transitionService, exceptionHandlerProvider) {
+      /**
+       * @type {ng.RouterProvider}
+       */
       this.globals = globals;
+      /**
+       * @type {ng.TransitionProvider}
+       */
       this.transitionService = transitionService;
+
       this.stateRegistry = undefined;
 
       /** @type {ng.UrlService} */
@@ -34096,7 +33798,7 @@
 
       const { globals } = this;
 
-      const latestThing = () => globals.transitionHistory.peekTail();
+      const latestThing = () => globals._transitionHistory.peekTail();
 
       const latest = latestThing();
 
@@ -34311,7 +34013,7 @@
     getCurrentPath() {
       const { globals } = this;
 
-      const latestSuccess = globals.successfulTransitions.peekTail();
+      const latestSuccess = globals._successfulTransitions.peekTail();
 
       const rootPath = () => [new PathNode(this.stateRegistry.root())];
 
@@ -34370,7 +34072,7 @@
        */
       const rejectedTransitionHandler = (trans) => (error) => {
         if (error instanceof Rejection) {
-          const isLatest = this.globals.lastStartedTransitionId <= trans.$id;
+          const isLatest = this.globals._lastStartedTransitionId <= trans.$id;
 
           if (error.type === RejectType._IGNORED) {
             isLatest && this.urlService.update();
@@ -34666,10 +34368,10 @@
           return $anchorScroll;
         }
 
-        return async function ($element) {
+        return (/** @type {Element} */ $element) => {
           validateInstanceOf($element, Element, "$element");
 
-          return setTimeout(() => {
+          setTimeout(() => {
             $element.scrollIntoView(false);
           }, 0);
         };
@@ -34834,7 +34536,9 @@
     fromProvider(provider, params, context) {
       const deps = annotate(provider);
 
-      const providerFn = isArray(provider) ? tail(provider) : provider;
+      const providerFn = isArray(provider)
+        ? /** @type {Function} */ (tail(provider))
+        : provider;
 
       const resolvable = new Resolvable("", providerFn, deps);
 
@@ -35600,8 +35304,6 @@
     );
   }
 
-  /** @typedef {import('./interface.ts').StateDeclaration} StateDeclaration */
-
   /**
    * Internal representation of a ng-router state.
    *
@@ -35611,16 +35313,16 @@
    *
    * This class prototypally inherits from the corresponding [[StateDeclaration]].
    * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
-   * @implements {StateDeclaration}
+   * @implements {ng.StateDeclaration}
    */
   class StateObject {
-    name = undefined;
-    navigable = undefined;
+    name;
+    navigable;
     /** @type {?StateObject} */
-    parent = undefined;
-    params = undefined;
-    url = undefined;
-    includes = undefined;
+    parent;
+    params;
+    url;
+    includes;
 
     /**
      * @param {import('./interface.ts').StateDeclaration} config
@@ -35639,7 +35341,7 @@
        */
       const nameGlob = this.name ? Glob.fromString(this.name) : null;
 
-      this.__stateObjectCache = { nameGlob };
+      this._stateObjectCache = { nameGlob };
     }
 
     /**
@@ -35721,7 +35423,7 @@
   /** Predicate which returns true if the object is a [[StateDeclaration]] object */
   StateObject.isStateDeclaration = (obj) => isFunction(obj.$$state);
   /** Predicate which returns true if the object is an internal [[StateObject]] object */
-  StateObject.isState = (obj) => isObject(obj.__stateObjectCache);
+  StateObject.isState = (obj) => isObject(obj._stateObjectCache);
 
   /**
    * Creates a [[UrlRule]]
@@ -36025,20 +35727,6 @@
     return idSort(a, b);
   }
 
-  function getHandlerFn(handler) {
-    if (
-      !isFunction(handler) &&
-      !isString(handler) &&
-      !is(TargetState)(handler) &&
-      !TargetState.isDef(handler)
-    ) {
-      throw new Error(
-        "'handler' must be a string, function, TargetState, or have a state: 'newtarget' property",
-      );
-    }
-
-    return isFunction(handler) ? handler : val(handler);
-  }
   /**
    * API for managing URL rules
    *
@@ -36055,102 +35743,7 @@
       this._sortFn = defaultRuleSortFn;
       this._rules = [];
       this._id = 0;
-      this.urlRuleFactory = urlRuleFactory;
-    }
-
-    /**
-     * Defines the initial state, path, or behavior to use when the app starts.
-     *
-     * This rule defines the initial/starting state for the application.
-     *
-     * This rule is triggered the first time the URL is checked (when the app initially loads).
-     * The rule is triggered only when the url matches either `""` or `"/"`.
-     *
-     * Note: The rule is intended to be used when the root of the application is directly linked to.
-     * When the URL is *not* `""` or `"/"` and doesn't match other rules, the [[otherwise]] rule is triggered.
-     * This allows 404-like behavior when an unknown URL is deep-linked.
-     *
-     * #### Example:
-     * Start app at `home` state.
-     * ```js
-     * .initial({ state: 'home' });
-     * ```
-     *
-     * #### Example:
-     * Start app at `/home` (by url)
-     * ```js
-     * .initial('/home');
-     * ```
-     *
-     * #### Example:
-     * When no other url rule matches, go to `home` state
-     * ```js
-     * .initial((matchValue, url, router) => {
-     *   console.log('initial state');
-     *   return { state: 'home' };
-     * })
-     * ```
-     *
-     * @param handler The initial state or url path, or a function which returns the state or url path (or performs custom logic).
-     */
-    initial(handler) {
-      const handlerFn = getHandlerFn(handler);
-
-      const matchFn = (urlParts, router) =>
-        router.globals.transitionHistory.size() === 0 &&
-        !!/^\/?$/.exec(urlParts.path);
-
-      this.rule(this.urlRuleFactory.create(matchFn, handlerFn));
-    }
-
-    /**
-     * Defines the state, url, or behavior to use when no other rule matches the URL.
-     *
-     * This rule is matched when *no other rule* matches.
-     * It is generally used to handle unknown URLs (similar to "404" behavior, but on the client side).
-     *
-     * - If `handler` a string, it is treated as a url redirect
-     *
-     * #### Example:
-     * When no other url rule matches, redirect to `/index`
-     * ```js
-     * .otherwise('/index');
-     * ```
-     *
-     * - If `handler` is an object with a `state` property, the state is activated.
-     *
-     * #### Example:
-     * When no other url rule matches, redirect to `home` and provide a `dashboard` parameter value.
-     * ```js
-     * .otherwise({ state: 'home', params: { dashboard: 'default' } });
-     * ```
-     *
-     * - If `handler` is a function, the function receives the current url ([[UrlParts]]) and the [[UIRouter]] object.
-     *   The function can perform actions, and/or return a value.
-     *
-     * #### Example:
-     * When no other url rule matches, manually trigger a transition to the `home` state
-     * ```js
-     * .otherwise((matchValue, urlParts, router) => {
-     *   router.stateService.go('home');
-     * });
-     * ```
-     *
-     * #### Example:
-     * When no other url rule matches, go to `home` state
-     * ```js
-     * .otherwise((matchValue, urlParts, router) => {
-     *   return { state: 'home' };
-     * });
-     * ```
-     *
-     * @param handler The url path to redirect to, or a function which returns the url path (or performs custom logic).
-     */
-    otherwise(handler) {
-      const handlerFn = getHandlerFn(handler);
-
-      this._otherwiseFn = this.urlRuleFactory.create(val(true), handlerFn);
-      this._sorted = false;
+      this._urlRuleFactory = urlRuleFactory;
     }
 
     /**
@@ -36172,7 +35765,7 @@
      * A rule should have a `match` function which returns truthy if the rule matched.
      * It should also have a `handler` function which is invoked if the rule is the best match.
      *
-     * @return a function that deregisters the rule
+     * @returns {() => void } a function that deregisters the rule
      */
     rule(rule) {
       if (!UrlRuleFactory.isUrlRule(rule)) throw new Error("invalid rule");
@@ -36192,7 +35785,7 @@
     rules() {
       this.ensureSorted();
 
-      return this._rules.concat(this._otherwiseFn ? [this._otherwiseFn] : []);
+      return this._rules;
     }
 
     /**
@@ -36336,7 +35929,7 @@
      * @return the registered [[UrlRule]]
      */
     when(matcher, handler, options) {
-      const rule = this.urlRuleFactory.create(matcher, handler);
+      const rule = this._urlRuleFactory.create(matcher, handler);
 
       if (isDefined(options && options.priority))
         rule.priority = options.priority;
@@ -36386,31 +35979,32 @@
 
     /**
      * @param {ng.LocationProvider} $locationProvider
-     * @param {import("../../router/state/state-service.js").StateProvider} stateService
+     * @param {import("../../router/state/state-service.js").StateProvider} stateProvider
      * @param {import("../router.js").RouterProvider} globals
      * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
      */
-    constructor($locationProvider, stateService, globals, urlConfigProvider) {
+    constructor($locationProvider, stateProvider, globals, urlConfigProvider) {
       /** @private */
       this._locationProvider = $locationProvider;
-      this.stateService = stateService;
+      this.stateService = stateProvider;
 
-      /** Provides services related to the URL */
-      this.urlRuleFactory = new UrlRuleFactory(this, this.stateService, globals);
+      /** @type {UrlRuleFactory} Provides services related to the URL */
+      this._urlRuleFactory = new UrlRuleFactory(this, this.stateService, globals);
 
       /**
        * The nested [[UrlRules]] API for managing URL rules and rewrites
+       * @ignore
        * @type {UrlRules}
        */
-      this.rules = new UrlRules(this.urlRuleFactory);
+      this._rules = new UrlRules(this._urlRuleFactory);
       /**
        * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
        * @type {import("./url-config.js").UrlConfigProvider}
        */
-      this.config = urlConfigProvider;
+      this._config = urlConfigProvider;
 
-      /** Creates a new [[Param]] for a given location (DefType) */
-      this.paramFactory = new ParamFactory(this.config);
+      /** @type {ParamFactory} Creates a new [[Param]] for a given location (DefType) */
+      this._paramFactory = new ParamFactory(this._config);
 
       this._urlListeners = [];
     }
@@ -36672,7 +36266,7 @@
      */
     match(url) {
       url = Object.assign({ path: "", search: {}, hash: "" }, url);
-      const rules = this.rules.rules();
+      const rules = this._rules.rules();
 
       // Checks a single rule. Returns { rule: rule, match: match, weight: weight } if it matched, or undefined
       /**
@@ -36783,7 +36377,7 @@
      * @returns The UrlMatcher.
      */
     compile(urlPattern, config) {
-      const urlConfig = this.config;
+      const urlConfig = this._config;
 
       // backward-compatible support for config.params -> config.state.params
       const params = config && !config.state && config.params;
@@ -36797,7 +36391,7 @@
       return new UrlMatcher(
         urlPattern,
         urlConfig.paramTypes,
-        this.paramFactory,
+        this._paramFactory,
         Object.assign(globalConfig, config),
       );
     }
@@ -36834,8 +36428,10 @@
   }
 
   class StateMatcher {
-    constructor(_states) {
-      this._states = _states;
+    /** @param {import("./interface.ts").StateStore} states */
+    constructor(states) {
+      /** @type {import("./interface.ts").StateStore} */
+      this._states = states;
     }
 
     isRelative(stateName) {
@@ -36860,12 +36456,10 @@
       ) {
         return state;
       } else if (isStr && matchGlob) {
-        const _states = Object.values(this._states);
+        const states = Object.values(this._states);
 
-        const matches = _states.filter(
-          (_state) =>
-            _state.__stateObjectCache.nameGlob &&
-            _state.__stateObjectCache.nameGlob.matches(name),
+        const matches = states.filter((stateObj) =>
+          stateObj._stateObjectCache.nameGlob?.matches(name),
         );
 
         if (matches.length > 1) {
@@ -37194,11 +36788,11 @@
   class StateBuilder {
     /**
      * @param {import('./state-matcher.js').StateMatcher} matcher
-     * @param urlService
+     * @param {ng.UrlService} urlService
      */
     constructor(matcher, urlService) {
-      this.matcher = matcher;
-      this.$injector = undefined;
+      this._matcher = matcher;
+      this._$injector = undefined;
       const self = this;
 
       const root = () => matcher.find("");
@@ -37208,7 +36802,7 @@
 
         return matcher.find(self.parentName(state)) || root();
       }
-      this.builders = {
+      this._builders = {
         name: [(state) => state.name],
         self: [selfBuilder],
         parent: [parentBuilder],
@@ -37218,7 +36812,7 @@
         // Keep track of the closest ancestor state that has a URL (i.e. is navigable)
         navigable: [getNavigableBuilder(isRoot)],
         // TODO
-        params: [getParamsBuilder(urlService.paramFactory)],
+        params: [getParamsBuilder(urlService._paramFactory)],
         // Each framework-specific ng-router implementation should define its own `views` builder
         // e.g., src/ng1/statebuilders/views.ts
         views: [],
@@ -37231,7 +36825,7 @@
     }
 
     builder(name, fn) {
-      const { builders } = this;
+      const { _builders: builders } = this;
 
       const array = builders[name] || [];
 
@@ -37254,7 +36848,7 @@
      * @returns the built State object
      */
     build(state) {
-      const { matcher, builders } = this;
+      const { _matcher: matcher, _builders: builders } = this;
 
       const parent = this.parentName(state);
 
@@ -37330,13 +36924,14 @@
   class StateQueueManager {
     /**
      * @param {import("./state-registry.js").StateRegistryProvider} stateRegistry
-     * @param {*} urlServiceRules
-     * @param {Record<string, ng.StateObject>} states
+     * @param {import("../url/url-rules.js").UrlRules} urlServiceRules
+     * @param {import("./interface.ts").StateStore} states
      * @param {*} builder
      * @param {*} listeners
      */
     constructor(stateRegistry, urlServiceRules, states, builder, listeners) {
       this.stateRegistry = stateRegistry;
+      /** @type {import("../url/url-rules.js").UrlRules} */
       this.urlServiceRules = urlServiceRules;
       this.states = states;
       this.builder = builder;
@@ -37432,11 +37027,16 @@
       return states;
     }
 
+    /**
+     *
+     * @param {ng.StateDeclaration} state
+     * @returns {() => void} a function that deregisters the rule
+     */
     attachRoute(state) {
       if (state.abstract || !state.url) return;
       const rulesApi = this.urlServiceRules;
 
-      rulesApi.rule(rulesApi.urlRuleFactory.create(state));
+      rulesApi.rule(rulesApi._urlRuleFactory.create(state));
     }
   }
 
@@ -37462,12 +37062,12 @@
      * @param {ng.ViewService} viewService
      */
     constructor(urlService, stateService, globals, viewService) {
-      /** @type {Record<string, import("./state-object.js").StateObject>} */
+      /** @type {import("./interface.ts").StateStore} */
       this.states = {};
 
       stateService.stateRegistry = this; // <- circular wiring
       this.urlService = urlService;
-      this.urlServiceRules = urlService.rules;
+      this.urlServiceRules = urlService._rules;
       this.$injector = undefined;
       this.listeners = [];
       this.matcher = new StateMatcher(this.states);
@@ -37502,7 +37102,7 @@
        */
       ($injector) => {
         this.$injector = $injector;
-        this.builder.$injector = $injector;
+        this.builder._$injector = $injector;
 
         return this;
       },
@@ -37628,7 +37228,7 @@
     }
 
     _deregisterTree(state) {
-      const all = this.get().map((x) => x.$$state());
+      const all = this.getAll().map((x) => x.$$state());
 
       const getChildren = (states) => {
         const _children = all.filter((x) => states.indexOf(x.parent) !== -1);
@@ -37667,11 +37267,18 @@
      * @returns {import('./state-object').StateObject[]} a list of removed states
      */
     deregister(stateOrName) {
-      const _state = this.get(stateOrName);
+      const state =
+        /** @type {import("./interface.ts").BuiltStateDeclaration} */ (
+          this.get(stateOrName)
+        );
 
-      if (!_state)
+      if (!state)
         throw new Error(`Can't deregister state; not found: ${stateOrName}`);
-      const deregisteredStates = this._deregisterTree(_state.$$state());
+      const deregisteredStates = this._deregisterTree(
+        /** @type {import("./interface.ts").BuiltStateDeclaration} */ (
+          state
+        ).$$state(),
+      );
 
       this.listeners.forEach((listener) =>
         listener(
@@ -38758,20 +38365,26 @@
    */
   function ngChannelDirective($eventBus) {
     return {
+      scope: false,
       link: (scope, element, attrs) => {
         const channel = attrs.ngChannel;
 
         const hasTemplateContent = element.childNodes.length > 0;
 
-        const unsubscribe = $eventBus.subscribe(channel, (value) => {
-          if (hasTemplateContent) {
-            if (isObject(value)) {
-              scope.$merge(value);
+        const unsubscribe = $eventBus.subscribe(
+          channel,
+          (/** @type {string | Object} */ value) => {
+            if (hasTemplateContent) {
+              if (isObject(value)) {
+                scope.$merge(value);
+              }
+            } else if (isString(value)) {
+              element.innerHTML = value;
+            } else {
+              element.innerHTML = value.toString();
             }
-          } else {
-            element.innerHTML = value;
-          }
-        });
+          },
+        );
 
         scope.$on("$destroy", () => unsubscribe());
       },
@@ -38783,7 +38396,7 @@
   /**
    * @param {ng.ParseService} $parse
    * @param {ng.LogService} $log
-   * @returns {import('interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngSetterDirective($parse, $log) {
     return {
@@ -38805,7 +38418,7 @@
           return;
         }
 
-        const updateModel = (value) => {
+        const updateModel = (/** @type {string} */ value) => {
           assignModel(scope, value.trim());
         };
 
@@ -38943,7 +38556,7 @@
 
       let called = false;
 
-      const wrapper = (...args) => {
+      const wrapper = (/** @type {any[]} */ ...args) => {
         if (called) return;
         called = true;
 
@@ -39090,28 +38703,206 @@
   }
 
   /**
-   * SSE Provider
-   *
-   * Usage:
-   *   const source = $sse('/events', {
-   *     onMessage: (data) => console.log(data),
-   *     onError: (err) => console.error(err),
-   *     retryDelay: 2000,
-   *     heartbeatTimeout: 10000,
-   *   });
-   *
-   *   source.close();
+   * Shared Stream Connection Manager
+   * Handles reconnect, heartbeat, and event callbacks for SSE or WebSocket
    */
+  class StreamConnection {
+    /**
+     * @param {() => EventSource | WebSocket} createFn - Function that creates a new EventSource or WebSocket.
+     * @param {ng.StreamConnectionConfig} config - Configuration object with callbacks, retries, heartbeat, transformMessage.
+     * @param {ng.LogService} log - Optional logger (default: console).
+     */
+    constructor(createFn, config = {}, log = console) {
+      /** @private @type {() => EventSource | WebSocket} */
+      this._createFn = createFn;
+      this._config = {
+        retryDelay: 1000,
+        maxRetries: Infinity,
+        heartbeatTimeout: 15000,
+        transformMessage: (/** @type {string} */ data) => {
+          try {
+            return JSON.parse(data);
+          } catch {
+            return data;
+          }
+        },
+        ...config,
+      };
+      this._log = log;
+      this._retryCount = 0;
+      this._closed = false;
+      this._heartbeatTimer = undefined;
+      /** @type {EventSource | WebSocket | null} */
+      this._connection = null;
+
+      this.connect();
+    }
+
+    /**
+     * Establishes a new connection using the provided createFn.
+     * Closes any existing connection before creating a new one.
+     */
+    connect() {
+      if (this._closed) return;
+
+      // Close the old connection if it exists
+      if (this._connection && typeof this._connection.close === "function") {
+        this._connection.close();
+      }
+
+      // Create new connection
+      this._connection = this._createFn();
+
+      // Bind events for the new connection
+      this._bindEvents();
+    }
+
+    /**
+     * Sends data over a WebSocket connection.
+     * Logs a warning if called on a non-WebSocket connection.
+     * @param {any} data - Data to send.
+     */
+    send(data) {
+      if (this._connection instanceof WebSocket) {
+        this._connection.send(JSON.stringify(data));
+      } else {
+        this._log.warn("Send is only supported on WebSocket connections");
+      }
+    }
+
+    /**
+     * Closes the connection manually and clears the heartbeat timer.
+     */
+    close() {
+      this._closed = true;
+      clearTimeout(this._heartbeatTimer);
+
+      if (this._connection && this._connection.close) {
+        this._connection.close();
+      }
+    }
+
+    /**
+     * @private
+     * Binds event handlers to the underlying connection (EventSource or WebSocket)
+     * for open, message, error, and close events.
+     */
+    _bindEvents() {
+      const conn = this._connection;
+
+      if (conn instanceof EventSource) {
+        conn.addEventListener("open", (err) => this._handleOpen(err));
+        conn.addEventListener("message", (err) =>
+          this._handleMessage(err.data, err),
+        );
+        conn.addEventListener("error", (err) => this._handleError(err));
+      } else if (conn instanceof WebSocket) {
+        conn.onopen = (err) => this._handleOpen(err);
+        conn.onmessage = (err) => this._handleMessage(err.data, err);
+        conn.onerror = (err) => this._handleError(err);
+        conn.onclose = () => this._handleClose();
+      }
+    }
+
+    /**
+     * @private
+     * Handles the open event from the connection.
+     * @param {Event} event - The open event.
+     */
+    _handleOpen(event) {
+      this._retryCount = 0;
+      this._config.onOpen?.(event);
+      this._resetHeartbeat();
+    }
+
+    /**
+     * @private
+     * Handles incoming messages, applies the transformMessage function,
+     * and calls the onMessage callback.
+     * @param {any} data - Raw message data.
+     * @param {Event} event - The message event.
+     */
+    _handleMessage(data, event) {
+      try {
+        data = this._config.transformMessage?.(data) ?? data;
+      } catch {
+        /* empty */
+      }
+      this._config.onMessage?.(data, event);
+      this._resetHeartbeat();
+    }
+
+    /**
+     * @private
+     * Handles errors emitted from the connection.
+     * Calls onError callback and schedules a reconnect.
+     * @param {any} err - Error object or message.
+     */
+    _handleError(err) {
+      this._config.onError?.(err);
+      this._scheduleReconnect();
+    }
+
+    /**
+     * @private
+     * Handles close events for WebSocket connections.
+     * Triggers reconnect logic.
+     */
+    _handleClose() {
+      this._scheduleReconnect();
+    }
+
+    /**
+     * @private
+     * Schedules a reconnect attempt based on retryCount and config.maxRetries.
+     * Calls onReconnect callback if reconnecting.
+     */
+    _scheduleReconnect() {
+      if (this._closed) return;
+
+      if (this._retryCount < this._config.maxRetries) {
+        this._retryCount++;
+        this._config.onReconnect?.(this._retryCount);
+        setTimeout(() => this.connect(), this._config.retryDelay);
+      } else {
+        this._log.warn("StreamConnection: Max retries reached");
+      }
+    }
+
+    /**
+     * @private
+     * Resets the heartbeat timer. If the timer expires, the connection is closed
+     * and a reconnect is attempted.
+     */
+    _resetHeartbeat() {
+      if (!this._config.heartbeatTimeout) return;
+
+      clearTimeout(this._heartbeatTimer);
+      this._heartbeatTimer = setTimeout(() => {
+        this._log.warn("StreamConnection: heartbeat timeout, reconnecting...");
+        this._closeInternal();
+        this._retryCount++;
+        this._config.onReconnect?.(this._retryCount);
+        this.connect();
+      }, this._config.heartbeatTimeout);
+    }
+
+    /**
+     * @private
+     */
+    _closeInternal() {
+      clearTimeout(this._heartbeatTimer);
+      this._connection?.close();
+    }
+  }
+
   class SseProvider {
     constructor() {
-      /**
-       * Optional provider-level defaults
-       * @type {ng.SseConfig}
-       */
+      /** @type {ng.SseConfig} */
       this.defaults = {
         retryDelay: 1000,
         maxRetries: Infinity,
-        heartbeatTimeout: 15000, // 15 seconds
+        heartbeatTimeout: 15000,
         transformMessage(data) {
           try {
             return JSON.parse(data);
@@ -39124,20 +38915,32 @@
 
     $get = [
       $injectTokens._log,
-      /**
-       * Returns the $sse service function
-       * @param {ng.LogService} log
-       * @returns {ng.SseService}
-       */
-      (log) => {
+      /** @param {ng.LogService} log */ (log) => {
         this._$log = log;
 
+        /** @type {ng.SseService} */
         return (url, config = {}) => {
           const mergedConfig = { ...this.defaults, ...config };
 
           const finalUrl = this.#buildUrl(url, mergedConfig.params);
 
-          return this.#createConnection(finalUrl, mergedConfig);
+          return new StreamConnection(
+            () =>
+              new EventSource(finalUrl, {
+                withCredentials: !!mergedConfig.withCredentials,
+              }),
+            {
+              ...mergedConfig,
+              onMessage: (data, event) => {
+                // Cast Event -> MessageEvent safely
+                mergedConfig.onMessage?.(
+                  data,
+                  /** @type{MessageEvent} */ (event),
+                );
+              },
+            },
+            this._$log,
+          );
         };
       },
     ];
@@ -39147,6 +38950,7 @@
      * @param {string} url
      * @param {Record<string, any>=} params
      * @returns {string}
+     * @throws {URIError}
      */
     #buildUrl(url, params) {
       if (!params) return url;
@@ -39156,91 +38960,6 @@
 
       return url + (url.includes("?") ? "&" : "?") + query;
     }
-
-    /**
-     * Creates a managed SSE connection with reconnect and heartbeat
-     * @param {string} url
-     * @param {ng.SseConfig} config
-     * @returns {import("./interface.ts").SseConnection}
-     */
-    #createConnection(url, config) {
-      let es;
-
-      let retryCount = 0;
-
-      let closed = false;
-
-      let heartbeatTimer;
-
-      const connect = () => {
-        if (closed) return;
-
-        es = new EventSource(url, {
-          withCredentials: !!config.withCredentials,
-        });
-
-        es.addEventListener("open", (event) => {
-          retryCount = 0;
-          config.onOpen?.(event);
-
-          if (config.heartbeatTimeout) resetHeartbeat();
-        });
-
-        es.addEventListener("message", (event) => {
-          let { data } = event;
-
-          try {
-            data = config.transformMessage ? config.transformMessage(data) : data;
-          } catch {
-            /* empty */
-          }
-          config.onMessage?.(data, event);
-
-          if (config.heartbeatTimeout) resetHeartbeat();
-        });
-
-        es.addEventListener("error", (err) => {
-          config.onError?.(err);
-
-          if (closed) return;
-          es.close();
-
-          if (retryCount < config.maxRetries) {
-            retryCount++;
-            config.onReconnect?.(retryCount);
-            setTimeout(connect, config.retryDelay);
-          } else {
-            this._$log.warn("SSE: Max retries reached");
-          }
-        });
-      };
-
-      const resetHeartbeat = () => {
-        clearTimeout(heartbeatTimer);
-        heartbeatTimer = setTimeout(() => {
-          this._$log.warn("SSE: heartbeat timeout, reconnecting...");
-          es.close();
-          config.onReconnect?.(++retryCount);
-          connect();
-        }, config.heartbeatTimeout);
-      };
-
-      connect();
-
-      return {
-        close() {
-          closed = true;
-          clearTimeout(heartbeatTimer);
-          es.close();
-        },
-        connect() {
-          if (closed === false) {
-            close();
-          }
-          connect();
-        },
-      };
-    }
   }
 
   /**
@@ -39335,11 +39054,7 @@
       this.defaults = {};
     }
 
-    $get = [
-      $injectTokens._exceptionHandler,
-      /** @param {ng.ExceptionHandlerService} $exceptionHandler  */
-      ($exceptionHandler) => new CookieService(this.defaults, $exceptionHandler),
-    ];
+    $get = () => new CookieService(this.defaults);
   }
 
   /**
@@ -39353,14 +39068,10 @@
     /**
      * @param {ng.CookieOptions} defaults
      *   Default cookie attributes defined by `$cookiesProvider.defaults`.
-     * @param {ng.ExceptionHandlerService} $exceptionHandler
      */
-    constructor(defaults, $exceptionHandler) {
+    constructor(defaults) {
       /** @private @type {ng.CookieOptions} */
       this._defaults = Object.freeze({ ...defaults });
-
-      /** @private @type {ng.ExceptionHandlerService} */
-      this._$exceptionHandler = $exceptionHandler;
     }
 
     /**
@@ -39372,14 +39083,9 @@
      */
     get(key) {
       validateIsString(key, "key");
+      const all = parseCookies();
 
-      try {
-        const all = parseCookies();
-
-        return all[key] || null;
-      } catch (err) {
-        throw this._$exceptionHandler(err);
-      }
+      return all[key] || null;
     }
 
     /**
@@ -39397,13 +39103,7 @@
 
       if (!raw) return null;
 
-      try {
-        return /** @type {T} */ (JSON.parse(raw));
-      } catch (err) {
-        this._$exceptionHandler(err);
-
-        return null;
-      }
+      return /** @type {T} */ (JSON.parse(raw));
     }
 
     /**
@@ -39413,11 +39113,7 @@
      * @throws {URIError} – If decodeURIComponent fails
      */
     getAll() {
-      try {
-        return parseCookies();
-      } catch (err) {
-        return this._$exceptionHandler(err);
-      }
+      return parseCookies();
     }
 
     /**
@@ -39426,6 +39122,7 @@
      * @param {string} key
      * @param {string} value
      * @param {ng.CookieOptions} [options]
+     * @throws {URIError} if key or value cannot be encoded
      */
     put(key, value, options = {}) {
       validateIsString(key, "key");
@@ -39434,14 +39131,10 @@
 
       const encodedVal = encodeURIComponent(value);
 
-      try {
-        document.cookie = `${encodedKey}=${encodedVal}${buildOptions({
-        ...this._defaults,
-        ...options,
-      })}`;
-      } catch (err) {
-        this._$exceptionHandler(err);
-      }
+      document.cookie = `${encodedKey}=${encodedVal}${buildOptions({
+      ...this._defaults,
+      ...options,
+    })}`;
     }
 
     /**
@@ -39455,19 +39148,9 @@
     putObject(key, value, options) {
       validateIsString(key, "key");
       validateRequired(value, "value");
-      assert(!isNullOrUndefined(value), BADARGVALUE);
-
-      try {
-        const str = JSON.stringify(value);
+      const str = JSON.stringify(value);
 
-        this.put(key, str, options);
-      } catch (err) {
-        this._$exceptionHandler(
-          new TypeError(
-            `badserialize: "${key}" => ${/** @type {Error} */ (err).message}`,
-          ),
-        );
-      }
+      this.put(key, str, options);
     }
 
     /**
@@ -40116,6 +39799,37 @@
     ];
   }
 
+  /**
+   * @returns {ng.Directive}
+   */
+  function ngListenerDirective() {
+    return {
+      scope: false,
+      link: (scope, element, attrs) => {
+        const channel = attrs.ngListener || element.id;
+
+        const hasTemplateContent = element.childNodes.length;
+
+        /** @type {EventListener} */
+        const fn = (event) => {
+          const value = /** @type {CustomEvent} */ (event).detail;
+
+          if (hasTemplateContent) {
+            if (isObject(value)) {
+              scope.$merge(value);
+            }
+          } else if (isString(value)) {
+            element.innerHTML = value;
+          }
+        };
+
+        element.addEventListener(channel, fn);
+
+        scope.$on("$destroy", () => element.removeEventListener(channel, fn));
+      },
+    };
+  }
+
   /**
    * Initializes core `ng` module.
    * @param {ng.Angular} angular
@@ -40165,6 +39879,7 @@
                 ngInclude: ngIncludeDirective,
                 ngInject: ngInjectDirective,
                 ngInit: ngInitDirective,
+                ngListener: ngListenerDirective,
                 ngMessages: ngMessagesDirective,
                 ngMessage: ngMessageDirective,
                 ngMessageExp: ngMessageExpDirective,
@@ -40201,7 +39916,7 @@
                 ngScope: ngScopeDirective,
               })
               .directive({
-                input: hiddenInputBrowserCacheDirective,
+                input: hiddenInputDirective,
                 ngAnimateSwap: ngAnimateSwapDirective,
                 ngAnimateChildren: $$AnimateChildrenDirective,
                 // aria directives
@@ -40293,8 +40008,13 @@
   /** @type {ModuleRegistry} */
   const moduleRegistry = {};
 
-  class Angular {
-    constructor() {
+  class Angular extends EventTarget {
+    constructor(submodule = false) {
+      super();
+
+      /** @private @type {boolean} */
+      this._submodule = submodule;
+
       /** @private @type {!Array<string|any>} */
       this._bootsrappedModules = [];
 
@@ -40308,7 +40028,7 @@
        * @public
        * @type {string} `version` from `package.json`
        */
-      this.version = "0.15.0"; //inserted via rollup plugin
+      this.version = "0.15.2"; //inserted via rollup plugin
 
       /**
        * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
@@ -40338,7 +40058,9 @@
         /** @type {any} */ (this.$t)[i] = i;
       });
 
-      window.angular = this;
+      if (!submodule) {
+        window.angular = this;
+      }
       registerNgModule(this);
     }