@angular-wave/angular.ts 0.15.1 → 0.15.2

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.15.1 - December 21, 2025 17:06:20 */
+/* Version: 0.15.2 - December 24, 2025 03:47:38 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -790,18 +790,6 @@ function fromJson(json) {
   return isString(json) ? JSON.parse(json) : json;
 }
 
-/**
- * @param {Date} date
- * @param {number} minutes
- */
-function addDateMinutes(date, minutes) {
-  const newDate = new Date(date.getTime());
-
-  newDate.setMinutes(newDate.getMinutes() + minutes);
-
-  return newDate;
-}
-
 /**
  * Parses an escaped url query string into key-value pairs.
  * @param {string} keyValue
@@ -9935,7 +9923,7 @@ class CompileProvider {
 
                 let linkNode = $compileNode._getAny();
 
-                if (scope.$$destroyed) {
+                if (scope._destroyed) {
                   continue;
                 }
 
@@ -10002,7 +9990,7 @@ class CompileProvider {
           ) {
             let childBoundTranscludeFn = boundTranscludeFn;
 
-            if (scope.$$destroyed) {
+            if (scope._destroyed) {
               return;
             }
 
@@ -12924,9 +12912,6 @@ function ngModelDirective() {
   };
 }
 
-// Regex code was initially obtained from SO prior to modification: https://stackoverflow.com/questions/3143070/javascript-regex-iso-datetime#answer-3143231
-const ISO_DATE_REGEXP =
-  /^\d{4,}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+(?:[+-][0-2]\d:[0-5]\d|Z)$/;
 // See valid URLs in RFC3987 (http://tools.ietf.org/html/rfc3987)
 // Note: We are being more lenient, because browsers are too.
 //   1. Scheme
@@ -12974,35 +12959,14 @@ const PARTIAL_VALIDATION_TYPES = new Map();
 
 const inputType = {
   text: textInputType,
-  date: createDateInputType(
-    "date",
-    DATE_REGEXP,
-    createDateParser(DATE_REGEXP, ["yyyy", "MM", "dd"]),
-  ),
-  "datetime-local": createDateInputType(
+  date: createStringDateInputType("date", DATE_REGEXP),
+  "datetime-local": createStringDateInputType(
     "datetimelocal",
     DATETIMELOCAL_REGEXP,
-    createDateParser(DATETIMELOCAL_REGEXP, [
-      "yyyy",
-      "MM",
-      "dd",
-      "HH",
-      "mm",
-      "ss",
-      "sss",
-    ]),
-  ),
-  time: createDateInputType(
-    "time",
-    TIME_REGEXP,
-    createDateParser(TIME_REGEXP, ["HH", "mm", "ss", "sss"]),
-  ),
-  week: createDateInputType("week", WEEK_REGEXP, weekParser),
-  month: createDateInputType(
-    "month",
-    MONTH_REGEXP,
-    createDateParser(MONTH_REGEXP, ["yyyy", "MM"]),
   ),
+  time: createStringDateInputType("time", TIME_REGEXP),
+  week: createStringDateInputType("week", WEEK_REGEXP),
+  month: createStringDateInputType("month", MONTH_REGEXP),
   number: numberInputType,
   url: urlInputType,
   email: emailInputType,
@@ -13131,318 +13095,56 @@ function baseInputType(_, element, attr, ctrl) {
   };
 }
 
-function weekParser(isoWeek, existingDate) {
-  if (isDate(isoWeek)) {
-    return isoWeek;
-  }
-
-  function getFirstThursdayOfYear(year) {
-    // 0 = index of January
-    const dayOfWeekOnFirst = new Date(year, 0, 1).getDay();
-
-    // 4 = index of Thursday (+1 to account for 1st = 5)
-    // 11 = index of *next* Thursday (+1 account for 1st = 12)
-    return new Date(
-      year,
-      0,
-      // eslint-disable-next-line no-magic-numbers
-      (dayOfWeekOnFirst <= 4 ? 5 : 12) - dayOfWeekOnFirst,
-    );
-  }
-
-  if (isString(isoWeek)) {
-    WEEK_REGEXP.lastIndex = 0;
-    const parts = WEEK_REGEXP.exec(isoWeek);
-
-    if (parts) {
-      const year = +parts[1];
-
-      const week = +parts[2];
-
-      let hours = 0;
-
-      let minutes = 0;
-
-      let seconds = 0;
-
-      let milliseconds = 0;
-
-      const firstThurs = getFirstThursdayOfYear(year);
-
-      const DAYS = 7;
-
-      const addDays = (week - 1) * DAYS;
-
-      if (existingDate) {
-        hours = existingDate.getHours();
-        minutes = existingDate.getMinutes();
-        seconds = existingDate.getSeconds();
-        milliseconds = existingDate.getMilliseconds();
-      }
-
-      return new Date(
-        year,
-        0,
-        firstThurs.getDate() + addDays,
-        hours,
-        minutes,
-        seconds,
-        milliseconds,
-      );
-    }
-  }
-
-  return NaN;
-}
-
-function createDateParser(regexp, mapping) {
-  return function (iso, previousDate) {
-    let parts;
-
-    let map;
-
-    if (isDate(iso)) {
-      return iso;
-    }
-
-    if (isString(iso)) {
-      // When a date is JSON'ified to wraps itself inside of an extra
-      // set of double quotes. This makes the date parsing code unable
-      // to match the date string and parse it as a date.
-      if (iso.charAt(0) === '"' && iso.charAt(iso.length - 1) === '"') {
-        iso = iso.substring(1, iso.length - 1);
-      }
-
-      if (ISO_DATE_REGEXP.test(iso)) {
-        return new Date(iso);
-      }
-      regexp.lastIndex = 0;
-      parts = regexp.exec(iso);
-
-      if (parts) {
-        parts.shift();
-
-        if (previousDate) {
-          map = {
-            yyyy: previousDate.getFullYear(),
-            MM: previousDate.getMonth() + 1,
-            dd: previousDate.getDate(),
-            HH: previousDate.getHours(),
-            mm: previousDate.getMinutes(),
-            ss: previousDate.getSeconds(),
-            sss: previousDate.getMilliseconds() / 1000,
-          };
-        } else {
-          map = { yyyy: 1970, MM: 1, dd: 1, HH: 0, mm: 0, ss: 0, sss: 0 };
-        }
-
-        Object.entries(parts).forEach(([index, part]) => {
-          if (index < mapping.length) {
-            map[mapping[index]] = +part;
-          }
-        });
-
-        const date = new Date(
-          map.yyyy,
-          map.MM - 1,
-          map.dd,
-          map.HH,
-          map.mm,
-          map.ss || 0,
-          map.sss * 1000 || 0,
-        );
-
-        if (map.yyyy < 100) {
-          // In the constructor, 2-digit years map to 1900-1999.
-          // Use `setFullYear()` to set the correct year.
-          date.setFullYear(map.yyyy);
-        }
-
-        return date;
-      }
-    }
-
-    return NaN;
-  };
-}
-
-const MONTH_INPUT_FORMAT = /\b\d{4}-(0[1-9]|1[0-2])\b/;
-
-function createDateInputType(type, regexp, parseDate) {
-  return function dynamicDateInputType(
-    scope,
-    element,
-    attr,
-    ctrl,
-    $filter,
-    $parse,
-  ) {
-    badInputChecker(scope, element, attr, ctrl, type);
+/**
+ * @param {string} type
+ * @param {RegExp} regexp
+ * @returns {*}
+ */
+function createStringDateInputType(type, regexp) {
+  return function stringDateInputType(scope, element, attr, ctrl, $parse) {
     baseInputType(scope, element, attr, ctrl);
-    let previousDate;
-
     ctrl.$parsers.push((value) => {
       if (ctrl.$isEmpty(value)) return null;
 
-      if (regexp.test(value)) {
-        // Do not convert for native HTML
-        if (["month", "week", "datetimelocal", "time", "date"].includes(type)) {
-          return value;
-        }
+      if (regexp.test(value)) return value;
 
-        // Note: We cannot read ctrl.$modelValue, as there might be a different
-        // parser/formatter in the processing chain so that the model
-        // contains some different data format!
-        return parseDateAndConvertTimeZoneToLocal(value, previousDate);
-      }
       ctrl.$$parserName = type;
 
       return undefined;
     });
 
-    ctrl.$formatters.push(function (value) {
-      if (value && !isString(value)) {
-        throw ngModelMinErr("datefmt", "Expected `{0}` to be a String", value);
-      }
-
-      if (type === "month") {
-        if (isNullOrUndefined(value)) {
-          return "";
-        }
-
-        if (!MONTH_INPUT_FORMAT.test(value)) {
-          throw ngModelMinErr(
-            "datefmt",
-            "Expected month `{0}` to be a 'YYYY-DD'",
-            value,
-          );
-        }
-      }
+    ctrl.$formatters.push((value) => {
+      if (ctrl.$isEmpty(value)) return "";
 
-      if (type === "week") {
-        if (isNullOrUndefined(value)) {
-          return "";
-        }
-
-        if (!WEEK_REGEXP.test(value)) {
-          throw ngModelMinErr(
-            "datefmt",
-            "Expected week `{0}` to be a 'yyyy-Www'",
-            value,
-          );
-        }
-      }
-
-      if (type === "datetimelocal") {
-        if (isNullOrUndefined(value)) {
-          return "";
-        }
-
-        if (!DATETIMELOCAL_REGEXP.test(value)) {
-          throw ngModelMinErr(
-            "datefmt",
-            "Expected week `{0}` to be a in date time format. See: https://developer.mozilla.org/en-US/docs/Web/HTML/Date_and_time_formats#local_date_and_time_strings",
-            value,
-          );
-        }
+      if (!isString(value)) {
+        throw ngModelMinErr("datefmt", "Expected `{0}` to be a string", value);
       }
 
       return value;
-
-      // if (isValidDate(value)) {
-      //   previousDate = value;
-      //   const timezone = ctrl.$options.getOption("timezone");
-
-      //   if (timezone) {
-      //     previousTimezone = timezone;
-      //     previousDate = convertTimezoneToLocal(previousDate, timezone, true);
-      //   }
-
-      //   return value;
-      // }
-      // previousDate = null;
-      // previousTimezone = null;
-      // return "";
     });
 
+    // Optional min/max
     if (isDefined(attr.min) || attr.ngMin) {
-      let minVal = attr.min || $parse(attr.ngMin)(scope);
+      let minVal = attr.min || $parse?.(attr.ngMin)(scope);
 
-      let parsedMinVal = parseObservedDateValue(deProxy(minVal));
-
-      ctrl.$validators.min = function (value) {
-        if (type === "month") {
-          return (
-            isUndefined(parsedMinVal) ||
-            parseDate(value) >= parseDate(parsedMinVal)
-          );
-        }
-
-        return (
-          !isValidDate(value) ||
-          isUndefined(parsedMinVal) ||
-          parseDate(value) >= parsedMinVal
-        );
-      };
+      ctrl.$validators.min = (_modelValue, viewValue) =>
+        ctrl.$isEmpty(viewValue) || viewValue >= minVal;
       attr.$observe("min", (val) => {
-        if (val !== minVal) {
-          parsedMinVal = parseObservedDateValue(val);
-          minVal = val;
-          ctrl.$validate();
-        }
+        minVal = val;
+        ctrl.$validate();
       });
     }
 
     if (isDefined(attr.max) || attr.ngMax) {
-      let maxVal = attr.max || $parse(attr.ngMax)(scope);
-
-      let parsedMaxVal = parseObservedDateValue(deProxy(maxVal));
-
-      ctrl.$validators.max = function (value) {
-        if (type === "month") {
-          return (
-            isUndefined(parsedMaxVal) ||
-            parseDate(value) <= parseDate(parsedMaxVal)
-          );
-        }
+      let maxVal = attr.max || $parse?.(attr.ngMax)(scope);
 
-        return (
-          !isValidDate(value) ||
-          isUndefined(parsedMaxVal) ||
-          parseDate(value) <= parsedMaxVal
-        );
-      };
+      ctrl.$validators.max = (_modelValue, viewValue) =>
+        ctrl.$isEmpty(viewValue) || viewValue <= maxVal;
       attr.$observe("max", (val) => {
-        if (val !== maxVal) {
-          parsedMaxVal = parseObservedDateValue(val);
-          maxVal = val;
-          ctrl.$validate();
-        }
+        maxVal = val;
+        ctrl.$validate();
       });
     }
-
-    function isValidDate(value) {
-      // Invalid Date: getTime() returns NaN
-      return value && !(value.getTime && Number.isNaN(value.getTime()));
-    }
-
-    function parseObservedDateValue(val) {
-      return isDefined(val) && !isDate(val)
-        ? parseDateAndConvertTimeZoneToLocal(val) || undefined
-        : val;
-    }
-
-    function parseDateAndConvertTimeZoneToLocal(value, previousDateParam) {
-      const timezone = ctrl.$options.getOption("timezone");
-
-      let parsedDate = parseDate(value, previousDateParam);
-
-      if (!Number.isNaN(parsedDate) && timezone) {
-        parsedDate = convertTimezoneToLocal(parsedDate, timezone);
-      }
-
-      return parsedDate;
-    }
   };
 }
 
@@ -13567,7 +13269,7 @@ function isValidForStep(viewValue, stepBase, step) {
   return (value - stepBase) % step === 0;
 }
 
-function numberInputType(scope, element, attr, ctrl, $filter, $parse) {
+function numberInputType(scope, element, attr, ctrl, $parse) {
   badInputChecker(scope, element, attr, ctrl, "number");
   numberFormatterParser(ctrl);
   baseInputType(scope, element, attr, ctrl);
@@ -13906,7 +13608,7 @@ function parseConstantExpr($parse, context, name, expression, fallback) {
   return fallback;
 }
 
-function checkboxInputType(scope, element, attr, ctrl, $filter, $parse) {
+function checkboxInputType(scope, element, attr, ctrl, $parse) {
   const trueValue = parseConstantExpr(
     $parse,
     scope,
@@ -13945,14 +13647,13 @@ function checkboxInputType(scope, element, attr, ctrl, $filter, $parse) {
   ctrl.$parsers.push((value) => (value ? trueValue : falseValue));
 }
 
-inputDirective.$inject = [$injectTokens._filter, $injectTokens._parse];
+inputDirective.$inject = [$injectTokens._parse];
 
 /**
- * @param {ng.FilterFactory} $filter
  * @param {ng.ParseService} $parse
  * @returns {ng.Directive}
  */
-function inputDirective($filter, $parse) {
+function inputDirective($parse) {
   return {
     restrict: "E",
     require: ["?ngModel"],
@@ -13964,7 +13665,6 @@ function inputDirective($filter, $parse) {
             element,
             attr,
             ctrls[0],
-            $filter,
             $parse,
           );
         }
@@ -13976,47 +13676,18 @@ function inputDirective($filter, $parse) {
 /**
  * @returns {ng.Directive}
  */
-function hiddenInputBrowserCacheDirective() {
-  const valueProperty = {
-    configurable: true,
-    enumerable: false,
-    get() {
-      return this.getAttribute("value") || "";
-    },
-    set(val) {
-      this.setAttribute("value", val);
-    },
-  };
-
+function hiddenInputDirective() {
   return {
     restrict: "E",
-    priority: 200,
     compile(_, attr) {
-      if (attr.type?.toLowerCase() !== "hidden") {
-        return undefined;
-      }
+      if (attr.type?.toLowerCase() !== "hidden") return undefined;
 
-      const res = {
+      return {
         pre(_scope, element) {
-          const node = element;
-
-          // Support: Edge
-          // Moving the DOM around prevents autofillling
-          if (node.parentNode) {
-            node.parentNode.insertBefore(node, node.nextSibling);
-          }
-
-          // Support: FF, IE
-          // Avoiding direct assignment to .value prevents autofillling
-          if (Object.defineProperty) {
-            Object.defineProperty(node, "value", valueProperty);
-          }
-
-          return undefined;
+          /** @type {HTMLInputElement} */ (element).value =
+            element.getAttribute("value") ?? "";
         },
       };
-
-      return res;
     },
   };
 }
@@ -14059,40 +13730,6 @@ function ngValueDirective() {
   };
 }
 
-/**
- * @param {Date} date
- * @param {any} timezone
- * @param {undefined} [reverse]
- */
-function convertTimezoneToLocal(date, timezone, reverse) {
-  const doReverse = 1;
-
-  const dateTimezoneOffset = date.getTimezoneOffset();
-
-  const timezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
-
-  return addDateMinutes(
-    date,
-    doReverse * (timezoneOffset - dateTimezoneOffset),
-  );
-}
-
-const MS_PER_MINUTE = 60_000; // 60,000 ms in a minute
-
-/**
- * @param {any} timezone
- * @param {number} [fallback]
- * @returns {number}
- */
-function timezoneToOffset(timezone, fallback) {
-  const requestedTimezoneOffset =
-    Date.parse(`Jan 01, 1970 00:00:00 ${timezone}`) / MS_PER_MINUTE;
-
-  return isNumberNaN(requestedTimezoneOffset)
-    ? (fallback ?? 0)
-    : requestedTimezoneOffset;
-}
-
 scriptDirective.$inject = [$injectTokens._templateCache];
 
 /**
@@ -15067,6 +14704,7 @@ function ngShowDirective($animate) {
 
 ngHideDirective.$inject = [$injectTokens._animate];
 /**
+ * @param {ng.AnimateService} $animate
  * @returns {ng.Directive}
  */
 function ngHideDirective($animate) {
@@ -15264,9 +14902,9 @@ function ngIncludeDirective(
           if (src) {
             // set the 2nd param to true to ignore the template request error so that the inner
             // contents and scope can be cleaned up.
-            await $templateRequest(src, true).then(
+            await $templateRequest(src).then(
               (response) => {
-                if (scope.$$destroyed) return;
+                if (scope._destroyed) return;
 
                 if (thisChangeId !== changeCounter) return;
                 const newScope = scope.$new();
@@ -15298,7 +14936,7 @@ function ngIncludeDirective(
                 scope.$eval(onloadExp);
               },
               (err) => {
-                if (scope.$$destroyed) return;
+                if (scope._destroyed) return;
 
                 if (thisChangeId === changeCounter) {
                   cleanupLastIncludeContent();
@@ -22436,7 +22074,7 @@ class RootScopeProvider {
  *
  * @param {Object} target - The object to be wrapped in a proxy.
  * @param {Scope} [context] - The context for the handler, used to track listeners.
- * @returns {Scope} - A proxy that intercepts operations on the target object,
+ * @returns {Scope|Object} - A proxy that intercepts operations on the target object,
  *                                     or the original value if the target is not an object.
  */
 function createScope(target = {}, context) {
@@ -22492,7 +22130,8 @@ function isNonScope(target) {
     target instanceof Promise ||
     target instanceof HTMLCollection ||
     target instanceof NodeList ||
-    target instanceof Event
+    target instanceof Event ||
+    target instanceof Date
   ) {
     return true;
   }
@@ -22527,20 +22166,17 @@ class Scope {
     /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners */
     this.watchers = context ? context.watchers : new Map();
 
-    /** @type {Map<String, Function[]>} Event listeners */
-    this.$$listeners = new Map();
-
-    /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
-    this.foreignListeners = context ? context.foreignListeners : new Map();
+    /** @private @type {Map<String, Function[]>} Event listeners */
+    this._listeners = new Map();
 
-    /** @type {Set<Proxy<ng.Scope>>} */
-    this.foreignProxies = context ? context.foreignProxies : new Set();
+    /** @private @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
+    this._foreignListeners = context ? context._foreignListeners : new Map();
 
-    /** @type {WeakMap<Object, Array<string>>} */
-    this.objectListeners = context ? context.objectListeners : new WeakMap();
+    /** @private @type {Set<Proxy<ng.Scope>>} */
+    this._foreignProxies = context ? context._foreignProxies : new Set();
 
-    /** @type {Map<Function, {oldValue: any, fn: Function}>} */
-    this.functionListeners = context ? context.functionListeners : new Map();
+    /** @private @type {WeakMap<Object, Array<string>>} */
+    this._objectListeners = context ? context._objectListeners : new WeakMap();
 
     /** @type {Proxy<Scope>} Current proxy being operated on */
     this.$proxy = null;
@@ -22575,40 +22211,39 @@ class Scope {
         ? null
         : context;
 
-    this.filters = [];
-
-    /** @type {boolean} */
-    this.$$destroyed = false;
+    /** @ignore @type {boolean} */
+    this._destroyed = false;
 
-    this.scheduled = [];
+    /** @private @type {import("./interface.ts").Listener[]} A list of scheduled Event listeners */
+    this._scheduled = [];
 
     this.$scopename = undefined;
 
     /** @private */
     this.propertyMap = {
-      $watch: this.$watch.bind(this),
-      $new: this.$new.bind(this),
-      $newIsolate: this.$newIsolate.bind(this),
-      $destroy: this.$destroy.bind(this),
-      $flushQueue: this.$flushQueue.bind(this),
-      $eval: this.$eval.bind(this),
       $apply: this.$apply.bind(this),
-      $postUpdate: this.$postUpdate.bind(this),
-      $isRoot: this.#isRoot.bind(this),
-      $on: this.$on.bind(this),
-      $emit: this.$emit.bind(this),
       $broadcast: this.$broadcast.bind(this),
-      $transcluded: this.$transcluded.bind(this),
+      $children: this.$children,
+      $destroy: this.$destroy.bind(this),
+      $emit: this.$emit.bind(this),
+      $eval: this.$eval.bind(this),
+      $flushQueue: this.$flushQueue.bind(this),
+      $getById: this.$getById.bind(this),
       $handler: /** @type {Scope} */ (this),
+      $id: this.$id,
+      $isRoot: this.#isRoot.bind(this),
       $merge: this.$merge.bind(this),
-      $getById: this.$getById.bind(this),
-      $searchByName: this.$searchByName.bind(this),
-      $proxy: this.$proxy,
+      $new: this.$new.bind(this),
+      $newIsolate: this.$newIsolate.bind(this),
+      $on: this.$on.bind(this),
       $parent: this.$parent,
+      $postUpdate: this.$postUpdate.bind(this),
+      $proxy: this.$proxy,
       $root: this.$root,
-      $children: this.$children,
-      $id: this.$id,
       $scopename: this.$scopename,
+      $searchByName: this.$searchByName.bind(this),
+      $transcluded: this.$transcluded.bind(this),
+      $watch: this.$watch.bind(this),
     };
   }
 
@@ -22668,18 +22303,18 @@ class Scope {
             this.#scheduleListener(listeners);
           }
 
-          const foreignListeners = this.foreignListeners.get(property);
+          const _foreignListeners = this._foreignListeners.get(property);
 
-          if (foreignListeners) {
-            this.#scheduleListener(foreignListeners);
+          if (_foreignListeners) {
+            this.#scheduleListener(_foreignListeners);
           }
         }
 
-        if (this.objectListeners.get(target[property])) {
-          this.objectListeners.delete(target[property]);
+        if (this._objectListeners.get(target[property])) {
+          this._objectListeners.delete(target[property]);
         }
         target[property] = createScope(value, this);
-        this.objectListeners.set(target[property], [property]);
+        this._objectListeners.set(target[property], [property]);
 
         return true;
       }
@@ -22700,10 +22335,10 @@ class Scope {
             this.#scheduleListener(listeners);
           }
 
-          const foreignListeners = this.foreignListeners.get(property);
+          const _foreignListeners = this._foreignListeners.get(property);
 
-          if (foreignListeners) {
-            this.#scheduleListener(foreignListeners);
+          if (_foreignListeners) {
+            this.#scheduleListener(_foreignListeners);
           }
 
           this.#checkeListenersForAllKeys(value);
@@ -22756,8 +22391,8 @@ class Scope {
         }
 
         if (isArray(target)) {
-          if (this.objectListeners.has(proxy) && property !== "length") {
-            const keyList = this.objectListeners.get(proxy);
+          if (this._objectListeners.has(proxy) && property !== "length") {
+            const keyList = this._objectListeners.get(proxy);
 
             for (let i = 0, l = keyList.length; i < l; i++) {
               const currentListeners = this.watchers.get(keyList[i]);
@@ -22773,7 +22408,7 @@ class Scope {
       return true;
     } else {
       if (isUndefined(target[property]) && isProxy(value)) {
-        this.foreignProxies.add(/** @type {Proxy<ng.Scope>} */ (value));
+        this._foreignProxies.add(/** @type {Proxy<ng.Scope>} */ (value));
         target[property] = value;
 
         if (!this.watchers.has(property)) {
@@ -22794,8 +22429,8 @@ class Scope {
 
         // Handle the case where we need to start observing object after a watcher has been set
         if (isUndefined(oldValue) && isObject(target[property])) {
-          if (!this.objectListeners.has(target[property])) {
-            this.objectListeners.set(target[property], [property]);
+          if (!this._objectListeners.has(target[property])) {
+            this._objectListeners.set(target[property], [property]);
           }
           const keyList = keys(value);
 
@@ -22858,14 +22493,14 @@ class Scope {
           });
         }
 
-        let foreignListeners = this.foreignListeners.get(property);
+        let _foreignListeners = this._foreignListeners.get(property);
 
-        if (!foreignListeners && this.$parent?.foreignListeners) {
-          foreignListeners = this.$parent.foreignListeners.get(property);
+        if (!_foreignListeners && this.$parent?._foreignListeners) {
+          _foreignListeners = this.$parent._foreignListeners.get(property);
         }
 
-        if (foreignListeners) {
-          let scheduled = foreignListeners;
+        if (_foreignListeners) {
+          let scheduled = _foreignListeners;
 
           // filter for repeaters
           const hashKey = this.$target._hashKey;
@@ -22873,8 +22508,8 @@ class Scope {
           if (hashKey) {
             scheduled = [];
 
-            for (let i = 0, l = foreignListeners.length; i < l; i++) {
-              const listener = foreignListeners[i];
+            for (let i = 0, l = _foreignListeners.length; i < l; i++) {
+              const listener = _foreignListeners[i];
 
               if (listener.originalTarget._hashKey === hashKey) {
                 scheduled.push(listener);
@@ -22888,15 +22523,15 @@ class Scope {
         }
       }
 
-      if (this.objectListeners.has(proxy) && property !== "length") {
-        const keyList = this.objectListeners.get(proxy);
+      if (this._objectListeners.has(proxy) && property !== "length") {
+        const keyList = this._objectListeners.get(proxy);
 
         for (let i = 0, l = keyList.length; i < l; i++) {
           const key = keyList[i];
 
           const listeners = this.watchers.get(key);
 
-          if (listeners && this.scheduled !== listeners) {
+          if (listeners && this._scheduled !== listeners) {
             this.#scheduleListener(listeners);
           }
         }
@@ -22936,8 +22571,8 @@ class Scope {
       isArray(target) &&
       ["pop", "shift", "unshift"].includes(/** @type { string } */ (property))
     ) {
-      if (this.objectListeners.has(proxy)) {
-        const keyList = this.objectListeners.get(proxy);
+      if (this._objectListeners.has(proxy)) {
+        const keyList = this._objectListeners.get(proxy);
 
         for (let i = 0, l = keyList.length; i < l; i++) {
           const key = keyList[i];
@@ -22945,13 +22580,13 @@ class Scope {
           const listeners = this.watchers.get(key);
 
           if (listeners) {
-            this.scheduled = listeners;
+            this._scheduled = listeners;
           }
         }
       }
 
       if (property === "unshift") {
-        this.#scheduleListener(this.scheduled);
+        this.#scheduleListener(this._scheduled);
       }
     }
 
@@ -22976,8 +22611,8 @@ class Scope {
         this.#scheduleListener(listeners);
       }
 
-      if (this.objectListeners.has(this.$proxy)) {
-        const keyList = this.objectListeners.get(this.$proxy);
+      if (this._objectListeners.has(this.$proxy)) {
+        const keyList = this._objectListeners.get(this.$proxy);
 
         for (let i = 0, l = keyList.length; i < l; i++) {
           const key = keyList[i];
@@ -22988,9 +22623,9 @@ class Scope {
         }
       }
 
-      if (this.scheduled) {
-        this.#scheduleListener(this.scheduled);
-        this.scheduled = [];
+      if (this._scheduled) {
+        this.#scheduleListener(this._scheduled);
+        this._scheduled = [];
       }
 
       return true;
@@ -22998,8 +22633,8 @@ class Scope {
 
     delete target[property];
 
-    if (this.objectListeners.has(this.$proxy)) {
-      const keyList = this.objectListeners.get(this.$proxy);
+    if (this._objectListeners.has(this.$proxy)) {
+      const keyList = this._objectListeners.get(this.$proxy);
 
       for (let i = 0, l = keyList.length; i < l; i++) {
         const key = keyList[i];
@@ -23241,7 +22876,7 @@ class Scope {
             watchProp.split(".").slice(0, -1).join("."),
           )(/** @type {Scope} */ (listener.originalTarget));
 
-          if (potentialProxy && this.foreignProxies.has(potentialProxy)) {
+          if (potentialProxy && this._foreignProxies.has(potentialProxy)) {
             potentialProxy.$handler.#registerForeignKey(key, listener);
             potentialProxy.$handler.#scheduleListener([listener]);
 
@@ -23324,7 +22959,7 @@ class Scope {
     const listenerObject = listener.watchFn(this.$target);
 
     if (isObject(listenerObject)) {
-      this.objectListeners.set(listenerObject, [key]);
+      this._objectListeners.set(listenerObject, [key]);
     }
 
     if (keySet.length > 0) {
@@ -23418,10 +23053,10 @@ class Scope {
 
   /** @internal **/
   #registerForeignKey(key, listener) {
-    if (this.foreignListeners.has(key)) {
-      this.foreignListeners.get(key).push(listener);
+    if (this._foreignListeners.has(key)) {
+      this._foreignListeners.get(key).push(listener);
     } else {
-      this.foreignListeners.set(key, [listener]);
+      this._foreignListeners.set(key, [listener]);
     }
   }
 
@@ -23446,7 +23081,7 @@ class Scope {
   }
 
   // #deregisterForeignKey(key, id) {
-  //   const listenerList = this.foreignListeners.get(key);
+  //   const listenerList = this._foreignListeners.get(key);
   //   if (!listenerList) return false;
 
   //   const index = listenerList.findIndex((x) => x.id === id);
@@ -23454,9 +23089,9 @@ class Scope {
 
   //   listenerList.splice(index, 1);
   //   if (listenerList.length) {
-  //     this.foreignListeners.set(key, listenerList);
+  //     this._foreignListeners.set(key, listenerList);
   //   } else {
-  //     this.foreignListeners.delete(key);
+  //     this._foreignListeners.delete(key);
   //   }
   //   return true;
   // }
@@ -23516,11 +23151,11 @@ class Scope {
    * @returns {(function(): void)|*}
    */
   $on(name, listener) {
-    let namedListeners = this.$$listeners.get(name);
+    let namedListeners = this._listeners.get(name);
 
     if (!namedListeners) {
       namedListeners = [];
-      this.$$listeners.set(name, namedListeners);
+      this._listeners.set(name, namedListeners);
     }
     namedListeners.push(listener);
 
@@ -23531,7 +23166,7 @@ class Scope {
         namedListeners.splice(indexOfListener, 1);
 
         if (namedListeners.length === 0) {
-          this.$$listeners.delete(name);
+          this._listeners.delete(name);
         }
       }
     };
@@ -23567,7 +23202,7 @@ class Scope {
    */
   #eventHelper({ name, event, broadcast }, ...args) {
     if (!broadcast) {
-      if (!this.$$listeners.has(name)) {
+      if (!this._listeners.has(name)) {
         if (this.$parent) {
           return this.$parent.$handler.#eventHelper(
             { name, event, broadcast },
@@ -23599,7 +23234,7 @@ class Scope {
 
     const listenerArgs = concat([event], [event].concat(args), 1);
 
-    const listeners = this.$$listeners.get(name);
+    const listeners = this._listeners.get(name);
 
     if (listeners) {
       let { length } = listeners;
@@ -23666,7 +23301,7 @@ class Scope {
   }
 
   $destroy() {
-    if (this.$$destroyed) return;
+    if (this._destroyed) return;
 
     this.$broadcast("$destroy");
 
@@ -23697,8 +23332,8 @@ class Scope {
       }
     }
 
-    this.$$listeners.clear();
-    this.$$destroyed = true;
+    this._listeners.clear();
+    this._destroyed = true;
   }
 
   /**
@@ -23780,31 +23415,23 @@ class Scope {
    * @returns {ng.Scope|undefined}
    */
   $searchByName(name) {
-    /**
-     * @param {ng.Scope} scope
-     * @param {string} nameParam
-     * @returns {ng.Scope|undefined}
-     */
-    function getByName(scope, nameParam) {
-      if (scope.$scopename === nameParam) {
-        return scope;
-      } else {
-        let res = undefined;
+    const stack = [this.$root];
 
-        for (const child of scope.$children) {
-          const found = getByName(child, nameParam);
+    while (stack.length) {
+      const scope = stack.pop();
 
-          if (found) {
-            res = found;
-            break;
-          }
-        }
+      if (scope.$scopename === name) {
+        return scope;
+      }
 
-        return res;
+      if (scope.$children?.length) {
+        for (let i = scope.$children.length - 1; i >= 0; i--) {
+          stack.push(scope.$children[i]);
+        }
       }
     }
 
-    return getByName(this.$root, name);
+    return undefined;
   }
 }
 
@@ -23856,146 +23483,65 @@ function collectChildIds(child) {
   return ids;
 }
 
-const $templateRequestMinErr = minErr("$templateRequest");
-
 /**
- * Used to configure the options passed to the {@link $http} service when making a template request.
+ * Provider for the `$templateRequest` service.
  *
- * For example, it can be used for specifying the "Accept" header that is sent to the server, when
- * requesting a template.
+ * Fetches templates via HTTP and caches them in `$templateCache`.
+ * Templates are assumed trusted. This provider allows configuring
+ * per-request `$http` options such as headers, timeout, or transform functions.
  */
-function TemplateRequestProvider() {
-  let httpOptions;
-
-  /**
-   * The options to be passed to the {@link $http} service when making the request.
-   * You can use this to override options such as the "Accept" header for template requests.
-   * The {@link $templateRequest} will set the `cache` and the `transformResponse` properties of the
-   * options if not overridden here.
-   *
-   * @param {string=} val new value for the {@link $http} options.
-   * @returns {string|TemplateRequestProvider} Returns the {@link $http} options when used as getter and self if used as setter.
-   */
-  this.httpOptions = function (val) {
-    if (val) {
-      httpOptions = val;
+class TemplateRequestProvider {
+  /** @type {ng.RequestShortcutConfig|undefined} */
+  httpOptions;
 
-      return this;
-    }
-
-    return httpOptions;
-  };
-
-  /**
-   * The `$templateRequest` service runs security checks then downloads the provided template using
-   * `$http` and, upon success, stores the contents inside of `$templateCache`. If the HTTP request
-   * fails or the response data of the HTTP request is empty, a `$compile` error will be thrown (the
-   * exception can be thwarted by setting the 2nd parameter of the function to true). Note that the
-   * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted
-   * when `tpl` is of type string and `$templateCache` has the matching entry.
-   *
-   * If you want to pass custom options to the `$http` service, such as setting the Accept header you
-   * can configure this via {@link $templateRequestProvider#httpOptions}.
-   *
-   * `$templateRequest` is used internally by {@link $compile}, {@link ngRoute.$route}, and directives such
-   * as {@link ngInclude} to download and cache templates.
-   *
-   * 3rd party modules should use `$templateRequest` if their services or directives are loading
-   * templates.
-   *
-   * @param {string} tpl The HTTP request template URL
-   * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
-   *
-   * @return {Promise} a promise for the HTTP response data of the given URL.
-   *
-   * @property {number} totalPendingRequests total amount of pending template requests being downloaded.
-   */
-  this.$get = [
-    $injectTokens._exceptionHandler,
+  /** @returns {Array} DI tokens for Angular.ts injection */
+  $get = [
     $injectTokens._templateCache,
     $injectTokens._http,
-    $injectTokens._sce,
     /**
-     *
-     * @param {ng.ExceptionHandlerService} $exceptionHandler
      * @param {ng.TemplateCacheService} $templateCache
      * @param {ng.HttpService} $http
-     * @param {*} $sce
      * @returns {ng.TemplateRequestService}
      */
-    function ($exceptionHandler, $templateCache, $http, $sce) {
-      function handleRequestFn(tpl, ignoreRequestError) {
-        handleRequestFn.totalPendingRequests++;
-
-        // We consider the template cache holds only trusted templates, so
-        // there's no need to go through adding the template again to the trusted
-        // resources for keys that already are included in there. This also makes
-        // AngularTS accept any script directive, no matter its name. However, we
-        // still need to unwrap trusted types.
-
-        if (!isString(tpl) || !$templateCache.has(tpl)) {
-          try {
-            tpl = $sce.getTrustedResourceUrl(tpl);
-
-            if (!tpl) {
-              return Promise.reject("Template not found");
-            }
-          } catch (err) {
-            return Promise.reject(err.message);
-          }
-        }
-
-        let transformResponse =
-          $http.defaults && $http.defaults.transformResponse;
+    ($templateCache, $http) => {
+      /**
+       * Fetch a template via HTTP and cache it.
+       *
+       * @param {string} templateUrl URL of the template
+       * @returns {Promise<string>} Resolves with template content
+       */
+      const fetchTemplate = (templateUrl) => {
+        // Filter out default transformResponse for template requests
+        let transformResponse = $http.defaults?.transformResponse ?? null;
 
         if (isArray(transformResponse)) {
-          transformResponse = transformResponse.filter(function (transformer) {
-            return transformer !== defaultHttpResponseTransform;
-          });
+          transformResponse = transformResponse.filter(
+            (x) => x !== defaultHttpResponseTransform,
+          );
         } else if (transformResponse === defaultHttpResponseTransform) {
           transformResponse = null;
         }
 
-        return $http
-          .get(
-            tpl,
-            extend(
-              {
-                cache: $templateCache,
-                transformResponse,
-              },
-              httpOptions,
-            ),
-          )
-          .finally(function () {
-            handleRequestFn.totalPendingRequests--;
-          })
-          .then(function (response) {
-            $templateCache.set(tpl, response.data);
-
-            return response.data;
-          }, handleError);
-
-        function handleError(resp) {
-          if (!ignoreRequestError) {
-            resp = $templateRequestMinErr(
-              "tpload",
-              "Failed to load template: {0} (HTTP status: {1} {2})",
-              tpl,
-              resp.status,
-              resp.statusText,
-            );
-
-            $exceptionHandler(resp);
-          }
+        /** @type {ng.RequestShortcutConfig} */
+        const config = extend(
+          {
+            cache: $templateCache,
+            transformResponse,
+          },
+          this.httpOptions || {},
+        );
 
-          return Promise.reject(resp);
-        }
-      }
+        return $http.get(templateUrl, config).then(
+          (response) => {
+            $templateCache.set(templateUrl, response.data);
 
-      handleRequestFn.totalPendingRequests = 0;
+            return response.data;
+          },
+          (resp) => Promise.reject(resp),
+        );
+      };
 
-      return handleRequestFn;
+      return fetchTemplate;
     },
   ];
 }
@@ -24335,7 +23881,7 @@ function ngMessagesIncludeDirective($templateRequest, $compile) {
       const src = attrs.ngMessagesInclude || attrs.src;
 
       $templateRequest(src).then((html) => {
-        if ($scope.$$destroyed) return;
+        if ($scope._destroyed) return;
 
         if (isString(html) && !html.trim()) ; else {
           // Non-empty template - compile and link
@@ -38813,6 +38359,7 @@ ngChannelDirective.$inject = [$injectTokens._eventBus];
  */
 function ngChannelDirective($eventBus) {
   return {
+    scope: false,
     link: (scope, element, attrs) => {
       const channel = attrs.ngChannel;
 
@@ -38827,6 +38374,8 @@ function ngChannelDirective($eventBus) {
             }
           } else if (isString(value)) {
             element.innerHTML = value;
+          } else {
+            element.innerHTML = value.toString();
           }
         },
       );
@@ -40361,7 +39910,7 @@ function registerNgModule(angular) {
               ngScope: ngScopeDirective,
             })
             .directive({
-              input: hiddenInputBrowserCacheDirective,
+              input: hiddenInputDirective,
               ngAnimateSwap: ngAnimateSwapDirective,
               ngAnimateChildren: $$AnimateChildrenDirective,
               // aria directives
@@ -40454,9 +40003,12 @@ const STRICT_DI = "strict-di";
 const moduleRegistry = {};
 
 class Angular extends EventTarget {
-  constructor() {
+  constructor(submodule = false) {
     super();
 
+    /** @private @type {boolean} */
+    this._submodule = submodule;
+
     /** @private @type {!Array<string|any>} */
     this._bootsrappedModules = [];
 
@@ -40470,7 +40022,7 @@ class Angular extends EventTarget {
      * @public
      * @type {string} `version` from `package.json`
      */
-    this.version = "0.15.1"; //inserted via rollup plugin
+    this.version = "0.15.2"; //inserted via rollup plugin
 
     /**
      * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
@@ -40500,7 +40052,9 @@ class Angular extends EventTarget {
       /** @type {any} */ (this.$t)[i] = i;
     });
 
-    window.angular = this;
+    if (!submodule) {
+      window.angular = this;
+    }
     registerNgModule(this);
   }