angular-toolbox 0.0.8 → 0.9.1

package/fesm2022/angular-toolbox.mjs

@@ -0,0 +1,3709 @@
+import * as i0 from '@angular/core';
+import { NgModule, EventEmitter, Directive, Output, Input, HostListener, Inject, Injectable, inject, Pipe } from '@angular/core';
+import * as i1 from '@angular/router';
+import { RouterModule } from '@angular/router';
+import { DOCUMENT, XhrFactory } from '@angular/common';
+import { HttpStatusCode, HttpHeaders, HttpRequest } from '@angular/common/http';
+import { Observable, of } from 'rxjs';
+import * as i1$1 from '@angular/platform-browser';
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ */
+class AngularToolboxModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AngularToolboxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.3", ngImport: i0, type: AngularToolboxModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AngularToolboxModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AngularToolboxModule, decorators: [{
+            type: NgModule
+        }] });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ */
+const NAME$4 = "SubscriptionError";
+/**
+ * Represents errors thrown by `SubscriptionService` instances.
+ */
+class SubscriptionError extends Error {
+    /**
+     * Creates en new `SubscriptionService` instances.
+     *
+     * @param message A human-readable description of the error.
+     */
+    constructor(message) {
+        super(message);
+        this.name = NAME$4;
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ */
+const NAME$3 = "IntegrityError";
+/**
+ * Represents a data integrity violation error.
+ */
+class IntegrityError extends Error {
+    /**
+     * Creates en new `IntegrityError` instances.
+     *
+     * @param message A human-readable description of the error.
+     */
+    constructor(message) {
+        super(message);
+        this.name = NAME$3;
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ */
+const NAME$2 = "AppBridgeError";
+/**
+ * Represents exceptions thrown by the `AppBridge` class.
+ */
+class AppBridgeError extends ReferenceError {
+    /**
+     * @private
+     */
+    constructor(message) {
+        super(message);
+        this.name = NAME$2;
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ */
+const NAME$1 = "HttpMockServiceError";
+/**
+ * Represents errors thrown by `HttpMockService` instances.
+ */
+class HttpMockServiceError extends Error {
+    /**
+     * Creates en new `HttpMockService` instances.
+     *
+     * @param message A human-readable description of the error.
+     */
+    constructor(message) {
+        super(message);
+        this.name = NAME$1;
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * A reference to an immutable empty string.
+ */
+const EMPTY_STRING = "";
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * A reference to the `"button"` value of the `role` property.
+ */
+const BUTTON_ROLE = 'button';
+/**
+ * A reference to the `"link"` value of the `role` property.
+ */
+const LINK_ROLE = 'link';
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * The regexp used to validate UUID strings.
+ */
+const VALIDATOR = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+/**
+ * A class that represents an immutable universally unique identifier (UUID).
+ * This class is not available in workers.
+ */
+class Uuid {
+    /**
+     * @private
+     * Stores a boolean value used to lock constructor access.
+     */
+    static { this._lockConstructor = true; }
+    /**
+     * @private
+     * Stores a reference to all UUIDs already created.
+     */
+    static { this._hash = EMPTY_STRING; }
+    /**
+     * @private
+     * Created a new `Uuid` instance.
+     *
+     * @param uuid A string used that represents the UUID associated with this `Uuid` instance.
+     *             If `null` creates a random UUID value.
+     * @param tracked If `true`, stores the UUID reference in the system.
+     */
+    constructor(uuid, tracked) {
+        if (Uuid._lockConstructor)
+            throw new ReferenceError("Uuid class has private constructor.");
+        const UUID = uuid || crypto.randomUUID();
+        this._uuid = UUID;
+        if (tracked)
+            Uuid._hash += `${UUID}|`;
+        Uuid._lockConstructor = true;
+    }
+    /**
+     * Returns a string that represents the UUID value associated with this `Uuid` instance.
+     *
+     * @returns The UUID string value associated with this `Uuid` instance.
+     */
+    toString() {
+        return this._uuid;
+    }
+    /**
+     * Compares the given `Uuid` instance with this `Uuid`.
+     *
+     * @param uuid The `Uuid` instance to compare with this `Uuid`.
+     *
+     * @returns `true` whether both `Uuid` instances are equal; `false` otherwise.
+     */
+    equals(uuid) {
+        return this._uuid === uuid.toString();
+    }
+    /**
+     * Creates and returns a new `Uuid` instance.
+     *
+     * @param track If `true`, stores the UUID reference in the system.
+     *
+     * @returns A new `Uuid` instance.
+     */
+    static build(track = false) {
+        Uuid._lockConstructor = false;
+        return new Uuid(null, track);
+    }
+    /**
+     * Creates and returns a new `Uuid` instance built from the specified `uuid` parameter.
+     *
+     * @param uuid The UUID string value used to create the new `Uuid` instance.
+     * @param track If `true`, performs a validation process to ensure that the UUID string does not exists in the system.
+     *
+     * @returns A new `Uuid` instance built from the specified `uuid` parameter.
+     */
+    static fromString(uuid, track = false) {
+        if (track) {
+            if (!this.isTracked(uuid))
+                throw new IntegrityError("Data Integrity Violation. UUID already exists: " + uuid);
+        }
+        if (!Uuid.validate(uuid))
+            throw new TypeError("Invalid UUID value: " + uuid);
+        Uuid._lockConstructor = false;
+        return new Uuid(uuid, track);
+    }
+    /**
+     * Performs validation on the specified `uuid` string parameter.
+     *
+     * @param uuid A UUID representation string to validate.
+     * @returns `true` whether the `uuid` string parameter is valid; `false` otherwise.
+     */
+    static validate(uuid) {
+        return VALIDATOR.test(uuid);
+    }
+    /**
+     * Performs a test to ensure that the UUID string is not tracked the system.
+     *
+     * @param uuid A UUID representation string to test.
+     * @returns `true` whether the `uuid` string parameter is tracked; `false` otherwise.
+     */
+    static isTracked(uuid) {
+        return !Uuid._hash.includes(uuid);
+    }
+    /**
+     * Releases the `Uuid` instance from the tracking system and makes it elligible for garbage collection.
+     *
+     * @returns `true` whether the `Uuid` instance was found and removed; `false` otherwise.
+     */
+    destroy() {
+        const ref = this._uuid;
+        if (!Uuid.isTracked(ref)) {
+            Uuid._hash = Uuid._hash.replace(ref, EMPTY_STRING);
+            return true;
+        }
+        return false;
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * A reference to the `"undefined"` type.
+ */
+const UNDEFINED = "undefined";
+/**
+ * A reference to the `"object"` type.
+ */
+const OBJECT = "object";
+/**
+ * A reference to the `"boolean"` type.
+ */
+const BOOLEAN = "boolean";
+/**
+ * A reference to the `"number"` type.
+ */
+const NUMBER = "number";
+/**
+ * A reference to the `"bigint"` type.
+ */
+const BIGINT = "bigint";
+/**
+ * A reference to the `"function"` type.
+ */
+const FUNCTION = "function";
+/**
+ * A reference to the `"string"` type.
+ */
+const STRING = "string";
+/**
+ * A reference to the `"symbol"` type.
+ */
+const SYMBOL = "symbol";
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * The base class that must be extended by objects to be indentified by the
+ * Angular Toolbox Subscription Service.
+ */
+class IdentifiableComponent {
+    constructor() {
+        /**
+         * @private
+         */
+        this._uuid = Uuid.build();
+    }
+    /**
+     * Returns the unique identifier for this object.
+     *
+     * @returns An instance of the `Uuid` class.
+     */
+    getID() {
+        return this._uuid;
+    }
+}
+;
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * The base class for all directives that are responsible for navigation whithin ab Angular app.
+ */
+class NavigationDirectiveBase {
+    /**
+     * @private
+     */
+    constructor(elmRef, role) {
+        this.elmRef = elmRef;
+        const elm = elmRef.nativeElement;
+        elm.role = role;
+        elm.tabIndex = 0;
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ */
+const ENTER_KEY = 'Enter';
+/**
+ * @private
+ */
+const ROUTER_LINK_REF = 'ng-reflect-router-link';
+/**
+ * An easy-to-use directive that enables keyboard navigation and provides support for keyboard "Enter" key events.
+ */
+class ButtonRoleDirective extends NavigationDirectiveBase {
+    /**
+     * @private
+     */
+    onKeyup(event, value) {
+        if (event.key !== ENTER_KEY)
+            return;
+        this.processEvent(event, value);
+    }
+    /**
+     * @private
+     */
+    onClick(event, value) {
+        if (this.delegateClick === undefined)
+            return;
+        this.processEvent(event, value);
+    }
+    /**
+     * @private
+     */
+    constructor(elmRef, _router) {
+        super(elmRef, BUTTON_ROLE);
+        this._router = _router;
+        /**
+         * Dispatches events when the user presses the "Enter" key.
+         */
+        this.enter = new EventEmitter();
+        /**
+         * @private
+         */
+        this._routerLinkRef = null;
+    }
+    /**
+     * @private
+     */
+    ngAfterViewInit() {
+        const elm = this.elmRef.nativeElement;
+        this._routerLinkRef = elm.getAttribute(ROUTER_LINK_REF);
+    }
+    /**
+     * @private
+     */
+    processEvent(event, value) {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        if (this._routerLinkRef) {
+            this._router.navigate([this._routerLinkRef]);
+            return;
+        }
+        this.elmRef.nativeElement.blur();
+        this.enter.emit(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ButtonRoleDirective, deps: [{ token: i0.ElementRef }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.3", type: ButtonRoleDirective, isStandalone: true, selector: "[buttonRole]", inputs: { delegateClick: "delegateClick" }, outputs: { enter: "enter" }, host: { listeners: { "keyup": "onKeyup($event,$event.target.value)", "click": "onClick($event,$event.target.value)" } }, providers: [
+            RouterModule
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ButtonRoleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[buttonRole]',
+                    providers: [
+                        RouterModule
+                    ],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.Router }], propDecorators: { enter: [{
+                type: Output
+            }], delegateClick: [{
+                type: Input
+            }], onKeyup: [{
+                type: HostListener,
+                args: ['keyup', ["$event", "$event.target.value"]]
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ["$event", "$event.target.value"]]
+            }] } });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * An easy-to-use directive that enables keyboard navigation and provides support for navigating to an external URL.
+ */
+class NavigateToUrlDirective extends NavigationDirectiveBase {
+    /**
+     * @private
+     */
+    onClick() {
+        const HREF = this.href;
+        if (!HREF)
+            throw new ReferenceError("href attribute is not defined.");
+        this._document.defaultView.location.href = HREF;
+    }
+    /**
+     * @private
+     */
+    constructor(_document, elmRef) {
+        super(elmRef, LINK_ROLE);
+        this._document = _document;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NavigateToUrlDirective, deps: [{ token: DOCUMENT }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.3", type: NavigateToUrlDirective, isStandalone: true, selector: "[navigateToUrl]", inputs: { href: "href" }, host: { listeners: { "click": "onClick()" } }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NavigateToUrlDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[navigateToUrl]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ElementRef }], propDecorators: { href: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * An internal convenient object that defined default `ScrollIntoViewOptions` objects.
+ */
+const DEFAULT_SCROLL_BEHAVIOR = { behavior: "smooth", block: "start", inline: "nearest" };
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * Provides functionality to activate anchor navigation through the native Angular router.
+ */
+class AnchorLinklDirective extends NavigationDirectiveBase {
+    /**
+     * @private
+     */
+    onClick(event) {
+        event.preventDefault();
+        const HREF = this.href;
+        this._router.navigate([], { fragment: HREF.slice(1) });
+        this._document.querySelector(HREF).scrollIntoView(DEFAULT_SCROLL_BEHAVIOR);
+    }
+    /**
+     * @private
+     */
+    constructor(_document, elmRef, _router) {
+        super(elmRef, LINK_ROLE);
+        this._document = _document;
+        this._router = _router;
+    }
+    /**
+     * @private
+     */
+    ngAfterViewInit() {
+        const HREF = this.href;
+        if (!HREF)
+            throw new ReferenceError("href attribute is not defined.");
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AnchorLinklDirective, deps: [{ token: DOCUMENT }, { token: i0.ElementRef }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.3", type: AnchorLinklDirective, isStandalone: true, selector: "[anchorLink]", inputs: { href: "href" }, host: { listeners: { "click": "onClick($event)" } }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AnchorLinklDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[anchorLink]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ElementRef }, { type: i1.Router }], propDecorators: { href: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ */
+const CHILD_LIST_TYPE = "childList";
+/**
+ * Allows injection of any value into an HTML element container (`div`, `button`, etc...).
+ * A rendered event is emitted after the injected content has been rendered and is
+ * available for DOM manipulation.
+ */
+class ContentRendererDirective {
+    /**
+     * @private
+     */
+    constructor(_elmRef) {
+        this._elmRef = _elmRef;
+        /**
+         * Dispatches events when the content of the HTML element has been rendered.
+         */
+        this.rendered = new EventEmitter();
+        const nativeElement = this._elmRef.nativeElement;
+        this._observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type === CHILD_LIST_TYPE)
+                    this.rendered.emit(nativeElement);
+            });
+        });
+    }
+    /**
+     * @private
+     */
+    ngOnDestroy() {
+        this._observer.disconnect();
+    }
+    /**
+     * @private
+     */
+    ngOnInit() {
+        this._observer.observe(this._elmRef.nativeElement, { attributes: false, childList: true, characterData: false });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ContentRendererDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.3", type: ContentRendererDirective, isStandalone: true, selector: "[contentRenderer]", outputs: { rendered: "rendered" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ContentRendererDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[contentRenderer]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { rendered: [{
+                type: Output
+            }] } });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+;
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * The default provider for the `VersionService` configuration. You typically define
+ * the custom properties in the main `NgModule` declaration to initialize the application
+ * config:
+ *
+ * @NgModule({
+ * ...
+ * providers: [
+ *   { provide: VERSION_CONFIG, useValue: { major: 1, minor: 2, patch: 12 } }
+ * ],
+ * ...
+ * });
+ */
+const VERSION_CONFIG = {
+    /**
+     * Specifies the major number of this config.
+     */
+    major: 0,
+    /**
+     * Specifies the minor number of this config.
+     */
+    minor: 0,
+    /**
+     * Specifies the patch number of this config.
+     */
+    patch: 0,
+    /**
+     * Specifies the timestamp that corresponds to the build date for this `Version` object.
+     * Default value is `NaN`.
+     */
+    buildTimestamp: NaN
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * Reference to the dark mode default storage key.
+ */
+const STORAGE_KEY = "dark-mode-key";
+/**
+ * Reference to the dark mode default css property.
+ */
+const CSS_PROP = "dark-mode";
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * The default provider for the `DarkModeService` configuration. You typically define
+ * the custom properties in the main NgModule declaration to initialize the app dark mode:
+ *
+ * @NgModule({
+ * ...
+ * providers: [
+ *   { provide: DARK_MODE_CONFIG, useValue: { enableDarkMode: true } }
+ * ],
+ * ...
+ * });
+ */
+const DARK_MODE_CONFIG = {
+    /**
+     * Indicates whether the dark mode uses browser settings (`true`), or not (`false`).
+     * Default value is `false`.
+     */
+    darkModeEnabled: false,
+    /**
+     * Indicates whether the dark mode uses browser settings (`true`), or not (`false`).
+     * Default value is `false`.
+     */
+    detectBrowserSettings: false,
+    /**
+     * CSS property name used to set the dark mode look and feel.
+     * Default value is `'dark-mode'`.
+     */
+    cssProperty: CSS_PROP,
+    /**
+     * Reference to the key value used to persist the dark mode state to local storage.
+     * Default value is `'dark-mode-key'`.
+     */
+    storageKey: STORAGE_KEY
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * A lightweight service that helps to manage unregistration issues of Angular subscriptions.
+ */
+class SubscriptionService {
+    constructor() {
+        /**
+         * @private
+         * Stores an internal reference to the last reference used with the `register()`
+         * method.
+         */
+        this._lastRef = null;
+        /**
+         * @private
+         * The internal `Subscription` instances storage.
+         */
+        this._subMap = new Map();
+    }
+    /**
+     * Stores a new `Subscription` instance associated with the specified reference.
+     *
+     * @param ref The reference for which to store a new `Subscription` instance.
+     *            Can be either a string or an `Identifiable` object.
+     * @param subscription The `Subscription` instance to register.
+     *
+     * @returns A reference to this `SubscriptionService` instance.
+     */
+    register(ref, subscription) {
+        const REF = this.getRef(ref);
+        this._lastRef = REF;
+        if (!this._subMap.has(REF))
+            this._subMap.set(REF, []);
+        this._subMap.get(REF)?.push(subscription);
+        return this;
+    }
+    /**
+     * Stores a new `Subscription` instance associated with the reference specified
+     * by the last `register()` method invokation.
+     *
+     * @param subscription The `Subscription` instance to register.
+     *
+     * @returns A reference to this `SubscriptionService` instance.
+     */
+    append(subscription) {
+        if (!this._lastRef)
+            throw new SubscriptionError("Illegal Access Error: you must call the register() method before invoking the append() method.");
+        return this.register(this._lastRef, subscription);
+    }
+    /**
+     * Unsubscribes and removes all `Subscription` instances associated with the specified reference.
+     *
+     * @param ref The reference for which to remove all `Subscription` instances.
+     *            Can be either a string or an `Identifiable` object.
+     *
+     * @returns `true` whether the specified reference exists; `false` otherwise.
+     */
+    clearAll(ref) {
+        const REF = this.getRef(ref);
+        let result = false;
+        if (this._lastRef === REF)
+            this._lastRef = null;
+        if (this._subMap.has(REF)) {
+            this._subMap.get(REF)?.forEach(subscription => {
+                if (!subscription.closed)
+                    subscription.unsubscribe();
+            });
+            this._subMap.delete(REF);
+            result = true;
+        }
+        return result;
+    }
+    /**
+     * Returns all `Subscription` instances associated with the specified reference.
+     *
+     * @param ref The reference for which to remove get `Subscription` instances.
+     *            Can be either a string or an `Identifiable` object.
+     *
+     * @returns All `Subscription` instances associated with the specified reference, or
+     *          `null` whether the specified reference does not exists.
+     */
+    get(ref) {
+        return this._subMap.get(this.getRef(ref)) || null;
+    }
+    /**
+     * @private
+     * Returns the string reference for the regsitration process.
+     *
+     * @param ref The reference to be used the regsitration process.
+     *            Can be either a string or an `Identifiable` object.
+     *
+     * @returns the string reference for the regsitration process.
+     */
+    getRef(ref) {
+        let targetRef;
+        if (typeof ref === "string")
+            targetRef = ref;
+        else if (ref instanceof IdentifiableComponent)
+            targetRef = ref.getID().toString();
+        else
+            throw new TypeError("ref must be of type of string or Identifiable");
+        return targetRef;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: SubscriptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: SubscriptionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: SubscriptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+// --> Internal constants
+/**
+ * @private
+ */
+const ADD_ACTION = "add";
+/**
+ * @private
+ */
+const REMOVE_ACTION = "remove";
+/**
+ * @private
+ */
+const TRUE = "true";
+/**
+ * A lightweight service that provides Dark Mode implementation for your Angular application.
+ */
+class DarkModeService {
+    /**
+     * @private
+     * Creates a new `DarkModeService` instance.
+     *
+     * @param _document The reference to the `Document` singleton.
+     * @param config The reference to the `DarkModeConfig` provider.
+     */
+    constructor(_document, config) {
+        this._document = _document;
+        /**
+         * @private
+         */
+        this._darkModeEnabled = false;
+        /**
+         * @private
+         */
+        this._cssProperty = CSS_PROP;
+        /**
+         * @private
+         */
+        this._storageKey = STORAGE_KEY;
+        /**
+         * The callback function that is triggered when the dark mode changes.
+         *
+         * @typeParam `EventEmitter<boolean>` the value returned by the `darkModeEnabled()` property.
+         */
+        this.change = new EventEmitter(true);
+        this.initDarkMode(config);
+    }
+    /**
+     * Toogles the dark mode state.
+     */
+    toggleDarkMode() {
+        this._darkModeEnabled ? this.disableDarkMode() : this.enableDarkMode();
+    }
+    /**
+     * Sets the dark mode state to active.
+     */
+    enableDarkMode() {
+        this.setDarkMode(ADD_ACTION);
+        this.setStoredDarkMode();
+    }
+    /**
+     * Sets the dark mode state to inactive.
+     */
+    disableDarkMode() {
+        this.setDarkMode(REMOVE_ACTION);
+        this.setStoredDarkMode();
+    }
+    /**
+     * Returns a `boolean` value that indicates whether the dark mode state is active (`true`), or not (`false`).
+     *
+     * @returns `true` whether the dark mode state is active; `false` otherwise.
+     */
+    darkModeEnabled() {
+        return this._darkModeEnabled;
+    }
+    /**
+     * Returns the value of the CSS property as defined by the config provider.
+     *
+     * @returns The value of the CSS property.
+     */
+    getCssProperty() {
+        return this._cssProperty;
+    }
+    /**
+     * Returns the value of the storage key as defined by the config provider.
+     *
+     * @returns The value of the storage key.
+     */
+    getStorageKey() {
+        return this._storageKey;
+    }
+    /**
+     * Removes the dark mode information from local storage.
+     */
+    invalidateStorage() {
+        localStorage.removeItem(this._storageKey);
+    }
+    /**
+     * @private
+     */
+    initDarkMode(config) {
+        this._darkModeEnabled = config.darkModeEnabled || false;
+        this._cssProperty = config.cssProperty || CSS_PROP;
+        this._storageKey = config.storageKey || STORAGE_KEY;
+        if (this._darkModeEnabled) {
+            this.enableDarkMode();
+        }
+        else {
+            this.initStoredDarkMode();
+        }
+        if (config.detectBrowserSettings)
+            this.initBrowserMode();
+    }
+    /**
+     * @private
+     */
+    initStoredDarkMode() {
+        const result = localStorage.getItem(this._storageKey);
+        if (result === TRUE)
+            this.enableDarkMode();
+    }
+    /**
+     * @private
+     */
+    setStoredDarkMode() {
+        const data = String(this._darkModeEnabled);
+        localStorage.setItem(this._storageKey, data);
+    }
+    /**
+     * @private
+     */
+    setDarkMode(action) {
+        const classList = this._document.body.classList;
+        if (action === ADD_ACTION) {
+            classList.add(this._cssProperty);
+            this._darkModeEnabled = true;
+        }
+        else if (action === REMOVE_ACTION) {
+            classList.remove(this._cssProperty);
+            this._darkModeEnabled = false;
+        }
+        this.change.emit(this._darkModeEnabled);
+    }
+    /**
+     * @private
+     */
+    initBrowserMode() {
+        if (this.matchDarkTheme())
+            return this.enableDarkMode();
+        this.disableDarkMode();
+    }
+    /**
+     * @private
+     */
+    matchDarkTheme() {
+        return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: DarkModeService, deps: [{ token: DOCUMENT }, { token: DARK_MODE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: DarkModeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: DarkModeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DARK_MODE_CONFIG]
+                }] }] });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * A lightweight service that provides scrolling capabilities to your Angular application.
+ */
+class ScrollService {
+    /**
+     * @private
+     * Creates a new `ScrollService` instance.
+     *
+     * @param _document The reference to the `Document` singleton.
+     */
+    constructor(_document) {
+        this._document = _document;
+        /**
+         * The callback function that is triggered when a scroll operation is performed.
+         *
+         * @typeParam `EventEmitter<Event>` The reference to the original scroll event.
+         */
+        this.onScroll = new EventEmitter();
+        window.addEventListener("scroll", (e) => {
+            this.onScroll.next(e);
+        });
+    }
+    /**
+     * Scrolls the ancestor containers of the element with the specified selector such that
+     * this element  is visible to the user.
+     *
+     * @param selector The selector of the target element.
+     * @param arg A `boolean` value:
+     * If `true`, the top of the element will be aligned to the top of the visible area of the
+     * scrollable ancestor.
+     * If `false`, the bottom of the element will be aligned to the bottom of the visible area
+     * of the scrollable ancestor.
+     * @param arg A dictionary containing the scroll parameters.
+     */
+    scrollIntoView(selector, arg) {
+        const elm = this._document.querySelector(selector);
+        if (elm)
+            elm.scrollIntoView(arg);
+    }
+    /**
+     * Scrolls the app viewport to the top of the browser window.
+     *
+     * @param behavior Specifies whether the scrolling should animate smoothly (`smooth`),
+     *                 happen instantly in a single jump (`instant`), or let the browser
+     *                 choose (`auto`, `default`).
+     */
+    gotoTop(behavior = 'smooth') {
+        const options = {
+            top: 0,
+            behavior: behavior
+        };
+        this.scroll(options);
+    }
+    /**
+     * Scrolls the app viewport according to the specified options, into the browser window.
+     *
+     * @param options A dictionary containing the scroll parameters.
+     */
+    scroll(options) {
+        window.scroll(options);
+    }
+    /**
+     * Scrolls the app viewport by the specified `x/y` coordinates, into the browser window.
+     *
+     * @param x The horizontal pixel value that you want to scroll by.
+     * @param y The vertical  pixel value that you want to scroll by.
+     */
+    scrollBy(x, y) {
+        window.scrollBy(x, y);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ScrollService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ScrollService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ScrollService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * The `AppBridge` class is an internal invoker utility that executes commans declared
+ * by the `AppBridgeService` instance.
+ */
+class AppBridge {
+    constructor() {
+        /**
+         * @private
+         * Stores all commands registered by the `AppBridgeService` instance.
+         */
+        this._commandMap = new Map();
+    }
+    /**
+     * Executes the command with the specified `name` parameter.
+     *
+     * @param name The reference to the command to execute.
+     * @param args The list of parmeters so be sent to the command.
+     */
+    execute(name, ...args) {
+        const command = this._commandMap.get(name);
+        if (command)
+            command.apply(null, args);
+        else
+            throw new AppBridgeError(`Invalid AppBridge command: method width name '${name}' does not exist.`);
+    }
+    /**
+     * Registers a command.
+     *
+     * @param name The name of the command to register.
+     * @param command The command to register.
+     */
+    addCommand(name, command) {
+        this._commandMap.set(name, command);
+    }
+    /**
+     * Unregisters a command.
+     *
+     * @param name The name of the command to unregister.
+     *
+     * @returns `true` whether the command existed and has been removed; `false` otherwise.
+     */
+    removeCommand(name) {
+        return this._commandMap.delete(name);
+    }
+    /**
+     * Returns the command with the specified name.
+     *
+     * @param name The name of the command to retrieve.
+     *
+     * @returns Returns the command associated with the specified name.
+     *          If no command is associated with the specified name, `undefined` is returned.
+     */
+    getCommand(name) {
+        return this._commandMap.get(name);
+    }
+    /**
+     * Returns a boolean indicating whether a command with the specified name exists or not.
+     *
+     * @param name The name of the command to retrieve.
+     *
+     * @returns Returns `true` whether the command exists; `false` otherwise.
+     */
+    hasCommand(name) {
+        return this._commandMap.has(name);
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ */
+const APP_PRIDGE_REF = "appBridge";
+/**
+ * @private
+ */
+const HREF = "href";
+/**
+ * @private
+ */
+const NATIVE_COMMANDS = "navigate|goToAnchor|declareCommand|deleteCommand|getCommand";
+/**
+ * A utility service that allows dynamically injected HTML fragments, to interact with the Angular application.
+ */
+class AppBrigeService {
+    /**
+     * @private
+     */
+    constructor(_router, _zone, _document) {
+        this._router = _router;
+        this._zone = _zone;
+        this._document = _document;
+        this._defaultView = _document.defaultView;
+        this._appBridge = new AppBridge();
+        if (!this._defaultView[APP_PRIDGE_REF])
+            this._defaultView[APP_PRIDGE_REF] = this;
+    }
+    /**
+     * Provides the ability to invoke the `navigate()` method of the Angular app router.
+     *
+     * @param commands The commands array as specified by the Angular router `navigate()` method.
+     * @param extras The navigation options as specified by the Angular router `navigate()` method.
+     * @return `Promise` that resolves to `true` when navigation succeeds, or `false` when navigation fails.
+     *
+     * @see https://angular.dev/api/router/Router#navigate
+     */
+    navigate(commands, extras) {
+        return this._zone.run(() => {
+            return this._router.navigate(commands, extras);
+        });
+    }
+    /**
+     * Allows to scroll to the fragment specified by the `href` attribute when the user element interact with the associated element.
+     *
+     * @example
+     * <a href="#myAnchor" onclick="appBridge.goToAnchor(event)">My Section</a></code>
+     *
+     * @param event The event that triggers the anchor navigation.
+     * @return `Promise` that resolves to `true` when navigation succeeds, or `false` when navigation fails.
+     *
+     * @see https://angular.dev/api/router/Router#navigate
+     */
+    goToAnchor(event) {
+        event.preventDefault();
+        const anchor = event.target.getAttribute(HREF);
+        if (!anchor)
+            throw new ReferenceError("href attribute is not defined.");
+        const elm = this._document.querySelector(anchor);
+        if (!elm)
+            return new Promise((resolve) => resolve(false));
+        elm.scrollIntoView(DEFAULT_SCROLL_BEHAVIOR);
+        return this._zone.run(() => {
+            return this._router.navigate([], { fragment: anchor.slice(1) });
+        });
+    }
+    /**
+     * Declares a new JavaScript command to be used with dynamically loaded documents.
+     *
+     * @param name The name of the command to declare.
+     * @param command The reference to a JavaScript command to be used with dynamically loaded documents.
+     */
+    declareCommand(name, command) {
+        this.checkCommandName(name);
+        if (!this._appBridge.hasCommand(name)) {
+            this._appBridge.addCommand(name, command);
+            Object.defineProperty(this, name, {
+                configurable: true,
+                get: function () {
+                    return this._appBridge.getCommand(name);
+                }
+            });
+        }
+    }
+    /**
+     * Unregisters a JavaScript command previously referenced with the `declareCommand()` method.
+     *
+     * @param name The name of the command to remove.
+     *
+     * @returns `true` whether the command existed and has been removed; `false` otherwise.
+     */
+    deleteCommand(name) {
+        this.checkCommandName(name);
+        if (!this._appBridge.removeCommand(name))
+            return false;
+        delete this._defaultView[APP_PRIDGE_REF][name];
+        return true;
+    }
+    /**
+     * Returns the JavaScript command previously referenced with the `declareCommand()` method.
+     *
+     * @param name The name of the command to retrieve.
+     * @returns The JavaScript command previously referenced with the specified `name` parameter.
+     *          If no command is found, returns `undefined`.
+     */
+    getCommand(name) {
+        return this._appBridge.getCommand(name);
+    }
+    /**
+     * @private
+     */
+    checkCommandName(name) {
+        if (NATIVE_COMMANDS.includes(name))
+            throw new AppBridgeError("Command name cannot be the reference to a native command: " + name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AppBrigeService, deps: [{ token: i1.Router }, { token: i0.NgZone }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AppBrigeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AppBrigeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * Specifies the semantic versioning of an API.
+ */
+class VersionImpl {
+    /**
+     * @private
+     */
+    constructor(major, minor, patch, buildTimeStamp) {
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+        this.buildTimeStamp = buildTimeStamp;
+    }
+    /**
+     * Returns a string representation of this `Version` object in the form `M.m.p`, where
+     * `M` represents the major number, `m` represents the minor number and `p` represents
+     * the patch number of this `VersionImpl` instance.
+     *
+     * @returns A string representation of this `VersionImpl` instance.
+     */
+    toString() {
+        return `${this.major}.${this.minor}.${this.patch}`;
+    }
+}
+;
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * A lightweight service that provides Semantic Versioning implementation for your Angular projects.
+ */
+class VersionService {
+    /**
+     * Creates a new VersionService instance.
+     * @param config the reference to the VersionConfig provider.
+     */
+    constructor(config) {
+        this._version = new VersionImpl(config.major, config.minor, config.patch, config.buildTimestamp);
+    }
+    /**
+     * Returns the version of the associated Angular project.
+     *
+     * @return the version of the associated Angular project.
+     */
+    getVersion() {
+        return this._version;
+    }
+    /**
+     * Returns the build timestamp of the associated Angular project.
+     *
+     * @return the  build timestamp of the associated Angular project.
+     */
+    getBuildTimestamp() {
+        return this._version.buildTimeStamp;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: VersionService, deps: [{ token: VERSION_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: VersionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: VersionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VERSION_CONFIG]
+                }] }] });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * Provides the list of HTTP verbs.
+ */
+var HTTPMethodRef;
+(function (HTTPMethodRef) {
+    /**
+     * @private
+     * A reference to the `connect` route associated with the `CONNECT` HTTP verb.
+     */
+    HTTPMethodRef["CONNECT"] = "connect";
+    /**
+     * @private
+     * A reference to the `delete` route associated with the `DELETE` HTTP verb.
+     */
+    HTTPMethodRef["DELETE"] = "delete";
+    /**
+     * @private
+     * A reference to the `get` route associated with the `GET` HTTP verb.
+     */
+    HTTPMethodRef["GET"] = "get";
+    /**
+     * @private
+     * A reference to the `head` route associated with the `HEAD` HTTP verb.
+     */
+    HTTPMethodRef["HEAD"] = "head";
+    /**
+     * @private
+     * A reference to the `options` route associated with the `OPTIONS` HTTP verb.
+     */
+    HTTPMethodRef["OPTIONS"] = "options";
+    /**
+     * @private
+     * A reference to the `patch` route associated with the `PATCH` HTTP verb.
+     */
+    HTTPMethodRef["PATCH"] = "patch";
+    /**
+     * @private
+     * A reference to the `post` route associated with the `POST` HTTP verb.
+     */
+    HTTPMethodRef["POST"] = "post";
+    /**
+     * @private
+     * A reference to the `put` route associated with the `PUT` HTTP verb.
+     */
+    HTTPMethodRef["PUT"] = "put";
+    /**
+     * @private
+     * A reference to the `trace` route associated with the `TRACE` HTTP verb.
+     */
+    HTTPMethodRef["TRACE"] = "trace";
+})(HTTPMethodRef || (HTTPMethodRef = {}));
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * The reference to the default delimiter.
+ * Value is `"/"`.
+ */
+const DEFAULT_DELIMITER = "/";
+/**
+ * @private
+ * The reference to the case insensitive flag.
+ * Value is `"i"`.
+ */
+const I_FLAG = "i";
+/**
+ * @private
+ * The reference to the global flag.
+ * Value is `"g"`.
+ */
+const G_FLAG = "g";
+/**
+ * @private
+ * The reference to the `{` `TokenType`.
+ */
+const LEFT_CURLY_BRACE = "{";
+/**
+ * @private
+ * The reference to the `}` `TokenType`.
+ */
+const RIGHT_CURLY_BRACE = "}";
+/**
+ * @private
+ * The reference to the `*` `TokenType`.
+ */
+const ASTERISK = "*";
+/**
+ * @private
+ * The reference to the `+` `TokenType`.
+ */
+const PLUS = "+";
+/**
+ * @private
+ * The reference to the `?` `TokenType`.
+ */
+const QUESTION_MARK = "?";
+/**
+ * @private
+ * The reference to the `NAME` `TokenType`.
+ */
+const NAME = "NAME";
+/**
+ * @private
+ * The reference to the `PATTERN` `TokenType`.
+ */
+const PATTERN = "PATTERN";
+/**
+ * @private
+ * The reference to the `CHAR` `TokenType`.
+ */
+const CHAR = "CHAR";
+/**
+ * @private
+ * The reference to the `ESCAPED` `TokenType`.
+ */
+const ESCAPED = "ESCAPED";
+/**
+ * @private
+ * The reference to the `END` `TokenType`.
+ */
+const END = "END";
+/**
+ * @private
+ * The reference to the semi colon (`;`) character.
+ */
+const SEMI_COLON = ";";
+/**
+ * @private
+ * The reference to the colon (`:`) character.
+ */
+const COLON = ":";
+/**
+ * @private
+ * The reference to the left parenthesis (`(`) character.
+ */
+const LEFT_PARENTHESIS = "(";
+/**
+ * @private
+ * The reference to the right parenthesis (`)`) character.
+ */
+const RIGHT_PARENTHESIS = ")";
+/**
+ * @private
+ * The reference to the escaped back slash (`\\`) character.
+ */
+const ESC_BACK_SLASH = "\\";
+/**
+ * @private
+ * The reference to the carret (`^`) character.
+ */
+const CARRET = "^";
+/**
+ * @private
+ * The reference to the carret (`$`) character.
+ */
+const DOLLAR = "$";
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ */
+const ESCAPE_REGEXP = /([.+*?=^!:${}()[\]|/\\])/g;
+/**
+ * @private
+ */
+const ESCAPE_VALUE = "\\$1";
+/**
+ * @private
+ * Escape a regular expression string.
+ *
+ * @param str The regular expression string to escape.
+ * @returns An escaped a regular expression string.
+ */
+const escapeRegexpString = (str) => {
+    return str.replace(ESCAPE_REGEXP, ESCAPE_VALUE);
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ * Get the flags for a regexp from the spcified options.
+ *
+ * @param options The options used to determine the flags for a regexp.
+ * @returns The flags for a regexp depending on the spcified options.
+ */
+const getFlags = (options) => {
+    return options.sensitive ? EMPTY_STRING : I_FLAG;
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ * Returns a function that converts a token into a regexp string.
+ */
+const toKeyRegexp = (stringify, delimiter) => {
+    const segmentPattern = `[^${escapeRegexpString(delimiter)}]+?`;
+    return (key) => {
+        const prefix = key.prefix ? stringify(key.prefix) : EMPTY_STRING;
+        const suffix = key.suffix ? stringify(key.suffix) : EMPTY_STRING;
+        const modifier = key.modifier || EMPTY_STRING;
+        if (key.name) {
+            const pattern = key.pattern || segmentPattern;
+            if (key.modifier === PLUS || key.modifier === ASTERISK) {
+                const mod = key.modifier === ASTERISK ? QUESTION_MARK : EMPTY_STRING;
+                const split = key.separator ? stringify(key.separator) : EMPTY_STRING;
+                return `(?:${prefix}((?:${pattern})(?:${split}(?:${pattern}))*)${suffix})${mod}`;
+            }
+            return `(?:${prefix}(${pattern})${suffix})${modifier}`;
+        }
+        return `(?:${prefix}${suffix})${modifier}`;
+    };
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ * Escape and repeat loose characters for regular expressions.
+ *
+ * @param value The string expression to escape.
+ * @param loose
+ * @returns The escaped string transfromed from the original string expression.
+ */
+const looseReplacer = (value, loose) => {
+    return loose ? `${escapeRegexpString(value)}+` : escapeRegexpString(value);
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ * Encode all non-delimiter characters using the encode function.
+ */
+const toStringify = (loose, delimiter) => {
+    if (!loose)
+        return escapeRegexpString;
+    const re = new RegExp(`[^${escapeRegexpString(delimiter)}]+|(.)`, G_FLAG);
+    return (value) => value.replace(re, looseReplacer);
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @Private
+ * Expose a function for taking tokens and returning a RegExp.
+ */
+const tokenDataToRegexp = (data, keys, options) => {
+    const { trailing = true, start = true, end = true, loose = true, } = options;
+    const stringify = toStringify(loose, data.delimiter);
+    const keyToRegexp = toKeyRegexp(stringify, data.delimiter);
+    let pattern = start ? CARRET : EMPTY_STRING;
+    for (const token of data.tokens) {
+        if (typeof token === STRING) {
+            pattern += stringify(token);
+        }
+        else {
+            if (token.name)
+                keys.push(token);
+            pattern += keyToRegexp(token);
+        }
+    }
+    if (trailing)
+        pattern += `(?:${stringify(data.delimiter)})?`;
+    pattern += end ? DOLLAR : `(?=${escapeRegexpString(data.delimiter)}|$)`;
+    // URLs in general are case-sensitive (with the exception of machine names).
+    // See https://www.w3.org/TR/WD-html40-970708/htmlweb.html
+    // Note that default modifier is "i".
+    return new RegExp(pattern, getFlags(options));
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ * Tokenized path instance.
+ */
+class TokenData {
+    /**
+     * @private
+     * Creates a new `TokenData` instance.
+     *
+     * @param tokens A list of `Token` objects.
+     * @param delimiter the string delimiter for this `TokenData` instance.
+     */
+    constructor(tokens, delimiter) {
+        this.tokens = tokens;
+        this.delimiter = delimiter;
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ */
+class Iter {
+    /**
+     * @private
+     */
+    constructor(_tokens) {
+        this._tokens = _tokens;
+        /**
+         * @private
+         */
+        this._index = 0;
+    }
+    /**
+     * @private
+     */
+    tryConsume(type) {
+        const token = this.peek();
+        if (token.type !== type)
+            return;
+        this._index++;
+        return token.value;
+    }
+    /**
+     * @private
+     */
+    consume(type) {
+        const value = this.tryConsume(type);
+        if (value !== undefined)
+            return value;
+        const { type: nextType, index } = this.peek();
+        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: https://git.new/pathToRegexpError`);
+    }
+    /**
+     * @private
+     */
+    text() {
+        let result = EMPTY_STRING;
+        let value;
+        while ((value = this.tryConsume(CHAR) || this.tryConsume(ESCAPED))) {
+            result += value;
+        }
+        return result;
+    }
+    /**
+     * @private
+     */
+    modifier() {
+        return this.tryConsume(QUESTION_MARK) || this.tryConsume(ASTERISK) || this.tryConsume(PLUS) || EMPTY_STRING;
+    }
+    /**
+     * @private
+     */
+    peek() {
+        return this._tokens[this._index];
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ * A markup interface for token types consumed by `Lexer` objects.
+ */
+const SIMPLE_TOKENS = {
+    "!": "!",
+    "@": "@",
+    ";": ";",
+    "*": "*",
+    "+": "+",
+    "?": "?",
+    "{": "{",
+    "}": "}",
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ */
+const ID_CHAR = /^\p{XID_Continue}$/u;
+/**
+ * @private
+ * A lexer method that tokenizes input string.
+ *
+ * @param str The string expression to analyse.
+ * @returns A new `Iter`object instance built from the specified input string.
+ */
+const lexer = (str) => {
+    const chars = [...str];
+    const tokens = [];
+    let i = 0;
+    while (i < chars.length) {
+        const value = chars[i];
+        const type = SIMPLE_TOKENS[value];
+        if (type) {
+            tokens.push({ type, index: i++, value });
+            continue;
+        }
+        if (value === ESC_BACK_SLASH) {
+            tokens.push({ type: ESCAPED, index: i++, value: chars[i++] });
+            continue;
+        }
+        if (value === COLON) {
+            let name = EMPTY_STRING;
+            while (ID_CHAR.test(chars[++i])) {
+                name += chars[i];
+            }
+            if (!name) {
+                throw new TypeError(`Missing parameter name at ${i}`);
+            }
+            tokens.push({ type: NAME, index: i, value: name });
+            continue;
+        }
+        if (value === LEFT_PARENTHESIS) {
+            const pos = i++;
+            let count = 1;
+            let pattern = EMPTY_STRING;
+            if (chars[i] === QUESTION_MARK) {
+                throw new TypeError(`Pattern cannot start with "?" at ${i}`);
+            }
+            while (i < chars.length) {
+                if (chars[i] === ESC_BACK_SLASH) {
+                    pattern += chars[i++] + chars[i++];
+                    continue;
+                }
+                if (chars[i] === RIGHT_PARENTHESIS) {
+                    count--;
+                    if (count === 0) {
+                        i++;
+                        break;
+                    }
+                }
+                else if (chars[i] === LEFT_PARENTHESIS) {
+                    count++;
+                    if (chars[i + 1] !== QUESTION_MARK) {
+                        throw new TypeError(`Capturing groups are not allowed at ${i}`);
+                    }
+                }
+                pattern += chars[i++];
+            }
+            if (count)
+                throw new TypeError(`Unbalanced pattern at ${pos}`);
+            if (!pattern)
+                throw new TypeError(`Missing pattern at ${pos}`);
+            tokens.push({ type: PATTERN, index: i, value: pattern });
+            continue;
+        }
+        tokens.push({ type: CHAR, index: i, value: chars[i++] });
+    }
+    tokens.push({ type: END, index: i, value: EMPTY_STRING });
+    return new Iter(tokens);
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ * A NOOP `Endoder` function.
+ * @param value The input string value.
+ * @returns The input string value.
+ */
+const NOOP_VALUE = (value) => value;
+/**
+ * @private
+ * Parse a string for the raw tokens.
+ */
+const stringToTokenData = (str, options = {}) => {
+    const { delimiter = DEFAULT_DELIMITER, encodePath = NOOP_VALUE, } = options;
+    const tokens = [];
+    const it = lexer(str);
+    let keyIndex = 0;
+    do {
+        const path = it.text();
+        if (path)
+            tokens.push(encodePath(path));
+        const name = it.tryConsume(NAME);
+        const pattern = it.tryConsume(PATTERN);
+        if (name || pattern) {
+            tokens.push({
+                name: name || String(keyIndex++),
+                pattern,
+            });
+            const next = it.peek();
+            if (next.type === ASTERISK) {
+                throw new TypeError(`Unexpected * at ${next.index}, you probably want \`/*\` or \`{/:foo}*\`: https://git.new/pathToRegexpError`);
+            }
+            continue;
+        }
+        const asterisk = it.tryConsume(ASTERISK);
+        if (asterisk) {
+            tokens.push({
+                name: String(keyIndex++),
+                pattern: `[^${escape(delimiter)}]*`,
+                modifier: ASTERISK,
+                separator: delimiter,
+            });
+            continue;
+        }
+        const open = it.tryConsume(LEFT_CURLY_BRACE);
+        if (open) {
+            const prefix = it.text();
+            const name = it.tryConsume(NAME);
+            const pattern = it.tryConsume(PATTERN);
+            const suffix = it.text();
+            const separator = it.tryConsume(SEMI_COLON) ? it.text() : prefix + suffix;
+            it.consume(RIGHT_CURLY_BRACE);
+            const modifier = it.modifier();
+            tokens.push({
+                name: name || (pattern ? String(keyIndex++) : EMPTY_STRING),
+                prefix: encodePath(prefix),
+                suffix: encodePath(suffix),
+                pattern,
+                modifier,
+                separator,
+            });
+            continue;
+        }
+        it.consume(END);
+        break;
+    } while (true);
+    return new TokenData(tokens, delimiter);
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * Reference to the original type for this class.
+ */
+const HTTP_MOCK_SERVICE = "HttpMockService";
+/**
+ * The `HttpMockService` class provides the API for managing HTTP mock configuration objects.
+ */
+class HttpMockService {
+    constructor() {
+        /**
+         * @private
+         * Ensures that class type is still accessible after TypeScript compilation.
+         */
+        this.type = HTTP_MOCK_SERVICE;
+        /**
+         * @private
+         * The list of IDs associated with each config object.
+         */
+        this._configIdList = [];
+        /**
+         * @private
+         * Stores the complete collection of mocking behaviors for each registered config.
+         */
+        this._configList = new Map();
+        /**
+         * @private
+         * The reference to the current app URL origin.
+         */
+        this.APP_ORIGIN = window.location.origin;
+    }
+    /**
+     * Adds the specified `HttpMockConfig` object to this `HttpMockService` instance.
+     *
+     * @param config The `HttpMockConfig` object to add to this `HttpMockService` instance.
+     * @Returns The `Uuid` instance associated with the added `HttpMockConfig` object.
+     */
+    addConfig(config) {
+        const origin = config.origin || this.APP_ORIGIN;
+        this.checkOrigin(origin);
+        let id = config.id;
+        if (!id) {
+            id = Uuid.build();
+            config.id = id;
+        }
+        else {
+            if (this.hasRegisteredConfig(id))
+                throw new HttpMockServiceError(`A config object has already been registered with the id: ["${id.toString()}"].`);
+        }
+        this._configIdList.push(id);
+        const uuid = id.toString();
+        config.interceptors.forEach((interceptor) => this.extractConfig(interceptor, origin, uuid));
+        return id;
+    }
+    /**
+     * Returns the current app URL origin.
+     *
+     * @returns A string that represents the current app URL origin.
+     */
+    getAppOrigin() {
+        return this.APP_ORIGIN;
+    }
+    /**
+     * Removes the configuration registered with the specified `uuid` from this `HttpMockService` instance.
+     *
+     * @param uuid The UUID of the configuration to remove.
+     */
+    removeConfig(uuid) {
+        if (!this.hasRegisteredConfig(uuid))
+            return;
+        const configId = uuid.toString();
+        this._configList.forEach((value, key) => {
+            this.deleteConfigById(value, configId);
+            if (value.size === 0)
+                this._configList.delete(key);
+        });
+        this._configIdList.splice(this._configIdList.indexOf(uuid), 1);
+    }
+    /**
+     * Removes all registred configurations from this `HttpMockService` instance.
+     */
+    clearConfigs() {
+        this._configList.clear();
+        this._configIdList.length = 0;
+    }
+    /**
+     * Returns a boolean value that indicates whether a config with the specified UUID has been registered
+     * (`true`), or not (`false`).
+     *
+     * @param uuid The UUID of the config to check.
+     * @returns `true` whether a config with the specified UUID has been registered; `false` otherwise.
+     */
+    hasRegisteredConfig(uuid) {
+        return this._configIdList.indexOf(uuid) !== -1;
+    }
+    /**
+     * Returns the `RouteMockConfig` object associated with the specified `URL` instance and HTTP method.
+     *
+     * @param url The `URL` instance for which to find a route config.
+     * @param method The HTTP method for which to find a route config.
+     * @returns The `RouteMockConfig` object associated with the specified `URL` instance and HTTP method whether it exists;
+     *          `undefined` otherwise.
+     */
+    getRouteConfig(url, method) {
+        const urlConfigList = this._configList.get(url.origin);
+        const route = url.pathname;
+        let result = undefined;
+        if (!urlConfigList)
+            return result;
+        const methodList = urlConfigList.get(method);
+        if (!methodList)
+            return result;
+        let len = methodList.length - 1;
+        while (len >= 0) {
+            const methodMap = methodList[len];
+            const regexp = methodMap.regexp;
+            if (regexp.test(route)) {
+                result = {
+                    methodConfig: methodMap.methodMock,
+                    parameters: this.buildParameters(regexp, methodMap.keys, route)
+                };
+                break;
+            }
+            len--;
+        }
+        return result;
+    }
+    /**
+     * @rivate
+     */
+    buildParameters(regexp, keys, route) {
+        const execResult = regexp.exec(route);
+        if (!execResult)
+            return null;
+        const params = {};
+        let len = execResult.length - 1;
+        let i = 1;
+        for (; i <= len; ++i) {
+            const key = keys[i - 1];
+            params[key.name] = execResult[i];
+        }
+        return params;
+    }
+    /**
+     * @rivate
+     */
+    extractConfig(interceptor, globalOrigin, configId) {
+        const endpoints = interceptor.endpoints;
+        let origin = interceptor.origin;
+        if (origin)
+            this.checkOrigin(origin);
+        else
+            origin = globalOrigin;
+        if (!this._configList.has(origin))
+            this._configList.set(origin, new Map());
+        endpoints.forEach((endpoint) => {
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.GET, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.POST, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.PUT, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.DELETE, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.HEAD, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.OPTIONS, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.PATCH, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.CONNECT, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.TRACE, configId);
+        });
+    }
+    /**
+     * @rivate
+     */
+    extractEndpointConfig(origin, endpoint, method, configId) {
+        const ep = endpoint;
+        if (!ep[method])
+            return;
+        const originConfig = this._configList.get(origin);
+        const route = endpoint.route;
+        const data = stringToTokenData(route);
+        const keys = [];
+        const regexp = tokenDataToRegexp(data, keys, {});
+        if (!originConfig.has(method))
+            originConfig.set(method, []);
+        const methodConfig = originConfig.get(method);
+        methodConfig.push({
+            regexp: regexp,
+            keys: keys,
+            methodMock: ep[method],
+            configId: configId
+        });
+    }
+    /**
+     * @rivate
+     */
+    checkOrigin(origin) {
+        if (origin.endsWith(DEFAULT_DELIMITER))
+            throw new SyntaxError(`Origin must not end with a / character: ["${origin}"].`);
+    }
+    /**
+     * @rivate
+     */
+    deleteConfigById(storageMap, configId) {
+        storageMap.forEach((storage, key) => {
+            const cleanedConfig = this.cleanConfig(storage, configId);
+            if (cleanedConfig.length)
+                storageMap.set(key, cleanedConfig);
+            else
+                storageMap.delete(key);
+        });
+    }
+    /**
+     * @rivate
+     */
+    cleanConfig(storage, configId) {
+        return storage.filter((value) => value.configId !== configId);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: HttpMockService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: HttpMockService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: HttpMockService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * The definition function for the `@HttpMock` decorator.
+ *
+ * @param config The `HttpMockConfig` object used to initialize the HTTP Mocking Framework.
+ */
+const HttpMock = (config) => {
+    return (constructor) => {
+        const getMockService = (instance) => {
+            return Object.values(instance).find((v) => {
+                return (v.hasOwnProperty('type') && v.type === HTTP_MOCK_SERVICE);
+            });
+        };
+        const ngOnInit = constructor.prototype.ngOnInit;
+        const ngOnDestroy = constructor.prototype.ngOnDestroy;
+        const uiid = config.id || Uuid.build();
+        if (!ngOnDestroy)
+            throw new ReferenceError("Component must implement the OnDestroy interface.");
+        if (!ngOnInit)
+            throw new ReferenceError("Component must implement the OnInit interface.");
+        if (!config.id)
+            config.id = uiid;
+        constructor.prototype.ngOnInit = function () {
+            const mockService = getMockService(this);
+            if (!mockService)
+                throw new ReferenceError("No provider found for HttpMockService.");
+            mockService.addConfig(config);
+            ngOnInit.call(this);
+        };
+        constructor.prototype.ngOnDestroy = function () {
+            const mockService = getMockService(this);
+            // An exception is already thrown by the ngOnInit() method when HttpMockService is not provided.
+            // Following check statement prevents failure during Unit Testing:
+            if (mockService)
+                mockService.removeConfig(uiid);
+            ngOnDestroy.call(this);
+        };
+    };
+};
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ */
+const OK = "OK";
+/**
+ * A statefull builder for creating new `HttpResponseMock` instances.
+ */
+class HttpResponseMockBuilder {
+    constructor() {
+        /**
+         * @private
+         */
+        this._response = {
+            url: null,
+            body: null,
+            status: HttpStatusCode.Ok,
+            statusText: OK,
+            error: null,
+            delay: 0
+        };
+    }
+    /**
+     * Sets the body property of the new `HttpResponseMock` instance with the specified `body` value.
+     *
+     * @param body The value used to set the body property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    body(body) {
+        this._response.body = body;
+        return this;
+    }
+    /**
+     * Sets the headers property of the new `HttpResponseMock` instance with the specified `headers` value.
+     *
+     * @param headers The value used to set the `headers` property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    headers(headers) {
+        this._response.headers = headers;
+        return this;
+    }
+    /**
+     * Sets the `status` property of the new `HttpResponseMock` instance with the specified `status` value.
+     *
+     * @param status The value used to set the `status` property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    status(status) {
+        this._response.status = status;
+        return this;
+    }
+    /**
+     * Sets the `statusText` property of the new `HttpResponseMock` instance with the specified `statusText` value.
+     *
+     * @param statusText The value used to set the `statusText` property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    statusText(statusText) {
+        this._response.statusText = statusText;
+        return this;
+    }
+    /**
+     * Sets the `url` property of the new `HttpResponseMock` instance with the specified `url` value.
+     *
+     * @param url The value used to set the `url` property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    url(url) {
+        this._response.url = url;
+        return this;
+    }
+    /**
+     * Sets the `delay` property of the new `HttpResponseMock` instance with the specified `timer` duration.
+     * Maximum value is `10000` miliseconds (10 seconds).
+     *
+     * @param timer The value used to set the `delay` property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    delay(timer = 0) {
+        this._response.delay = timer;
+        return this;
+    }
+    /**
+     * Returns a new `HttpResponseMock` instance, built from the properties specified with the
+     * `HttpResponseMockBuilder` methods.
+     *
+     * @param error An optional value used to set the `error` property of the new `HttpResponseMock` instance.
+     *              The `error` parameter values take precedence over all other properties of the `HttpResponseMock`
+     *              instance.
+     * @returns A new `HttpResponseMock` instance.
+     */
+    response(error = null) {
+        this._response.error = error;
+        return this._response;
+    }
+}
+/**
+ * A utility function used to create new "chainable" `HttpResponseMockBuilder` instances.
+ *
+ * @returns A new `HttpResponseMockBuilder` instance.
+ */
+const httpResponseMock = () => new HttpResponseMockBuilder();
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * A statefull builder for creating new `HttpHeaders` instances.
+ */
+class HttpHeadersMockBuilder {
+    constructor() {
+        /**
+         * @private
+         */
+        this._headers = new HttpHeaders();
+    }
+    /**
+     * Sets the `"Cache-Control"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Cache-Control"` property of the new `HttpHeaders` instance.
+     * Default value is `"no-cache"`.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    cacheControl(value = "no-cache") {
+        this.setHeader("Cache-Control", value);
+        return this;
+    }
+    /**
+     * Sets the `"CContent-Type"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Content-Type"` property of the new `HttpHeaders` instance.
+     * Default value is `"application/json; charset=utf-8"`.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    contentType(value = "application/json; charset=utf-8") {
+        this.setHeader("Content-Type", value);
+        return this;
+    }
+    /**
+     * Sets the `"Priority"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Priority"` property of the new `HttpHeaders` instance.
+     * Default value is `"u=0, i"`.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    priority(value = "u=0, i") {
+        this.setHeader("Priority", value);
+        return this;
+    }
+    /**
+     * Sets the `"User-Agent"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"User-Agent"` property of the new `HttpHeaders` instance.
+     * Default value is the navigator user agent.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    userAgent(value = null) {
+        this.setHeader("User-Agent", value || navigator.userAgent);
+        return this;
+    }
+    /**
+     * Sets the `"Accept-Language"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Accept-Language"` property of the new `HttpHeaders` instance.
+     * Default value is the navigator language.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    acceptLanguage(value = null) {
+        this.setHeader("Accept-Language", value || navigator.language);
+        return this;
+    }
+    /**
+     * Sets the `"Accept"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Accept"` property of the new `HttpHeaders` instance.
+     * Default value is `'*\/*'`.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    accept(value = "*/*") {
+        this.setHeader("Accept", value);
+        return this;
+    }
+    /**
+     * Sets the `"Accept-Encoding"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Accept-Encoding"` property of the new `HttpHeaders` instance.
+     * Default value is `"ngzip, deflate, br, zstd"`.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    acceptEncoding(value = "gzip, deflate, br, zstd") {
+        this.setHeader("Accept-Encoding", value);
+        return this;
+    }
+    /**
+     * Sets or modifies a value of the new `HttpHeaders` instance.
+     *
+     * @param name The header name.
+     * @param value The value or values to set or override for the given header.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    set(name, value) {
+        this.setHeader(name, value);
+        return this;
+    }
+    /**
+     * Return a new `HttpHeaders` instance, built from the properties specified with the
+     * `HttpHeadersMockBuilder` methods.
+     *
+     * @returns A new `HttpHeaders` instance.
+     */
+    headers() {
+        return this._headers;
+    }
+    /**
+     * @private
+     */
+    setHeader(name, value) {
+        const values = Array.isArray(value) ? value.join(", ") : value;
+        this._headers = this._headers.set(name, values);
+    }
+}
+/**
+ * A utility function used to create new "chainable" `HttpHeadersMockBuilder` instances.
+ *
+ * @returns A new `HttpHeadersMockBuilder` instance;
+ */
+const httpHeadersMock = () => new HttpHeadersMockBuilder();
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * A utility class used by delegate `XhrProxy` instances to dispatch `ProgressEvent`
+ * instances.
+ *
+ * This class is not exposed.
+ */
+class ProgressEventMock extends ProgressEvent {
+    constructor() {
+        super(...arguments);
+        /**
+         * @private
+         */
+        this._total = NaN;
+        /**
+         * @private
+         */
+        this._loaded = 0;
+    }
+    /**
+     * A 64-bit unsigned integer indicating the size, in bytes, of the data already
+     * transmitted or processed.
+     */
+    set total(value) {
+        this._total = value;
+    }
+    get total() {
+        return this._total;
+    }
+    /**
+     * A 64-bit unsigned integer indicating the total size, in bytes, of the data being
+     * transmitted or processed.
+     */
+    set loaded(value) {
+        this._loaded = value;
+    }
+    get loaded() {
+        return this._loaded;
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/benlesh/event-target-polyfill
+ * - Copyright (c) 2020 Ben Lesh
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/benlesh/event-target-polyfill/blob/master/LICENSE
+ */
+/**
+ * @private
+ */
+const ADD = "addEventListener";
+/**
+ * @private
+ */
+const REMOVE = "removeEventListener";
+/**
+ * @private
+ * A utility class the provides an implementation for the `EventTarget` interface.
+ * This class is used internally by the framework; please do not expose it.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget
+ */
+class EventTargetImpl {
+    /**
+     * @private
+     */
+    constructor() {
+        this._listenerList = new Map();
+    }
+    /**
+     * @private
+     * Sets up a function that will be called whenever the specified event is delivered to the target.
+     *
+     * @param type a case-sensitive string representing the event type to listen for.
+     * @param listener the object that receives a notification (an object that implements the
+     *                 `Event` interface) when an event of the specified type occurs.
+     * @param options an object that specifies characteristics about the event listener.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
+     */
+    addEventListener(type, listener, options) {
+        this.checkArgLength(arguments.length, ADD);
+        const ll = this._listenerList;
+        if (!ll.has(type))
+            ll.set(type, new Map());
+        const listenersForType = ll.get(type);
+        if (!listenersForType.has(listener)) {
+            // Any given listener is only registered once
+            listenersForType.set(listener, options);
+        }
+    }
+    /**
+     * @private
+     * Removes an event listener previously registered with `EventTarget.addEventListener()` from the target.
+     *
+     * @param type a case-sensitive which specifies the type of event for which to remove an event listener.
+     * @param listener the event listener function of the event handler to remove from the event target.
+     * @param options An options object that specifies characteristics about the event listener.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener
+     */
+    removeEventListener(type, listener, options) {
+        this.checkArgLength(arguments.length, REMOVE);
+        const ll = this._listenerList;
+        if (ll.has(type)) {
+            const listenersForType = ll.get(type);
+            if (listenersForType.has(listener))
+                listenersForType.delete(listener);
+        }
+    }
+    /**
+     * @private
+     * Sends an `Event` to this to the `Event` object, (synchronously) invoking the affected event listeners
+     * in the appropriate order.
+     *
+     * @param event the `Event object to dispatch. Its Event.target property will be set to the current EventTarget.
+     * @returns true since there are no cancellable events on a base `EventTarget`.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/dispatchEvent
+     */
+    dispatchEvent(event) {
+        if (!(event instanceof Event)) {
+            throw new TypeError("Failed to execute 'dispatchEvent' on 'EventTarget': parameter 1 is not of type 'Event'.");
+        }
+        const type = event.type;
+        const ll = this._listenerList;
+        const listenersForType = ll.get(type);
+        if (!listenersForType)
+            return true;
+        for (const listnerEntry of listenersForType.entries()) {
+            const listener = listnerEntry[0];
+            const options = listnerEntry[1];
+            // Listener functions must be executed with the EventTarget as the `this` context.
+            if (typeof listener === FUNCTION)
+                listener.call(this, event);
+            // Listener objects have their handleEvent method called, if they have one
+            else if (listener && typeof listener.handleEvent === FUNCTION)
+                listener.handleEvent(event);
+            if (options && options.once)
+                listenersForType.delete(listener);
+        }
+        return true;
+    }
+    /**
+     * @private
+     */
+    checkArgLength(argLen, method) {
+        if (argLen < 2) {
+            throw new TypeError(`TypeError: Failed to execute '${method}' on 'EventTarget': 2 arguments required, but ${argLen === 1 ? 'only 1' : '0'} present.`);
+        }
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ *
+ * Elemenets marked as "Useless" are never invoked by the Angular framework.
+ */
+class XhrBase extends EventTargetImpl {
+    constructor() {
+        super(...arguments);
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API
+         */
+        this.UNSENT = 0;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API
+         */
+        this.OPENED = 1;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API
+         */
+        this.HEADERS_RECEIVED = 2;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API
+         */
+        this.LOADING = 3;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API
+         */
+        this.DONE = 4;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API
+         */
+        this.withCredentials = false;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API - Useless
+         */
+        this.onabort = null;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API - Useless
+         */
+        this.onerror = null;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API - Useless
+         */
+        this.onload = null;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API - Useless
+         */
+        this.onloadend = null;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API - Useless
+         */
+        this.onloadstart = null;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API - Useless
+         */
+        this.onprogress = null;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API - Useless
+         */
+        this.onreadystatechange = null;
+        /**
+         * @private
+         *
+         * XMLHTTPRequest API - Useless
+         */
+        this.ontimeout = null;
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API - Useless
+     */
+    get responseXML() {
+        return null;
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API - Useless
+     */
+    overrideMimeType(mime) { }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API - Useless
+     */
+    getResponseHeader(name) { return null; }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * Internal reference to a new line character.
+ */
+const NL = "\n";
+/**
+ * @private
+ * A set of static utilities for manipulating `HttpHeaders` objects.
+ */
+class HttpHeadersUtil {
+    /**
+     * @private
+     * Returns a string representation the the specified `HttpHeaders `object, compatible with the format
+     * expected by the `XMLHttpRequest.getAllResponseHeaders()` method.
+     *
+     * @param headers The `HttpHeaders` object to format.
+     *
+     * @returns A string compatible with the format expected by the `XMLHttpRequest.getAllResponseHeaders()` method.
+     */
+    static stringify(headers) {
+        let result = EMPTY_STRING;
+        if (!headers)
+            return result;
+        const keys = headers.keys();
+        const last = keys.length - 1;
+        keys.forEach((key, index) => {
+            result += `${key}: ${headers.getAll(key)}${index !== last ? NL : EMPTY_STRING}`;
+        });
+        return result;
+    }
+    /**
+     * @private
+     * Creates the default `HttpHeaders` object for a mocked HTTP request.
+     *
+     * @returns The default `HttpHeaders` object for a mocked HTTP request.
+     */
+    static createDefaultRequestHeaders() {
+        // "Accept" header is set by Angular framework when missing
+        return httpHeadersMock().cacheControl()
+            .acceptEncoding()
+            .acceptLanguage()
+            .priority()
+            .userAgent()
+            .headers();
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * A static utility class for building `DataStorage` objects.
+ */
+class DataStorageBuilder {
+    /**
+     * @private
+     * Builds and returns a new `DataStorage` objects.
+     *
+     * @param httpResponse The `HttpResponseMock` to be stored by the framework.
+     * @param data The data of the HTTP response to be stored by the framework.
+     *
+     * @returns A new `DataStorage` objects.
+     */
+    static buildDataStorage(httpResponse, data) {
+        // TODO: add support for different data types (string, Blob, etc.)
+        const stringifiedData = data ? JSON.stringify(data) : EMPTY_STRING;
+        return {
+            httpResponse: httpResponse,
+            loaded: 0,
+            total: data ? new Blob([stringifiedData]).size : 0,
+            data: data,
+            stringifiedData: stringifiedData
+        };
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * The maximum value for a delayed HTTP response.
+ */
+const MAX_TIMER = 10000;
+/**
+ * @private
+ * Intenal "onreadystatechange" event.
+ */
+const READY_STATE_CHANGE_EVENT = new Event("onreadystatechange");
+/**
+ * @private
+ */
+const EVT_PROPS_CONFIG = { writable: false, value: this };
+/**
+ * @private
+ * A utility class used as delegate of `XMLHttpRequest` functionalities when
+ * a HTTP request is intercepted by the Mocking Framework .
+ */
+class DelegateXhr extends XhrBase {
+    /**
+     * Returns the response body content.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/response
+     */
+    get response() {
+        return this._dataStorage?.data || null;
+    }
+    /**
+     * Returns the numerical HTTP status code of the `XMLHttpRequest` response.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/status
+     */
+    get status() {
+        return this._status;
+    }
+    /**
+     * Returns a string containing the response status message as returned by the HTTP server.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/statusText
+     */
+    get statusText() {
+        return this._statusText;
+    }
+    /**
+     * Returns the state the `XMLHttpRequest` client is in.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/readyState
+     */
+    get readyState() {
+        return this._readyState;
+    }
+    /**
+     * Returns the serialized URL of the response or the empty string if the URL is `null`.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseURL
+     */
+    get responseURL() {
+        return this._url;
+    }
+    /**
+     * Returns the text received from a server following a request being sent.
+     *
+     * Throws an `InvalidStateError` DOMException if responseType is not the empty string or "text".
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseText
+     */
+    get responseText() {
+        return this._dataStorage?.stringifiedData || EMPTY_STRING;
+    }
+    /**
+     *  Returns an `XMLHttpRequestUpload` object that can be observed to monitor an upload progress.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/upload
+     */
+    get upload() {
+        return null;
+    }
+    /**
+     * @private
+     */
+    open(method, url, async, username, password) {
+        this._method = method;
+        this._url = url;
+        this.setReadyState(this.OPENED);
+    }
+    /**
+     * Aborts the request if it has already been sent. When a request is aborted, its `readyState`
+     * is changed to `XMLHttpRequest.UNSENT` and the request status code is set to `0`.
+     */
+    abort() {
+        this._readyState = this.UNSENT;
+        this._status = 0;
+        this.eventDispatch("abort");
+    }
+    /**
+     * Returns all the response headers, separated by CRLF, as a string, or returns `null`
+     * if no response has been received.
+     *
+     * @returns All the response headers, separated by CRLF, as a string, or returns `null`
+     *          if no response has been received.
+     */
+    getAllResponseHeaders() {
+        return this._dataStorage ? HttpHeadersUtil.stringify(this._headers) : EMPTY_STRING;
+    }
+    /**
+     * Sends the request to the server.
+     *
+     * @param body A body of data to be sent in the XHR request.
+     */
+    send(body) {
+        const request = new HttpRequest(this._method, this._url, body);
+        const rc = this._routeConfig;
+        const httpResponseMock = rc.methodConfig.data(request, rc.parameters);
+        let timer = httpResponseMock.delay || 0;
+        if (timer > MAX_TIMER)
+            timer = MAX_TIMER;
+        this._loadSubscription = this.loadData(httpResponseMock).subscribe((data) => {
+            this._dataStorage = DataStorageBuilder.buildDataStorage(httpResponseMock, data);
+            const error = this._dataStorage.httpResponse.error;
+            setTimeout(() => {
+                this.setReadyState(this.HEADERS_RECEIVED);
+                if (error)
+                    return this.onError(error);
+                this.setReadyState(this.LOADING);
+                const response = this._dataStorage.httpResponse;
+                let headers = response.headers;
+                if (headers) {
+                    this._headers.keys().forEach((key) => {
+                        headers = headers.set(key, this._headers.get(key));
+                    });
+                    this._headers = headers;
+                }
+                if (!this._progressiveDownload) {
+                    this._statusText = response.statusText || EMPTY_STRING;
+                    this._status = response.status || 0;
+                    return this.onLoadComplete();
+                }
+                this.doProgressiveDownload();
+            }, timer);
+        });
+    }
+    /**
+     * Sets the value of an HTTP request header.
+     *
+     * @param name The name of the header whose value is to be set.
+     * @param value The value to set as the body of the header.
+     */
+    setRequestHeader(name, value) {
+        this._headers = this._headers.set(name, value);
+    }
+    /**
+     * @private
+     */
+    constructor(routeConfig) {
+        super();
+        /**
+         * @private
+         * Indicates whether the progressive download is activated, or not.
+         */
+        this._progressiveDownload = false;
+        /**
+         * @private
+         *
+         * Internal storage for HTTP response `data`.
+         */
+        this._dataStorage = null;
+        /**
+         * @private
+         *
+         * Internal storage for the HTTP request `readyState`.
+         */
+        this._readyState = this.UNSENT;
+        /**
+         * @private
+         *
+         * Internal storage for the HTTP request `headers`.
+         */
+        this._headers = null;
+        /**
+         * @private
+         *
+         * Internal storage for the HTTP request `status`.
+         */
+        this._status = 0;
+        /**
+         * @private
+         *
+         * Internal storage for the HTTP request `statusText`.
+         */
+        this._statusText = EMPTY_STRING;
+        /**
+         * @private
+         */
+        this._loadSubscription = null;
+        /**
+         *  Returns an an enumerated string value specifying the type of data contained in the response.
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType
+         */
+        this.responseType = "";
+        const methodConfig = routeConfig.methodConfig;
+        this._routeConfig = routeConfig;
+        this._progressiveDownload = methodConfig.progressive || false;
+        this.responseType = methodConfig.responseType || "";
+        this._headers = new HttpHeaders();
+    }
+    /**
+     * @private
+     * Internally used by the framework to delete a `DelegateXhr` instance.
+     */
+    destroy() {
+        this._routeConfig = null;
+        this._headers = null;
+        this._dataStorage = null;
+        if (this._loadSubscription) {
+            this._loadSubscription.unsubscribe();
+            this._loadSubscription = null;
+        }
+    }
+    /**
+     * @private
+     */
+    doProgressiveDownload() {
+        const total = this._dataStorage.total;
+        if (total <= 200) {
+            console.warn("[Angular Toolbox]: Body content is too small for emulating progressive download! Minimum size is 200 octets.");
+            return this.onLoadComplete();
+        }
+        // TODO: ameliorate the following process:
+        const self = this;
+        const chunckSize = Math.floor(total / 10);
+        let cursor = 0;
+        this._statusText = "Partial Content";
+        this._status = HttpStatusCode.PartialContent;
+        const idx = setInterval(() => {
+            cursor += chunckSize;
+            if (cursor > total) {
+                cursor = total;
+                clearInterval(idx);
+                self.onLoadComplete();
+            }
+            else {
+                this._dataStorage.loaded = cursor;
+                self.dispatchProgressEvent();
+            }
+        }, 100);
+    }
+    /**
+     * @private
+     */
+    onLoadComplete() {
+        this._dataStorage.loaded = this._dataStorage.total;
+        this.setReadyState(this.DONE);
+        this.dispatchProgressEvent("load");
+    }
+    /**
+     * @private
+     */
+    onError(error) {
+        this._status = error.status;
+        this._statusText = error.statusText;
+        this.setReadyState(this.DONE);
+        this.dispatchProgressEvent("error");
+    }
+    /**
+     * @private
+     */
+    eventDispatch(type) {
+        const event = new Event(type);
+        Object.defineProperty(event, 'target', EVT_PROPS_CONFIG);
+        Object.defineProperty(event, 'currentTarget', EVT_PROPS_CONFIG);
+        this.dispatchEvent(event);
+    }
+    /**
+     * @private
+     */
+    dispatchProgressEvent(type = "progress") {
+        const d = this._dataStorage;
+        const event = new ProgressEventMock(type);
+        event.loaded = d.loaded;
+        event.total = d.total;
+        this.dispatchEvent(event);
+    }
+    /**
+     * @private
+     */
+    setReadyState(state) {
+        this._readyState = state;
+        const event = this.onreadystatechange;
+        if (event)
+            event.call(this, READY_STATE_CHANGE_EVENT);
+    }
+    /**
+     * @private
+     */
+    loadData(httpResponseMock) {
+        const responseBody = httpResponseMock.body;
+        return (responseBody instanceof Observable) ? responseBody : of(responseBody);
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * An error used as reference for unit testing.
+ * Angular framework calls `XMLHttpRequest` method only after the `open()` method invokation.
+ */
+const XHR_ERROR = (method) => {
+    throw new Error(`Attempt to call ${method}() method before calling open().`);
+};
+/**
+ * @private
+ * A XHR proxy that is used by the Mocking Framework to apply HTTP call strategies.
+ */
+class XhrProxyImpl extends XhrBase {
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    get response() {
+        return this.XHR ? this.XHR.response : undefined;
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    get status() {
+        return this.XHR ? this.XHR.status : 0;
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    get statusText() {
+        return this.XHR ? this.XHR.statusText : EMPTY_STRING;
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    get readyState() {
+        return this.XHR ? this.XHR.readyState : this.UNSENT;
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    get responseURL() {
+        return this.XHR ? this.XHR.responseURL : EMPTY_STRING;
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    get responseText() {
+        return this.XHR ? this.XHR.responseText : EMPTY_STRING;
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    get responseType() {
+        return this.XHR ? this.XHR.responseType : EMPTY_STRING;
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    set responseType(value) {
+        if (!this.XHR)
+            XHR_ERROR("responseType");
+        this.XHR.responseType = value;
+    }
+    get upload() {
+        return this.XHR.upload;
+    }
+    open(method, url, async, username, password) {
+        const m = method.toString().toLowerCase();
+        const parsedUrl = URL.canParse(url) ? new URL(url) : new URL(this._httpMockService.getAppOrigin() + url);
+        const config = this._httpMockService.getRouteConfig(parsedUrl, m);
+        if (this.XHR && this.XHR instanceof DelegateXhr)
+            this.XHR.destroy();
+        this.XHR = config ? new DelegateXhr(config) : new XMLHttpRequest();
+        this.XHR.withCredentials = this.withCredentials;
+        this.XHR.open(m.toString(), parsedUrl.toString());
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    abort() {
+        if (this.XHR)
+            return this.XHR.abort();
+        XHR_ERROR("abort");
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    getAllResponseHeaders() {
+        return this.XHR ? this.XHR.getAllResponseHeaders() : EMPTY_STRING;
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    addEventListener(type, listener, options) {
+        if (this.XHR)
+            return this.XHR.addEventListener(type, listener, options);
+        XHR_ERROR("addEventListener");
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    removeEventListener(type, listener, options) {
+        if (this.XHR)
+            return this.XHR.removeEventListener(type, listener, options);
+        XHR_ERROR("removeEventListener");
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    send(body) {
+        if (this.XHR)
+            return this.XHR.send(body);
+        XHR_ERROR("send");
+    }
+    /**
+     * @private
+     *
+     * XMLHTTPRequest API
+     */
+    setRequestHeader(name, value) {
+        if (this.XHR)
+            return this.XHR.setRequestHeader(name, value);
+        XHR_ERROR("setRequestHeader");
+    }
+    /**
+     * @private
+     *
+     * For Unit Testing only.
+     */
+    instanceOf(classRef) {
+        return this.XHR instanceof classRef;
+    }
+    /**
+     * @private
+     */
+    constructor(_httpMockService) {
+        super();
+        this._httpMockService = _httpMockService;
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * The concrete implementation of the `XhrFactory` interface.
+ */
+class XhrProxyFactoryImpl extends XhrFactory {
+    /**
+     * @private
+     */
+    constructor(_httpMockService) {
+        super();
+        this._httpMockService = _httpMockService;
+    }
+    /**
+     * @private
+     */
+    build() {
+        return new XhrProxyImpl(this._httpMockService);
+    }
+}
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * A factory function that creates and returns a new `XhrFactory` object.
+ *
+ * @returns A new `XhrFactory` object.
+ */
+const httpMockFactory = () => {
+    return new XhrProxyFactoryImpl(inject(HttpMockService));
+};
+
+/**
+ * A basic implementation of HTML sanitization pipe.
+ */
+class SafeHtmlPipe {
+    /**
+     * @private
+     */
+    constructor(_sanitizer) {
+        this._sanitizer = _sanitizer;
+    }
+    /**
+     * Transforms the HTML input string value into a `SafeHtml` instance and returns the result
+     * of the transformation.
+     *
+     * @param value The HTML input value to transform into a `SafeHtml` instance.
+     * @returns A `SafeHtml` instance based on the specified input value.
+     */
+    transform(value) {
+        return this._sanitizer.bypassSecurityTrustHtml(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: SafeHtmlPipe, deps: [{ token: i1$1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.0.3", ngImport: i0, type: SafeHtmlPipe, isStandalone: true, name: "safeHtml" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: SafeHtmlPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'safeHtml',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1$1.DomSanitizer }] });
+
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/*
+ * Public API Surface of angular-toolbox
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { APP_PRIDGE_REF, AnchorLinklDirective, AngularToolboxModule, AppBridgeError, AppBrigeService, BIGINT, BOOLEAN, BUTTON_ROLE, ButtonRoleDirective, CSS_PROP, ContentRendererDirective, DARK_MODE_CONFIG, DarkModeService, EMPTY_STRING, FUNCTION, HTTP_MOCK_SERVICE, HttpHeadersMockBuilder, HttpMock, HttpMockService, HttpMockServiceError, HttpResponseMockBuilder, IdentifiableComponent, IntegrityError, LINK_ROLE, NUMBER, NavigateToUrlDirective, OBJECT, STORAGE_KEY, STRING, SYMBOL, SafeHtmlPipe, ScrollService, SubscriptionError, SubscriptionService, UNDEFINED, Uuid, VERSION_CONFIG, VersionService, httpHeadersMock, httpMockFactory, httpResponseMock };
+//# sourceMappingURL=angular-toolbox.mjs.map