@angular-wave/angular.ts 0.15.0 → 0.15.1

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.15.0 - December 14, 2025 04:42:34 */
+/* Version: 0.15.1 - December 21, 2025 17:06:17 */
 (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,66 +765,41 @@
   }
 
   /**
-   * Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
-   * stripped since AngularTS uses this notation internally.
+   * 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
-   *
-   * 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;
-  }
-
+  /**
+   * @param {Date} date
+   * @param {number} minutes
+   */
   function addDateMinutes(date, minutes) {
     const newDate = new Date(date.getTime());
 
@@ -796,25 +808,13 @@
     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 +838,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 +848,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 +925,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 +941,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 that there are no proto properties for objects.
+   * Assumes there are no proto properties.
+   *
+   * @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 +989,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 +1006,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 +1098,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 +1157,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 +1178,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 +1442,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 +1868,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 +2322,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 +2432,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 +2458,11 @@
     }
   }
 
+  /**
+   * @param {HTMLElement} element
+   * @param {HTMLElement} parent
+   * @param {ChildNode | null | undefined} after
+   */
   function animatedomInsert(element, parent, after) {
     const originalVisibility = element.style.visibility;
 
@@ -2798,11 +2830,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 +2900,6 @@
   }
 
   const BADARG = "badarg";
-  const BADARGVALUE = "badarg: value";
 
   /** @type {Map<ng.Validator, string>} */
   const reasons = new Map([
@@ -2971,6 +3002,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 +3177,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 +3200,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 +3254,15 @@
                 backend = localStorage;
               }
 
-              return createPersistentProxy(instance, name, backend, {
-                serialize,
-                deserialize,
-              });
+              return createPersistentProxy(
+                instance,
+                name,
+                /** @type {import("./inteface.ts").StorageLike} */ (backend),
+                {
+                  serialize,
+                  deserialize,
+                },
+              );
             }
           }
 
@@ -3685,7 +3739,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 +3808,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 +3852,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 +4736,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 +4766,7 @@
 
             const target = targetSelector
               ? document.querySelector(targetSelector)
-              : elmenetParam;
+              : elementParam;
 
             if (!target) {
               $log.warn(`${attrName}: target "${targetSelector}" not found`);
@@ -5685,14 +5727,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 +5852,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 +5863,9 @@
       if (this._isList) {
         return this._nodes;
       } else {
-        return this._element || this._node;
+        return /** @type {Element | Node | ChildNode} */ (
+          this._element || this._node
+        );
       }
     }
 
@@ -5828,7 +5874,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 +7032,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 +7075,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 +7117,7 @@
             classVal,
           );
         } else {
-          this.$nodeRef.element.classList.add(classVal);
+          this._nodeRef.element.classList.add(classVal);
         }
       }
     }
@@ -7065,7 +7136,7 @@
             classVal,
           );
         } else {
-          this.$nodeRef.element.classList.remove(classVal);
+          this._nodeRef.element.classList.remove(classVal);
         }
       }
     }
@@ -7084,7 +7155,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 +7167,7 @@
             toRemove,
           );
         } else {
-          this.$nodeRef.element.classList.remove(...toRemove.trim().split(/\s+/));
+          this._nodeRef.element.classList.remove(...toRemove.trim().split(/\s+/));
         }
       }
     }
@@ -7144,7 +7215,7 @@
         }
       }
 
-      const nodeName = this.$nodeRef.node.nodeName.toLowerCase();
+      const nodeName = this._nodeRef.node.nodeName.toLowerCase();
 
       let maybeSanitizedValue;
 
@@ -7205,6 +7276,7 @@
     }
 
     /**
+     * @template T
      * Observes an interpolated attribute.
      * 
      * The observer function will be invoked once during the next `$digest` following
@@ -7212,11 +7284,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 +8442,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 +8693,7 @@
 
             const { index } = previousCompileContext;
 
-            templateAttrs.$nodeRef = compileNodeRef;
+            templateAttrs._nodeRef = compileNodeRef;
             let directive;
 
             let directiveName;
@@ -8672,7 +8744,7 @@
 
               if (compileNode === linkNode) {
                 attrs = templateAttrs;
-                $element = templateAttrs.$nodeRef;
+                $element = templateAttrs._nodeRef;
               } else {
                 $element = new NodeRef(linkNode);
                 attrs = new Attributes(
@@ -9098,7 +9170,7 @@
                   terminalPriority = directive.priority;
                   $template = compileNodeRef;
                   compileNodeRef = new NodeRef(document.createComment(""));
-                  templateAttrs.$nodeRef = compileNodeRef;
+                  templateAttrs._nodeRef = compileNodeRef;
                   compileNode = compileNodeRef.node;
                   ctxNodeRef.node = compileNode;
                   replaceWith(
@@ -10797,13 +10869,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 +10884,7 @@
       /* empty */
     },
     $getControls: () => [],
