@angular-wave/angular.ts 0.7.2 → 0.7.4

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.7.2 - June 28, 2025 21:48:50 */
+/* Version: 0.7.4 - July 11, 2025 03:03:25 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -1136,39 +1136,29 @@
     return Object.prototype.hasOwnProperty.call(obj, key);
   }
 
-  /**
-   * @typedef {Object} ExpandoStore
-   *
-   * @property {!Object<string, any>} data
-   * @property {!Object} events
-   * @property {?Function} handle
-   *
-   */
-
-  const EXPANDO = "ng";
-
   /**
    * Expando cache for adding properties to DOM nodes with JavaScript.
    * This used to be an Object in JQLite decorator, but swapped out for a Map
    * for performance reasons and convenience methods. A proxy is available for
    * additional logic handling.
    *
-   * @type {Map<number, ExpandoStore>}
+   * @type {Map<number, import('../interface.ts').ExpandoStore>}
    */
   const Cache = new Map();
 
-  /**
-   * Key for storing scope data, attached to an element
-   */
-  const SCOPE_KEY = "$scope";
+  /** @type {number} */
+  let jqId = 1;
 
   /**
    * Key for storing isolate scope data, attached to an element
    */
   const ISOLATE_SCOPE_KEY = "$isolateScope";
+  const EXPANDO = "ng";
 
-  /** @type {number} */
-  let jqId = 1;
+  /**
+   * Key for storing scope data, attached to an element
+   */
+  const SCOPE_KEY = "$scope";
 
   const DASH_LOWERCASE_REGEXP = /-([a-z])/g;
   const UNDERSCORE_LOWERCASE_REGEXP = /_([a-z])/g;
@@ -1269,7 +1259,7 @@
    *
    * @param {Element} element
    * @param {boolean} [createIfNecessary=false]
