@angular-wave/angular.ts 0.7.2 → 0.7.4

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.7.2 - June 28, 2025 21:48:51 */
+/* Version: 0.7.4 - July 11, 2025 03:03:27 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -1130,39 +1130,29 @@ function hasOwn(obj, key) {
   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;
@@ -1263,7 +1253,7 @@ function removeElementData(element, name) {
  *
  * @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];
@@ -1272,9 +1262,7 @@ function getExpando(element, createIfNecessary = false) {
   if (createIfNecessary && !expandoStore) {
     element[EXPANDO] = expandoId = jqNextId();
     expandoStore = {
-      events: {},
       data: {},
-      handle: null,
     };
     Cache.set(expandoId, expandoStore);
   }
@@ -1333,19 +1321,15 @@ function dealoc(element, onlyDescendants) {
 }
 
 /**
- * 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
   }
@@ -1622,10 +1606,6 @@ function getBooleanAttrName(element, name) {
  */
 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]);
   }
 }
@@ -1718,6 +1698,9 @@ function extractElementNode$1(element) {
  *   angular.$injectTokens.$animate,
  *   angular.$injectTokens.$templateRequest,
  * ];
+ *
+ * function myDirective($animate, $templateRequest) { ... }
+ *
  * ```
  * @type Readonly<Record<string, string>>
  */
@@ -1828,27 +1811,11 @@ class NgModule {
     /** @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
@@ -2177,7 +2144,6 @@ class AbstractInjector {
 
 /**
  * Injector for providers
- * @extends {AbstractInjector}
  */
 class ProviderInjector extends AbstractInjector {
   /**
@@ -2207,15 +2173,13 @@ class ProviderInjector extends AbstractInjector {
 
 /**
  * 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;
@@ -2353,7 +2317,7 @@ function createInjector(modulesToLoad, strictDi = false) {
     strictDi,
   ));
 
-  const protoInstanceInjector = new InjectorService(strictDi, providerInjector);
+  const protoInstanceInjector = new InjectorService(providerInjector, strictDi);
 
   providerCache.$injectorProvider = {
     // $injectionProvider return instance injector
@@ -7577,7 +7541,9 @@ class CompileProvider {
           }
 
           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;
           }
@@ -10645,7 +10611,7 @@ function ngValueDirective() {
 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) {
@@ -11306,6 +11272,8 @@ function ngBindHtmlDirective($parse) {
 }
 
 /**
+ * @param {string} name
+ * @param {boolean|number} selector
  * @returns {() => import("../../interface.ts").Directive}
  */
 function classDirective(name, selector) {
@@ -11321,6 +11289,7 @@ function classDirective(name, selector) {
       link(scope, element, attr) {
         let classCounts = getCacheData(element, "$classCounts");
         let oldModulo = true;
+        /** @type {string|undefined} */
         let oldClassString;
 
         if (!classCounts) {
@@ -11339,6 +11308,9 @@ function classDirective(name, selector) {
           ngClassWatchAction(toClassString(val));
         });
 
+        /**
+         * @param {string} classString
+         */
         function addClasses(classString) {
           classString = digestClassCounts(split(classString), 1);
           if (hasAnimate(element)) {
@@ -11352,6 +11324,9 @@ function classDirective(name, selector) {
           }
         }
 
+        /**
+         * @param {string} classString
+         */
         function removeClasses(classString) {
           classString = digestClassCounts(split(classString), -1);
           if (hasAnimate(element)) {
@@ -11365,6 +11340,10 @@ function classDirective(name, selector) {
           }
         }
 
+        /**
+         * @param {string} oldClassString
+         * @param {string} newClassString
+         */
         function updateClasses(oldClassString, newClassString) {
           const oldClassArray = split(oldClassString);
           const newClassArray = split(newClassString);
@@ -11415,6 +11394,9 @@ function classDirective(name, selector) {
           oldModulo = newModulo;
         }
 
+        /**
+         * @param {string} newClassString
+         */
         function ngClassWatchAction(newClassString) {
           if (oldModulo === selector) {
             updateClasses(oldClassString, newClassString);
@@ -11561,8 +11543,6 @@ function ngHideDirective($animate) {
 
 ngIfDirective.$inject = ["$animate"];
 /**
- *
- * TODO // Add type for animate service
  * @param {*}  $animate
  * @returns {import("../../interface.ts").Directive}
  */
@@ -12204,7 +12184,7 @@ function ngRepeatDirective($animate) {
 function ngStyleDirective() {
   return {
     restrict: "A",
-    link: (scope, element, attr) => {
+    link(scope, element, attr) {
       let oldStyles;
       scope.$watch(attr["ngStyle"], (newStyles) => {
         if (oldStyles) {
@@ -14900,23 +14880,17 @@ class AnimateRunner {
 }
 
 /**
- * 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;
 }
 
 /**
@@ -14963,7 +14937,7 @@ class TemplateCacheProvider {
  * @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 */
 
@@ -18529,8 +18503,8 @@ function HttpProvider() {
      *
      * @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
      */
@@ -18968,9 +18942,9 @@ function HttpProvider() {
             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() {
@@ -19078,17 +19052,27 @@ function HttpProvider() {
  * {@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);
+      },
+    ];
+  }
 }
 
 /**
@@ -19215,8 +19199,10 @@ function createHttpBackend($browser) {
     // 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)) {
@@ -20220,57 +20206,27 @@ function urlsEqual(a, b) {
   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) {
@@ -20285,6 +20241,10 @@ class LogProvider {
     return arg;
   }
 
+  /**
+   * @private
+   * @param {string} type
+   */
   consoleLog(type) {
     const console = window.console || {};
     const logFn = console[type] || console.log || (() => {});
@@ -20295,8 +20255,14 @@ class LogProvider {
     };
   }
 
+  /**
+   * @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"),
@@ -20310,7 +20276,6 @@ class LogProvider {
         };
       })(),
     };
-    return LogService;
   }
 }
 
@@ -21565,7 +21530,7 @@ class TaskTrackerFactoryProvider {
     /**
      * 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),
@@ -21580,7 +21545,7 @@ class TaskTrackerFactoryProvider {
  */
 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 */
@@ -21758,8 +21723,8 @@ function TemplateRequestProvider() {
     /**
      *
      * @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
      */
@@ -26101,6 +26066,7 @@ const pushTo = curry((arr, val) => {
   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.
@@ -26268,6 +26234,7 @@ const uniqR = (acc, token) =>
  * ```
  */
 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
