@angular-wave/angular.ts 0.17.0 → 0.18.0

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.17.0 - January 10, 2026 13:15:01 */
+/* Version: 0.18.0 - January 11, 2026 16:26:12 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -1467,7 +1467,6 @@ const $injectTokens = {
   _interpolate: "$interpolate",
   _location: "$location",
   _log: "$log",
-  _viewScroll: "$viewScroll",
   _parse: "$parse",
   _rest: "$rest",
   _rootScope: "$rootScope",
@@ -2646,18 +2645,6 @@ function validateIsString(arg, name) {
   return validate(isString, arg, name);
 }
 
-/**
- * @template T
- * @param {unknown} arg - The value to validate.
- * @param {new (...args: any[]) => T} type - The constructor to check against.
- * @param {string} name - Parameter name (included in error message).
- * @returns {T} The validated instance.
- * @throws {TypeError} If the value is not an instance of the specified type.
- */
-function validateInstanceOf(arg, type, name) {
-  return validate((v) => v instanceof type, arg, name);
-}
-
 const $injectorMinErr$1 = minErr($injectTokens._injector);
 
 const providerSuffix = "Provider";
@@ -3539,7 +3526,7 @@ function HttpProvider() {
     /**
      *
      * @param {ng.InjectorService} $injector
-     * @param {ng.SCEService} $sce
+     * @param {ng.SceService} $sce
      * @param {ng.CookieService} $cookie
      * @returns
      */
@@ -6390,8 +6377,8 @@ function SceProvider() {
     /**
      *
      * @param {ng.ParseService} $parse
-     * @param {ng.SCEDelegateService} $sceDelegate
-     * @return {ng.SCEService}
+     * @param {ng.SceDelegateService} $sceDelegate
+     * @return {ng.SceService}
      */
     ($parse, $sceDelegate) => {
       const sce = shallowCopy(SCE_CONTEXTS);
@@ -6647,7 +6634,7 @@ function SceProvider() {
         };
       });
 
-      return /** @type {ng.SCEService} */ (sce);
+      return /** @type {ng.SceService} */ (sce);
     },
   ];
 }