-   * @returns {import("../core/cache/cache.js").ExpandoStore}
+   * @returns {import("../interface.ts").ExpandoStore}
    */
   function getExpando(element, createIfNecessary = false) {
     let expandoId = element[EXPANDO];
@@ -1278,9 +1268,7 @@
     if (createIfNecessary && !expandoStore) {
       element[EXPANDO] = expandoId = jqNextId();
       expandoStore = {
-        events: {},
         data: {},
-        handle: null,
       };
       Cache.set(expandoId, expandoStore);
     }
@@ -1339,19 +1327,15 @@
   }
 
   /**
-   * If `ExpandoStore.data` and `ExpandoStore.events` are empty,
-   * then delete element's `ExpandoStore` and set its `ExpandoId`
+   * If expando store data is empty, then delete it and set its expando id.
    * to undefined.
    * @param {Element} element
    */
   function removeIfEmptyData(element) {
     const expandoId = element[EXPANDO];
-    const { events, data } = Cache.get(expandoId);
+    const { data } = Cache.get(expandoId);
 
-    if (
-      (!data || !Object.keys(data).length) &&
-      (!events || !Object.keys(events).length)
-    ) {
+    if (!data || !Object.keys(data).length) {
       Cache.delete(expandoId);
       element[EXPANDO] = undefined; // don't delete DOM expandos. Chrome don't like it
     }
@@ -1628,10 +1612,6 @@
    */
   function cleanElementData(nodes) {
     for (let i = 0, ii = nodes.length; i < ii; i++) {
-      const events = (Cache.get(nodes[i][EXPANDO]) || {}).events;
-      if (events && events.$destroy) {
-        nodes[i].dispatchEvent(new Event("$destroy"));
-      }
       removeElementData(nodes[i]);
     }
   }
@@ -1724,6 +1704,9 @@
    *   angular.$injectTokens.$animate,
    *   angular.$injectTokens.$templateRequest,
    * ];
+   *
+   * function myDirective($animate, $templateRequest) { ... }
+   *
    * ```
    * @type Readonly<Record<string, string>>
    */
@@ -1834,27 +1817,11 @@
       /** @type {!Array.<Function>} */
       this.runBlocks = [];
 
-      /** @type {Object} */
-      this.infoState = {};
-
       if (configFn) {
         this.config(configFn);
       }
     }
 
-    /**
-     * @param {Object} value
-     * @returns
-     */
-    info(value) {
-      if (isDefined(value)) {
-        assert(isObject(value), "module info value must be an object");
-        this.infoState = value;
-        return this;
-      }
-      return this.infoState;
-    }
-
     /**
      * @param {string} name
      * @param {any} object
@@ -2183,7 +2150,6 @@
 
   /**
    * Injector for providers
-   * @extends {AbstractInjector}
    */
   class ProviderInjector extends AbstractInjector {
     /**
@@ -2213,15 +2179,13 @@
 
   /**
    * Injector for factories and services
-   * @extends {AbstractInjector}
    */
   class InjectorService extends AbstractInjector {
     /**
-     *
-     * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
      * @param {ProviderInjector} providerInjector
+     * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
      */
-    constructor(strictDi, providerInjector) {
+    constructor(providerInjector, strictDi) {
       super(strictDi);
       this.providerInjector = providerInjector;
       this.modules = this.providerInjector.modules;
@@ -2359,7 +2323,7 @@
       strictDi,
     ));
 
-    const protoInstanceInjector = new InjectorService(strictDi, providerInjector);
+    const protoInstanceInjector = new InjectorService(providerInjector, strictDi);
 
     providerCache.$injectorProvider = {
       // $injectionProvider return instance injector
@@ -7583,7 +7547,9 @@
             }
 
             function triggerOnChangesHook() {
-              destination["$onChanges"] && destination["$onChanges"](changes);
+              destination["$onChanges"] &&
+                changes &&
+                destination["$onChanges"](changes);
               // Now clear the changes so that we schedule onChanges when more changes arrive
               changes = undefined;
             }
@@ -10651,7 +10617,7 @@
   scriptDirective.$inject = ["$templateCache"];
 
   /**
-   * @param {import('../../core/cache/cache-factory').TemplateCache} $templateCache
+   * @param {import('../../services/template-cache/interface.ts').TemplateCache} $templateCache
    * @returns {import('../../interface.ts').Directive}
    */
   function scriptDirective($templateCache) {
@@ -11312,6 +11278,8 @@
   }
 
   /**
+   * @param {string} name
+   * @param {boolean|number} selector
    * @returns {() => import("../../interface.ts").Directive}
    */
   function classDirective(name, selector) {
@@ -11327,6 +11295,7 @@
         link(scope, element, attr) {
           let classCounts = getCacheData(element, "$classCounts");
           let oldModulo = true;
+          /** @type {string|undefined} */
           let oldClassString;
 
           if (!classCounts) {
@@ -11345,6 +11314,9 @@
             ngClassWatchAction(toClassString(val));
           });
 
+          /**
+           * @param {string} classString
+           */
           function addClasses(classString) {
             classString = digestClassCounts(split(classString), 1);
             if (hasAnimate(element)) {
@@ -11358,6 +11330,9 @@
             }
           }
 
+          /**
+           * @param {string} classString
+           */
           function removeClasses(classString) {
             classString = digestClassCounts(split(classString), -1);
             if (hasAnimate(element)) {
@@ -11371,6 +11346,10 @@
             }
           }
 
+          /**
+           * @param {string} oldClassString
+           * @param {string} newClassString
+           */
           function updateClasses(oldClassString, newClassString) {
             const oldClassArray = split(oldClassString);
             const newClassArray = split(newClassString);
@@ -11421,6 +11400,9 @@
             oldModulo = newModulo;
           }
 
+          /**
+           * @param {string} newClassString
+           */
           function ngClassWatchAction(newClassString) {
             if (oldModulo === selector) {
               updateClasses(oldClassString, newClassString);
@@ -11567,8 +11549,6 @@
 
   ngIfDirective.$inject = ["$animate"];
   /**
-   *
-   * TODO // Add type for animate service
    * @param {*}  $animate
    * @returns {import("../../interface.ts").Directive}
    */
@@ -12210,7 +12190,7 @@
   function ngStyleDirective() {
     return {
       restrict: "A",
-      link: (scope, element, attr) => {
+      link(scope, element, attr) {
         let oldStyles;
         scope.$watch(attr["ngStyle"], (newStyles) => {
           if (oldStyles) {
@@ -14906,23 +14886,17 @@
   }
 
   /**
-   * A cache for maping template names to their respective content.
-   *
-   * @typedef {Map<string, string>} TemplateCache
-   */
-
-  /**
-   * Service responsible for providing a cache for templates.
-   *
-   * @class TemplateCacheProvider
-   * @description Provides an instance of a template cache that can be used to store and retrieve template content.
+   * Provides an instance of a cache that can be used to store and retrieve template content.
    */
   class TemplateCacheProvider {
+    constructor() {
+      /** @type {import('./interface.ts').TemplateCache} */
+      this.cache = new Map();
+    }
     /**
-     * @description Returns a new instance of a `TemplateCache`, which is a Map used to store templates.
-     * @returns {TemplateCache} A new instance of the template cache (Map object).
+     * @returns {import('./interface.ts').TemplateCache}
      */
-    $get = () => new Map();
+    $get = () => this.cache;
   }
 
   /**
@@ -14969,7 +14943,7 @@
    * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
    */
 
-  /** @typedef {import('../services/log').LogService} LogService */
+  /** @typedef {import('../services/log/interface.ts').LogService} LogService */
 
   /** @typedef {import("./error-handler.ts").ErrorHandler}  ErrorHandler */
 
@@ -18535,8 +18509,8 @@
        *
        * @param {*} $browser
        * @param {*} $httpBackend
-       * @param {*} $rootScope
-       * @param {import("../../core/di/internal-injector").InjectorService} $injector
+       * @param {import("../../core/scope/scope.js").Scope} $rootScope
+       * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
        * @param {*} $sce
        * @returns
        */
@@ -18974,9 +18948,9 @@
               Object.entries(eventHandlers).forEach(([key, eventHandler]) => {
                 applyHandlers[key] = function (event) {
                   if (useApplyAsync) {
-                    setTimeout(() => $rootScope.$apply(callEventHandler));
+                    setTimeout(() => callEventHandler());
                   } else {
-                    $rootScope.$apply(callEventHandler);
+                    callEventHandler();
                   }
 
                   function callEventHandler() {
@@ -19084,17 +19058,27 @@
    * {@link ng.$http $http}.
    *
    */
-  function HttpBackendProvider() {
-    this.$get = [
-      "$browser",
-      /**
-       * @param {import('../browser.js').Browser} $browser
-       * @returns
-       */
-      function ($browser) {
-        return createHttpBackend($browser);
-      },
-    ];
+  /**
+   * HTTP backend used by the {@link ng.$http service} that delegates to
+   * XMLHttpRequest object and deals with browser incompatibilities.
+   *
+   * You should never need to use this service directly, instead use the higher-level abstractions:
+   * {@link ng.$http $http}.
+   *
+   */
+  class HttpBackendProvider {
+    constructor() {
+      this.$get = [
+        "$browser",
+        /**
+         * @param {import('../browser.js').Browser} $browser
+         * @returns
+         */
+        function ($browser) {
+          return createHttpBackend($browser);
+        },
+      ];
+    }
   }
 
   /**
@@ -19221,8 +19205,10 @@
       // http.timeout = promise             abort
       // xhr.abort()                        abort (The xhr object is normally inaccessible, but
       //                                    can be exposed with the xhrFactory)
+      /** @type {number} */
+      let timeoutId;
       if (timeout > 0) {
-        var timeoutId = setTimeout(() => {
+        timeoutId = setTimeout(() => {
           timeoutRequest("timeout");
         }, timeout);
       } else if (isPromiseLike(timeout)) {
@@ -20226,57 +20212,27 @@
     return a === b || urlResolve(a).href === urlResolve(b).href;
   }
 
-  ///////////////////////////////////////////////////////////////////////////
-  // LogService
-  // see http://docs.angularjs.org/api/ng/service/$log
-  // see http://docs.angularjs.org/api/ng/provider/$logProvider
-  ///////////////////////////////////////////////////////////////////////////
-
-  /**
-   * @typedef {(...args: any[]) => void} LogCall
-   */
-
-  /**
-   * @typedef {Object} LogService
-   * @property {LogCall} debug - Log a debug messages
-   * @property {LogCall} error - Log a error message
-   * @property {LogCall} info - Log a info message
-   * @property {LogCall} log - Log a general message
-   * @property {LogCall} warn - Log a warning message
-   */
-
-  /**
-   * @type {LogService}
-   */
-  let LogService = {
-    debug: undefined,
-    error: undefined,
-    info: undefined,
-    log: undefined,
-    warn: undefined,
-  };
-
   /**
-   * @type {LogProvider}
-   * Use the `$logProvider` to configure how the application logs messages
+   * Configuration provider for `$log` service
    */
   class LogProvider {
+    /** @private */
     constructor() {
-      this.debug = true;
+      /** @type {boolean} */
+      this.debug = false;
+      /** @private @type {import("./interface.ts").LogServiceFactory | null} */
+      this._override = null;
     }
 
     /**
-     * @param {boolean=} flag enable or disable debug level messages
-     * @returns {*} current value if used as getter or itself (chaining) if used as setter
+     * Override the default {@link LogService} implemenation
+     * @param {import("./interface.ts").LogServiceFactory} fn
      */
-    debugEnabled(flag) {
-      if (typeof flag !== "undefined") {
-        this.debug = flag;
-        return this;
-      }
-      return this.debug;
+    setLogger(fn) {
+      this._override = fn;
     }
 
+    /** @private */
     formatError(arg) {
       if (isError(arg)) {
         if (arg.stack) {
@@ -20291,6 +20247,10 @@
       return arg;
     }
 
+    /**
+     * @private
+     * @param {string} type
+     */
     consoleLog(type) {
       const console = window.console || {};
       const logFn = console[type] || console.log || (() => {});
@@ -20301,8 +20261,14 @@
       };
     }
 
+    /**
+     * @returns {import("./interface.ts").LogService}
+     */
     $get() {
-      LogService = {
+      if (this._override) {
+        return this._override();
+      }
+      return {
         log: this.consoleLog("log"),
         info: this.consoleLog("info"),
         warn: this.consoleLog("warn"),
@@ -20316,7 +20282,6 @@
           };
         })(),
       };
-      return LogService;
     }
   }
 
@@ -21571,7 +21536,7 @@
       /**
        * Creates a new `TaskTracker` instance.
        *
-       * @param {import('../services/log.js').LogService} log - The logging service.
+       * @param {import('../services/log/interface.ts').LogService} log - The logging service.
        * @returns {TaskTracker} A new `TaskTracker` instance.
        */
       (log) => new TaskTracker(log),
@@ -21586,7 +21551,7 @@
    */
   class TaskTracker {
     /**
-     * @param {import('../services/log.js').LogService} log - The logging service.
+     * @param {import('../services/log/interface.ts').LogService} log - The logging service.
      */
     constructor(log) {
       /** @private */
@@ -21764,8 +21729,8 @@
       /**
        *
        * @param {import('../core/exception-handler.js').ErrorHandler} $exceptionHandler
-       * @param {import('../core/cache/cache-factory.js').TemplateCache} $templateCache
-       * @param {*} $http
+       * @param {import('../services/template-cache/interface.ts').TemplateCache} $templateCache
+       * @param {import("interface.ts").HttpService} $http
        * @param {*} $sce
        * @returns
        */
@@ -26107,6 +26072,7 @@
     arr.push(val);
     return val;
   });
+
   /**
    * Applies a set of defaults to an options object.  The options object is filtered
    * to only those properties of the objects in the defaultsList.
@@ -26274,6 +26240,7 @@
    * ```
    */
   const unnest = (arr) => arr.reduce(unnestR, []);
+
   /**
    * Given a .filter Predicate, builds a .filter Predicate which throws an error if any elements do not pass.
    * @example
@@ -26288,6 +26255,7 @@
    * ```
    */
   const assertPredicate = assertFn;
+
   function assertFn(predicateOrMap, errMsg = "assert failure") {
     return (obj) => {
       const result = predicateOrMap(obj);
@@ -26368,10 +26336,17 @@
     memo[key] = value;
     return memo;
   }
-  /** Get the last element of an array */
+
+  /**
+   * Returns the last element of an array, or undefined if the array is empty.
+   * @template T
+   * @param {T[]} arr - The input array.
+   * @returns {T | undefined} The last element or undefined.
+   */
   function tail(arr) {
-    return (arr.length && arr[arr.length - 1]) || undefined;
+    return arr.length > 0 ? arr[arr.length - 1] : undefined;
   }
+
   /**
    * shallow copy from src to dest
    */
@@ -27686,12 +27661,15 @@
       Object.prototype.hasOwnProperty.bind(cfg || {}),
     ).length === 0;
 
-  let DefType;
-  (function (DefType) {
-    DefType[(DefType["PATH"] = 0)] = "PATH";
-    DefType[(DefType["SEARCH"] = 1)] = "SEARCH";
-    DefType[(DefType["CONFIG"] = 2)] = "CONFIG";
-  })(DefType || (DefType = {}));
+  /**
+   * @private
+   * @enum {number}
+   */
+  const DefType = {
+    PATH: 0,
+    SEARCH: 1,
+    CONFIG: 2,
+  };
 
   function getParamDeclaration(paramName, location, state) {
     const noReloadOnSearch =
@@ -27704,6 +27682,7 @@
     );
     return Object.assign(defaultConfig, paramConfig);
   }