@@ -26282,6 +26249,7 @@ const unnest = (arr) => arr.reduce(unnestR, []);
  * ```
  */
 const assertPredicate = assertFn;
+
 function assertFn(predicateOrMap, errMsg = "assert failure") {
   return (obj) => {
     const result = predicateOrMap(obj);
@@ -26362,10 +26330,17 @@ function applyPairs(memo, keyValTuple) {
   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
  */
@@ -27680,12 +27655,15 @@ const isShorthand = (cfg) =>
     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 =
@@ -27698,6 +27676,7 @@ function getParamDeclaration(paramName, location, state) {
   );
   return Object.assign(defaultConfig, paramConfig);
 }
+
 function unwrapShorthand(cfg) {
   cfg = isShorthand(cfg) ? { value: cfg } : cfg;
   getStaticDefaultValue["__cacheable"] = true;
@@ -27707,6 +27686,7 @@ function unwrapShorthand(cfg) {
   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.`);
@@ -27731,6 +27711,7 @@ function getType(cfg, urlType, location, id, paramTypes) {
   }
   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;
@@ -27741,6 +27722,7 @@ function getSquashPolicy(config, isOptional, defaultPolicy) {
     `Invalid squash policy: '${squash}'. Valid policies: false, true, or arbitrary string`,
   );
 }
