@angular-wave/angular.ts 0.9.7 → 0.9.9

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.9.7 - October 26, 2025 04:17:19 */
+/* Version: 0.9.9 - October 28, 2025 22:08:29 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -1810,6 +1810,7 @@ const $injectTokens = Object.freeze({
   $sceDelegate: "$sceDelegate",
   $state: "$state",
   $stateRegistry: "$stateRegistry",
+  $sse: "$sse",
   $$sanitizeUri: "$$sanitizeUri",
   $$sanitizeUriProvider: "$$sanitizeUriProvider",
   $templateCache: "$templateCache",
@@ -4014,22 +4015,26 @@ function SceProvider() {
  */
 const ngEventDirectives = {};
 
-"click copy cut dblclick focus blur keydown keyup load mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup paste submit touchstart touchend touchmove"
+"click copy cut dblclick focus blur keydown keyup load mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup paste submit touchstart touchend touchmove offline online"
   .split(" ")
   .forEach((eventName) => {
     const directiveName = directiveNormalize(`ng-${eventName}`);
     ngEventDirectives[directiveName] = [
-      "$parse",
-      "$exceptionHandler",
+      $injectTokens.$parse,
+      $injectTokens.$exceptionHandler,
+      $injectTokens.$window,
+
       /**
        * @param {import("../../core/parse/interface.ts").ParseService} $parse
        * @param {ng.ExceptionHandlerService} $exceptionHandler
+       * @param {ng.WindowService} $window
        * @returns
        */
-      ($parse, $exceptionHandler) => {
+      ($parse, $exceptionHandler, $window) => {
         return createEventDirective(
           $parse,
           $exceptionHandler,
+          $window,
           directiveName,
           eventName,
         );
@@ -4041,6 +4046,7 @@ const ngEventDirectives = {};
  *
  * @param {ng.ParseService} $parse
  * @param {ng.ExceptionHandlerService} $exceptionHandler
+ * @param {ng.WindowService} $window
  * @param {string} directiveName
  * @param {string} eventName
  * @returns {ng.Directive}
@@ -4048,6 +4054,7 @@ const ngEventDirectives = {};
 function createEventDirective(
   $parse,
   $exceptionHandler,
+  $window,
   directiveName,
   eventName,
 ) {
@@ -4055,14 +4062,58 @@ function createEventDirective(
     restrict: "A",
     compile(_element, attr) {
       const fn = $parse(attr[directiveName]);
-      return function ngEventHandler(scope, element) {
-        element.addEventListener(eventName, (event) => {
+      return (scope, element) => {
+        const handler = (event) => {
           try {
             fn(scope, { $event: event });
           } catch (error) {
             $exceptionHandler(error);
           }
-        });
+        };
+        element.addEventListener(eventName, handler);
+
+        scope.$on("$destroy", () =>
+          element.removeEventListener(eventName, handler),
+        );
+      };
+    },
+  };
+}
+
+/**
+ *
+ * @param {ng.ParseService} $parse
+ * @param {ng.ExceptionHandlerService} $exceptionHandler
+ * @param {ng.WindowService} $window
+ * @param {string} directiveName
+ * @param {string} eventName
+ * @returns {ng.Directive}
+ */
+function createWindowEventDirective(
+  $parse,
+  $exceptionHandler,
+  $window,
+  directiveName,
+  eventName,
+) {
+  return {
+    restrict: "A",
+    compile(_element, attr) {
+      const fn = $parse(attr[directiveName]);
+      return (scope) => {
+        const handler = (event) => {
+          try {
+            fn(scope, { $event: event });
+          } catch (error) {
+            $exceptionHandler(error);
+          }
+        };
+
+        $window.addEventListener(eventName, handler);
+
+        scope.$on("$destroy", () =>
+          $window.removeEventListener(eventName, handler),
+        );
       };
     },
   };
@@ -4431,91 +4482,6 @@ function ngObserveDirective(source, prop) {
   };
 }
 
-/**
- * A function passed as the fifth argument to a {@type PublicLinkFn} link function.
- * It behaves like a linking function, with the `scope` argument automatically created
- * as a new child of the transcluded parent scope.
- *
- * The function returns the DOM content to be injected (transcluded) into the directive.
- *
- * @callback TranscludeFn
- * @param {Element | Node | ChildNode | NodeList | Node[]} [clone] - The DOM node to be inserted into the transcluded directive.
- * @param {import("../scope/scope.js").Scope} [scope] - The new child scope created from the transcluded parent.
- * @returns void
-
-/**
- * A specialized version of {@link TranscludeFn} with the scope argument already bound.
- * This function requires no parameters and returns the same result as {@link TranscludeFn}.
- *
- * @typedef {() => Element|Node} BoundTranscludeFn
- */
-
-/**
- * @typedef {Object} SimpleChange
- * @property {any} currentValue
- * @property {boolean} firstChange
- */
-
-/**
- * @description A function returned by the '$compile' service that links a compiled template to a scope.
- *
- * @callback PublicLinkFn
- * @param {import('../scope/scope.js').Scope} scope - Scope to link with element
- * @param {TranscludeFn} [cloneConnectFn]
- * @param {*} [options]
- * @return {Element|Node|ChildNode|Node[]} The nodes to be linked.
- */
-
-/**
- * @description Entry point for the '$compile' service.
- *
- * @callback CompileFn
- * @param {string|Element|Node|ChildNode|NodeList} compileNode - The node to be compiled.
- * @param {TranscludeFn} [transcludeFn] - An optional transclusion function to be used during compilation.
- * @param {number} [maxPriority] - An optional maximum priority for directives.
- * @param {string} [ignoreDirective] - An optional directive to ignore during compilation.
- * @param {*} [previousCompileContext] - An optional context from a previous compilation. TODO
- * @returns {PublicLinkFn} A public link function.
- */
-
-/**
- * @typedef {Object} LinkFnMapping
- * @property {number} index
- * @property {NodeLinkFnCtx} [nodeLinkFnCtx]
- * @property {CompositeLinkFn} [childLinkFn]
- */
-
-/**
- * @typedef {function(): CompositeLinkFn} CompileNodesFn
- */
-
-/**
- * @callback NodeLinkFn
- * @returns {Node|Element|NodeList}
- */
-
-/**
- * @typedef {Object} NodeLinkFnCtx
- * @property {NodeLinkFn} nodeLinkFn
- * @property {boolean} terminal
- * @property {TranscludeFn} transclude
- * @property {boolean} transcludeOnThisElement
- * @property {boolean} templateOnThisElement
- * @property {boolean} newScope
- */
-
-/**
- * @typedef {function(): NodeLinkFn} ApplyDirectivesToNodeFn
- */
-
-/**
- * @description Function that aggregates all linking fns for a compilation root (nodeList)
- * @callback CompositeLinkFn
- * @param {import('../scope/scope.js').Scope} scope - The scope to be linked to the template
- * @param {NodeRef} $linkNode - wrapper around a nodeList
- * @param {Function} [parentBoundTranscludeFn]
- */
-
 const $compileMinErr = minErr("$compile");
 const EXCLUDED_DIRECTIVES = ["ngIf", "ngRepeat"];
 const ALL_OR_NOTHING_ATTRS = ["ngSrc", "ngSrcset", "src", "srcset"];
@@ -4539,7 +4505,6 @@ class CompileProvider {
     const bindingCache = Object.create(null);
 
     /**
-     *
      * @param {import("../scope/scope.js").Scope} scope
      * @param {string} directiveName
      * @param {boolean} isController
@@ -5052,12 +5017,11 @@ class CompileProvider {
             ? (x) => x
             : (x) => x.replace(/\{\{/g, startSymbol).replace(/}}/g, endSymbol);
 
-        const NG_PREFIX_BINDING = /^ng(Attr|Prop|On|Observe)([A-Z].*)$/;
+        const NG_PREFIX_BINDING = /^ng(Attr|Prop|On|Observe|Window)([A-Z].*)$/;
         return compile;
 
-        //= ===============================
         /**
-         * @type {CompileFn}
+         * @type {ng.CompileService}
          */
         function compile(
           element,
@@ -5071,7 +5035,7 @@ class CompileProvider {
           /**
            * The composite link function is a composite of individual node linking functions.
            * It will be invoke by the public link function below.
-           * @type {CompositeLinkFn}
+           * @type {ng.CompositeLinkFn}
            */
           let compositeLinkFn = compileNodes(
             nodeRef,
@@ -5084,7 +5048,7 @@ class CompileProvider {
           let namespace = null;
           return publicLinkFn;
 
-          /** @type {PublicLinkFn} */
+          /** @type {ng.PublicLinkFn} */
           function publicLinkFn(scope, cloneConnectFn, options) {
             if (!nodeRef) {
               throw $compileMinErr(
@@ -5206,7 +5170,7 @@ class CompileProvider {
          * @param {number=} [maxPriority] Max directive priority.
          * @param {*} [ignoreDirective]
          * @param {*} [previousCompileContext]
-         * @returns {CompositeLinkFn} A composite linking function of all of the matched directives or null.
+         * @returns {ng.CompositeLinkFn} A composite linking function of all of the matched directives or null.
          */
         function compileNodes(
           nodeRefList,
@@ -5219,7 +5183,7 @@ class CompileProvider {
            * Aggregates for the composite linking function, where a node in a node list is mapped
            * to a corresponding link function. For single elements, the node should be mapped to
            * a single node link function.
-           * @type {LinkFnMapping[]}
+           * @type {ng.LinkFnMapping[]}
            */
           const linkFnsList = []; // An array to hold node indices and their linkFns
           let nodeLinkFnFound;
@@ -5239,7 +5203,7 @@ class CompileProvider {
               ignoreDirective,
             );
 
-            /** @type {NodeLinkFnCtx} */
+            /** @type {ng.NodeLinkFnCtx} */
             let nodeLinkFnCtx;
 
             if (directives.length) {
@@ -5386,10 +5350,10 @@ class CompileProvider {
 
         /**
          * Prebinds the transclusion function to a scope
-         * @param {import("../scope/scope.js").Scope} scope
+         * @param {ng.Scope} scope
          * @param {*} transcludeFn
          * @param {*} previousBoundTranscludeFn
-         * @returns {BoundTranscludeFn}
+         * @returns {ng.BoundTranscludeFn}
          */
         function createBoundTranscludeFn(
           scope,
@@ -5447,7 +5411,7 @@ class CompileProvider {
          */
         function collectDirectives(node, attrs, maxPriority, ignoreDirective) {
           /**
-           * @type {import('../../interface.ts').Directive[]}
+           * @type {ng.Directive[]}
            */
           const directives = [];
           const { nodeType } = node;
@@ -5473,6 +5437,7 @@ class CompileProvider {
                 let isNgProp = false;
                 let isNgEvent = false;
                 let isNgObserve = false;
+                let isWindow = false;
 
                 let attr = node.attributes[j];
                 let name = attr.name;
@@ -5486,6 +5451,7 @@ class CompileProvider {
                   isNgProp = ngPrefixMatch[1] === "Prop";
                   isNgEvent = ngPrefixMatch[1] === "On";
                   isNgObserve = ngPrefixMatch[1] === "Observe";
+                  isWindow = ngPrefixMatch[1] === "Window";
 
                   // Normalize the non-prefixed name
                   name = name
@@ -5495,17 +5461,28 @@ class CompileProvider {
                     .replace(/_(.)/g, (match, letter) => letter.toUpperCase());
                 }
 
-                if (isNgProp || isNgEvent) {
+                if (isNgProp || isNgEvent || isWindow) {
                   attrs[nName] = value;
                   attrsMap[nName] = attr.name;
 
                   if (isNgProp) {
                     addPropertyDirective(node, directives, nName, name);
-                  } else {
+                  } else if (isNgEvent) {
                     directives.push(
                       createEventDirective(
                         $parse,
                         $exceptionHandler,
+                        window,
+                        nName,
+                        name,
+                      ),
+                    );
+                  } else {
+                    directives.push(
+                      createWindowEventDirective(
+                        $parse,
+                        $exceptionHandler,
+                        window,
                         nName,
                         name,
                       ),
@@ -5568,7 +5545,7 @@ class CompileProvider {
          * @param maxPriority
          * @param ignoreDirective
          * @param previousCompileContext
-         * @returns {PublicLinkFn|TranscludeFn}
+         * @returns {ng.PublicLinkFn|ng.TranscludeFn}
          */
         function compilationGenerator(
           eager,
@@ -5615,14 +5592,14 @@ class CompileProvider {
          *        this needs to be pre-sorted by priority order.
          * @param {Node | Element} compileNode  DOM node to apply the compile functions to
          * @param {Attributes} templateAttrs The shared attribute function
-         * @param {TranscludeFn} transcludeFn
+         * @param {ng.TranscludeFn} transcludeFn
          * @param {Object=} originalReplaceDirective An optional directive that will be ignored when
          *                                           compiling the transclusion.
          * @param {Array.<Function>} [preLinkFns]
          * @param {Array.<Function>} [postLinkFns]
          * @param {Object} [previousCompileContext] Context used for previous compilation of the current
          *                                        node
-         * @returns {NodeLinkFnCtx} node link function
+         * @returns {ng.NodeLinkFnCtx} node link function
          */
         function applyDirectivesToNode(
           directives,
@@ -5657,7 +5634,7 @@ class CompileProvider {
           let directiveName;
           let $template;
           let replaceDirective = originalReplaceDirective;
-          /** @type {TranscludeFn} */
+          /** @type {ng.TranscludeFn} */
           let childTranscludeFn = transcludeFn;
 
           let didScanForMultipleTransclusion = false;
@@ -5666,7 +5643,7 @@ class CompileProvider {
 
           /**
            * Links all the directives of a single node.
-           * @type {NodeLinkFn}
+           * @type {ng.NodeLinkFn}
            */
           // @ts-ignore
           let nodeLinkFn = function (
@@ -6348,7 +6325,7 @@ class CompileProvider {
               ii = directives.length;
             } else if (directive.compile) {
               try {
-                /** @type {PublicLinkFn} */
+                /** @type {ng.PublicLinkFn} */
                 const linkFn = directive.compile(
                   compileNodeRef.getAny(),
                   templateAttrs,
@@ -7364,7 +7341,7 @@ class CompileProvider {
                   }
 
                   /**
-                   * @type {SimpleChange}
+                   * @type {import("./inteface.ts").SimpleChange}
                    */
                   initialChanges[scopeName] = {
                     currentValue: destination[scopeName],
@@ -7517,7 +7494,7 @@ class CompileProvider {
                   parentGet = $parse(attrs[attrName]);
 
                   destination.$target[scopeName] = parentGet(scope.$target);
-                  /** @type {SimpleChange} */
+                  /** @type {import("./inteface.ts").SimpleChange} */
                   initialChanges[scopeName] = {
                     currentValue: destination.$target[scopeName],
                     firstChange: firstChange,
@@ -11485,7 +11462,7 @@ const ngClassOddDirective = classDirective("Odd", 0);
 const ngClassEvenDirective = classDirective("Even", 1);
 
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
 function ngCloakDirective() {
   return {
@@ -11776,7 +11753,7 @@ function ngIncludeDirective(
 ngIncludeFillContentDirective.$inject = [$injectTokens.$compile];
 
 /**
- * @param {import("../../core/compile/compile.js").CompileFn} $compile
+ * @param {ng.CompileService} $compile
  * @returns {import("../../interface.ts").Directive}
  */
 function ngIncludeFillContentDirective($compile) {
@@ -12407,7 +12384,7 @@ const NG_OPTIONS_REGEXP =
 ngOptionsDirective.$inject = ["$compile", "$parse"];
 /**
  *
- * @param {import("../../core/compile/compile.js").CompileFn} $compile
+ * @param {ng.CompileService} $compile
  * @param {import("../../core/parse/interface.ts").ParseService} $parse
  * @returns {import("../../interface.ts").Directive}
  */
@@ -12934,8 +12911,8 @@ const ngTranscludeMinErr = minErr("ngTransclude");
 
 ngTranscludeDirective.$inject = ["$compile"];
 /**
- * @param {import("../../core/compile/compile.js").CompileFn} $compile
- * @returns {import("../../interface.ts").Directive}
+ * @param {ng.CompileService} $compile
+ * @returns {ng.Directive}
  */
 function ngTranscludeDirective($compile) {
   return {
@@ -12946,9 +12923,9 @@ function ngTranscludeDirective($compile) {
 
       /**
        *
-       * @param {import("../../core/scope/scope.js").Scope} $scope
+       * @param {ng.Scope} $scope
        * @param {Element} $element
-       * @param {import("../../core/compile/attributes.js").Attributes} $attrs
+       * @param {ng.Attributes} $attrs
        * @param {*} _controller
        * @param {*} $transclude
        */
@@ -18301,7 +18278,7 @@ function HttpProvider() {
     $injectTokens.$sce,
     /**
      *
-     * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
+     * @param {ng.InjectorService} $injector
      * @param {*} $sce
      * @returns
      */
@@ -35017,8 +34994,8 @@ function registerControllerCallbacks(
 
 ngChannelDirective.$inject = [$injectTokens.$eventBus];
 /**
- * @param {import("../../services/pubsub/pubsub.js").PubSub} $eventBus
- * @returns {import("../../interface.ts").Directive}
+ * @param {ng.PubSubService} $eventBus
+ * @returns {ng.Directive}
  */
 function ngChannelDirective($eventBus) {
   return {
@@ -35105,10 +35082,18 @@ function ngSetterDirective($parse, $log) {
  * @param {"get" | "delete" | "post" | "put"} method
  * @returns {ng.DirectiveFactory}
  */
-function defineDirective(method) {
-  const attrName = "ng" + method.charAt(0).toUpperCase() + method.slice(1);
+function defineDirective(method, attrOverride) {
+  const attrName =
+    attrOverride || "ng" + method.charAt(0).toUpperCase() + method.slice(1);
   const directive = createHttpDirective(method, attrName);
-  directive["$inject"] = [$injectTokens.$http, $injectTokens.$compile, $injectTokens.$log, $injectTokens.$parse, $injectTokens.$state];
+  directive["$inject"] = [
+    $injectTokens.$http,
+    $injectTokens.$compile,
+    $injectTokens.$log,
+    $injectTokens.$parse,
+    $injectTokens.$state,
+    $injectTokens.$sse,
+  ];
   return directive;
 }
 
@@ -35124,6 +35109,9 @@ const ngPostDirective = defineDirective("post");
 /** @type {ng.DirectiveFactory} */
 const ngPutDirective = defineDirective("put");
 
+/** @type {ng.DirectiveFactory} */
+const ngSseDirective = defineDirective("get", "ngSse");
+
 /**
  * @typedef {"click" | "change" | "submit"} EventType
  */
@@ -35241,9 +35229,10 @@ function createHttpDirective(method, attrName) {
    * @param {ng.LogService} $log
    * @param {ng.ParseService} $parse
    * @param {ng.StateService} $state
+   * @param {ng.SseService} $sse
    * @returns {ng.Directive}
    */
-  return function ($http, $compile, $log, $parse, $state) {
+  return function ($http, $compile, $log, $parse, $state, $sse) {
     /**
      * Collects form data from the element or its associated form.
      *
@@ -35332,7 +35321,6 @@ function createHttpDirective(method, attrName) {
         element.addEventListener(eventName, async (event) => {
           if (/** @type {HTMLButtonElement} */ (element).disabled) return;
           if (tag === "form") event.preventDefault();
-
           const swap = attrs["swap"] || "innerHTML";
           const targetSelector = attrs["target"];
           const target = targetSelector
@@ -35386,7 +35374,6 @@ function createHttpDirective(method, attrName) {
               $compile,
             );
           };
-
           if (isDefined(attrs["delay"])) {
             await wait(parseInt(attrs["delay"]) | 0);
           }
@@ -35425,11 +35412,57 @@ function createHttpDirective(method, attrName) {
             }
             $http[method](url, data, config).then(handler).catch(handler);
           } else {
-            $http[method](url).then(handler).catch(handler);
+            // If SSE mode is enabled
+            if (method === "get" && attrs["ngSse"]) {
+              const sseUrl = url;
+              const config = {
+                withCredentials: attrs["withCredentials"] === "true",
+                transformMessage: (data) => {
+                  try {
+                    return JSON.parse(data);
+                  } catch {
+                    return data;
+                  }
+                },
+                onOpen: () => {
+                  $log.info(`${attrName}: SSE connection opened to ${sseUrl}`);
+                  if (isDefined(attrs["loading"])) attrs.$set("loading", false);
+                  if (isDefined(attrs["loadingClass"]))
+                    attrs.$removeClass(attrs["loadingClass"]);
+                },
+                onMessage: (data) => {
+                  const res = { status: 200, data };
+                  handler(res);
+                },
+                onError: (err) => {
+                  $log.error(`${attrName}: SSE error`, err);
+                  const res = { status: 500, data: err };
+                  handler(res);
+                },
+              };
+
+              // Open the SSE connection using the injected service
+              const source = $sse(sseUrl, config);
+
+              // Cleanup on scope destroy
+              scope.$on("$destroy", () => {
+                $log.info(`${attrName}: closing SSE connection`);
+                source.close();
+              });
+            } else {
+              $http[method](url).then(handler).catch(handler);
+            }
           }
         });
 
-        scope.$on("$destroy", () => clearInterval(intervalId));
+        if (intervalId) {
+          scope.$on("$destroy", () => clearInterval(intervalId));
+        }
+
+        // Eagerly execute for 'load' event
+        if (eventName == "load") {
+          element.dispatchEvent(new Event("load"));
+        }
       },
     };
   };
@@ -35500,6 +35533,142 @@ function ngElDirective() {
   };
 }
 
+/**
+ * SSE Provider
+ *
+ * Usage:
+ *   const source = $sse('/events', {
+ *     onMessage: (data) => console.log(data),
+ *     onError: (err) => console.error(err),
+ *     withCredentials: true
+ *   });
+ *
+ *   // later:
+ *   source.close();
+ */
+
+class SseProvider {
+  constructor() {
+    /**
+     * Optional provider-level defaults
+     * @type {ng.SseConfig}
+     */
+    this.defaults = {};
+  }
+
+  /**
+   * Returns the $sse service function
+   * @returns {ng.SseService}
+   */
+  $get =
+    () =>
+    (url, config = {}) => {
+      const finalUrl = this.#buildUrl(url, config.params);
+      return this.#createEventSource(finalUrl, config);
+    };
+
+  /**
+   * Build URL with query parameters
+   * @param {string} url - Base URL
+   * @param {Record<string, any>=} params - Query parameters
+   * @returns {string} URL with serialized query string
+   */
+  #buildUrl(url, params) {
+    if (!params) return url;
+    const query = Object.entries(params)
+      .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+      .join("&");
+    return url + (url.includes("?") ? "&" : "?") + query;
+  }
+
+  /**
+   * Create and manage an EventSource
+   * @param {string} url - URL for SSE connection
+   * @param {ng.SseConfig} config - Configuration object
+   * @returns {EventSource} The EventSource instance wrapped as SseService
+   */
+  #createEventSource(url, config) {
+    const es = new EventSource(url, {
+      withCredentials: !!config.withCredentials,
+    });
+
+    if (config.onOpen) {
+      es.addEventListener("open", (e) => config.onOpen(e));
+    }
+
+    es.addEventListener("message", (e) => {
+      let data = e.data;
+      try {
+        data = config.transformMessage
+          ? config.transformMessage(data)
+          : JSON.parse(data);
+      } catch {
+        // leave as raw string if not JSON
+      }
+      config.onMessage?.(data, e);
+    });
+
+    if (config.onError) {
+      es.addEventListener("error", (e) => config.onError(e));
+    }
+
+    return es;
+  }
+}
+
+/**
+ * @returns {ng.Directive}
+ */
+function ngViewportDirective() {
+  return {
+    restrict: "A",
+    link(scope, element, attrs) {
+      const enterExpr = attrs["onEnter"];
+      const leaveExpr = attrs["onLeave"];
+
+      const observer = new IntersectionObserver(
+        (entries) => {
+          entries.forEach((entry) => {
+            if (entry.isIntersecting) {
+              if (enterExpr) scope.$eval(enterExpr);
+            } else {
+              if (leaveExpr) scope.$eval(leaveExpr);
+            }
+          });
+        },
+        {
+          root: null, // viewport
+          threshold: 0.1, // consider "in view" if 10% visible
+        },
+      );
+
+      observer.observe(element);
+
+      // Clean up when the element is removed from DOM
+      const parent = element.parentNode;
+      let mutationObserver;
+      if (parent) {
+        mutationObserver = new MutationObserver((mutations) => {
+          for (const mutation of mutations) {
+            Array.from(mutation.removedNodes).forEach((removedNode) => {
+              if (removedNode === element) {
+                observer.disconnect();
+                mutationObserver.disconnect();
+              }
+            });
+          }
+        });
+        mutationObserver.observe(parent, { childList: true });
+      }
+
+      scope.$on("$destroy", () => {
+        observer.disconnect();
+        if (mutationObserver) mutationObserver.disconnect();
+      });
+    },
+  };
+}
+
 /**
  * Initializes core `ng` module.
  * @param {import('./angular.js').Angular} angular
@@ -35560,6 +35729,7 @@ function registerNgModule(angular) {
               ngSetter: ngSetterDirective,
               ngShow: ngShowDirective,
               ngStyle: ngStyleDirective,
+              ngSse: ngSseDirective,
               ngSwitch: ngSwitchDirective,
               ngSwitchWhen: ngSwitchWhenDirective,
               ngSwitchDefault: ngSwitchDefaultDirective,
@@ -35576,6 +35746,7 @@ function registerNgModule(angular) {
               maxlength: maxlengthDirective,
               ngValue: ngValueDirective,
               ngModelOptions: ngModelOptionsDirective,
+              ngViewport: ngViewportDirective,
             })
             .directive({
               input: hiddenInputBrowserCacheDirective,
@@ -35631,6 +35802,7 @@ function registerNgModule(angular) {
             $router: Router,
             $sce: SceProvider,
             $sceDelegate: SceDelegateProvider,
+            $sse: SseProvider,
             $templateCache: TemplateCacheProvider,
             $templateRequest: TemplateRequestProvider,
             $urlConfig: UrlConfigProvider,
@@ -35673,7 +35845,7 @@ class Angular {
     /**
      * @type {string} `version` from `package.json`
      */
-    this.version = "0.9.7"; //inserted via rollup plugin
+    this.version = "0.9.9"; //inserted via rollup plugin
 
     /** @type {!Array<string|any>} */
     this.bootsrappedModules = [];
@@ -35766,10 +35938,10 @@ class Angular {
       $injectTokens.$compile,
       $injectTokens.$injector,
       /**
-       * @param {import('./core/scope/scope.js').Scope} scope
+       * @param {ng.Scope} scope
        * @param {Element} el
-       * @param {import("./core/compile/compile.js").CompileFn} compile
-       * @param {import("./core/di/internal-injector.js").InjectorService} $injector
+       * @param {ng.CompileService} compile
+       * @param {ng.InjectorService} $injector
        */
       (scope, el, compile, $injector) => {
         // ng-route deps