-    $$renameControl: (control, name) => {
+    _renameControl: (control, name) => {
       control.$name = name;
     },
     $removeControl: () => {
@@ -10830,7 +10902,7 @@
     $setSubmitted: () => {
       /* empty */
     },
-    $$setSubmitted: () => {
+    _setSubmitted: () => {
       /* empty */
     },
   };
@@ -10887,11 +10959,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 +10974,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 +11003,7 @@
 
       this.$$classCache[VALID_CLASS] = isValid;
       this.$$classCache[INVALID_CLASS] = !isValid;
+      this.$target = {};
     }
 
     /**
@@ -10941,7 +11014,7 @@
      * a form that uses `ng-model-options` to pend updates.
      */
     $rollbackViewValue() {
-      this.$$controls.forEach((control) => {
+      this._controls.forEach((control) => {
         control.$rollbackViewValue();
       });
     }
@@ -10954,7 +11027,7 @@
      * usually handles calling this in response to input events.
      */
     $commitViewValue() {
-      this.$$controls.forEach((control) => {
+      this._controls.forEach((control) => {
         control.$commitViewValue();
       });
     }
@@ -10978,7 +11051,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 +11073,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 +11099,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 +11118,7 @@
           this.$setValidity(name, null, control);
         });
 
-      arrayRemove(this.$$controls, control);
+      arrayRemove(this._controls, control);
 
       control.$target.$$parentForm = nullFormCtrl;
     }
@@ -11096,7 +11171,7 @@
       this.$dirty = false;
       this.$pristine = true;
       this.$submitted = false;
-      this.$$controls.forEach((control) => {
+      this._controls.forEach((control) => {
         control.$setPristine();
       });
     }
@@ -11111,7 +11186,7 @@
      * back to its pristine state.
      */
     $setUntouched() {
-      this.$$controls.forEach((control) => {
+      this._controls.forEach((control) => {
         control.$setUntouched();
       });
     }
@@ -11127,19 +11202,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 +11532,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 +11755,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 +11792,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 +11835,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 +11992,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 +12001,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 +12484,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 +12521,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 +12647,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 +12846,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 +12895,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) => {
@@ -13988,6 +14065,40 @@
     };
   }
 
+  /**
+   * @param {Date} date
+   * @param {any} timezone
+   * @param {undefined} [reverse]
+   */
+  function convertTimezoneToLocal(date, timezone, reverse) {
+    const doReverse = 1;
+
+    const dateTimezoneOffset = date.getTimezoneOffset();
+
+    const timezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
+
+    return addDateMinutes(
+      date,
+      doReverse * (timezoneOffset - dateTimezoneOffset),
+    );
+  }
+
+  const MS_PER_MINUTE = 60_000; // 60,000 ms in a minute
+
+  /**
+   * @param {any} timezone
+   * @param {number} [fallback]
+   * @returns {number}
+   */
+  function timezoneToOffset(timezone, fallback) {
+    const requestedTimezoneOffset =
+      Date.parse(`Jan 01, 1970 00:00:00 ${timezone}`) / MS_PER_MINUTE;
+
+    return isNumberNaN(requestedTimezoneOffset)
+      ? (fallback ?? 0)
+      : requestedTimezoneOffset;
+  }
+
   scriptDirective.$inject = [$injectTokens._templateCache];
 
   /**
@@ -14017,8 +14128,6 @@
       "selectValueMap",
       "emptyOption",
       "optionsMap",
-      "$scope",
-      "$element",
     ];
 
     /**
@@ -14046,8 +14155,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 +14188,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 +14202,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 +14225,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 +14350,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 +14371,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 +14530,7 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function selectDirective() {
     return {
@@ -14644,7 +14753,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 +14764,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 +14783,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 +15073,7 @@
 
   ngHideDirective.$inject = [$injectTokens._animate];
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngHideDirective($animate) {
     return {
@@ -15004,7 +15115,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 +15130,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) {
@@ -15231,7 +15347,7 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngInitDirective() {
     return {
@@ -15253,7 +15369,7 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngNonBindableDirective() {
     return {
@@ -15399,7 +15515,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 +15843,7 @@
 
       // asks for $scope to fool the BC controller module
       controller: [
-        "$scope",
+        $injectTokens._scope,
         class {
           constructor() {
             this.cases = {};
@@ -15756,19 +15872,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 +15915,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 +15934,7 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngSwitchWhenDirective() {
     return {
@@ -15841,7 +15964,7 @@
   }
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngSwitchDefaultDirective() {
     return {
@@ -17471,13 +17594,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 +17631,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 +17678,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 +17698,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 +18320,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 +18343,6 @@
         json: jsonFilter,
         limitTo: limitToFilter,
         orderBy: orderByFilter,
-        isState: $IsStateFilter,
-        includedByState: $IncludedByStateFilter,
       }).forEach(([k, v]) =>
         this.register(k, /** @type {ng.FilterFactory} */ (v)),
       );
@@ -18378,9 +18466,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 +19115,7 @@
 
     let argsToWatch;
 
-    let isStatelessFilter;
+    let isFilter;
 
     const decoratedNode = /** @type  {DecoratedASTNode} */ (ast);
 
@@ -19158,10 +19246,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 +19255,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 +19402,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 +20443,7 @@
       const fn = this._astCompiler.compile(ast);
 
       fn.literal = isLiteral(ast);
-      fn.constant = isConstant(ast);
+      fn.constant = !!ast.constant;
 
       return fn;
     }
