@angular-wave/angular.ts 0.12.0 → 0.13.0

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.12.0 - November 29, 2025 19:42:35 */
+/* Version: 0.13.0 - December 2, 2025 01:18:46 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -22,6 +22,9 @@ const ALIASED_ATTR = {
 };
 
 const isProxySymbol = Symbol("isProxy");
+const BADARG = "badarg";
+const BADARGKEY = "badarg: key";
+const BADARGVALUE = "badarg: value";
 
 /**
  *
@@ -1754,7 +1757,7 @@ function elementAcceptsData(node) {
  * @returns {void}
  */
 function dealoc(element, onlyDescendants) {
-  if (!element) return;
+  if (!element || element instanceof Comment) return;
   if (Array.isArray(element)) {
     element.forEach((x) => dealoc(x, onlyDescendants));
   } else {
@@ -1893,7 +1896,7 @@ function getScope(element) {
  * Set scope for a given element.
  *
  * @param {Element|Node|ChildNode} element - The DOM element to set data on.
- * @param {import("../core/scope/scope.js").Scope} scope - The Scope attached to this element
+ * @param {ng.Scope} scope - The Scope attached to this element
  */
 function setScope(element, scope) {
   return setCacheData(element, SCOPE_KEY, scope);
@@ -1903,7 +1906,7 @@ function setScope(element, scope) {
  * Set isolate scope for a given element.
  *
  * @param {Element} element - The DOM element to set data on.
- * @param {import("../core/scope/scope.js").Scope} scope - The Scope attached to this element
+ * @param {ng.Scope} scope - The Scope attached to this element
  */
 function setIsolateScope(element, scope) {
   return setCacheData(element, ISOLATE_SCOPE_KEY, scope);
@@ -1914,7 +1917,7 @@ function setIsolateScope(element, scope) {
  *
  * @param {Element} element - The DOM element to get data from.
  * @param {string} [name] - Controller name.
- * @returns {import("../core/scope/scope.js").Scope|undefined} - The retrieved data
+ * @returns {ng.Scope|undefined} - The retrieved data
  */
 function getController(element, name) {
   return getInheritedData(element, `$${name || "ngController"}Controller`);
@@ -2203,6 +2206,7 @@ const $injectTokens = Object.freeze({
   $animateCss: "$animateCss",
   $aria: "$aria",
   $compile: "$compile",
+  $cookie: "$cookie",
   $controller: "$controller",
   $document: "$document",
   $eventBus: "$eventBus",
@@ -2215,6 +2219,7 @@ const $injectTokens = Object.freeze({
   $log: "$log",
   $viewScroll: "$viewScroll",
   $parse: "$parse",
+  $rest: "$rest",
   $rootScope: "$rootScope",
   $rootElement: "$rootElement",
   $router: "$router",
@@ -3011,6 +3016,8 @@ class NgModule {
     this.services = [];
 
     this.wasmModules = [];
+
+    this.restDefinitions = [];
   }
 
   /**
@@ -3260,31 +3267,50 @@ class NgModule {
   /**
    * @param {string} name
    * @param {Function} ctor
+   * @param {ng.StorageType} type
+   * @param {ng.StorageBackend} [backendOrConfig]
    * @returns {NgModule}
    */
-  local(name, ctor) {
+  store(name, ctor, type, backendOrConfig) {
     if (ctor && isFunction(ctor)) {
       ctor["$$moduleName"] = name;
     }
-    this.invokeQueue.push([$injectTokens.$provide, "local", [name, ctor]]);
+    this.invokeQueue.push([
+      $injectTokens.$provide,
+      "store",
+      [name, ctor, type, backendOrConfig],
+    ]);
     return this;
   }
 
   /**
-   * @param {string} name
-   * @param {Function} ctor
-   * @param {ng.StorageBackend} backendOrConfig
+   * @template T, ID
+   * Register a REST resource during module configuration.
+   * @param {string} name - Service name
+   * @param {string} url - Base URL or URI template
+   * @param {ng.EntityClass<T>} entityClass - Optional constructor for mapping JSON
+   * @param {Object=} options - Optional RestService options (interceptors, etc)
    * @returns {NgModule}
    */
-  store(name, ctor, backendOrConfig) {
-    if (ctor && isFunction(ctor)) {
-      ctor["$$moduleName"] = name;
-    }
+  rest(name, url, entityClass, options = {}) {
+    const def = { name, url, entityClass, options };
+    this.restDefinitions.push(def);
+
+    // push provider/factory to invokeQueue
     this.invokeQueue.push([
       $injectTokens.$provide,
-      "store",
-      [name, ctor, backendOrConfig],
+      "factory",
+      [
+        name,
+        [
+          $injectTokens.$rest,
+          /** @param {(baseUrl:string, entityClass?:Function, options?:object) => ng.RestService<T, ID>} $rest */ (
+            $rest,
+          ) => $rest(url, entityClass, options),
+        ],
+      ],
     ]);
+
     return this;
   }
 }
@@ -3607,8 +3633,8 @@ function createPersistentProxy(target, key, storage, options = {}) {
       obj[prop] = value;
       try {
         storage.setItem(key, serialize(obj));
-      } catch {
-        console.warn(`Failed to persist data for key "${key}"`);
+      } catch (e) {
+        console.warn(`Failed to persist data for key "${e}"`);
       }
       return true;
     },
@@ -3646,9 +3672,7 @@ function createInjector(modulesToLoad, strictDi = false) {
       service: supportObject(service),
       value: supportObject(value),
       constant: supportObject(constant),
-      session: supportObject(session),
-      local: supportObject(local),
-      store: supportObject(store),
+      store,
       decorator,
     },
   };
@@ -3783,66 +3807,80 @@ function createInjector(modulesToLoad, strictDi = false) {
   }
 
   /**
-   * Registers a session-persistent service
-   */
-  function session(name, ctor) {
-    return provider(name, {
-      $get: ($injector) => {
-        const instance = $injector.instantiate(ctor);
-        return createPersistentProxy(instance, name, sessionStorage);
-      },
-    });
-  }
-
-  /**
-   * Registers a localStorage-persistent service
-   */
-  function local(name, ctor) {
-    return provider(name, {
-      $get: ($injector) => {
-        const instance = $injector.instantiate(ctor);
-        return createPersistentProxy(instance, name, localStorage);
-      },
-    });
-  }
-
-  /**
-   * Registers a service persisted in a custom storage
+   * Registers a service persisted in a storage
    *
    * @param {string} name - Service name
    * @param {Function} ctor - Constructor for the service
+   * @param {ng.StorageType} type - Type of storage to be instantiated
    * @param {Storage|Object} backendOrConfig - Either a Storage-like object (getItem/setItem) or a config object
    *                                           with { backend, serialize, deserialize }
    */
-  function store(name, ctor, backendOrConfig) {
+  function store(name, ctor, type, backendOrConfig = {}) {
     return provider(name, {
-      $get: ($injector) => {
-        const instance = $injector.instantiate(ctor);
-
-        let backend;
-        let serialize = JSON.stringify;
-        let deserialize = JSON.parse;
-
-        if (backendOrConfig) {
-          if (typeof backendOrConfig.getItem === "function") {
-            // raw Storage object
-            backend = backendOrConfig;
-          } else if (isObject(backendOrConfig)) {
-            backend = backendOrConfig.backend || localStorage;
-            if (backendOrConfig.serialize)
-              serialize = backendOrConfig.serialize;
-            if (backendOrConfig.deserialize)
-              deserialize = backendOrConfig.deserialize;
+      $get: /** @param {ng.InjectorService} $injector */ ($injector) => {
+        switch (type) {
+          case "session": {
+            const instance = $injector.instantiate(ctor);
+            return createPersistentProxy(instance, name, sessionStorage);
+          }
+          case "local": {
+            const instance = $injector.instantiate(ctor);
+            return createPersistentProxy(instance, name, localStorage);
+          }
+          case "cookie": {
+            const instance = $injector.instantiate(ctor);
+            const $cookie = $injector.get($injectTokens.$cookie);
+            const serialize = backendOrConfig.serialize ?? JSON.stringify;
+            const deserialize = backendOrConfig.deserialize ?? JSON.parse;
+            const cookieOpts = backendOrConfig.cookie ?? {};
+
+            return createPersistentProxy(instance, name, {
+              getItem(key) {
+                const raw = $cookie.get(key);
+                return raw == null ? null : raw;
+              },
+
+              setItem(key, value) {
+                $cookie.put(key, value, cookieOpts);
+              },
+
+              removeItem(key) {
+                $cookie.remove(key, cookieOpts);
+              },
+
+              serialize,
+              deserialize,
+            });
           }
-        } else {
-          // fallback default
-          backend = localStorage;
-        }
+          case "custom": {
+            const instance = $injector.instantiate(ctor);
+
+            let backend;
+            let serialize = JSON.stringify;
+            let deserialize = JSON.parse;
+
+            if (backendOrConfig) {
+              if (typeof backendOrConfig.getItem === "function") {
+                // raw Storage object
+                backend = backendOrConfig;
+              } else if (isObject(backendOrConfig)) {
+                backend = backendOrConfig.backend || localStorage;
+                if (backendOrConfig.serialize)
+                  serialize = backendOrConfig.serialize;
+                if (backendOrConfig.deserialize)
+                  deserialize = backendOrConfig.deserialize;
+              }
+            } else {
+              // fallback default
+              backend = localStorage;
+            }
 
-        return createPersistentProxy(instance, name, backend, {
-          serialize,
-          deserialize,
-        });
+            return createPersistentProxy(instance, name, backend, {
+              serialize,
+              deserialize,
+            });
+          }
+        }
       },
     });
   }
@@ -5707,7 +5745,7 @@ class CompileProvider {
     const bindingCache = Object.create(null);
 
     /**
-     * @param {import("../scope/scope.js").Scope} scope
+     * @param {ng.Scope} scope
      * @param {string} directiveName
      * @param {boolean} isController
      * @returns {Object} a configuration object for attribute bindings
@@ -5845,8 +5883,8 @@ class CompileProvider {
             "$injector",
             "$exceptionHandler",
             /**
-             * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
-             * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
+             * @param {ng.InjectorService} $injector
+             * @param {ng.ExceptionHandlerService} $exceptionHandler
              */
             function ($injector, $exceptionHandler) {
               const directives = [];
@@ -6174,11 +6212,11 @@ class CompileProvider {
       /**
        * @param {ng.InjectorService} $injector
        * @param {*} $interpolate
-       * @param {import("../../services/exception/exception-handler.js").ErrorHandler} $exceptionHandler
+       * @param {ng.ExceptionHandlerService} $exceptionHandler
        * @param {ng.TemplateRequestService} $templateRequest
        * @param {ng.ParseService} $parse
        * @param {*} $controller
-       * @param {import('../scope/scope.js').Scope} $rootScope
+       * @param {ng.Scope} $rootScope
        * @param {*} $sce
        * @param {ng.AnimateService} $animate
        * @returns
@@ -6465,7 +6503,7 @@ class CompileProvider {
           /**
            * The composite link function links all the individual nodes
            *
-           * @param {import("../scope/scope.js").Scope} scope
+           * @param {ng.Scope} scope
            * @param {NodeRef} nodeRef
            * @param {*} [parentBoundTranscludeFn]
            */
@@ -7025,7 +7063,7 @@ class CompileProvider {
                   transcludeFn,
                 );
               } catch (e) {
-                $exceptionHandler(e, startingTag($element.getAny()));
+                $exceptionHandler(e);
               }
             }
 
@@ -7078,7 +7116,7 @@ class CompileProvider {
                   transcludeFn,
                 );
               } catch (e) {
-                $exceptionHandler(e, startingTag($element.getAny()));
+                $exceptionHandler(e);
               }
             }
 
@@ -7543,7 +7581,7 @@ class CompileProvider {
                   );
                 }
               } catch (e) {
-                $exceptionHandler(e, startingTag(compileNodeRef.getAny()));
+                $exceptionHandler(e);
               }
             }
 
@@ -8494,9 +8532,9 @@ class CompileProvider {
         // Set up $watches for isolate scope and controller bindings.
         /**
          *
-         * @param {import('../scope/scope.js').Scope} scope
+         * @param {ng.Scope} scope
          * @param {*} attrs
-         * @param {import('../scope/scope.js').Scope}  destination - child scope or isolate scope
+         * @param {ng.Scope}  destination - child scope or isolate scope
          * @param {*} bindings
          * @param {*} directive
          * @returns
@@ -9704,11 +9742,11 @@ class NgModelController {
   ];
 
   /**
-   * @param {import('../../core/scope/scope.js').Scope} $scope
-   * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
-   * @param {import('../../core/compile/attributes.js').Attributes} $attr
+   * @param {ng.Scope} $scope
+   * @param {ng.ExceptionHandlerService} $exceptionHandler
+   * @param {ng.Attributes} $attr
    * @param {Element} $element
-   * @param {import("../../core/parse/interface.ts").ParseService} $parse
+   * @param {ng.ParseService} $parse
    * @param {ng.AnimateService} $animate
    * @param {*} $interpolate
    */
@@ -9766,7 +9804,7 @@ class NgModelController {
 
     /**
      * @type {import("../../core/parse/interface.ts").CompiledExpression |
-     *        (function(import("../../core/scope/scope.js").Scope): any)}
+     *        (function(ng.Scope): any)}
      */
     this.$$ngModelGet = this.$$parsedNgModel;
     this.$$ngModelSet = this.$$parsedNgModelAssign;
@@ -9779,7 +9817,7 @@ class NgModelController {
     /** @type {number} */
     this.$$currentValidationRunId = 0;
 
-    /** @type {import('../../core/scope/scope.js').Scope} */
+    /** @type {ng.Scope} */
     this.$$scope = $scope; // attempt to bind to nearest controller if present
     this.$$attr = $attr;
     this.$$element = $element;
@@ -11885,13 +11923,13 @@ class SelectController {
 
   /**
    * @param {HTMLSelectElement} $element
-   * @param {import('../../core/scope/scope.js').Scope} $scope
+   * @param {ng.Scope} $scope
    */
   constructor($element, $scope) {
     /** @type {HTMLSelectElement} */
     this.$element = $element;
 
-    /** @type {import('../../core/scope/scope.js').Scope} */
+    /** @type {ng.Scope} */
     this.$scope = $scope;
 
     /** @type {Object<string, any>} */
@@ -12446,14 +12484,14 @@ function optionDirective($interpolate) {
 }
 
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
 function ngBindDirective() {
   return {
     /**
-     * @param {import('../../core/scope/scope.js').Scope} scope
+     * @param {ng.Scope} scope
      * @param {Element} element
-     * @param {import('../../core/compile/attributes.js').Attributes} attr
+     * @param {ng.Attributes} attr
      */
     link(scope, element, attr) {
       scope.$watch(
@@ -12475,7 +12513,7 @@ function ngBindDirective() {
 function ngBindTemplateDirective() {
   return {
     /**
-     * @param {import('../../core/scope/scope.js').Scope} _scope
+     * @param {ng.Scope} _scope
      * @param {Element} element
      * @param {import('../../core/compile/attributes.js').Attributes} attr
      */
@@ -12499,7 +12537,7 @@ function ngBindHtmlDirective($parse) {
       $parse(tAttrs["ngBindHtml"]); // checks for interpolation errors
       return (
         /**
-         * @param {import('../../core/scope/scope.js').Scope} scope
+         * @param {ng.Scope} scope
          * @param {Element} element
          */
         (scope, element) => {
@@ -12870,8 +12908,8 @@ ngIncludeDirective.$inject = [
  * @param {ng.TemplateRequestService} $templateRequest
  * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
  * @param {ng.AnimateService} $animate
- * @param {import('../../services/exception/interface.ts').ErrorHandler} $exceptionHandler
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.ExceptionHandlerService} $exceptionHandler
+ * @returns {ng.Directive}
  */
 function ngIncludeDirective(
   $templateRequest,
@@ -13398,7 +13436,7 @@ function ngRepeatDirective($animate) {
                   /**
                    * Clone attach function
                    * @param {Array<NodeList>} clone
-                   * @param {import("../../core/scope/scope.js").Scope} scope
+                   * @param {ng.Scope} scope
                    */
 
                   (clone, scope) => {
@@ -13624,14 +13662,14 @@ ngOptionsDirective.$inject = ["$compile", "$parse"];
 /**
  *
  * @param {ng.CompileService} $compile
- * @param {import("../../core/parse/interface.ts").ParseService} $parse
- * @returns {import("../../interface.ts").Directive}
+ * @param {ng.ParseService} $parse
+ * @returns {ng.Directive}
  */
 function ngOptionsDirective($compile, $parse) {
   /**
    * @param {import('../../interface.ts').Expression} optionsExp
    * @param {HTMLSelectElement} selectElement
-   * @param {import('../../core/scope/scope.js').Scope} scope
+   * @param {ng.Scope} scope
    * @returns
    */
   function parseOptionsExpression(optionsExp, selectElement, scope) {
@@ -13811,9 +13849,9 @@ function ngOptionsDirective($compile, $parse) {
 
   /**
    *
-   * @param {import("../../core/scope/scope.js").Scope} scope
+   * @param {ng.Scope} scope
    * @param {HTMLSelectElement} selectElement
-   * @param {import("../../core/compile/attributes.js").Attributes} attr
+   * @param {ng.Attributes} attr
    * @param {*} ctrls
    */
   function ngOptionsPostLink(scope, selectElement, attr, ctrls) {
@@ -14201,7 +14239,7 @@ function ngTranscludeDirective($compile) {
 
         /**
          * @param {NodeList | Node} clone
-         * @param {import("../../core/scope/scope.js").Scope} transcludedScope
+         * @param {ng.Scope} transcludedScope
          */
         function ngTranscludeCloneAttachFn(clone, transcludedScope) {
           if (notWhitespace(clone)) {
@@ -14386,7 +14424,7 @@ const requiredDirective = [
     require: "?ngModel",
     link:
       /**
-       * @param {import("../../core/scope/scope.js").Scope} scope
+       * @param {ng.Scope} scope
        * @param {Element} _elm
        * @param {import("../../core/compile/attributes.js").Attributes} attr
        * @param {import("../../interface.ts").NgModelController} ctrl
@@ -15315,78 +15353,66 @@ class TemplateCacheProvider {
 }
 
 /**
- * Handles uncaught exceptions thrown in AngularTS expressions.
- *
- * By default, this service delegates to `$log.error()`, logging the exception to the browser console.
- * You can override this behavior to provide custom exception handling—such as reporting errors
- * to a backend server, or altering the log level used.
+ * Unified exception handler used throughout AngularTS.
  *
- * ## Default Behavior
+ * This service receives uncaught exceptions from both synchronous and asynchronous operations.
+ * Its purpose is to provide a central point through which the framework
+ * processes errors.
  *
- * Uncaught exceptions within AngularTS expressions are intercepted and passed to this service.
- * The default implementation logs the error using `$log.error(exception, cause)`.
+ * By default, `$exceptionHandler` simply rethrows the exception. This ensures fail-fast
+ * behavior, making errors visible immediately in development and in unit tests.
+ * Applications may override this service to introduce custom error handling.
  *
- * ## Custom Implementation
- *
- * You can override the default `$exceptionHandler` by providing your own factory. This allows you to:
- * - Log errors to a remote server
- * - Change the log level (e.g., from `error` to `warn`)
- * - Trigger custom error-handling workflows
- *
- * ### Example: Overriding `$exceptionHandler`
+ * ### Example: Custom `$exceptionHandler`
  *
  * ```js
  * angular
- *   .module('exceptionOverwrite', [])
- *   .factory('$exceptionHandler', ['$log', 'logErrorsToBackend', function($log, logErrorsToBackend) {
- *     return function myExceptionHandler(exception, cause) {
- *       logErrorsToBackend(exception, cause);
- *       $log.warn(exception, cause); // Use warn instead of error
+ *   .module('app')
+ *   .factory('$exceptionHandler', function(myLogger) {
+ *     return function handleError(error) {
+ *       myLogger.capture(error);
+ *       // Rethrow to preserve fail-fast behavior:
+ *       throw error;
  *     };
- *   }]);
+ *   });
  * ```
- * - You may also manually invoke the exception handler:
+ *
+ * IMPORTANT: custom implementation should always rethrow the error as the framework assumes that `$exceptionHandler` always does the throwing.
+ *
+ * ### Manual Invocation
+ *
+ * You can invoke the exception handler directly when catching errors in your own code:
  *
  * ```js
  * try {
- *   // Some code that might throw
- * } catch (e) {
- *   $exceptionHandler(e, 'optional context');
+ *   riskyOperation();
+ * } catch (err) {
+ *   $exceptionHandler(err);
  * }
  * ```
  *
- * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
+ * @see {@link ng.ExceptionHandlerService ExceptionHandlerService}
  */
 
-/** @typedef {import('../log/interface.ts').LogService} LogService */
-
-/** @typedef {import("./interface.ts").ErrorHandler}  ErrorHandler */
-
 /**
- * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.
- * Can be overridden to implement custom error-handling logic.
+ * Provider for the `$exceptionHandler` service.
+ *
+ * The default implementation rethrows exceptions, enabling strict fail-fast behavior.
+ * Applications may replace the handler via by setting `errorHandler`property or by providing their own
+ * `$exceptionHandler` factory.
  */
 class ExceptionHandlerProvider {
   constructor() {
-    /** @type {LogService} */
-    this.log = window.console;
-
-    /** @type {ErrorHandler} */
-    this.errorHandler = (exception, cause) => {
-      this.log.error(exception, cause);
+    /** @type {ng.ExceptionHandlerService} */
+    this.handler = (exception) => {
+      throw exception;
     };
-
-    this.$get = [
-      "$log",
-      /**
-       * @param {LogService} $log
-       * @returns {ErrorHandler}
-       */
-      ($log) => {
-        this.log = $log;
-        return this.errorHandler;
-      },
-    ];
+  }
+  /**
+   * @returns {ng.ExceptionHandlerService}
+   */
+  $get() {
+    return (exception) => this.handler(exception);
   }
 }
 
@@ -17999,7 +18025,7 @@ function addWatchDelegate(parsedExpression) {
 
 /**
  *
- * @param {import('../scope/scope.js').Scope} scope
+ * @param {ng.Scope} scope
  * @param {Function} listener
  * @param {*} objectEquality
  * @param {import('./interface').CompiledExpression} parsedExpression
@@ -25716,12 +25742,11 @@ function AnimationProvider() {
 
 /**
  * @typedef {import('./interface.ts').RafScheduler} RafScheduler
- * @typedef {import('../interface.ts').ServiceProvider} ServiceProvider
  */
 
 /**
  * Service provider that creates a requestAnimationFrame-based scheduler.
- * @type {ServiceProvider}
+ * @type {ng.ServiceProvider}
  */
 class RafSchedulerProvider {
   constructor() {
@@ -33917,8 +33942,8 @@ class UrlService {
     $injectTokens.$rootScope,
     /**
      *
-     * @param {import('../../services/location/location.js').Location} $location
-     * @param {import('../../core/scope/scope.js').Scope} $rootScope
+     * @param {ng.LocationService} $location
+     * @param {ng.Scope} $rootScope
      * @returns {UrlService}
      */
     ($location, $rootScope) => {
@@ -36270,6 +36295,722 @@ function ngScopeDirective() {
   };
 }
 
+/**
+ * Service provider that creates a {@link CookieService $cookie} service.
+ * @type {ng.ServiceProvider}
+ */
+class CookieProvider {
+  constructor() {
+    this.defaults = {};
+  }
+
+  $get = [
+    $injectTokens.$exceptionHandler,
+    /** @param {ng.ExceptionHandlerService} $exceptionHandler  */
+    ($exceptionHandler) => new CookieService(this.defaults, $exceptionHandler),
+  ];
+}
+
+/**
+ *
+ * Provides high-level APIs for interacting with browser cookies:
+ *  - Raw get/set/remove
+ *  - JSON serialization helpers
+ *  - Global defaults supplied by $cookiesProvider
+ */
+class CookieService {
+  /**
+   * @param {ng.CookieOptions} defaults
+   *   Default cookie attributes defined by `$cookiesProvider.defaults`.
+   * @param {ng.ExceptionHandlerService} $exceptionHandler
+   */
+  constructor(defaults, $exceptionHandler) {
+    assert(isObject(defaults), BADARG);
+    assert(isFunction($exceptionHandler), BADARG);
+    /** @type {ng.CookieOptions} */
+    this.defaults = Object.freeze({ ...defaults });
+    this.$exceptionHandler = $exceptionHandler;
+  }
+
+  /**
+   * Retrieves a raw cookie value.
+   *
+   * @param {string} key
+   * @returns {string|null}
+   */
+  get(key) {
+    assert(isString(key), BADARG);
+    const all = parseCookies();
+    return all[key] || null;
+  }
+
+  /**
+   * Retrieves a cookie and deserializes its JSON content.
+   *
+   * @template T
+   * @param {string} key
+   * @returns {T|null}
+   * @throws {SyntaxError} if cookie JSON is invalid
+   */
+  getObject(key) {
+    assert(isString(key), BADARG);
+    const raw = this.get(key);
+    if (!raw) return null;
+    try {
+      return /** @type {T} */ (JSON.parse(raw));
+    } catch (err) {
+      this.$exceptionHandler(
+        new SyntaxError(`badparse: "${key}" => ${err.message}`),
+      );
+    }
+  }
+
+  /**
+   * Returns an object containing all raw cookies.
+   *
+   * @returns {Record<string, string>}
+   */
+  getAll() {
+    return parseCookies();
+  }
+
+  /**
+   * Sets a raw cookie value.
+   *
+   * @param {string} key
+   * @param {string} value
+   * @param {ng.CookieOptions} [options]
+   */
+  put(key, value, options = {}) {
+    assert(isString(key), BADARGKEY);
+    assert(isString(value), BADARGVALUE);
+    const encodedKey = encodeURIComponent(key);
+    const encodedVal = encodeURIComponent(value);
+
+    try {
+      document.cookie =
+        `${encodedKey}=${encodedVal}` +
+        buildOptions({ ...this.defaults, ...options });
+    } catch (e) {
+      this.$exceptionHandler(e);
+    }
+  }
+
+  /**
+   * Serializes an object as JSON and stores it as a cookie.
+   *
+   * @param {string} key
+   * @param {any} value
+   * @param {ng.CookieOptions} [options]
+   * @throws {TypeError} if Object cannot be converted to JSON
+   */
+  putObject(key, value, options) {
+    assert(isString(key), BADARGKEY);
+    assert(!isNullOrUndefined(value), BADARGVALUE);
+    try {
+      const str = JSON.stringify(value);
+      this.put(key, str, options);
+    } catch (err) {
+      this.$exceptionHandler(
+        new TypeError(`badserialize: "${key}" => ${err.message}`),
+      );
+    }
+  }
+
+  /**
+   * Removes a cookie by setting an expired date.
+   *
+   * @param {string} key
+   * @param {ng.CookieOptions} [options]
+   */
+  remove(key, options = {}) {
+    assert(isString(key), BADARG);
+    this.put(key, "", {
+      ...this.defaults,
+      ...options,
+      expires: new Date(0),
+    });
+  }
+}
+
+/*----------Helpers----------*/
+
+/**
+ * @returns {Record<string,string>}
+ */
+function parseCookies() {
+  /** @type {Record<string, string>} */
+  const out = {};
+  if (!document.cookie) return out;
+
+  const parts = document.cookie.split("; ");
+  for (const part of parts) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue; // skip malformed cookie
+    const key = decodeURIComponent(part.substring(0, eq));
+    const val = decodeURIComponent(part.substring(eq + 1));
+    out[key] = val;
+  }
+  return out;
+}
+
+/**
+ * Build cookie options string from an options object.
+ * Safely validates types for path, domain, expires, secure, and samesite.
+ *
+ * @param {ng.CookieOptions} opts
+ * @returns {string}
+ * @throws {TypeError} if any of options are invalid
+ */
+function buildOptions(opts = {}) {
+  const parts = [];
+
+  // Path
+  if (isDefined(opts.path)) {
+    if (!isString(opts.path))
+      throw new TypeError(BADARG + `:path ${opts.path}`);
+    parts.push(`path=${opts.path}`);
+  }
+
+  // Domain
+  if (isDefined(opts.domain)) {
+    if (!isString(opts.domain))
+      throw new TypeError(BADARG + `:domain ${opts.domain}`);
+    parts.push(`domain=${opts.domain}`);
+  }
+
+  // Expires
+  if (opts.expires != null) {
+    let expDate;
+
+    if (opts.expires instanceof Date) {
+      expDate = opts.expires;
+    } else if (isNumber(opts.expires) || isString(opts.expires)) {
+      expDate = new Date(opts.expires);
+    } else {
+      throw new TypeError(BADARG + `:expires ${String(opts.expires)}`);
+    }
+
+    if (isNaN(expDate.getTime())) {
+      throw new TypeError(BADARG + `:expires ${String(opts.expires)}`);
+    }
+
+    parts.push(`expires=${expDate.toUTCString()}`);
+  }
+
+  // Secure
+  if (opts.secure) {
+    parts.push("secure");
+  }
+
+  // SameSite
+  if (isDefined(opts.samesite)) {
+    if (!isString(opts.samesite))
+      throw new TypeError(BADARG + `:samesite ${opts.samesite}`);
+    const s = opts.samesite.toLowerCase();
+    if (!["lax", "strict", "none"].includes(s)) {
+      throw new TypeError(BADARG + `:samesite ${opts.samesite}`);
+    }
+    parts.push(`samesite=${s}`);
+  }
+
+  // Join all parts with semicolons
+  return parts.length ? ";" + parts.join(";") : "";
+}
+
+/**
+ * RFC 6570 Level 4 URI Template expander
+ *
+ * Supports operators: (none), +, #, ., /, ;, ?, &
+ * Supports varspec modifiers: explode (*) and prefix (:len)
+ *
+ * Usage:
+ *   expandUriTemplate("/users/{id}", { id: 10 }) === "/users/10"
+ *   expandUriTemplate("/search{?q,lang}", { q: "a b", lang: "en" }) === "/search?q=a%20b&lang=en"
+ *   expandUriTemplate("/repos/{owner}/{repo}/issues{?labels*}", { labels: ["bug","ui"] }) === "/repos/x/y/issues?labels=bug&labels=ui"
+ *
+ * @param {string} template
+ * @param {Object<string, any>} vars
+ * @returns {string}
+ */
+function expandUriTemplate(template, vars = {}) {
+  if (typeof template !== "string")
+    throw new TypeError("template must be a string");
+
+  return template.replace(/\{([^}]+)\}/g, (match, expression) => {
+    return expandExpression(expression, vars);
+  });
+}
+
+/**
+ * Helper: percent-encode a string. If allowReserved true, reserved chars are NOT encoded.
+ * @param {string} str
+ * @param {boolean} allowReserved
+ * @returns {string}
+ */
+function pctEncode(str, allowReserved) {
+  // encodeURIComponent, then restore reserved if allowed
+  const encoded = encodeURIComponent(String(str));
+  if (allowReserved) {
+    // Reserved characters per RFC 3986
+    return encoded.replace(
+      /(%3A|%2F|%3F|%23|%5B|%5D|%40|%21|%24|%26|%27|%28|%29|%2A|%2B|%2C|%3B|%3D)/gi,
+      (m) => decodeURIComponent(m),
+    );
+  }
+  return encoded;
+}
+
+/**
+ * Parse and expand a single expression (content between { and }).
+ * @param {string} expression
+ * @param {Object<string, any>} vars
+ * @returns {string}
+ */
+function expandExpression(expression, vars) {
+  // Operator if first char in operator set
+  const operator = /^[+#./;?&]/.test(expression) ? expression[0] : "";
+  const op = operator;
+  const varlist = op ? expression.slice(1) : expression;
+
+  // operator configuration (separator, prefix, named, ifEmpty, allowReserved)
+  const OP = {
+    "": {
+      sep: ",",
+      prefix: "",
+      named: false,
+      ifEmpty: "",
+      allowReserved: false,
+    },
+    "+": {
+      sep: ",",
+      prefix: "",
+      named: false,
+      ifEmpty: "",
+      allowReserved: true,
+    },
+    "#": {
+      sep: ",",
+      prefix: "#",
+      named: false,
+      ifEmpty: "",
+      allowReserved: true,
+    },
+    ".": {
+      sep: ".",
+      prefix: ".",
+      named: false,
+      ifEmpty: "",
+      allowReserved: false,
+    },
+    "/": {
+      sep: "/",
+      prefix: "/",
+      named: false,
+      ifEmpty: "",
+      allowReserved: false,
+    },
+    ";": {
+      sep: ";",
+      prefix: ";",
+      named: true,
+      ifEmpty: "",
+      allowReserved: false,
+    },
+    "?": {
+      sep: "&",
+      prefix: "?",
+      named: true,
+      ifEmpty: "=",
+      allowReserved: false,
+    },
+    "&": {
+      sep: "&",
+      prefix: "&",
+      named: true,
+      ifEmpty: "=",
+      allowReserved: false,
+    },
+  };
+
+  const conf = OP[op];
+  if (!conf) throw new Error("Unsupported operator: " + op);
+
+  // split varspecs by comma, preserve whitespace trimmed
+  const varspecs = varlist
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  const expandedParts = [];
+
+  for (const spec of varspecs) {
+    // parse varspec: name, explode (*), prefix (:len)
+    const m = /^([A-Za-z0-9_.]+)(\*|(?::(\d+)))?$/.exec(spec);
+    if (!m) throw new Error("Invalid varspec: " + spec);
+    const varname = m[1];
+    const explode = m[2] === "*";
+    const prefixLength = m[3] ? parseInt(m[3], 10) : undefined;
+
+    const value = vars[varname];
+
+    // undefined or null = skip (no expansion)
+    if (value === undefined || value === null) {
+      continue;
+    }
+
+    // PROCESS arrays
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        // empty array: for named operators, emit key with empty ifEmpty, otherwise skip
+        if (conf.named) {
+          // emit key without value or with = depending on ifEmpty
+          if (conf.ifEmpty === "=") {
+            expandedParts.push(
+              `${pctEncode(varname, conf.allowReserved)}${conf.ifEmpty}`,
+            );
+          } else {
+            expandedParts.push(pctEncode(varname, conf.allowReserved));
+          }
+        }
+        continue;
+      }
+
+      if (explode) {
+        // each item becomes either 'k=v' (named) or 'v' (unnamed)
+        for (const item of value) {
+          if (item === null || item === undefined) continue;
+          if (conf.named) {
+            expandedParts.push(
+              `${pctEncode(varname, conf.allowReserved)}=${pctEncode(item, conf.allowReserved)}`,
+            );
+          } else {
+            expandedParts.push(pctEncode(item, conf.allowReserved));
+          }
+        }
+      } else {
+        // join by comma (or operator.sep?) — RFC: simple join with ','
+        const joined = value
+          .filter((v) => v !== null && v !== undefined)
+          .map((v) => pctEncode(v, conf.allowReserved))
+          .join(",");
+        if (conf.named) {
+          if (joined === "") {
+            expandedParts.push(
+              pctEncode(varname, conf.allowReserved) +
+                (conf.ifEmpty === "=" ? conf.ifEmpty : ""),
+            );
+          } else {
+            expandedParts.push(
+              `${pctEncode(varname, conf.allowReserved)}=${joined}`,
+            );
+          }
+        } else {
+          expandedParts.push(joined);
+        }
+      }
+      continue;
+    }
+
+    // PROCESS objects (associative arrays)
+    if (typeof value === "object") {
+      const keys = Object.keys(value);
+      if (keys.length === 0) {
+        if (conf.named) {
+          expandedParts.push(
+            pctEncode(varname, conf.allowReserved) +
+              (conf.ifEmpty === "=" ? conf.ifEmpty : ""),
+          );
+        }
+        continue;
+      }
+
+      if (explode) {
+        // each key/value pair becomes k=v (named) or k,v? For explode + named, RFC says 'k=v'
+        for (const k of keys) {
+          const v = value[k];
+          if (v === null || v === undefined) continue;
+          if (conf.named) {
+            expandedParts.push(
+              `${pctEncode(k, conf.allowReserved)}=${pctEncode(v, conf.allowReserved)}`,
+            );
+          } else {
+            // unnamed explode => k,v form pairs
+            expandedParts.push(
+              `${pctEncode(k, conf.allowReserved)}=${pctEncode(v, conf.allowReserved)}`,
+            );
+          }
+        }
+      } else {
+        // not exploded: join k,v pairs by ','
+        const pairs = keys
+          .map(
+            (k) =>
+              `${pctEncode(k, conf.allowReserved)},${pctEncode(value[k], conf.allowReserved)}`,
+          )
+          .join(",");
+        if (conf.named) {
+          if (pairs === "") {
+            expandedParts.push(
+              pctEncode(varname, conf.allowReserved) +
+                (conf.ifEmpty === "=" ? conf.ifEmpty : ""),
+            );
+          } else {
+            expandedParts.push(
+              `${pctEncode(varname, conf.allowReserved)}=${pairs}`,
+            );
+          }
+        } else {
+          expandedParts.push(pairs);
+        }
+      }
+      continue;
+    }
+
+    // PROCESS scalar (string/number/boolean)
+    let str = String(value);
+
+    // apply prefix modifier if present
+    if (typeof prefixLength === "number") {
+      str = str.substring(0, prefixLength);
+    }
+
+    // empty string handling
+    if (str === "") {
+      if (conf.named) {
+        // for named operators, emit key or key= depending on ifEmpty
+        if (conf.ifEmpty === "=") {
+          expandedParts.push(
+            `${pctEncode(varname, conf.allowReserved)}${conf.ifEmpty}`,
+          );
+        } else {
+          expandedParts.push(pctEncode(varname, conf.allowReserved));
+        }
+      } else {
+        // unnamed operators: empty string -> nothing (skip)
+        if (op === "+" || op === "#") {
+          // these allow empty expansions (produce nothing)
+          expandedParts.push(pctEncode(str, conf.allowReserved));
+        } else {
+          // skip adding anything
+          expandedParts.push(pctEncode(str, conf.allowReserved));
+        }
+      }
+      continue;
+    }
+
+    // default scalar behavior
+    if (conf.named) {
+      expandedParts.push(
+        `${pctEncode(varname, conf.allowReserved)}=${pctEncode(str, conf.allowReserved)}`,
+      );
+    } else {
+      expandedParts.push(pctEncode(str, conf.allowReserved));
+    }
+  } // end for varspecs
+
+  if (expandedParts.length === 0) return "";
+
+  // join parts with operator separator; prefix if needed
+  return conf.prefix + expandedParts.join(conf.sep);
+}
+
+/**
+ * @template T, ID
+ */
+class RestService {
+  static $nonscope = true;
+
+  /**
+   * Core REST service for CRUD operations.
+   * Safe, predictable, and optionally maps raw JSON to entity class instances.
+   *
+   * @param {ng.HttpService} $http Angular-like $http service
+   * @param {string} baseUrl Base URL or URI template
+   * @param {{new(data: any): T}=} entityClass Optional constructor to map JSON to objects
+   * @param {Object=} options Optional settings (interceptors, headers, etc.)
+   */
+  constructor($http, baseUrl, entityClass, options = {}) {
+    assert(isString(baseUrl) && baseUrl.length > 0, "baseUrl required");
+
+    /** @private */
+    this.$http = $http;
+    /** @private */
+    this.baseUrl = baseUrl;
+    /** @private */
+    this.entityClass = entityClass;
+    /** @private */
+    this.options = options;
+  }
+
+  /**
+   * Build full URL from template and parameters
+   * @param {string} template
+   * @param {Record<string, any>} params
+   * @returns {string}
+   */
+  buildUrl(template, params) {
+    // Safe: ensure params is an object
+    return expandUriTemplate(template, params || {});
+  }
+
+  /**
+   * Map raw JSON to entity instance or return as-is
+   * @param {any} data
+   * @returns {T|any}
+   */
+  #mapEntity(data) {
+    if (!data) return data;
+    return this.entityClass ? new this.entityClass(data) : data;
+  }
+
+  /**
+   * List entities
+   * @param {Record<string, any>=} params
+   * @returns {Promise<T[]>}
+   */
+  async list(params = {}) {
+    const url = this.buildUrl(this.baseUrl, params);
+    const resp = await this.#request("get", url, null, params);
+    if (!Array.isArray(resp.data)) return [];
+    return resp.data.map((d) => this.#mapEntity(d));
+  }
+
+  /**
+   * Read single entity by ID
+   * @param {ID} id
+   * @param {Record<string, any>=} params
+   * @returns {Promise<T|null>}
+   */
+  async read(id, params = {}) {
+    if (id == null) return null;
+    const url = this.buildUrl(`${this.baseUrl}/${id}`, params);
+    try {
+      const resp = await this.#request("get", url, null, params);
+      return this.#mapEntity(resp.data);
+    } catch {
+      return null; // fail-safe
+    }
+  }
+
+  /**
+   * Create a new entity
+   * @param {T} item
+   * @returns {Promise<T>}
+   */
+  async create(item) {
+    assert(item != null, "item required for create");
+    const resp = await this.#request("post", this.baseUrl, item);
+    return this.#mapEntity(resp.data);
+  }
+
+  /**
+   * Update entity by ID
+   * @param {ID} id
+   * @param {Partial<T>} item
+   * @returns {Promise<T|null>}
+   */
+  async update(id, item) {
+    assert(id != null, "id required for update");
+    const url = `${this.baseUrl}/${id}`;
+    try {
+      const resp = await this.#request("put", url, item);
+      return this.#mapEntity(resp.data);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Delete entity by ID
+   * @param {ID} id
+   * @returns {Promise<boolean>}
+   */
+  async delete(id) {
+    if (id == null) return false;
+    const url = `${this.baseUrl}/${id}`;
+    try {
+      await this.#request("delete", url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Core HTTP request wrapper
+   * @param {"get"|"post"|"put"|"delete"} method
+   * @param {string} url
+   * @param {any=} data
+   * @param {Record<string, any>=} params
+   * @returns {Promise<any>}
+   */
+  async #request(method, url, data = null, params = {}) {
+    try {
+      return await this.$http({
+        method,
+        url,
+        data,
+        params,
+        ...this.options,
+      });
+    } catch (err) {
+      console.error(`[RestService] HTTP ${method} failed for ${url}`, err);
+      throw err; // propagate for caller handling
+    }
+  }
+}
+
+/**
+ * Provider for registering REST endpoints during module configuration.
+ */
+class RestProvider {
+  constructor() {
+    /** @private @type {ng.RestDefinition<any>[]} */
+    this.definitions = [];
+  }
+
+  /**
+   * Register a REST resource at config phase
+   * @template T
+   * @param {string} name Service name
+   * @param {string} url Base URL or URI template
+   * @param {{new(data:any):T}=} entityClass Optional entity constructor
+   * @param {Object=} options Optional service options
+   */
+  rest(name, url, entityClass, options = {}) {
+    this.definitions.push({ name, url, entityClass, options });
+  }
+
+  /**
+   * $get factory: returns a factory function and allows access to named services
+   * @returns {(baseUrl:string, entityClass?:Function, options?:object) => RestService & { get(name:string): RestService, listNames(): string[] }}
+   */
+  $get = [
+    $injectTokens.$http,
+    ($http) => {
+      const services = new Map();
+
+      const factory = (baseUrl, entityClass, options = {}) => {
+        const svc = new RestService($http, baseUrl, entityClass, options);
+        return svc;
+      };
+
+      // create services from pre-registered definitions
+      for (const def of this.definitions) {
+        const svc = factory(def.url, def.entityClass, def.options);
+        services.set(def.name, svc);
+      }
+
+      // helpers to fetch named services
+      factory.get = (name) => services.get(name);
+      factory.listNames = () => Array.from(services.keys());
+
+      return factory;
+    },
+  ];
+}
+
 /**
  * Initializes core `ng` module.
  * @param {ng.Angular} angular
@@ -36393,6 +37134,7 @@ function registerNgModule(angular) {
             $$animateCache: AnimateCacheProvider,
             $$animateQueue: AnimateQueueProvider,
             $controller: ControllerProvider,
+            $cookie: CookieProvider,
             $exceptionHandler: ExceptionHandlerProvider,
             $filter: FilterProvider,
             $interpolate: InterpolateProvider,
@@ -36402,6 +37144,7 @@ function registerNgModule(angular) {
             $log: LogProvider,
             $parse: ParseProvider,
             $$rAFScheduler: RafSchedulerProvider,
+            $rest: RestProvider,
             $rootScope: RootScopeProvider,
             $router: Router,
             $sce: SceProvider,
@@ -36449,7 +37192,7 @@ class Angular {
     /**
      * @type {string} `version` from `package.json`
      */
-    this.version = "0.12.0"; //inserted via rollup plugin
+    this.version = "0.13.0"; //inserted via rollup plugin
 
     /** @type {!Array<string|any>} */
     this.bootsrappedModules = [];
@@ -36585,7 +37328,7 @@ class Angular {
    *     function that will be invoked by the injector as a `config` block.
    *     See: {@link angular.module modules}
    * @param {import("./interface.ts").AngularBootstrapConfig} [config]
-   * @returns {import('./core/di/internal-injector.js').InjectorService} The created injector instance for this application.
+   * @returns {ng.InjectorService} The created injector instance for this application.
    */
   bootstrap(element, modules, config) {
     config = config || {