+
 function getReplace(config, arrayMode, isOptional, squash) {
   const defaultPolicy = [
     { from: "", to: isOptional || arrayMode ? undefined : "" },
@@ -27754,7 +27736,16 @@ function getReplace(config, arrayMode, isOptional, squash) {
     (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);
@@ -28971,9 +28962,10 @@ class Rejection {
 
 /**
  * Configurable provider for an injectable event bus
- * @implements {ServiceProvider}
+ * @extends {ServiceProvider}
  */
 class PubSubProvider {
+  /** @private */
   constructor() {
     /**
      * @type {PubSub}
@@ -28998,10 +28990,10 @@ class PubSub {
    * 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;
 
     /**
@@ -29037,7 +29029,7 @@ class PubSub {
      * 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 =
@@ -29058,7 +29050,7 @@ class PubSub {
     /**
      * @private @const {boolean}
      */
-    this.async_ = Boolean(opt_async);
+    this.async_ = Boolean(async);
   }
 
   /**
@@ -29067,7 +29059,7 @@ class PubSub {
    * 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
@@ -29102,7 +29094,7 @@ class PubSub {
    * 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
@@ -29142,9 +29134,9 @@ class PubSub {
    * @param {Array} args Arguments to pass to the function.
    */
   static runAsync_(fn, context, args) {
-    setTimeout(() => {
+    Promise.resolve().then(() => {
       fn.apply(context, args);
-    }, 0);
+    });
   }
 
   /**
@@ -29175,7 +29167,7 @@ class PubSub {
   }
 
   /**
-   * 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.
    *
@@ -29210,7 +29202,7 @@ class PubSub {
    * 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.
@@ -32081,8 +32073,8 @@ class TemplateFactoryProvider {
     "$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
@@ -32181,7 +32173,7 @@ class TemplateFactoryProvider {
     if (url == null) return null;
     if (this._useHttp) {
       return this.$http
-        .get(url, {
+        .get(/** @type {string} */ (url), {
           cache: this.$templateCache,
           headers: { Accept: "text/html" },
         })
@@ -33493,7 +33485,13 @@ class UrlRules {
 }
 
 class ParamFactory {
+  /**
+   * @param {import("../url/url-config.js").UrlConfigProvider} urlServiceConfig
+   */
   constructor(urlServiceConfig) {
+    /**
+     * @type {import("../url/url-config.js").UrlConfigProvider}
+     */
     this.urlServiceConfig = urlServiceConfig;
   }
 
@@ -33547,7 +33545,7 @@ class UrlService {
      * 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;
 
@@ -34062,6 +34060,9 @@ function getNavigableBuilder(isRoot) {
   };
 }
 
+/**
+ * @param {import("../params/param-factory.js").ParamFactory} paramFactory
+ */
 function getParamsBuilder(paramFactory) {
   return function (state) {
     const makeConfigParam = (_config, id) =>
@@ -35573,43 +35574,29 @@ function registerControllerCallbacks(
   }
 }
 
+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);
       });
     },
   };
@@ -35618,7 +35605,7 @@ function ngChannelDirective() {
 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) {
@@ -35677,16 +35664,256 @@ function ngSetterDirective($parse, $log) {
   };
 }
 
-// @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",
@@ -35716,8 +35943,10 @@ function publishExternalAPI(angular) {
               ngClassOdd: ngClassOddDirective,
               ngCloak: ngCloakDirective,
               ngController: ngControllerDirective,
+              ngDelete: ngDeleteDirective,
               ngDisabled: ngDisabledAriaDirective,
               ngForm: ngFormDirective,
+              ngGet: ngGetDirective,
               ngHide: ngHideDirective,
               ngIf: ngIfDirective,
               ngInclude: ngIncludeDirective,
@@ -35728,6 +35957,8 @@ function publishExternalAPI(angular) {
               ngMessagesInclude: ngMessagesIncludeDirective,
               ngMessageDefault: ngMessageDefaultDirective,
               ngNonBindable: ngNonBindableDirective,
+              ngPost: ngPostDirective,
+              ngPut: ngPutDirective,
               ngRef: ngRefDirective,
               ngRepeat: ngRepeatDirective,
               ngSetter: ngSetterDirective,
@@ -35832,8 +36063,7 @@ function publishExternalAPI(angular) {
         return globals.params;
       },
     ])
-    .value("$trace", trace)
-    .info({ version: VERSION });
+    .value("$trace", trace);
 
   return ng;
 }
@@ -35853,18 +36083,15 @@ const modules = {};
 
 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 = [];
@@ -35876,7 +36103,7 @@ class Angular {
 
     window["angular"] = this;
     this.$injectTokens = $injectTokens;
-    publishExternalAPI(this);
+    registerNgModule(this);
   }
 
   /**