@@ -20381,18 +20461,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 +20524,7 @@
         /**
          *
          * @param {(any) => any} $filter
-         * @returns {import('./interface').ParseService}
+         * @returns {import('./interface.ts').ParseService}
          */
         function ($filter) {
           /** @type {import("./lexer/lexer.js").LexerOptions} */
@@ -20488,7 +20575,7 @@
           /**
            * @param {Function} parsedExpression
            * @param interceptorFn
-           * @returns {import('./interface').CompiledExpression|*}
+           * @returns {import('./interface.ts').CompiledExpression|*}
            */
           function addInterceptor(parsedExpression, interceptorFn) {
             if (!interceptorFn) {
@@ -20617,7 +20704,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 +21271,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 +21320,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 +21358,7 @@
      * @return {string} url
      */
     getUrl() {
-      return this.$$url;
+      return this._url;
     }
 
     /**
@@ -21283,8 +21370,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 +21383,7 @@
      * @return {string}
      */
     getPath() {
-      return $$path;
+      return _path;
     }
 
     /**
@@ -21305,8 +21392,8 @@
      * @return {Location} hash
      */
     setHash(hash) {
-      $$hash = hash !== null ? hash.toString() : "";
-      this.$$compose();
+      _hash = hash !== null ? hash.toString() : "";
+      this._compose();
 
       return this;
     }
@@ -21316,7 +21403,7 @@
      * @return {string} hash
      */
     getHash() {
-      return $$hash;
+      return _hash;
     }
 
     /**
@@ -21331,7 +21418,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 +21426,7 @@
               if (isNull(value)) delete search[key];
             });
 
-            $$search = search;
+            _search = search;
           } else {
             throw $locationMinErr(
               "isrcharg",
@@ -21349,14 +21436,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 +21454,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 +21578,11 @@
 
         parseAppUrl(pathUrl, true);
 
-        if (!$$path) {
-          $$path = "/";
+        if (!_path) {
+          _path = "/";
         }
 
-        this.$$compose();
+        this._compose();
       } else {
         const withoutBaseUrl =
           stripBaseUrl(this.appBase, url) ||
@@ -21529,9 +21616,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 +21668,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 +21701,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 +21727,7 @@
      * @returns {History['state']} The cached state.
      */
     state() {
-      return this.cachedState;
+      return this._cachedState;
     }
 
     /**
@@ -21651,9 +21739,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 +21749,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 +21773,7 @@
      * @returns void
      */
     #onUrlChange(callback) {
-      if (!this.urlChangeInit) {
+      if (!this._urlChangeInit) {
         window.addEventListener(
           "popstate",
           this.#fireStateOrUrlChange.bind(this),
@@ -21694,9 +21782,9 @@
           "hashchange",
           this.#fireStateOrUrlChange.bind(this),
         );
-        this.urlChangeInit = true;
+        this._urlChangeInit = true;
       }
-      this.urlChangeListeners.push(callback);
+      this._urlChangeListeners.push(callback);
     }
 
     $get = [
@@ -21932,12 +22020,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 +22183,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 +22349,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 +22359,7 @@
           /* empty */
         });
 
-      return (...args) => {
+      return (/** @type {any[]} */ ...args) => {
         const formattedArgs = args.map((arg) => this._formatError(arg));
 
         return logFn.apply(console, formattedArgs);
@@ -22781,7 +22874,7 @@
             let scheduled = foreignListeners;
 
             // filter for repeaters
-            const hashKey = this.$target.$$hashKey;
+            const hashKey = this.$target._hashKey;
 
             if (hashKey) {
               scheduled = [];
@@ -22789,7 +22882,7 @@
               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);
                 }
               }
@@ -24253,7 +24346,7 @@
           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 +24497,7 @@
   ];
 
   const isNodeOneOf = function (elem, nodeTypeArray) {
-    if (nodeTypeArray.indexOf(elem.nodeName) !== -1) {
-      return true;
-    }
-
-    return false;
+    return nodeTypeArray.indexOf(elem.nodeName) !== -1;
   };
 
   /**
@@ -27646,7 +27735,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 +28672,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 +28743,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 +28765,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 +28780,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 +28809,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 +28831,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 +29512,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 +29627,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 +29645,9 @@
       );
     };
 
-    const hasToString = (obj) =>
+    const hasToString = (
+      /** @type {{ constructor: ObjectConstructor; toString: any; }} */ obj,
+    ) =>
       isObject(obj) &&
       !isArray(obj) &&
       obj.constructor !== Object &&