@@ -6799,7 +6786,7 @@ class Attributes {
    *
    * @param {ng.AnimateService} $animate
    * @param {ng.ExceptionHandlerService} $exceptionHandler
-   * @param {ng.SCEService} $sce
+   * @param {ng.SceService} $sce
    * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
    * @param {Object & Record<string, any>} [attributesToCopy]
    */
@@ -6810,7 +6797,7 @@ class Attributes {
     /** @type {ng.ExceptionHandlerService} */
     this._exceptionHandler = $exceptionHandler;
 
-    /** @type {ng.SCEService} */
+    /** @type {ng.SceService} */
     this._sce = $sce;
     /**
      * A map of DOM element attribute names to the normalized name. This is needed
@@ -7053,7 +7040,7 @@ class Attributes {
     listeners.push(fn);
 
     if (
-      !listeners.$$inter &&
+      !listeners._inter &&
       hasOwn(this, key) &&
       !isUndefined(/** @type {Record<string, any>} */ (this)[key])
     ) {
@@ -7246,9 +7233,9 @@ class CompileProvider {
 
   /**
    * @param {import('../../interface.ts').Provider} $provide
-   * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $$sanitizeUriProvider
+   * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $sanitizeUriProvider
    */
-  constructor($provide, $$sanitizeUriProvider) {
+  constructor($provide, $sanitizeUriProvider) {
     const hasDirectives = {};
 
     const bindingCache = Object.create(null);
@@ -7589,12 +7576,12 @@ class CompileProvider {
      */
     this.aHrefSanitizationTrustedUrlList = function (regexp) {
       if (isDefined(regexp)) {
-        $$sanitizeUriProvider.aHrefSanitizationTrustedUrlList(regexp);
+        $sanitizeUriProvider.aHrefSanitizationTrustedUrlList(regexp);
 
         return undefined;
       }
 
-      return $$sanitizeUriProvider.aHrefSanitizationTrustedUrlList();
+      return $sanitizeUriProvider.aHrefSanitizationTrustedUrlList();
     };
 
     /**
@@ -7614,12 +7601,12 @@ class CompileProvider {
      */
     this.imgSrcSanitizationTrustedUrlList = function (regexp) {
       if (isDefined(regexp)) {
-        $$sanitizeUriProvider.imgSrcSanitizationTrustedUrlList(regexp);
+        $sanitizeUriProvider.imgSrcSanitizationTrustedUrlList(regexp);
 
         return undefined;
       }
 
-      return $$sanitizeUriProvider.imgSrcSanitizationTrustedUrlList();
+      return $sanitizeUriProvider.imgSrcSanitizationTrustedUrlList();
     };
 
     /**
@@ -7763,7 +7750,7 @@ class CompileProvider {
        * @param {ng.TemplateRequestService} $templateRequest
        * @param {ng.ParseService} $parse
        * @param {*} $controller
-       * @param {ng.SCEService} $sce
+       * @param {ng.SceService} $sce
        * @param {ng.AnimateService} $animate
        * @returns
        */
@@ -9059,7 +9046,7 @@ class CompileProvider {
                   undefined,
                   {
                     needsNewScope:
-                      directive.$$isolateScope || directive.$$newScope,
+                      directive._isolateScope || directive._newScope,
                   },
                 );
                 /** @type {import("./interface.ts").TranscludeFn} */ (
@@ -9253,7 +9240,7 @@ class CompileProvider {
 
               if (
                 _newIsolateScopeDirective === directive ||
-                directive.$$isolateScope
+                directive._isolateScope
               ) {
                 pre = cloneAndAnnotateFn(pre, { isolateScope: true });
               }
@@ -9266,7 +9253,7 @@ class CompileProvider {
 
               if (
                 _newIsolateScopeDirective === directive ||
-                directive.$$isolateScope
+                directive._isolateScope
               ) {
                 post = cloneAndAnnotateFn(post, { isolateScope: true });
               }
@@ -9395,7 +9382,7 @@ class CompileProvider {
             const locals = {
               $scope:
                 directive === _newIsolateScopeDirective ||
-                directive.$$isolateScope
+                directive._isolateScope
                   ? isolateScope
                   : scope,
               $element: $element.node,
@@ -9443,8 +9430,8 @@ class CompileProvider {
         function markDirectiveScope(directives, isolateScope, newScope) {
           for (let j = 0, jj = directives.length; j < jj; j++) {
             directives[j] = inherit$1(directives[j], {
-              $$isolateScope: isolateScope,
-              $$newScope: newScope,
+              _isolateScope: isolateScope,
+              _newScope: newScope,
             });
           }
         }
@@ -10135,7 +10122,7 @@ class CompileProvider {
                   // directive's linking fn during linking phase
                   attr[name] = interpolateFn(scope);
 
-                  (_observers[name] || (_observers[name] = [])).$$inter = true;
+                  (_observers[name] || (_observers[name] = []))._inter = true;
                   interpolateFn.expressions.forEach((x) => {
                     const targetScope =
                       (attr._observers && attr._observers[name]._scope) ||
@@ -14626,7 +14613,7 @@ function ngIncludeDirective(
             isDefined(autoScrollExp) &&
             (!autoScrollExp || scope.$eval(autoScrollExp))
           ) {
-            /** @type {ng.AnchorScrollFunction} */ ($anchorScroll)();
+            $anchorScroll();
           }
         }
 
@@ -16141,7 +16128,7 @@ entries(ALIASED_ATTR).forEach(([ngAttr]) => {
   ngAttributeAliasDirectives[normalized] = [
     $injectTokens._sce,
     /**
-     * @param {ng.SCEService} $sce
+     * @param {ng.SceService} $sce
      * @returns {ng.Directive}
      */
     function ($sce) {
@@ -16536,43 +16523,41 @@ class AnchorScrollProvider {
      *
      * @param {ng.LocationService} $location
      * @param {ng.Scope} $rootScope
-     * @returns
+     * @returns {ng.AnchorScrollService}
      */
     ($location, $rootScope) => {
       // Helper function to get first anchor from a NodeList
       // (using `Array#some()` instead of `angular#forEach()` since it's more performant
       //  and working in all supported browsers.)
+      /**
+       * @param {NodeListOf<HTMLElement>} list
+       * @returns {HTMLAnchorElement | undefined}
+       */
       function getFirstAnchor(list) {
-        let result = null;
+        for (let i = 0; i < list.length; i++) {
+          const el = list[i];
 
-        Array.prototype.some.call(list, (element) => {
-          if (getNodeName(element) === "a") {
-            result = element;
-
-            return true;
+          if (getNodeName(el) === "a") {
+            return /** @type {HTMLAnchorElement} */ (el);
           }
+        }
 
-          return false;
-        });
-
-        return result;
+        return undefined;
       }
 
       function getYOffset() {
         // Figure out a better way to configure this other than bolting on a property onto a function
-        let offset = /** @type {ng.AnchorScrollObject} */ (scroll).yOffset;
+        let offset = scroll.yOffset;
 
         if (isFunction(offset)) {
           offset = /** @type {Function} */ (offset)();
         } else if (offset instanceof Element) {
-          const elem = offset[0];
-
-          const style = window.getComputedStyle(elem);
+          const style = window.getComputedStyle(offset);
 
           if (style.position !== "fixed") {
             offset = 0;
           } else {
-            offset = elem.getBoundingClientRect().bottom;
+            offset = offset.getBoundingClientRect().bottom;
           }
         } else if (!isNumber(offset)) {
           offset = 0;
@@ -16581,29 +16566,24 @@ class AnchorScrollProvider {
         return offset;
       }
 
+      /**
+       * @param {HTMLElement} [elem]
+       */
       function scrollTo(elem) {
         if (elem) {
+          const rect = elem.getBoundingClientRect();
+
           elem.scrollIntoView();
 
-          const offset = getYOffset();
+          const offset = /** @type {number} */ (getYOffset());
 
           if (offset) {
-            // `offset` is the number of pixels we should scroll UP in order to align `elem` properly.
-            // This is true ONLY if the call to `elem.scrollIntoView()` initially aligns `elem` at the
-            // top of the viewport.
-            //
-            // IF the number of pixels from the top of `elem` to the end of the page's content is less
-            // than the height of the viewport, then `elem.scrollIntoView()` will align the `elem` some
-            // way down the page.
+            // `offset` is how many pixels we want the element to appear below the top of the viewport.
             //
-            // This is often the case for elements near the bottom of the page.
-            //
-            // In such cases we do not need to scroll the whole `offset` up, just the difference between
-            // the top of the element and the offset, which is enough to align the top of `elem` at the
-            // desired position.
-            const elemTop = elem.getBoundingClientRect().top;
-
-            window.scrollBy(0, elemTop - /** @type {number} */ (offset));
+            // `scrollIntoView()` does not always align the element at the top (e.g. near the bottom
+            // of the page). Therefore, we measure the element’s actual position after scrolling and
+            // only adjust by the difference needed to reach the desired offset.
+            window.scrollBy(0, rect.top - offset);
           }
         } else {
           window.scrollTo(0, 0);
@@ -16611,7 +16591,7 @@ class AnchorScrollProvider {
       }
 
       /** @type {ng.AnchorScrollService} */
-      const scroll = function (/** @type {string | number} */ hash) {
+      const scroll = (hash) => {
         // Allow numeric hashes
         hash = isString(hash)
           ? hash
@@ -16622,7 +16602,7 @@ class AnchorScrollProvider {
 
         // empty hash, scroll to the top of the page
         if (!hash) {
-          scrollTo(null);
+          scrollTo();
         }
         // element with given id
         else if ((elm = document.getElementById(hash))) scrollTo(elm);
@@ -16630,28 +16610,37 @@ class AnchorScrollProvider {
         else if ((elm = getFirstAnchor(document.getElementsByName(hash))))
           scrollTo(elm);
         // no element and hash === 'top', scroll to the top of the page
-        else if (hash === "top") scrollTo(null);
+        else if (hash === "top") scrollTo();
       };
 
       // does not scroll when user clicks on anchor link that is currently on
       // (no url change, no $location.getHash() change), browser native does scroll
       if (this.autoScrollingEnabled) {
-        $rootScope.$location = $location;
-        $rootScope.$watch("$location.$$hash", (newVal, oldVal) => {
-          // skip the initial scroll if $location.hash is empty
-          if (newVal === oldVal && newVal === "") return;
-
-          const action = () => scroll(newVal);
-
-          if (document.readyState === "complete") {
-            // Force the action to be run async for consistent behavior
-            // from the action's point of view
-            // i.e. it will definitely not be in a $apply
-            queueMicrotask(() => action());
-          } else {
-            window.addEventListener("load", () => action());
-          }
-        });
+        $rootScope.$on(
+          "$locationChangeSuccess",
+          /** @param {ng.ScopeEvent} _e  @param {string} newVal @param {string} oldVal */ (
+            _e,
+            newVal,
+            oldVal,
+          ) => {
+            const newUrl = urlResolve(newVal);
+
+            const ordUrl = urlResolve(oldVal);
+
+            if (newUrl.hash === ordUrl.hash && newUrl.hash === "") return;
+
+            const action = () => scroll(newUrl.hash);
+
+            if (document.readyState === "complete") {
+              // Force the action to be run async for consistent behavior
+              // from the action's point of view
+              // i.e. it will definitely not be in a $apply
+              queueMicrotask(() => action());
+            } else {
+              window.addEventListener("load", () => action());
+            }
+          },
+        );
       }
 
       return scroll;
@@ -16735,7 +16724,7 @@ function applyAnimationClassesFactory() {
 function prepareAnimationOptions(options) {
   const animateOptions = options || /** @type {ng.AnimationOptions} */ ({});
 
-  if (!animateOptions.$$prepared) {
+  if (!animateOptions._prepared) {
     let domOperation =
       animateOptions.domOperation ||
       (() => {
@@ -16749,7 +16738,7 @@ function prepareAnimationOptions(options) {
         /* empty */
       };
     };
-    animateOptions.$$prepared = true;
+    animateOptions._prepared = true;
   }
 
   return animateOptions;
@@ -16929,7 +16918,7 @@ function clearGeneratedClasses(element, options) {
  * @param {boolean} applyBlock
  * @returns {string[]}
  */
-function blockKeyframeAnimations(node, applyBlock) {
+function _blockKeyframeAnimations(node, applyBlock) {
   const value = applyBlock ? "paused" : "";
 
   const key = `animationPlayState`;
@@ -16981,7 +16970,7 @@ function AnimateProvider($provide) {
 
   let customFilter = null;
 
-  this.$$registeredAnimations = Object.create(null);
+  this._registeredAnimations = Object.create(null);
 
   /**
    * Registers a new injectable animation factory function. The factory function produces the
@@ -17029,7 +17018,7 @@ function AnimateProvider($provide) {
 
     const key = `${name}-animation`;
 
-    provider.$$registeredAnimations[name.substring(1)] = key;
+    provider._registeredAnimations[name.substring(1)] = key;
     $provide.factory(key, factory);
   };
 
@@ -17266,7 +17255,7 @@ function AnimateProvider($provide) {
          * Note that this does not cancel the underlying operation, e.g. the setting of classes or
          * adding the element to the DOM.
          *
-         * @param {import('./runner/animate-runner.js').AnimateRunner} runner An animation runner returned by an $animate function.
+         * @param {ng.AnimateRunner} runner An animation runner returned by an $animate function.
          */
         cancel(runner) {
           if (runner.cancel) {
@@ -17284,7 +17273,7 @@ function AnimateProvider($provide) {
          * @param {Element} parent - the parent element which will append the element as a child (so long as the after element is not present)
          * @param {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
+         * @returns {ng.AnimateRunner} the animation runner
          */
         enter(element, parent, after, options) {
           parent = parent || after.parentElement;
@@ -17315,7 +17304,7 @@ function AnimateProvider($provide) {
          * @param {Element} parent - the parent element which will append the element as a child (so long as the after element is not present)
          * @param {Element} after - after the sibling element after which the element will be appended
          * @param {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
+         * @returns {ng.AnimateRunner} the animation runner
          */
         move(element, parent, after, options) {
           parent = parent || after.parentElement;
@@ -17343,7 +17332,7 @@ function AnimateProvider($provide) {
          *
          * @param {Element} element the element which will be removed from the DOM
          * @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
+         * @returns {ng.AnimateRunner} the animation runner
          */
         leave(element, options) {
           return $$animateQueue.push(
@@ -17367,7 +17356,7 @@ function AnimateProvider($provide) {
          * @param {Element} element the element which the CSS classes will be applied to
          * @param {string} className the CSS class(es) that will be added (multiple classes are separated via spaces)
          * @param {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
+         * @return {ng.AnimateRunner}} animationRunner the animation runner
          */
         addClass(element, className, options) {
           options = prepareAnimateOptions(options);
@@ -17387,7 +17376,7 @@ function AnimateProvider($provide) {
          * @param {Element} element the element which the CSS classes will be applied to
          * @param {string} className the CSS class(es) that will be removed (multiple classes are separated via spaces)
          * @param {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
+         * @return {ng.AnimateRunner} animationRunner the animation runner
          */
         removeClass(element, className, options) {
           options = prepareAnimateOptions(options);
@@ -17409,7 +17398,7 @@ function AnimateProvider($provide) {
          * @param {string} remove the CSS class(es) that will be removed (multiple classes are separated via spaces)
          * @param {object=} options an optional collection of options/styles that will be applied to the element.
          *
-         * @return {import('./runner/animate-runner.js').AnimateRunner} the animation runner
+         * @return {ng.AnimateRunner} the animation runner
          */
         setClass(element, add, remove, options) {
           options = prepareAnimateOptions(options);
@@ -17438,7 +17427,7 @@ function AnimateProvider($provide) {
          *   }
          * });
          * ```
-         *  @return {import('./runner/animate-runner.js').AnimateRunner} the animation runner
+         *  @return {ng.AnimateRunner} the animation runner
          */
         animate(element, from, to, className, options) {
           options = prepareAnimateOptions(options);
@@ -18345,7 +18334,7 @@ class InterpolateProvider {
     /**
      *
      * @param {ng.ParseService} $parse
-     * @param {ng.SCEService} $sce
+     * @param {ng.SceService} $sce
      * @returns {ng.InterpolateService}
      */
     ($parse, $sce) => {
@@ -18948,9 +18937,9 @@ class Location {
       );
     }
     // The user might modify `stateObject` after invoking `$location.setState(stateObject)`
-    // but we're changing the $$state reference to $browser.state() during the $digest
+    // but we're changing the _statereference to $browser.state() during the $digest
     // so the modification window is narrow.
-    this.$$state = isUndefined(state) ? null : state;
+    this._state = isUndefined(state) ? null : state;
     urlUpdatedByLocation = true;
 
     return this;
@@ -18961,7 +18950,7 @@ class Location {
    * @returns {any}
    */
   getState() {
-    return this.$$state;
+    return this._state;
   }
 
   /**
@@ -19286,14 +19275,14 @@ class LocationProvider {
 
       $location.parseLinkUrl(initialUrl, initialUrl);
 
-      $location.$$state = this.state();
+      $location._state = this.state();
 
       const IGNORE_URI_REGEXP = /^\s*(javascript|mailto):/i;
 
       const setBrowserUrlWithFallback = (url, state) => {
         const oldUrl = $location.getUrl();
 
-        const oldState = $location.$$state;
+        const oldState = $location._state;
 
         try {
           this.setUrl(url, state);
@@ -19301,11 +19290,11 @@ class LocationProvider {
           // Make sure $location.getState() returns referentially identical (not just deeply equal)
           // state object; this makes possible quick checking if the state changed in the digest
           // loop. Checking deep equality would be too expensive.
-          $location.$$state = this.state();
+          $location._state = this.state();
         } catch (err) {
           // Restore old values if pushState fails
           $location.setUrl(/** @type {string} */ (oldUrl));
-          $location.$$state = oldState;
+          $location._state = oldState;
           $exceptionHandler(err);
         }
       };
@@ -19401,10 +19390,10 @@ class LocationProvider {
         queueMicrotask(() => {
           const oldUrl = $location.absUrl;
 
-          const oldState = $location.$$state;
+          const oldState = $location._state;
 
           $location.parse(newUrl);
-          $location.$$state = newState;
+          $location._state = newState;
 
           const { defaultPrevented } = $rootScope.$broadcast(
             "$locationChangeStart",
@@ -19420,7 +19409,7 @@ class LocationProvider {
 
           if (defaultPrevented) {
             $location.parse(oldUrl);
-            $location.$$state = oldState;
+            $location._state = oldState;
             setBrowserUrlWithFallback(oldUrl, oldState);
           } else {
             initializing = false;
@@ -19442,7 +19431,7 @@ class LocationProvider {
 
           const urlOrStateChanged =
             !urlsEqual(oldUrl, newUrl) ||
-            ($location.html5 && oldState !== $location.$$state);
+            ($location.html5 && oldState !== $location._state);
 
           if (initializing || urlOrStateChanged) {
             initializing = false;
@@ -19454,7 +19443,7 @@ class LocationProvider {
                 "$locationChangeStart",
                 $location.absUrl,
                 oldUrl,
-                $location.$$state,
+                $location._state,
                 oldState,
               );
 
@@ -19464,12 +19453,12 @@ class LocationProvider {
 
               if (defaultPrevented) {
                 $location.parse(oldUrl);
-                $location.$$state = oldState;
+                $location._state = oldState;
               } else {
                 if (urlOrStateChanged) {
                   setBrowserUrlWithFallback(
                     newUrl,
-                    oldState === $location.$$state ? null : $location.$$state,
+                    oldState === $location._state ? null : $location._state,
                   );
                 }
                 afterLocationChange(oldUrl, oldState);
@@ -19494,7 +19483,7 @@ class LocationProvider {
           "$locationChangeSuccess",
           $location.absUrl,
           oldUrl,
-          $location.$$state,
+          $location._state,
           oldState,
         );
       }
@@ -23871,37 +23860,37 @@ class NgMessageCtrl {
    * @param {ng.AnimateService} $animate
    */
   constructor($element, $scope, $attrs, $animate) {
-    this.$element = $element;
-    this.$scope = $scope;
-    this.$attrs = $attrs;
-    this.$animate = $animate;
-
-    this.latestKey = 0;
-    this.nextAttachId = 0;
-    this.messages = {};
-    this.renderLater = false;
-    this.cachedCollection = null;
-
-    this.head = undefined;
-    this.default = undefined;
-
-    this.$scope.$watch(
-      this.$attrs.ngMessages || this.$attrs.for,
-      this.render.bind(this),
+    this._element = $element;
+    this._scope = $scope;
+    this._attrs = $attrs;
+    this._animate = $animate;
+
+    this._latestKey = 0;
+    this._nextAttachId = 0;
+    this._messages = {};
+    this._renderLater = false;
+    this._cachedCollection = null;
+
+    this._head = undefined;
+    this._default = undefined;
+
+    this._scope.$watch(
+      this._attrs.ngMessages || this._attrs.for,
+      this._render.bind(this),
     );
   }
 
-  getAttachId() {
-    return this.nextAttachId++;
+  _getAttachId() {
+    return this._nextAttachId++;
   }
 
-  render(collection = {}) {
-    this.renderLater = false;
-    this.cachedCollection = collection;
+  _render(collection = {}) {
+    this._renderLater = false;
+    this._cachedCollection = collection;
 
     const multiple =
-      isAttrTruthy(this.$scope, this.$attrs.ngMessagesMultiple) ||
-      isAttrTruthy(this.$scope, this.$attrs.multiple);
+      isAttrTruthy(this._scope, this._attrs.ngMessagesMultiple) ||
+      isAttrTruthy(this._scope, this._attrs.multiple);
 
     const unmatchedMessages = [];
 
@@ -23909,7 +23898,7 @@ class NgMessageCtrl {
 
     let truthyKeys = 0;
 
-    let messageItem = this.head;
+    let messageItem = this._head;
 
     let messageFound = false;
 
@@ -23952,27 +23941,27 @@ class NgMessageCtrl {
 
     const messageMatched = unmatchedMessages.length !== totalMessages;
 
-    const attachDefault = this.default && !messageMatched && truthyKeys > 0;
+    const attachDefault = this._default && !messageMatched && truthyKeys > 0;
 
     if (attachDefault) {
-      this.default.attach();
-    } else if (this.default) {
-      this.default.detach();
+      this._default.attach();
+    } else if (this._default) {
+      this._default.detach();
     }
 
     if (messageMatched || attachDefault) {
-      this.$animate.setClass(this.$element, ACTIVE_CLASS, INACTIVE_CLASS);
+      this._animate.setClass(this._element, ACTIVE_CLASS, INACTIVE_CLASS);
     } else {
-      this.$animate.setClass(this.$element, INACTIVE_CLASS, ACTIVE_CLASS);
+      this._animate.setClass(this._element, INACTIVE_CLASS, ACTIVE_CLASS);
     }
   }
 
   reRender() {
-    if (!this.renderLater) {
-      this.renderLater = true;
+    if (!this._renderLater) {
+      this._renderLater = true;
       Promise.resolve().then(() => {
-        if (this.renderLater && this.cachedCollection) {
-          this.render(this.cachedCollection);
+        if (this._renderLater && this._cachedCollection) {
+          this._render(this._cachedCollection);
         }
       });
     }
@@ -23980,16 +23969,16 @@ class NgMessageCtrl {
 
   register(comment, messageCtrl, isDefault) {
     if (isDefault) {
-      this.default = messageCtrl;
+      this._default = messageCtrl;
     } else {
-      const nextKey = this.latestKey.toString();
+      const nextKey = this._latestKey.toString();
 
-      this.messages[nextKey] = {
+      this._messages[nextKey] = {
         message: messageCtrl,
       };
-      this.insertMessageNode(this.$element, comment, nextKey);
+      this.insertMessageNode(this._element, comment, nextKey);
       comment._ngMessageNode = nextKey;
-      this.latestKey++;
+      this._latestKey++;
     }
 
     this.reRender();
@@ -23997,13 +23986,13 @@ class NgMessageCtrl {
 
   deregister(comment, isDefault) {
     if (isDefault) {
-      delete this.default;
+      delete this._default;
     } else {
       const key = comment._ngMessageNode;
 
       delete comment._ngMessageNode;
-      this.removeMessageNode(this.$element, comment, key);
-      delete this.messages[key];
+      this.removeMessageNode(this._element, comment, key);
+      delete this._messages[key];
     }
     this.reRender();
   }
@@ -24017,7 +24006,7 @@ class NgMessageCtrl {
       const prevKey = prevNode._ngMessageNode;
 
       if (prevKey && prevKey.length) {
-        return this.messages[prevKey];
+        return this._messages[prevKey];
       }
 
       if (prevNode.childNodes.length && parentLookup.indexOf(prevNode) === -1) {
@@ -24035,10 +24024,10 @@ class NgMessageCtrl {
   }
 
   insertMessageNode(parent, comment, key) {
-    const messageNode = this.messages[key];
+    const messageNode = this._messages[key];
 
-    if (!this.head) {
-      this.head = messageNode;
+    if (!this._head) {
+      this._head = messageNode;
     } else {
       const match = this.findPreviousMessage(parent, comment);
 
@@ -24046,14 +24035,14 @@ class NgMessageCtrl {
         messageNode.next = match.next;
         match.next = messageNode;
       } else {
-        messageNode.next = this.head;
-        this.head = messageNode;
+        messageNode.next = this._head;
+        this._head = messageNode;
       }
     }
   }
 
   removeMessageNode(parent, comment, key) {
-    const messageNode = this.messages[key];
+    const messageNode = this._messages[key];
 
     if (!messageNode) return;
 
@@ -24062,7 +24051,7 @@ class NgMessageCtrl {
     if (match) {
       match.next = messageNode.next;
     } else {
-      this.head = messageNode.next;
+      this._head = messageNode.next;
     }
   }
 }
@@ -24193,8 +24182,8 @@ function ngMessageDirectiveFactory(isDefault) {
 
                   // Each time we attach this node to a message we get a new id that we can match
                   // when we are destroying the node later.
-                  const $$attachId = (currentElement.$$attachId =
-                    ngMessagesCtrl.getAttachId());
+                  const attachId = (currentElement._attachId =
+                    ngMessagesCtrl._getAttachId());
 
                   // in the event that the element or a parent element is destroyed
                   // by another structural directive then it's time
@@ -24204,7 +24193,7 @@ function ngMessageDirectiveFactory(isDefault) {
                     // So this handler only handles cases where something else removed the message element.
                     if (
                       currentElement &&
-                      currentElement.$$attachId === $$attachId
+                      currentElement._attachId === attachId
                     ) {
                       ngMessagesCtrl.deregister(commentNode, isDefault);
                       messageCtrl.detach();
@@ -24328,14 +24317,14 @@ function AriaProvider() {
       config(key) {
         return config[key];
       },
-      $$watchExpr: watchExpr,
+      _watchExpr: watchExpr,
     };
   };
 }
 
 ngDisabledAriaDirective.$inject = [$injectTokens._aria];
 function ngDisabledAriaDirective($aria) {
-  return $aria.$$watchExpr(
+  return $aria._watchExpr(
     "ngDisabled",
     "aria-disabled",
     nativeAriaNodeNames,
@@ -24345,7 +24334,7 @@ function ngDisabledAriaDirective($aria) {
 
 ngShowAriaDirective.$inject = [$injectTokens._aria];
 function ngShowAriaDirective($aria) {
-  return $aria.$$watchExpr("ngShow", "aria-hidden", [], true);
+  return $aria._watchExpr("ngShow", "aria-hidden", [], true);
 }
 
 /**
@@ -24431,7 +24420,7 @@ function ngClickAriaDirective($aria, $parse) {
 
 ngRequiredAriaDirective.$inject = [$injectTokens._aria];
 function ngRequiredAriaDirective($aria) {
-  return $aria.$$watchExpr(
+  return $aria._watchExpr(
     "ngRequired",
     "aria-required",
     nativeAriaNodeNames,
@@ -24441,7 +24430,7 @@ function ngRequiredAriaDirective($aria) {
 
 ngCheckedAriaDirective.$inject = [$injectTokens._aria];
 function ngCheckedAriaDirective($aria) {
-  return $aria.$$watchExpr(
+  return $aria._watchExpr(
     "ngChecked",
     "aria-checked",
     nativeAriaNodeNames,
@@ -24451,7 +24440,7 @@ function ngCheckedAriaDirective($aria) {
 
 ngValueAriaDirective.$inject = [$injectTokens._aria];
 function ngValueAriaDirective($aria) {
-  return $aria.$$watchExpr(
+  return $aria._watchExpr(
     "ngValue",
     "aria-checked",
     nativeAriaNodeNames,
@@ -24461,12 +24450,12 @@ function ngValueAriaDirective($aria) {
 
 ngHideAriaDirective.$inject = [$injectTokens._aria];
 function ngHideAriaDirective($aria) {
-  return $aria.$$watchExpr("ngHide", "aria-hidden", [], false);
+  return $aria._watchExpr("ngHide", "aria-hidden", [], false);
 }
 
 ngReadonlyAriaDirective.$inject = [$injectTokens._aria];
 function ngReadonlyAriaDirective($aria) {
-  return $aria.$$watchExpr(
+  return $aria._watchExpr(
     "ngReadonly",
     "aria-readonly",
     nativeAriaNodeNames,
@@ -25420,10 +25409,10 @@ function AnimateCssProvider() {
         let options =
           initialOptions ||
           /** @type {ng.AnimationOptions}}*/ ({
-            $$skipPreparationClasses: false,
+            _skipPreparationClasses: false,
           });
 
-        if (!options.$$prepared) {
+        if (!options._prepared) {
           options = prepareAnimationOptions(structuredClone(options));
         }
 
@@ -25560,7 +25549,7 @@ function AnimateCssProvider() {
           );
         }
 
-        if (!options.$$skipPreparationClasses) {
+        if (!options._skipPreparationClasses) {
           element.classList.add(
             ...preparationClasses.split(" ").filter((x) => x !== ""),
           );
@@ -25610,7 +25599,7 @@ function AnimateCssProvider() {
         // that if there is no transition defined then nothing will happen and this will also allow
         // other transitions to be stacked on top of each other without any chopping them out.
         if (isFirst) {
-          blockTransitions(node, SAFE_FAST_FORWARD_DURATION_VALUE);
+          _blockTransitions(node, SAFE_FAST_FORWARD_DURATION_VALUE);
         }
 
         let timings = computeTimings(node, cacheKey, !isStructural);
@@ -25623,29 +25612,30 @@ function AnimateCssProvider() {
 
         const flags = {};
 
-        flags.hasTransitions = timings.transitionDuration > 0;
-        flags.hasAnimations = timings.animationDuration > 0;
-        flags.hasTransitionAll =
-          flags.hasTransitions && timings.transitionProperty === "all";
-        flags.applyTransitionDuration =
+        flags._hasTransitions = timings.transitionDuration > 0;
+        flags._hasAnimations = timings.animationDuration > 0;
+        flags._hasTransitionAll =
+          flags._hasTransitions && timings.transitionProperty === "all";
+        flags._applyTransitionDuration =
           hasToStyles &&
-          ((flags.hasTransitions && !flags.hasTransitionAll) ||
-            (flags.hasAnimations && !flags.hasTransitions));
-        flags.applyAnimationDuration = options.duration && flags.hasAnimations;
-        flags.applyTransitionDelay =
+          ((flags._hasTransitions && !flags._hasTransitionAll) ||
+            (flags._hasAnimations && !flags._hasTransitions));
+        flags._applyAnimationDuration =
+          options.duration && flags._hasAnimations;
+        flags._applyTransitionDelay =
           truthyTimingValue(options.delay) &&
-          (flags.applyTransitionDuration || flags.hasTransitions);
-        flags.applyAnimationDelay =
-          truthyTimingValue(options.delay) && flags.hasAnimations;
-        flags.recalculateTimingStyles = addRemoveClassName.length > 0;
+          (flags._applyTransitionDuration || flags._hasTransitions);
+        flags._applyAnimationDelay =
+          truthyTimingValue(options.delay) && flags._hasAnimations;
+        flags._recalculateTimingStyles = addRemoveClassName.length > 0;
 
-        if (flags.applyTransitionDuration || flags.applyAnimationDuration) {
+        if (flags._applyTransitionDuration || flags._applyAnimationDuration) {
           maxDuration = options.duration
             ? parseFloat(/** @type {string} */ (options.duration))
             : maxDuration;
 
-          if (flags.applyTransitionDuration) {
-            flags.hasTransitions = true;
+          if (flags._applyTransitionDuration) {
+            flags._hasTransitions = true;
             timings.transitionDuration = maxDuration;
             applyOnlyDuration = node.style.transitionProperty.length > 0;
             temporaryStyles.push(
@@ -25653,14 +25643,14 @@ function AnimateCssProvider() {
             );
           }
 
-          if (flags.applyAnimationDuration) {
-            flags.hasAnimations = true;
+          if (flags._applyAnimationDuration) {
+            flags._hasAnimations = true;
             timings.animationDuration = maxDuration;
             temporaryStyles.push(getCssKeyframeDurationStyle(maxDuration));
           }
         }
 
-        if (maxDuration === 0 && !flags.recalculateTimingStyles) {
+        if (maxDuration === 0 && !flags._recalculateTimingStyles) {
           return closeAndReturnNoopAnimator();
         }
 
@@ -25673,11 +25663,11 @@ function AnimateCssProvider() {
             maxDelay = Math.max(delayStyle, 0);
           }
 
-          if (flags.applyTransitionDelay) {
+          if (flags._applyTransitionDelay) {
             temporaryStyles.push(getCssDelayStyle(delayStyle));
           }
 
-          if (flags.applyAnimationDelay) {
+          if (flags._applyAnimationDelay) {
             temporaryStyles.push(getCssDelayStyle(delayStyle, true));
           }
         }
@@ -25689,15 +25679,15 @@ function AnimateCssProvider() {
           isNullOrUndefined(options.duration) &&
           timings.transitionDuration > 0
         ) {
-          flags.recalculateTimingStyles =
-            flags.recalculateTimingStyles || isFirst;
+          flags._recalculateTimingStyles =
+            flags._recalculateTimingStyles || isFirst;
         }
 
         maxDelayTime = maxDelay * ONE_SECOND;
         maxDurationTime = maxDuration * ONE_SECOND;
 
-        flags.blockTransition = timings.transitionDuration > 0;
-        flags.blockKeyframeAnimation =
+        flags._blockTransition = timings.transitionDuration > 0;
+        flags._blockKeyframeAnimation =
           timings.animationDuration > 0 &&
           stagger.animationDelay > 0 &&
           stagger.animationDuration === 0;
@@ -25713,15 +25703,15 @@ function AnimateCssProvider() {
           applyAnimationFromStyles(element, options);
         }
 
-        if (flags.blockTransition || flags.blockKeyframeAnimation) {
+        if (flags._blockTransition || flags._blockKeyframeAnimation) {
           applyBlocking(maxDuration);
         } else if (!options.skipBlocking) {
-          blockTransitions(node, false);
+          _blockTransitions(node, false);
         }
 
         // TODO(matsko): for 1.5 change this code to have an animator object for better debugging
         return {
-          $$willAnimate: true,
+          _willAnimate: true,
           end: endFn,
           start() {
             if (animationClosed) return undefined;
@@ -25761,7 +25751,7 @@ function AnimateCssProvider() {
           animationClosed = true;
           animationPaused = false;
 
-          if (preparationClasses && !options.$$skipPreparationClasses) {
+          if (preparationClasses && !options._skipPreparationClasses) {
             element.classList.remove(...preparationClasses.split(" "));
           }
           activeClasses = pendClasses(preparationClasses, ACTIVE_CLASS_SUFFIX);
@@ -25770,8 +25760,8 @@ function AnimateCssProvider() {
             element.classList.remove(...activeClasses.split(" "));
           }
 
-          blockKeyframeAnimations(node, false);
-          blockTransitions(node, false);
+          _blockKeyframeAnimations(node, false);
+          _blockTransitions(node, false);
 
           temporaryStyles.forEach((entry) => {
             // There is only one way to remove inline style properties entirely from elements.
@@ -25824,12 +25814,12 @@ function AnimateCssProvider() {
         }
 
         function applyBlocking(duration) {
-          if (flags.blockTransition) {
-            blockTransitions(node, duration);
+          if (flags._blockTransition) {
+            _blockTransitions(node, duration);
           }
 
-          if (flags.blockKeyframeAnimation) {
-            blockKeyframeAnimations(node, !!duration);
+          if (flags._blockKeyframeAnimation) {
+            _blockKeyframeAnimations(node, !!duration);
           }
         }
 
@@ -25846,7 +25836,7 @@ function AnimateCssProvider() {
           close();
 
           return {
-            $$willAnimate: false,
+            _willAnimate: false,
             start() {
               return runner;
             },
@@ -25910,7 +25900,7 @@ function AnimateCssProvider() {
               animationPaused = !playAnimation;
 
               if (timings.animationDuration) {
-                const value = blockKeyframeAnimations(node, animationPaused);
+                const value = _blockKeyframeAnimations(node, animationPaused);
 
                 if (animationPaused) {
                   temporaryStyles.push(value);
@@ -25974,7 +25964,7 @@ function AnimateCssProvider() {
               ...activeClasses.split(" ").filter((x) => x !== ""),
             );
 
-            if (flags.recalculateTimingStyles) {
+            if (flags._recalculateTimingStyles) {
               cacheKey = animateCache._cacheKey(
                 node,
                 method,
@@ -25994,11 +25984,11 @@ function AnimateCssProvider() {
                 return;
               }
 
-              flags.hasTransitions = timings.transitionDuration > 0;
-              flags.hasAnimations = timings.animationDuration > 0;
+              flags._hasTransitions = timings.transitionDuration > 0;
+              flags._hasAnimations = timings.animationDuration > 0;
             }
 
-            if (flags.applyAnimationDelay) {
+            if (flags._applyAnimationDelay) {
               relativeDelay =
                 typeof options.delay !== "boolean" &&
                 truthyTimingValue(options.delay)
@@ -26020,13 +26010,13 @@ function AnimateCssProvider() {
 
               const easeVal = options.easing;
 
-              if (flags.hasTransitions) {
+              if (flags._hasTransitions) {
                 easeProp = "transitionTimingFunction";
                 temporaryStyles.push([easeProp, easeVal]);
                 node.style[easeProp] = easeVal;
               }
 
-              if (flags.hasAnimations) {
+              if (flags._hasAnimations) {
                 easeProp = "animationTimingFunction";
                 temporaryStyles.push([easeProp, easeVal]);
                 node.style[easeProp] = easeVal;
@@ -26112,7 +26102,7 @@ function AnimateCssProvider() {
   ];
 }
 
-function blockTransitions(node, duration) {
+function _blockTransitions(node, duration) {
   // we use a negative delay value since it performs blocking
   // yet it doesn't kill any existing transitions running on the
   // same element which makes this safe for class-based animations
@@ -26266,7 +26256,7 @@ function AnimateQueueProvider($animateProvider) {
      *
      * @param {ng.RootScopeService} $rootScope
      * @param {ng.InjectorService} $injector
-     * @param {*} $$animation
+     * @param {import("../interface.ts").AnimationService} $$animation
      * @returns {import("../queue/interface.ts").AnimateQueueService}
      */
     function ($rootScope, $injector, $$animation) {
@@ -26946,7 +26936,7 @@ function AnimateJsProvider($animateProvider) {
      * @param {ng.InjectorService} $injector
      * @returns {import("./interface.ts").AnimateJsFn}
      */
-    function ($injector) {
+    ($injector) => {
       const applyAnimationClasses = applyAnimationClassesFactory();
 
       /**
@@ -27016,7 +27006,7 @@ function AnimateJsProvider($animateProvider) {
         let runner;
 
         return {
-          $$willAnimate: true,
+          _willAnimate: true,
 
           start() {
             if (runner) return runner;
@@ -27064,7 +27054,7 @@ function AnimateJsProvider($animateProvider) {
             const klass = classList[i];
 
             const animationFactory =
-              $animateProvider.$$registeredAnimations[klass];
+              $animateProvider._registeredAnimations[klass];
 
             if (animationFactory && !flagMap[klass]) {
               matches.push($injector.get(animationFactory));
@@ -27187,7 +27177,7 @@ function AnimationProvider() {
      *
      * @param {ng.RootScopeService} $rootScope
      * @param {ng.InjectorService} $injector
-     * @returns
+     * @return {import("./interface.ts").AnimationService}
      */
     function ($rootScope, $injector) {
       /**
@@ -27877,7 +27867,7 @@ function AnimateCssDriverProvider($$animationProvider) {
 
           // read the comment within `prepareRegularAnimation` to understand
           // why this check is necessary
-          return animator.$$willAnimate ? animator : null;
+          return animator._willAnimate ? animator : null;
         }
 
         function getClassVal(element) {
@@ -27900,7 +27890,7 @@ function AnimateCssDriverProvider($$animationProvider) {
 
           // read the comment within `prepareRegularAnimation` to understand
           // why this check is necessary
-          return animator.$$willAnimate ? animator : null;
+          return animator._willAnimate ? animator : null;
         }
 
         function end() {
@@ -27998,11 +27988,11 @@ function AnimateCssDriverProvider($$animationProvider) {
         const animator = $animateCss(animationDetails.element, options);
 
         // the driver lookup code inside of $$animation attempts to spawn a
-        // driver one by one until a driver returns a.$$willAnimate animator object.
+        // driver one by one until a driver returns a._willAnimate animator object.
         // $animateCss will always return an object, however, it will pass in
         // a flag as a hint as to whether an animation was detected or not
 
-        return animator.$$willAnimate ? animator : null;
+        return animator._willAnimate ? animator : null;
       }
     },
   ];
@@ -28022,6 +28012,10 @@ function getUniqueValues(a, b) {
 }
 
 AnimateJsDriverProvider.$inject = provider([$injectTokens._animation]);
+
+/**
+ * @param {import("./animation.js").AnimationProvider} $$animationProvider
+ */
 function AnimateJsDriverProvider($$animationProvider) {
   $$animationProvider.drivers.push($injectTokens._animateJsDriver);
   this.$get = [
@@ -33207,7 +33201,7 @@ function treeChangesCleanup(trans) {
  */
 function makeEnterExitRetainHook(hookName) {
   return (transition, state) => {
-    const _state = state.$$state();
+    const _state = state._state();
 
     const hookFn = _state[hookName];
 
@@ -33292,7 +33286,7 @@ const registerEagerResolvePath = (transitionService) =>
  */
 const lazyResolveState = (trans, state) =>
   new ResolveContext(trans.treeChanges().to)
-    .subContext(state.$$state())
+    .subContext(state._state())
     .resolvePath("LAZY", trans)
     .then(() => {
       /* empty */
@@ -33484,7 +33478,7 @@ function registerLazyLoadHook(
       }
       const promises = transition
         .entering()
-        .filter((state) => !!state.$$state().lazyLoad)
+        .filter((state) => !!state._state().lazyLoad)
         .map((state) => lazyLoadState(transition, state, stateRegistry));
 
       return Promise.all(promises).then(retryTransition);
@@ -33500,7 +33494,7 @@ function registerLazyLoadHook(
  * @returns A promise for the lazy load result
  */
 function lazyLoadState(transition, state, stateRegistry) {
-  const lazyLoadFn = state.$$state().lazyLoad;
+  const lazyLoadFn = state._state().lazyLoad;
 
   // Store/get the lazy load promise on/from the hookfn so it doesn't get re-invoked
   let promise = lazyLoadFn._promise;
@@ -33508,7 +33502,7 @@ function lazyLoadState(transition, state, stateRegistry) {
   if (!promise) {
     const success = (result) => {
       delete state.lazyLoad;
-      delete state.$$state().lazyLoad;
+      delete state._state().lazyLoad;
       delete lazyLoadFn._promise;
 
       return result;
@@ -34770,37 +34764,6 @@ class StateProvider {
   }
 }
 
-class ViewScrollProvider {
-  constructor() {
-    this.enabled = false;
-  }
-
-  useAnchorScroll() {
-    this.enabled = true;
-  }
-
-  $get = [
-    $injectTokens._anchorScroll,
-    /**
-     * @param {ng.AnchorScrollObject} $anchorScroll
-     * @returns {ng.ViewScrollService}
-     */
-    ($anchorScroll) => {
-      if (this.enabled) {
-        return $anchorScroll;
-      }
-
-      return (/** @type {Element} */ $element) => {
-        validateInstanceOf($element, Element, "$element");
-
-        setTimeout(() => {
-          $element.scrollIntoView(false);
-        }, 0);
-      };
-    },
-  ];
-}
-
 /**
  * @typedef BindingTuple
  * @property {string} name
@@ -35740,7 +35703,7 @@ function encodeDashes(str) {
  *
  * Instances of this class are created when a [[StateDeclaration]] is registered with the [[StateRegistry]].
  *
- * A registered [[StateDeclaration]] is augmented with a getter ([[StateDeclaration.$$state]]) which returns the corresponding [[StateObject]] object.
+ * A registered [[StateDeclaration]] is augmented with a getter ([[StateDeclaration._state]]) which returns the corresponding [[StateObject]] object.
  *
  * This class prototypally inherits from the corresponding [[StateDeclaration]].
  * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
@@ -35760,7 +35723,7 @@ class StateObject {
    */
   constructor(config) {
     Object.assign(this, config);
-    this.$$state = () => {
+    this._state = () => {
       return this;
     };
     /**
@@ -35852,7 +35815,7 @@ class StateObject {
   }
 }
 /** Predicate which returns true if the object is a [[StateDeclaration]] object */
-StateObject.isStateDeclaration = (obj) => isFunction(obj.$$state);
+StateObject.isStateDeclaration = (obj) => isFunction(obj._state);
 /** Predicate which returns true if the object is an internal [[StateObject]] object */
 StateObject.isState = (obj) => isObject(obj._stateObjectCache);
 
@@ -35993,7 +35956,7 @@ class UrlRuleFactory {
    */
   fromState(stateOrDecl, stateService, globals) {
     const state = StateObject.isStateDeclaration(stateOrDecl)
-      ? stateOrDecl.$$state()
+      ? stateOrDecl._state()
       : stateOrDecl;
 
     /**
@@ -36946,7 +36909,7 @@ function parseUrl(url) {
 }
 
 function selfBuilder(state) {
-  state.self.$$state = () => state;
+  state.self._state = () => state;
 
   return state.self;
 }
@@ -37559,7 +37522,7 @@ class StateRegistryProvider {
       function decoratedNg1Hook(trans, state) {
         const resolveContext = new ResolveContext(trans.treeChanges(pathname));
 
-        const subContext = resolveContext.subContext(state.$$state());
+        const subContext = resolveContext.subContext(state._state());
 
         const locals = Object.assign(getLocals(subContext), {
           $state$: state,
@@ -37659,7 +37622,7 @@ class StateRegistryProvider {
   }
 
   _deregisterTree(state) {
-    const all = this.getAll().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);
@@ -37708,7 +37671,7 @@ class StateRegistryProvider {
     const deregisteredStates = this._deregisterTree(
       /** @type {import("./interface.ts").BuiltStateDeclaration} */ (
         state
-      ).$$state(),
+      )._state(),
     );
 
     this.listeners.forEach((listener) =>
@@ -38254,7 +38217,7 @@ function $StateRefActiveDirective(
  *   The ng-view can be targeted in a View using the name ([[StateDeclaration.views]]).
  *
  * - `autoscroll`: an expression. When it evaluates to true, the `ng-view` will be scrolled into view when it is activated.
- *   Uses [[$viewScroll]] to do the scrolling.
+ *   Uses [[$anchorScroll]] to do the scrolling.
  *
  * - `onload`: Expression to evaluate whenever the view updates.
  *
@@ -38372,18 +38335,18 @@ function $StateRefActiveDirective(
 $ViewDirective.$inject = [
   $injectTokens._view,
   $injectTokens._animate,
-  $injectTokens._viewScroll,
+  $injectTokens._anchorScroll,
   $injectTokens._interpolate,
 ];
 
 /**
  * @param {ng.ViewService} $view
  * @param {ng.AnimateService} $animate
- * @param {ng.AnchorScrollService} $viewScroll
+ * @param {ng.AnchorScrollService} $anchorScroll
  * @param {ng.InterpolateService} $interpolate
  * @returns {ng.Directive}
  */
-function $ViewDirective($view, $animate, $viewScroll, $interpolate) {
+function $ViewDirective($view, $animate, $anchorScroll, $interpolate) {
   function getRenderer() {
     return {
       enter(element, target, cb) {
@@ -38537,7 +38500,7 @@ function $ViewDirective($view, $animate, $viewScroll, $interpolate) {
                 (isDefined(autoScrollExp) && !autoScrollExp) ||
                 (autoScrollExp && scope.$eval(autoScrollExp))
               ) {
-                /** @type {ng.AnchorScrollFunction} */ ($viewScroll)(clone);
+                /** @type {ng.AnchorScrollService} */ ($anchorScroll)(clone);
               }
             });
             cleanupLastView();
@@ -40466,7 +40429,6 @@ function registerNgModule(angular) {
             $view: ViewService,
             $transitions: TransitionProvider,
             $state: StateProvider,
-            $viewScroll: ViewScrollProvider,
             $templateFactory: TemplateFactoryProvider,
             $url: UrlService,
             $stateRegistry: StateRegistryProvider,
@@ -40518,7 +40480,7 @@ class Angular extends EventTarget {
      * @public
      * @type {string} `version` from `package.json`
      */
-    this.version = "0.17.0"; //inserted via rollup plugin
+    this.version = "0.18.0"; //inserted via rollup plugin
 
     /**
      * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
@@ -40756,7 +40718,7 @@ class Angular extends EventTarget {
         stateRegistry
           .getAll()
           .map((x) => {
-            return x.$$state().resolvables;
+            return x._state().resolvables;
           })
           .reduce(unnestR, [])
           .filter(