@angular-wave/angular.ts 0.12.0 → 0.13.0

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.12.0 - November 29, 2025 19:42:34 */
+/* Version: 0.13.0 - December 2, 2025 01:18:44 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -28,6 +28,9 @@
   };
 
   const isProxySymbol = Symbol("isProxy");
+  const BADARG = "badarg";
+  const BADARGKEY = "badarg: key";
+  const BADARGVALUE = "badarg: value";
 
   /**
    *
@@ -1760,7 +1763,7 @@
    * @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 {
@@ -1899,7 +1902,7 @@
    * 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);
@@ -1909,7 +1912,7 @@
    * 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);
@@ -1920,7 +1923,7 @@
    *
    * @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`);
@@ -2209,6 +2212,7 @@
     $animateCss: "$animateCss",
     $aria: "$aria",
     $compile: "$compile",
+    $cookie: "$cookie",
     $controller: "$controller",
     $document: "$document",
     $eventBus: "$eventBus",
@@ -2221,6 +2225,7 @@
     $log: "$log",
     $viewScroll: "$viewScroll",
     $parse: "$parse",
+    $rest: "$rest",
     $rootScope: "$rootScope",
     $rootElement: "$rootElement",
     $router: "$router",
@@ -3017,6 +3022,8 @@
       this.services = [];
 
       this.wasmModules = [];
+
+      this.restDefinitions = [];
     }
 
     /**
@@ -3266,31 +3273,50 @@
     /**
      * @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;
     }
   }
@@ -3613,8 +3639,8 @@
         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;
       },
@@ -3652,9 +3678,7 @@
         service: supportObject(service),
         value: supportObject(value),
         constant: supportObject(constant),
-        session: supportObject(session),
-        local: supportObject(local),
-        store: supportObject(store),
+        store,
         decorator,
       },
     };
@@ -3789,66 +3813,80 @@
     }
 
     /**
-     * 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,
+              });
+            }
+          }
         },
       });
     }
@@ -5713,7 +5751,7 @@
       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
@@ -5851,8 +5889,8 @@
               "$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 = [];
@@ -6180,11 +6218,11 @@
         /**
          * @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
@@ -6471,7 +6509,7 @@
             /**
              * 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]
              */
@@ -7031,7 +7069,7 @@
                     transcludeFn,
                   );
                 } catch (e) {
-                  $exceptionHandler(e, startingTag($element.getAny()));
+                  $exceptionHandler(e);
                 }
               }
 
@@ -7084,7 +7122,7 @@
                     transcludeFn,
                   );
                 } catch (e) {
-                  $exceptionHandler(e, startingTag($element.getAny()));
+                  $exceptionHandler(e);
                 }
               }
 
@@ -7549,7 +7587,7 @@
                     );
                   }
                 } catch (e) {
-                  $exceptionHandler(e, startingTag(compileNodeRef.getAny()));
+                  $exceptionHandler(e);
                 }
               }
 
@@ -8500,9 +8538,9 @@
           // 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
@@ -9710,11 +9748,11 @@
     ];
 
     /**
-     * @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
      */
@@ -9772,7 +9810,7 @@
 
       /**
        * @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;
@@ -9785,7 +9823,7 @@
       /** @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;
@@ -11891,13 +11929,13 @@
 
     /**
      * @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>} */
@@ -12452,14 +12490,14 @@
   }
 
   /**
-   * @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(
@@ -12481,7 +12519,7 @@
   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
        */
@@ -12505,7 +12543,7 @@
         $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) => {
@@ -12876,8 +12914,8 @@
    * @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,
@@ -13404,7 +13442,7 @@
                     /**
                      * Clone attach function
                      * @param {Array<NodeList>} clone
-                     * @param {import("../../core/scope/scope.js").Scope} scope
+                     * @param {ng.Scope} scope
                      */
 
                     (clone, scope) => {
@@ -13630,14 +13668,14 @@
   /**
    *
    * @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) {
@@ -13817,9 +13855,9 @@
 
     /**
      *
-     * @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) {
@@ -14207,7 +14245,7 @@
 
           /**
            * @param {NodeList | Node} clone
-           * @param {import("../../core/scope/scope.js").Scope} transcludedScope
+           * @param {ng.Scope} transcludedScope
            */
           function ngTranscludeCloneAttachFn(clone, transcludedScope) {
             if (notWhitespace(clone)) {
@@ -14392,7 +14430,7 @@
       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
@@ -15321,78 +15359,66 @@
   }
 
   /**
-   * 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);
     }
   }
 
@@ -18005,7 +18031,7 @@
 
   /**
    *
-   * @param {import('../scope/scope.js').Scope} scope
+   * @param {ng.Scope} scope
    * @param {Function} listener
    * @param {*} objectEquality
    * @param {import('./interface').CompiledExpression} parsedExpression
@@ -25722,12 +25748,11 @@
 
   /**
    * @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() {
@@ -33923,8 +33948,8 @@
       $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) => {
@@ -36276,6 +36301,722 @@
     };
   }
 
+  /**
+   * 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
@@ -36399,6 +37140,7 @@
               $$animateCache: AnimateCacheProvider,
               $$animateQueue: AnimateQueueProvider,
               $controller: ControllerProvider,
+              $cookie: CookieProvider,
               $exceptionHandler: ExceptionHandlerProvider,
               $filter: FilterProvider,
               $interpolate: InterpolateProvider,
@@ -36408,6 +37150,7 @@
               $log: LogProvider,
               $parse: ParseProvider,
               $$rAFScheduler: RafSchedulerProvider,
+              $rest: RestProvider,
               $rootScope: RootScopeProvider,
               $router: Router,
               $sce: SceProvider,
@@ -36455,7 +37198,7 @@
       /**
        * @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 = [];
@@ -36591,7 +37334,7 @@
      *     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 || {