@@ -29544,12 +29657,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 +29696,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 +29708,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 +29727,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 +32302,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 +32364,7 @@
      * @returns
      */
     buildHooksForPhase(phase) {
-      return this.transition._transitionService
+      return this.transition._transitionProvider
         ._getEvents(phase)
         .map((type) => this.buildHooks(type))
         .reduce(unnestR, [])
@@ -32289,7 +32425,7 @@
             state,
             hook,
             _options,
-            this.transition._transitionService._$exceptionHandler,
+            this.transition._transitionProvider._$exceptionHandler,
           );
 
           return { hook, node, transitionHook };
@@ -32318,7 +32454,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 +32519,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 +32579,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 +32595,7 @@
       const enteringStates = this._treeChanges.entering.map((node) => node.state);
 
       PathUtils.applyViewConfigs(
-        this._transitionService.$view,
+        this._transitionProvider.$view,
         this._treeChanges.to,
         enteringStates,
       );
@@ -32773,7 +32915,7 @@
       );
 
       targetState = targetState.withOptions(newOptions, true);
-      const newTransition = this._transitionService.create(
+      const newTransition = this._transitionProvider.create(
         this._treeChanges.from,
         targetState,
       );
@@ -32959,9 +33101,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 +33444,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 +33493,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 +33804,7 @@
 
       /** @type {ng.ExceptionHandlerService} */
       this._$exceptionHandler = $exceptionHandler.handler;
-      globals.successfulTransitions.onEvict(treeChangesCleanup);
+      globals._successfulTransitions.onEvict(treeChangesCleanup);
     }
 
     $get = [
@@ -33940,8 +34089,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 +34252,7 @@
 
       const { globals } = this;
 
-      const latestThing = () => globals.transitionHistory.peekTail();
+      const latestThing = () => globals._transitionHistory.peekTail();
 
       const latest = latestThing();
 
@@ -34311,7 +34467,7 @@
     getCurrentPath() {
       const { globals } = this;
 
-      const latestSuccess = globals.successfulTransitions.peekTail();
+      const latestSuccess = globals._successfulTransitions.peekTail();
 
       const rootPath = () => [new PathNode(this.stateRegistry.root())];
 
@@ -34370,7 +34526,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 +34822,10 @@
           return $anchorScroll;
         }
 
-        return async function ($element) {
+        return (/** @type {Element} */ $element) => {
           validateInstanceOf($element, Element, "$element");
 
-          return setTimeout(() => {
+          setTimeout(() => {
             $element.scrollIntoView(false);
           }, 0);
         };
@@ -34834,7 +34990,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 +35758,6 @@
     );
   }
 
-  /** @typedef {import('./interface.ts').StateDeclaration} StateDeclaration */
-
   /**
    * Internal representation of a ng-router state.
    *
@@ -35611,16 +35767,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 +35795,7 @@
        */
       const nameGlob = this.name ? Glob.fromString(this.name) : null;
 
-      this.__stateObjectCache = { nameGlob };
+      this._stateObjectCache = { nameGlob };
     }
 
     /**
@@ -35721,7 +35877,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 +36181,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 +36197,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 +36219,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 +36239,7 @@
     rules() {
       this.ensureSorted();
 
-      return this._rules.concat(this._otherwiseFn ? [this._otherwiseFn] : []);
+      return this._rules;
     }
 
     /**
@@ -36336,7 +36383,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 +36433,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 +36720,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 +36831,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 +36845,7 @@
       return new UrlMatcher(
         urlPattern,
         urlConfig.paramTypes,
-        this.paramFactory,
+        this._paramFactory,
         Object.assign(globalConfig, config),
       );
     }
@@ -36834,8 +36882,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 +36910,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 +37242,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 +37256,7 @@
 
         return matcher.find(self.parentName(state)) || root();
       }
-      this.builders = {
+      this._builders = {
         name: [(state) => state.name],
         self: [selfBuilder],
         parent: [parentBuilder],
@@ -37218,7 +37266,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 +37279,7 @@
     }
 
     builder(name, fn) {
-      const { builders } = this;
+      const { _builders: builders } = this;
 
       const array = builders[name] || [];
 
@@ -37254,7 +37302,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 +37378,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 +37481,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 +37516,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 +37556,7 @@
        */
       ($injector) => {
         this.$injector = $injector;
-        this.builder.$injector = $injector;
+        this.builder._$injector = $injector;
 
         return this;
       },
@@ -37628,7 +37682,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 +37721,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(
@@ -38763,15 +38824,18 @@
 
         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;
-          }
-        });
+          },
+        );
 
         scope.$on("$destroy", () => unsubscribe());
       },
