@angular-wave/angular.ts 0.9.7 → 0.9.9

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.9.7 - October 26, 2025 04:17:18 */
+/* Version: 0.9.9 - October 28, 2025 22:08:28 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -1816,6 +1816,7 @@
     $sceDelegate: "$sceDelegate",
     $state: "$state",
     $stateRegistry: "$stateRegistry",
+    $sse: "$sse",
     $$sanitizeUri: "$$sanitizeUri",
     $$sanitizeUriProvider: "$$sanitizeUriProvider",
     $templateCache: "$templateCache",
@@ -4020,22 +4021,26 @@
    */
   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,
           );
@@ -4047,6 +4052,7 @@
    *
    * @param {ng.ParseService} $parse
    * @param {ng.ExceptionHandlerService} $exceptionHandler
+   * @param {ng.WindowService} $window
    * @param {string} directiveName
    * @param {string} eventName
    * @returns {ng.Directive}
@@ -4054,6 +4060,7 @@
   function createEventDirective(
     $parse,
     $exceptionHandler,
+    $window,
     directiveName,
     eventName,
   ) {
@@ -4061,14 +4068,58 @@
       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),
+          );
         };
       },
     };
@@ -4437,91 +4488,6 @@
     };
   }
 
-  /**
-   * 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"];
@@ -4545,7 +4511,6 @@
       const bindingCache = Object.create(null);
 
       /**
-       *
        * @param {import("../scope/scope.js").Scope} scope
        * @param {string} directiveName
        * @param {boolean} isController
@@ -5058,12 +5023,11 @@
               ? (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,
@@ -5077,7 +5041,7 @@
             /**
              * 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,
@@ -5090,7 +5054,7 @@
             let namespace = null;
             return publicLinkFn;
 
-            /** @type {PublicLinkFn} */
+            /** @type {ng.PublicLinkFn} */
             function publicLinkFn(scope, cloneConnectFn, options) {
               if (!nodeRef) {
                 throw $compileMinErr(
@@ -5212,7 +5176,7 @@
            * @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,
@@ -5225,7 +5189,7 @@
              * 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;
@@ -5245,7 +5209,7 @@
                 ignoreDirective,
               );
 
-              /** @type {NodeLinkFnCtx} */
+              /** @type {ng.NodeLinkFnCtx} */
               let nodeLinkFnCtx;
 
               if (directives.length) {
@@ -5392,10 +5356,10 @@
 
           /**
            * 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,
@@ -5453,7 +5417,7 @@
            */
           function collectDirectives(node, attrs, maxPriority, ignoreDirective) {
             /**
-             * @type {import('../../interface.ts').Directive[]}
+             * @type {ng.Directive[]}
              */
             const directives = [];
             const { nodeType } = node;
@@ -5479,6 +5443,7 @@
                   let isNgProp = false;
                   let isNgEvent = false;
                   let isNgObserve = false;
+                  let isWindow = false;
 
                   let attr = node.attributes[j];
                   let name = attr.name;
@@ -5492,6 +5457,7 @@
                     isNgProp = ngPrefixMatch[1] === "Prop";
                     isNgEvent = ngPrefixMatch[1] === "On";
                     isNgObserve = ngPrefixMatch[1] === "Observe";
+                    isWindow = ngPrefixMatch[1] === "Window";
 
                     // Normalize the non-prefixed name
                     name = name
@@ -5501,17 +5467,28 @@
                       .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,
                         ),
@@ -5574,7 +5551,7 @@
            * @param maxPriority
            * @param ignoreDirective
            * @param previousCompileContext
-           * @returns {PublicLinkFn|TranscludeFn}
+           * @returns {ng.PublicLinkFn|ng.TranscludeFn}
            */
           function compilationGenerator(
             eager,
@@ -5621,14 +5598,14 @@
            *        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,
@@ -5663,7 +5640,7 @@
             let directiveName;
             let $template;
             let replaceDirective = originalReplaceDirective;
-            /** @type {TranscludeFn} */
+            /** @type {ng.TranscludeFn} */
             let childTranscludeFn = transcludeFn;
 
             let didScanForMultipleTransclusion = false;
@@ -5672,7 +5649,7 @@
 
             /**
              * Links all the directives of a single node.
-             * @type {NodeLinkFn}
+             * @type {ng.NodeLinkFn}
              */
             // @ts-ignore
             let nodeLinkFn = function (
@@ -6354,7 +6331,7 @@
                 ii = directives.length;
               } else if (directive.compile) {
                 try {
-                  /** @type {PublicLinkFn} */
+                  /** @type {ng.PublicLinkFn} */
                   const linkFn = directive.compile(
                     compileNodeRef.getAny(),
                     templateAttrs,
@@ -7370,7 +7347,7 @@
                     }
 
                     /**
-                     * @type {SimpleChange}
+                     * @type {import("./inteface.ts").SimpleChange}
                      */
                     initialChanges[scopeName] = {
                       currentValue: destination[scopeName],
@@ -7523,7 +7500,7 @@
                     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,
@@ -11491,7 +11468,7 @@
   const ngClassEvenDirective = classDirective("Even", 1);
 
   /**
-   * @returns {import('../../interface.ts').Directive}
+   * @returns {ng.Directive}
    */
   function ngCloakDirective() {
     return {
@@ -11782,7 +11759,7 @@
   ngIncludeFillContentDirective.$inject = [$injectTokens.$compile];
 
   /**
-   * @param {import("../../core/compile/compile.js").CompileFn} $compile
+   * @param {ng.CompileService} $compile
    * @returns {import("../../interface.ts").Directive}
    */
   function ngIncludeFillContentDirective($compile) {
@@ -12413,7 +12390,7 @@
   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}
    */
@@ -12940,8 +12917,8 @@
 
   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 {
@@ -12952,9 +12929,9 @@
 
         /**
          *
-         * @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
          */
@@ -18307,7 +18284,7 @@
       $injectTokens.$sce,
       /**
        *
-       * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
+       * @param {ng.InjectorService} $injector
        * @param {*} $sce
        * @returns
        */
@@ -35023,8 +35000,8 @@
 
   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 {
@@ -35111,10 +35088,18 @@
    * @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;
   }
 
@@ -35130,6 +35115,9 @@
   /** @type {ng.DirectiveFactory} */
   const ngPutDirective = defineDirective("put");
 
+  /** @type {ng.DirectiveFactory} */
+  const ngSseDirective = defineDirective("get", "ngSse");
+
   /**
    * @typedef {"click" | "change" | "submit"} EventType
    */
@@ -35247,9 +35235,10 @@
      * @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.
        *
@@ -35338,7 +35327,6 @@
           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
@@ -35392,7 +35380,6 @@
                 $compile,
               );
             };
-
             if (isDefined(attrs["delay"])) {
               await wait(parseInt(attrs["delay"]) | 0);
             }
@@ -35431,11 +35418,57 @@
               }
               $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"));
+          }
         },
       };
     };
@@ -35506,6 +35539,142 @@
     };
   }
 
+  /**
+   * 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
@@ -35566,6 +35735,7 @@
                 ngSetter: ngSetterDirective,
                 ngShow: ngShowDirective,
                 ngStyle: ngStyleDirective,
+                ngSse: ngSseDirective,
                 ngSwitch: ngSwitchDirective,
                 ngSwitchWhen: ngSwitchWhenDirective,
                 ngSwitchDefault: ngSwitchDefaultDirective,
@@ -35582,6 +35752,7 @@
                 maxlength: maxlengthDirective,
                 ngValue: ngValueDirective,
                 ngModelOptions: ngModelOptionsDirective,
+                ngViewport: ngViewportDirective,
               })
               .directive({
                 input: hiddenInputBrowserCacheDirective,
@@ -35637,6 +35808,7 @@
               $router: Router,
               $sce: SceProvider,
               $sceDelegate: SceDelegateProvider,
+              $sse: SseProvider,
               $templateCache: TemplateCacheProvider,
               $templateRequest: TemplateRequestProvider,
               $urlConfig: UrlConfigProvider,
@@ -35679,7 +35851,7 @@
       /**
        * @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 = [];
@@ -35772,10 +35944,10 @@
         $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