+
   function unwrapShorthand(cfg) {
     cfg = isShorthand(cfg) ? { value: cfg } : cfg;
     getStaticDefaultValue["__cacheable"] = true;
@@ -27713,6 +27692,7 @@
     const $$fn = isInjectable(cfg.value) ? cfg.value : getStaticDefaultValue;
     return Object.assign(cfg, { $$fn });
   }
+
   function getType(cfg, urlType, location, id, paramTypes) {
     if (cfg.type && urlType && urlType.name !== "string")
       throw new Error(`Param '${id}' has two type configurations.`);
@@ -27737,6 +27717,7 @@
     }
     return cfg.type instanceof ParamType ? cfg.type : paramTypes.type(cfg.type);
   }
+
   /** returns false, true, or the squash value to indicate the "default parameter url squash policy". */
   function getSquashPolicy(config, isOptional, defaultPolicy) {
     const squash = config.squash;
@@ -27747,6 +27728,7 @@
       `Invalid squash policy: '${squash}'. Valid policies: false, true, or arbitrary string`,
     );
   }
+
   function getReplace(config, arrayMode, isOptional, squash) {
     const defaultPolicy = [
       { from: "", to: isOptional || arrayMode ? undefined : "" },
@@ -27760,7 +27742,16 @@
       (item) => configuredKeys.indexOf(item.from) === -1,
     ).concat(replace);
   }