@@ -38783,7 +38847,7 @@
   /**
    * @param {ng.ParseService} $parse
    * @param {ng.LogService} $log
-   * @returns {import('interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngSetterDirective($parse, $log) {
     return {
@@ -38805,7 +38869,7 @@
           return;
         }
 
-        const updateModel = (value) => {
+        const updateModel = (/** @type {string} */ value) => {
           assignModel(scope, value.trim());
         };
 
@@ -38943,7 +39007,7 @@
 
       let called = false;
 
-      const wrapper = (...args) => {
+      const wrapper = (/** @type {any[]} */ ...args) => {
         if (called) return;
         called = true;
 
@@ -39090,28 +39154,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 +39366,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 +39401,7 @@
      * @param {string} url
      * @param {Record<string, any>=} params
      * @returns {string}
+     * @throws {URIError}
      */
     #buildUrl(url, params) {
       if (!params) return url;
@@ -39156,91 +39411,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 +39505,7 @@
       this.defaults = {};
     }
 
-    $get = [
-      $injectTokens._exceptionHandler,
-      /** @param {ng.ExceptionHandlerService} $exceptionHandler  */
-      ($exceptionHandler) => new CookieService(this.defaults, $exceptionHandler),
-    ];
+    $get = () => new CookieService(this.defaults);
   }
 
   /**
@@ -39353,14 +39519,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 +39534,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 +39554,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 +39564,7 @@
      * @throws {URIError} – If decodeURIComponent fails
      */
     getAll() {
-      try {
-        return parseCookies();
-      } catch (err) {
-        return this._$exceptionHandler(err);
-      }
+      return parseCookies();
     }
 
     /**
@@ -39426,6 +39573,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 +39582,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 +39599,9 @@
     putObject(key, value, options) {
       validateIsString(key, "key");
       validateRequired(value, "value");
-      assert(!isNullOrUndefined(value), BADARGVALUE);
+      const str = JSON.stringify(value);
 
-      try {
-        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 +40250,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 +40330,7 @@
                 ngInclude: ngIncludeDirective,
                 ngInject: ngInjectDirective,
                 ngInit: ngInitDirective,
+                ngListener: ngListenerDirective,
                 ngMessages: ngMessagesDirective,
                 ngMessage: ngMessageDirective,
                 ngMessageExp: ngMessageExpDirective,
@@ -40293,8 +40459,10 @@
   /** @type {ModuleRegistry} */
   const moduleRegistry = {};
 
-  class Angular {
+  class Angular extends EventTarget {
     constructor() {
+      super();
+
       /** @private @type {!Array<string|any>} */
       this._bootsrappedModules = [];
 
@@ -40308,7 +40476,7 @@
        * @public
        * @type {string} `version` from `package.json`
        */
-      this.version = "0.15.0"; //inserted via rollup plugin
+      this.version = "0.15.1"; //inserted via rollup plugin
 
       /**
        * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"