+
   class Param {
+    /**
+     *
+     * @param {*} id
+     * @param {*} type
+     * @param {DefType} location
+     * @param {import("../url/url-config.js").UrlConfigProvider} urlConfig
+     * @param {*} state
+     */
     constructor(id, type, location, urlConfig, state) {
       const config = getParamDeclaration(id, location, state);
       type = getType(config, type, location, id, urlConfig.paramTypes);
@@ -28977,9 +28968,10 @@
 
   /**
    * Configurable provider for an injectable event bus
-   * @implements {ServiceProvider}
+   * @extends {ServiceProvider}
    */
   class PubSubProvider {
+    /** @private */
     constructor() {
       /**
        * @type {PubSub}
@@ -29004,10 +28996,10 @@
      * strings corresponding to native Object properties, e.g. "constructor",
      * "toString", "hasOwnProperty", etc.
      *
-     * @param {boolean=} opt_async Enable asynchronous behavior.  Recommended for
+     * @param {boolean=} async Enable asynchronous behavior.  Recommended for
      *     new code.  See notes on the publish() method.
      */
-    constructor(opt_async = false) {
+    constructor(async = false) {
       this.disposed = false;
 
       /**
@@ -29043,7 +29035,7 @@
        * representation minimizes the number of object allocations and has been
        * shown to be faster than an array of objects with three key-value pairs or
        * three parallel arrays, especially on IE.) Once a subscription is removed
-       * via {@link #unsubscribe} or {@link #unsubscribeByKey}, the three
+       * via {@link unsubscribe} or {@link unsubscribeByKey}, the three
        * corresponding array elements are deleted, and never reused. This means the
        * total number of subscriptions during the lifetime of the pubsub channel is
        * limited by the maximum length of a JavaScript array to (2^32 - 1) / 3 =
@@ -29064,7 +29056,7 @@
       /**
        * @private @const {boolean}
        */
-      this.async_ = Boolean(opt_async);
+      this.async_ = Boolean(async);
     }
 
     /**
@@ -29073,7 +29065,7 @@
      * is specified.  Subscribing the same function to the same topic multiple
      * times will result in multiple function invocations while publishing.
      * Returns a subscription key that can be used to unsubscribe the function from
-     * the topic via {@link #unsubscribeByKey}.
+     * the topic via {@link unsubscribeByKey}.
      *
      * @param {string} topic Topic to subscribe to.
      * @param {Function} fn Function to be invoked when a message is published to
@@ -29108,7 +29100,7 @@
      * method on the given `opt_context` object, or in the global scope if
      * no context is specified, and is then unsubscribed.  Returns a subscription
      * key that can be used to unsubscribe the function from the topic via
-     * {@link #unsubscribeByKey}.
+     * {@link unsubscribeByKey}.
      *
      * @param {string} topic Topic to subscribe to.
      * @param {Function} fn Function to be invoked once and then unsubscribed when
@@ -29148,9 +29140,9 @@
      * @param {Array} args Arguments to pass to the function.
      */
     static runAsync_(fn, context, args) {
-      setTimeout(() => {
+      Promise.resolve().then(() => {
         fn.apply(context, args);
-      }, 0);
+      });
     }
 
     /**
@@ -29181,7 +29173,7 @@
     }
 
     /**
-     * Removes a subscription based on the key returned by {@link #subscribe}.
+     * Removes a subscription based on the key returned by {@link subscribe}.
      * No-op if no matching subscription is found.  Returns a Boolean indicating
      * whether a subscription was removed.
      *
@@ -29216,7 +29208,7 @@
      * the order in which they were added, passing all arguments along.
      *
      * If this object was created with async=true, subscribed functions are called
-     * via setTimeout().  Otherwise, the functions are called directly, and if
+     * via Promise.resolve().  Otherwise, the functions are called directly, and if
      * any of them throw an uncaught error, publishing is aborted.
      *
      * @param {string} topic Topic to publish to.
@@ -32087,8 +32079,8 @@
       "$templateRequest",
       "$injector",
       /**
-       * @param {any} $http
-       * @param {import("../core/cache/cache-factory.js").TemplateCache} $templateCache
+       * @param {import("interface.ts").HttpService} $http
+       * @param {import("../services/template-cache/interface.ts").TemplateCache} $templateCache
        * @param {any} $templateRequest
        * @param {import("../core/di/internal-injector.js").InjectorService} $injector
        * @returns
@@ -32187,7 +32179,7 @@
       if (url == null) return null;
       if (this._useHttp) {
         return this.$http
-          .get(url, {
+          .get(/** @type {string} */ (url), {
             cache: this.$templateCache,
             headers: { Accept: "text/html" },
           })
@@ -33499,7 +33491,13 @@
   }
 
   class ParamFactory {
+    /**
+     * @param {import("../url/url-config.js").UrlConfigProvider} urlServiceConfig
+     */
     constructor(urlServiceConfig) {
+      /**
+       * @type {import("../url/url-config.js").UrlConfigProvider}
+       */
       this.urlServiceConfig = urlServiceConfig;
     }
 
@@ -33553,7 +33551,7 @@
        * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
        *
        * See: [[UrlConfig]] for details
-       * @type {import("./url-config").UrlConfigProvider}
+       * @type {import("./url-config.js").UrlConfigProvider}
        */
       this.config = urlConfigProvider;
 
@@ -34068,6 +34066,9 @@
     };
   }
 
+  /**
+   * @param {import("../params/param-factory.js").ParamFactory} paramFactory
+   */
   function getParamsBuilder(paramFactory) {
     return function (state) {
       const makeConfigParam = (_config, id) =>
@@ -35579,43 +35580,29 @@
     }
   }
 
+  ngChannelDirective.$inject = [$injectTokens.$eventBus];
   /**
-   * Dynamically updates an element's content based on events published on a specified channel.
-   * If data is sent via `EventBus` on the specified `ngChannel`, the directive attempts to update the element's content accordingly,
-   * either by directly setting the inner HTML or merging the scope's data if the element contains a template.
-   *
-   * If the element has a template and incoming data is an object, the directive will merge all key/value pairs onto the scope,
-   * allowing Angular expressions (`{{ yourModel }}`) to be evaluated and rendered.
-   *
-   * When the scope is destroyed, the directive automatically unsubscribes from the channel.
-   * Example:
-   *
-   * HTML:
-   * <div ng-channel="userChannel">Hello {{ user.firstName }} {{ user.lastName }}</div>
-   *
-   * JavaScript:
-   * angular.EventBus.publish('userChannel', { user: { firstName: 'John', lastName: 'Smith' } });
-   *
+   * @param {import("../../services/pubsub/pubsub.js").PubSub} $eventBus
    * @returns {import("../../interface.ts").Directive}
    */
-  function ngChannelDirective() {
+  function ngChannelDirective($eventBus) {
     return {
       link: (scope, element, attrs) => {
-        const hasTemplate = element.childNodes.length > 0;
         const channel = attrs["ngChannel"];
+        const hasTemplateContent = element.childNodes.length > 0;
 
-        const key = EventBus.subscribe(channel, async (val) => {
-          if (!hasTemplate) {
-            element.innerHTML = val;
-          } else {
-            if (isObject(val)) {
-              scope.$merge(val);
+        const key = $eventBus.subscribe(channel, (value) => {
+          if (hasTemplateContent) {
+            if (isObject(value)) {
+              scope.$merge(value);
             }
+          } else {
+            element.innerHTML = value;
           }
         });
 
         scope.$on("$destroy", () => {
-          EventBus.unsubscribeByKey(key);
+          $eventBus.unsubscribeByKey(key);
         });
       },
     };
@@ -35624,7 +35611,7 @@
   ngSetterDirective.$inject = ["$parse", "$log"];
   /**
    * @param {import('../../core/parse/interface.ts').ParseService} $parse
-   * @param {import('../../services/log.js').LogService} $log
+   * @param {import('../../services/log/interface.ts').LogService} $log
    * @returns {import('../../interface.ts').Directive}
    */
   function ngSetterDirective($parse, $log) {
@@ -35683,16 +35670,256 @@
     };
   }
 
-  // @private
+  /**
+   * @param {"get" | "delete" | "post" | "put"} method
+   * @returns {import('../../interface.ts').DirectiveFactory}
+   */
+  function defineDirective(method) {
+    const attrName = "ng" + method.charAt(0).toUpperCase() + method.slice(1);
+    const directive = createHttpDirective(method, attrName);
+    directive["$inject"] = ["$http", "$compile", "$log"];
+    return directive;
+  }
 
-  const VERSION = "0.7.2";
+  const ngGetDirective = defineDirective("get");
+  const ngDeleteDirective = defineDirective("delete");
+  const ngPostDirective = defineDirective("post");
+  const ngPutDirective = defineDirective("put");
+
+  /**
+   * @typedef {"click" | "change" | "submit"} EventType
+   */
+
+  /**
+   * Selects DOM event to listen for based on the element type.
+   *
+   * @param {Element} element - The DOM element to inspect.
+   * @returns {EventType} The name of the event to listen for.
+   */
+  function getEventNameForElement(element) {
+    const tag = element.tagName.toLowerCase();
+    if (["input", "textarea", "select"].includes(tag)) {
+      return "change";
+    } else if (tag === "form") {
+      return "submit";
+    }
+    return "click";
+  }
+
+  /**
+   * Handles DOM manipulation based on a swap strategy and server-rendered HTML.
+   *
+   * @param {string} html - The HTML string returned from the server.
+   * @param {import("../../interface.ts").SwapInsertPosition} swap
+   * @param {Element} target - The target DOM element to apply the swap to.
+   * @param {import('../../core/scope/scope.js').Scope} scope
+   * @param {import('../../core/compile/compile.js').CompileFn} $compile
+   */
+  function handleSwapResponse(html, swap, target, scope, $compile) {
+    let nodes = [];
+    if (!["textcontent", "delete", "none"].includes(swap)) {
+      if (!html) {
+        return;
+      }
+
+      if (isObject(html)) {
+        scope.$merge(html);
+        return;
+      }
+
+      const compiled = $compile(html)(scope);
+      nodes =
+        compiled instanceof DocumentFragment
+          ? Array.from(compiled.childNodes)
+          : [compiled];
+    }
+
+    switch (swap) {
+      case "innerHTML":
+        target.replaceChildren(...nodes);
+        break;
+
+      case "outerHTML": {
+        const parent = target.parentNode;
+        if (!parent) return;
+        const frag = document.createDocumentFragment();
+        nodes.forEach((n) => frag.appendChild(n));
+        parent.replaceChild(frag, target);
+        break;
+      }
+
+      case "textContent":
+        target.textContent = html;
+        break;
+
+      case "beforebegin":
+        nodes.forEach((node) => target.parentNode.insertBefore(node, target));
+        break;
+
+      case "afterbegin":
+        nodes
+          .slice()
+          .reverse()
+          .forEach((node) => target.insertBefore(node, target.firstChild));
+        break;
+
+      case "beforeend":
+        nodes.forEach((node) => target.appendChild(node));
+        break;
+
+      case "afterend":
+        nodes
+          .slice()
+          .reverse()
+          .forEach((node) =>
+            target.parentNode.insertBefore(node, target.nextSibling),
+          );
+        break;
+
+      case "delete":
+        target.remove();
+        break;
+
+      case "none":
+        break;
+
+      default:
+        target.replaceChildren(...nodes);
+        break;
+    }
+  }
+
+  /**
+   * Creates an HTTP directive factory that supports GET, DELETE, POST, PUT.
+   *
+   * @param {"get" | "delete" | "post" | "put"} method - HTTP method to use.
+   * @param {string} attrName - Attribute name containing the URL.
+   * @returns {import('../../interface.ts').DirectiveFactory}
+   */
+  function createHttpDirective(method, attrName) {
+    /**
+     * @param {import("interface.ts").HttpService} $http
+     * @param {import("../../core/compile/compile.js").CompileFn} $compile
+     * @param {import("../../services/log/interface.ts").LogService} $log
+     * @returns {import('../../interface.ts').Directive}
+     */
+    return function ($http, $compile, $log) {
+      /**
+       * Collects form data from the element or its associated form.
+       *
+       * @param {HTMLElement} element
+       * @returns {Object<string, any>}
+       */
+      function collectFormData(element) {
+        /** @type {HTMLFormElement | null} */
+        let form = null;
+
+        const tag = element.tagName.toLowerCase();
+
+        if (tag === "form") {
+          /** @type {HTMLFormElement} */
+          form = /** @type {HTMLFormElement} */ (element);
+        } else if ("form" in element && element.form) {
+          /** @type {HTMLFormElement} */
+          form = /** @type {HTMLFormElement} */ (element.form);
+        } else if (element.hasAttribute("form")) {
+          const formId = element.getAttribute("form");
+          if (formId) {
+            /** @type {HTMLElement | null} */
+            const maybeForm = document.getElementById(formId);
+            if (maybeForm && maybeForm.tagName.toLowerCase() === "form") {
+              form = /** @type {HTMLFormElement} */ (maybeForm);
+            }
+          }
+        }
+
+        if (!form) {
+          if (
+            "name" in element &&
+            typeof element.name === "string" &&
+            element.name.length > 0
+          ) {
+            if (
+              element instanceof HTMLInputElement ||
+              element instanceof HTMLTextAreaElement ||
+              element instanceof HTMLSelectElement
+            ) {
+              const key = element.name;
+              const value = element.value;
+              return { [key]: value };
+            }
+          }
+          return {};
+        }
+
+        const formData = new FormData(form);
+        const data = {};
+        formData.forEach((value, key) => {
+          data[key] = value;
+        });
+        return data;
+      }
+
+      return {
+        restrict: "A",
+        terminal: true,
+        link(scope, element, attrs) {
+          /** @type {EventType} */
+          const eventName = getEventNameForElement(element);
+          const tag = element.tagName.toLowerCase();
+
+          element.addEventListener(eventName, (event) => {
+            if (/** @type {HTMLButtonElement} */ (element).disabled) return;
+            if (tag === "form") event.preventDefault();
+
+            const swap = element.dataset.swap || "innerHTML";
+            const targetSelector = element.dataset.target;
+            const target = targetSelector
+              ? document.querySelector(targetSelector)
+              : element;
+
+            if (!target) {
+              $log.warn(`${attrName}: target "${targetSelector}" not found`);
+              return;
+            }
+
+            const url = attrs[attrName];
+            if (!url) {
+              $log.warn(`${attrName}: no URL specified`);
+              return;
+            }
+
+            const handler = (res) => {
+              const html = res.data;
+              handleSwapResponse(
+                html,
+                /** @type {import("../../interface.ts").SwapInsertPosition} */ (
+                  swap
+                ),
+                target,
+                scope,
+                $compile,
+              );
+            };
+
+            if (method === "post" || method === "put") {
+              const data = collectFormData(element);
+              $http[method](url, data).then(handler).catch(handler);
+            } else {
+              $http[method](url).then(handler).catch(handler);
+            }
+          });
+        },
+      };
+    };
+  }
 
   /**
    * Initializes core `ng` module.
    * @param {import('./loader.js').Angular} angular
    * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
    */
-  function publishExternalAPI(angular) {
+  function registerNgModule(angular) {
     const ng = angular
       .module(
         "ng",
@@ -35722,8 +35949,10 @@
                 ngClassOdd: ngClassOddDirective,
                 ngCloak: ngCloakDirective,
                 ngController: ngControllerDirective,
+                ngDelete: ngDeleteDirective,
                 ngDisabled: ngDisabledAriaDirective,
                 ngForm: ngFormDirective,
+                ngGet: ngGetDirective,
                 ngHide: ngHideDirective,
                 ngIf: ngIfDirective,
                 ngInclude: ngIncludeDirective,
@@ -35734,6 +35963,8 @@
                 ngMessagesInclude: ngMessagesIncludeDirective,
                 ngMessageDefault: ngMessageDefaultDirective,
                 ngNonBindable: ngNonBindableDirective,
+                ngPost: ngPostDirective,
+                ngPut: ngPutDirective,
                 ngRef: ngRefDirective,
                 ngRepeat: ngRepeatDirective,
                 ngSetter: ngSetterDirective,
@@ -35838,8 +36069,7 @@
           return globals.params;
         },
       ])
-      .value("$trace", trace)
-      .info({ version: VERSION });
+      .value("$trace", trace);
 
     return ng;
   }
@@ -35859,18 +36089,15 @@
 
   class Angular {
     constructor() {
-      Cache.clear(); // a ensure new instance of angular gets a clean cache
-
-      /** @type {Map<number, import("./core/cache/cache").ExpandoStore>} */
-      this.Cache = Cache;
+      this.$cache = Cache;
 
-      /** @type {import('./core/pubsub/pubsub.js').PubSub} */
-      this.EventBus = EventBus;
+      /** @type {import('./services/pubsub/pubsub.js').PubSub} */
+      this.$eventBus = EventBus;
 
       /**
        * @type {string} `version` from `package.json`
        */
-      this.version = VERSION;
+      this.version = "0.7.4"; //inserted via rollup plugin
 
       /** @type {!Array<string|any>} */
       this.bootsrappedModules = [];
@@ -35882,7 +36109,7 @@
 
       window["angular"] = this;
       this.$injectTokens = $injectTokens;
-      publishExternalAPI(this);
+      registerNgModule(this);
     }
 
     /**