@abp/ng.core 8.1.2 → 8.2.0-rc.1

package/fesm2022/abp-ng.core.mjs

@@ -1,13 +1,13 @@
 import * as i0 from '@angular/core';
-import { inject, ChangeDetectorRef, Component, Input, Injectable, InjectionToken, Inject, Optional, isDevMode, SkipSelf, signal, NgModuleFactory, Injector, Compiler, computed, Directive, EventEmitter, Output, Self, Pipe, NgModule, APP_INITIALIZER, LOCALE_ID, SecurityContext, effect, ElementRef, HostListener, ComponentFactoryResolver, ApplicationRef } from '@angular/core';
-import { of, BehaviorSubject, Subject, throwError, combineLatest, from, firstValueFrom, lastValueFrom, Observable, timer, pipe, concat, ReplaySubject, Subscription, map as map$1, fromEvent } from 'rxjs';
+import { inject, ChangeDetectorRef, Component, Input, Injectable, InjectionToken, NgModuleFactory, Injector, Compiler, Inject, signal, computed, Optional, isDevMode, SkipSelf, Directive, EventEmitter, Output, Self, Pipe, NgModule, APP_INITIALIZER, LOCALE_ID, SecurityContext, effect, ElementRef, HostListener, ComponentFactoryResolver, ApplicationRef } from '@angular/core';
+import { of, BehaviorSubject, Subject, throwError, firstValueFrom, lastValueFrom, Observable, timer, pipe, concat, ReplaySubject, map as map$1, Subscription, combineLatest, from, fromEvent } from 'rxjs';
 import * as i1$1 from '@angular/router';
 import { PRIMARY_OUTLET, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, Router, ActivatedRoute, TitleStrategy, RouterModule } from '@angular/router';
 import * as i1$2 from '@angular/common';
 import { registerLocaleData, DOCUMENT, DatePipe, DATE_PIPE_DEFAULT_TIMEZONE, CommonModule } from '@angular/common';
-import { map, distinctUntilChanged, filter, catchError, switchMap, take, tap, mapTo, takeUntil, delay, retryWhen, shareReplay, debounceTime, finalize } from 'rxjs/operators';
+import { map, distinctUntilChanged, filter, catchError, tap, take, switchMap, mapTo, takeUntil, delay, retryWhen, shareReplay, debounceTime, finalize } from 'rxjs/operators';
 import * as i1 from '@angular/common/http';
-import { HttpContextToken, HttpClient, HttpContext, HttpParams, HttpErrorResponse, HttpClientModule, HttpClientXsrfModule, HttpHeaders } from '@angular/common/http';
+import { HttpClient, HttpContextToken, HttpContext, HttpParams, HttpErrorResponse, HttpClientModule, HttpClientXsrfModule, HttpHeaders } from '@angular/common/http';
 import compare from 'just-compare';
 import clone from 'just-clone';
 import * as i1$3 from '@angular/forms';
@@ -276,31 +276,27 @@ function escapeHtmlChars(value) {
         : value;
 }
 
-const IS_EXTERNAL_REQUEST = new HttpContextToken(() => false);
-
-// source : https://github.com/armanozak/demo-angular-server-specific-interceptors
-class ExternalHttpClient extends HttpClient {
-    request(first, url, options = {}) {
-        if (typeof first === 'string') {
-            this.#setPlaceholderContext(options);
-            return super.request(first, url || '', options);
-        }
-        this.#setPlaceholderContext(first);
-        return super.request(first);
+class ContentProjectionService {
+    constructor(injector) {
+        this.injector = injector;
     }
-    #setPlaceholderContext(optionsOrRequest) {
-        optionsOrRequest.context ??= new HttpContext();
-        optionsOrRequest.context.set(IS_EXTERNAL_REQUEST, true);
+    projectContent(projectionStrategy, injector = this.injector) {
+        return projectionStrategy.injectContent(injector);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ExternalHttpClient, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ExternalHttpClient, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ContentProjectionService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ContentProjectionService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ExternalHttpClient, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ContentProjectionService, decorators: [{
             type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+
+function pushValueTo(array) {
+    return (element) => {
+        array.push(element);
+        return array;
+    };
+}
 
 function noop() {
     const fn = function () { };
@@ -337,6 +333,19 @@ function checkHasProp(object, key) {
     return Object.prototype.hasOwnProperty.call(object, key);
 }
 
+function getShortDateFormat(configStateService) {
+    const dateTimeFormat = configStateService.getDeep('localization.currentCulture.dateTimeFormat');
+    return dateTimeFormat.shortDatePattern;
+}
+function getShortTimeFormat(configStateService) {
+    const dateTimeFormat = configStateService.getDeep('localization.currentCulture.dateTimeFormat');
+    return dateTimeFormat?.shortTimePattern?.replace('tt', 'a');
+}
+function getShortDateShortTimeFormat(configStateService) {
+    const dateTimeFormat = configStateService.getDeep('localization.currentCulture.dateTimeFormat');
+    return `${dateTimeFormat.shortDatePattern} ${dateTimeFormat?.shortTimePattern?.replace('tt', 'a')}`;
+}
+
 function deepMerge(target, source) {
     if (isObjectAndNotArrayNotNode(target) && isObjectAndNotArrayNotNode(source)) {
         return deepMergeRecursively(target, source);
@@ -476,281 +485,139 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
-class RestService {
-    constructor(options, http, externalHttp, environment, httpErrorReporter) {
-        this.options = options;
-        this.http = http;
-        this.externalHttp = externalHttp;
-        this.environment = environment;
-        this.httpErrorReporter = httpErrorReporter;
-    }
-    getApiFromStore(apiName) {
-        return this.environment.getApiUrl(apiName);
-    }
-    handleError(err) {
-        this.httpErrorReporter.reportError(err);
-        return throwError(() => err);
-    }
-    request(request, config, api) {
-        config = config || {};
-        api = api || this.getApiFromStore(config.apiName);
-        const { method, params, ...options } = request;
-        const { observe = "body" /* Rest.Observe.Body */, skipHandleError } = config;
-        const url = this.removeDuplicateSlashes(api + request.url);
-        const httpClient = this.getHttpClient(config.skipAddingHeader);
-        return httpClient
-            .request(method, url, {
-            observe,
-            ...(params && {
-                params: this.getParams(params, config.httpParamEncoder),
-            }),
-            ...options,
-        })
-            .pipe(catchError(err => (skipHandleError ? throwError(() => err) : this.handleError(err))));
+function getRemoteEnv(injector, environment) {
+    const environmentService = injector.get(EnvironmentService);
+    const { remoteEnv } = environment;
+    const { headers = {}, method = 'GET', url } = remoteEnv || {};
+    if (!url)
+        return Promise.resolve();
+    const http = injector.get(HttpClient);
+    const httpErrorReporter = injector.get(HttpErrorReporterService);
+    return http
+        .request(method, url, { headers })
+        .pipe(catchError(err => {
+        httpErrorReporter.reportError(err);
+        return of(null);
+    }), // TODO: Consider get handle function from a provider
+    tap(env => environmentService.setState(mergeEnvironments(environment, env || {}, remoteEnv))))
+        .toPromise();
+}
+function mergeEnvironments(local, remote, config) {
+    switch (config.mergeStrategy) {
+        case 'deepmerge':
+            return deepMerge(local, remote);
+        case 'overwrite':
+        case null:
+        case undefined:
+            return remote;
+        default:
+            return config.mergeStrategy(local, remote);
     }
-    getHttpClient(isExternal) {
-        return isExternal ? this.externalHttp : this.http;
+}
+
+class LazyModuleFactory extends NgModuleFactory {
+    get moduleType() {
+        return this.moduleWithProviders.ngModule;
     }
-    getParams(params, encoder) {
-        const filteredParams = Object.entries(params).reduce((acc, [key, value]) => {
-            if (isUndefinedOrEmptyString(value))
-                return acc;
-            if (value === null && !this.options.sendNullsAsQueryParam)
-                return acc;
-            acc[key] = value;
-            return acc;
-        }, {});
-        return encoder
-            ? new HttpParams({ encoder, fromObject: filteredParams })
-            : new HttpParams({ fromObject: filteredParams });
+    constructor(moduleWithProviders) {
+        super();
+        this.moduleWithProviders = moduleWithProviders;
     }
-    removeDuplicateSlashes(url) {
-        return url.replace(/([^:]\/)\/+/g, '$1');
+    create(parentInjector) {
+        const injector = Injector.create({
+            ...(parentInjector && { parent: parentInjector }),
+            providers: this.moduleWithProviders.providers,
+        });
+        const compiler = injector.get(Compiler);
+        const factory = compiler.compileModuleSync(this.moduleType);
+        return factory.create(injector);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RestService, deps: [{ token: CORE_OPTIONS }, { token: i1.HttpClient }, { token: ExternalHttpClient }, { token: EnvironmentService }, { token: HttpErrorReporterService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RestService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RestService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [CORE_OPTIONS]
-                }] }, { type: i1.HttpClient }, { type: ExternalHttpClient }, { type: EnvironmentService }, { type: HttpErrorReporterService }] });
+function featuresFactory(configState, featureKeys, mapFn = features => features) {
+    return configState.getFeatures$(featureKeys).pipe(filter(Boolean), map(mapFn));
+}
 
-class AbpApplicationConfigurationService {
-    constructor(restService) {
-        this.restService = restService;
-        this.apiName = 'abp';
-        this.get = (options) => this.restService.request({
-            method: 'GET',
-            url: '/api/abp/application-configuration',
-            params: { includeLocalizationResources: options.includeLocalizationResources },
-        }, { apiName: this.apiName });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationConfigurationService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationConfigurationService, providedIn: 'root' }); }
+/** @deprecated the method will change in v8.0 */
+function downloadBlob(blob, filename) {
+    const blobUrl = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = blobUrl;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.dispatchEvent(new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+        view: window,
+    }));
+    document.body.removeChild(link);
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationConfigurationService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: RestService }] });
 
-class AbpApplicationLocalizationService {
-    constructor(restService) {
-        this.restService = restService;
-        this.apiName = 'abp';
-        this.get = (input) => this.restService.request({
-            method: 'GET',
-            url: '/api/abp/application-localization',
-            params: { cultureName: input.cultureName, onlyDynamics: input.onlyDynamics },
-        }, { apiName: this.apiName });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationLocalizationService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationLocalizationService, providedIn: 'root' }); }
+function isNumber(value) {
+    return value == Number(value);
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationLocalizationService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: RestService }] });
 
-const INCUDE_LOCALIZATION_RESOURCES_TOKEN = new InjectionToken('INCUDE_LOCALIZATION_RESOURCES_TOKEN');
+function mapEnumToOptions(_enum) {
+    const options = [];
+    for (const member in _enum)
+        if (!isNumber(member))
+            options.push({
+                key: member,
+                value: _enum[member],
+            });
+    return options;
+}
 
-class ConfigStateService {
-    setState(config) {
-        this.store.set(config);
-    }
-    get createOnUpdateStream() {
-        return this.store.sliceUpdate;
+function uuid(a) {
+    return a
+        ? (a ^ ((Math.random() * 16) >> (a / 4))).toString(16)
+        : ('' + 1e7 + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, uuid);
+}
+function generateHash(value) {
+    let hashed = 0;
+    let charCode;
+    for (let i = 0; i < value.length; i++) {
+        charCode = value.charCodeAt(i);
+        hashed = (hashed << 5) - hashed + charCode;
+        hashed |= 0;
     }
-    constructor(abpConfigService, abpApplicationLocalizationService, includeLocalizationResources) {
-        this.abpConfigService = abpConfigService;
-        this.abpApplicationLocalizationService = abpApplicationLocalizationService;
-        this.includeLocalizationResources = includeLocalizationResources;
-        this.updateSubject = new Subject();
-        this.store = new InternalStore({});
-        this.initUpdateStream();
+    return hashed;
+}
+function generatePassword(length = 8) {
+    length = Math.min(Math.max(4, length), 128);
+    const lowers = 'abcdefghijklmnopqrstuvwxyz';
+    const uppers = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const numbers = '0123456789';
+    const specials = '!@#$%&*()_+{}<>?[]./';
+    const all = lowers + uppers + numbers + specials;
+    const getRandom = (chrSet) => chrSet[Math.floor(Math.random() * chrSet.length)];
+    const password = Array({ length });
+    password[0] = getRandom(lowers);
+    password[1] = getRandom(uppers);
+    password[2] = getRandom(numbers);
+    password[3] = getRandom(specials);
+    for (let i = 4; i < length; i++) {
+        password[i] = getRandom(all);
     }
-    initUpdateStream() {
-        this.updateSubject
-            .pipe(switchMap(() => this.abpConfigService.get({
-            includeLocalizationResources: !!this.includeLocalizationResources,
-        })))
-            .pipe(switchMap(appState => this.getLocalizationAndCombineWithAppState(appState)))
-            .subscribe(res => this.store.set(res));
-    }
-    getLocalizationAndCombineWithAppState(appState) {
-        if (!appState.localization.currentCulture.cultureName) {
-            throw new Error('culture name should defined');
-        }
-        return this.getlocalizationResource(appState.localization.currentCulture.cultureName).pipe(map(result => ({ ...appState, localization: { ...appState.localization, ...result } })));
-    }
-    getlocalizationResource(cultureName) {
-        return this.abpApplicationLocalizationService.get({
-            cultureName: cultureName,
-            onlyDynamics: false,
-        });
-    }
-    refreshAppState() {
-        this.updateSubject.next();
-        return this.createOnUpdateStream(state => state).pipe(take(1));
-    }
-    refreshLocalization(lang) {
-        if (this.includeLocalizationResources) {
-            return this.refreshAppState().pipe(map(() => null));
-        }
-        else {
-            return this.getlocalizationResource(lang)
-                .pipe(tap(result => this.store.patch({ localization: { ...this.store.state.localization, ...result } })))
-                .pipe(map(() => null));
-        }
-    }
-    getOne$(key) {
-        return this.store.sliceState(state => state[key]);
-    }
-    getOne(key) {
-        return this.store.state[key];
-    }
-    getAll$() {
-        return this.store.sliceState(state => state);
-    }
-    getAll() {
-        return this.store.state;
-    }
-    getDeep$(keys) {
-        keys = splitKeys(keys);
-        return this.store
-            .sliceState(state => state)
-            .pipe(map(state => {
-            return keys.reduce((acc, val) => {
-                if (acc) {
-                    return acc[val];
-                }
-                return undefined;
-            }, state);
-        }));
-    }
-    getDeep(keys) {
-        keys = splitKeys(keys);
-        return keys.reduce((acc, val) => {
-            if (acc) {
-                return acc[val];
-            }
-            return undefined;
-        }, this.store.state);
-    }
-    getFeature(key) {
-        return this.store.state.features?.values?.[key];
-    }
-    getFeature$(key) {
-        return this.store.sliceState(state => state.features?.values?.[key]);
-    }
-    getFeatures(keys) {
-        const { features } = this.store.state;
-        if (!features)
-            return;
-        return keys.reduce((acc, key) => ({ ...acc, [key]: features.values[key] }), {});
-    }
-    getFeatures$(keys) {
-        return this.store.sliceState(({ features }) => {
-            if (!features?.values)
-                return;
-            return keys.reduce((acc, key) => ({ ...acc, [key]: features.values[key] }), {});
-        });
-    }
-    getSetting(key) {
-        return this.store.state.setting?.values?.[key];
-    }
-    getSetting$(key) {
-        return this.store.sliceState(state => state.setting?.values?.[key]);
-    }
-    getSettings(keyword) {
-        const settings = this.store.state.setting?.values || {};
-        if (!keyword)
-            return settings;
-        const keysFound = Object.keys(settings).filter(key => key.indexOf(keyword) > -1);
-        return keysFound.reduce((acc, key) => {
-            acc[key] = settings[key];
-            return acc;
-        }, {});
-    }
-    getSettings$(keyword) {
-        return this.store
-            .sliceState(state => state.setting?.values)
-            .pipe(map((settings = {}) => {
-            if (!keyword)
-                return settings;
-            const keysFound = Object.keys(settings).filter(key => key.indexOf(keyword) > -1);
-            return keysFound.reduce((acc, key) => {
-                acc[key] = settings[key];
-                return acc;
-            }, {});
-        }));
-    }
-    getGlobalFeatures() {
-        return this.store.state.globalFeatures;
-    }
-    getGlobalFeatures$() {
-        return this.store.sliceState(state => state.globalFeatures);
-    }
-    isGlobalFeatureEnabled(key, globalFeatures) {
-        const features = globalFeatures.enabledFeatures || [];
-        return features.some(f => key === f);
-    }
-    getGlobalFeatureIsEnabled(key) {
-        return this.isGlobalFeatureEnabled(key, this.store.state.globalFeatures);
+    return password.sort(() => 0.5 - Math.random()).join('');
+}
+
+function getPathName(url) {
+    const { pathname } = new URL(url, window.location.origin);
+    return pathname;
+}
+class WebHttpUrlEncodingCodec {
+    encodeKey(k) {
+        return encodeURIComponent(k);
     }
-    getGlobalFeatureIsEnabled$(key) {
-        return this.store.sliceState(state => this.isGlobalFeatureEnabled(key, state.globalFeatures));
+    encodeValue(v) {
+        return encodeURIComponent(v);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ConfigStateService, deps: [{ token: AbpApplicationConfigurationService }, { token: AbpApplicationLocalizationService }, { token: INCUDE_LOCALIZATION_RESOURCES_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ConfigStateService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ConfigStateService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: AbpApplicationConfigurationService }, { type: AbpApplicationLocalizationService }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [INCUDE_LOCALIZATION_RESOURCES_TOKEN]
-                }] }] });
-function splitKeys(keys) {
-    if (typeof keys === 'string') {
-        keys = keys.split('.');
+    decodeKey(k) {
+        return decodeURIComponent(k);
     }
-    if (!Array.isArray(keys)) {
-        throw new Error('The argument must be a dot string or an string array.');
+    decodeValue(v) {
+        return decodeURIComponent(v);
     }
-    return keys;
 }
 
 class AbpLocalStorageService {
@@ -854,208 +721,427 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImpor
                 }]
         }], ctorParameters: () => [{ type: ConfigStateService }, { type: AbpLocalStorageService }] });
 
-class LocalizationService {
-    /**
-     * Returns currently selected language
-     * Even though this looks like it's redundant to return the same value as `getLanguage()`,
-     * it's actually not. This could be invoked any time, and the latestLang could be different from the
-     * sessionState.getLanguage() value.
-     */
-    get currentLang() {
-        return this.latestLang || this.sessionState.getLanguage();
+const APP_INIT_ERROR_HANDLERS = new InjectionToken('APP_INIT_ERROR_HANDLERS');
+
+class AbpTenantService {
+    constructor(restService) {
+        this.restService = restService;
+        this.apiName = 'abp';
+        this.findTenantById = (id, config) => this.restService.request({
+            method: 'GET',
+            url: `/api/abp/multi-tenancy/tenants/by-id/${id}`,
+        }, { apiName: this.apiName, ...config });
+        this.findTenantByName = (name, config) => this.restService.request({
+            method: 'GET',
+            url: `/api/abp/multi-tenancy/tenants/by-name/${name}`,
+        }, { apiName: this.apiName, ...config });
     }
-    get currentLang$() {
-        return this.sessionState.getLanguage$();
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpTenantService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpTenantService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpTenantService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: RestService }] });
+
+const TENANT_KEY = new InjectionToken('TENANT_KEY');
+
+const IS_EXTERNAL_REQUEST = new HttpContextToken(() => false);
+
+// source : https://github.com/armanozak/demo-angular-server-specific-interceptors
+class ExternalHttpClient extends HttpClient {
+    request(first, url, options = {}) {
+        if (typeof first === 'string') {
+            this.#setPlaceholderContext(options);
+            return super.request(first, url || '', options);
+        }
+        this.#setPlaceholderContext(first);
+        return super.request(first);
     }
-    get languageChange$() {
-        return this._languageChange$.asObservable();
+    #setPlaceholderContext(optionsOrRequest) {
+        optionsOrRequest.context ??= new HttpContext();
+        optionsOrRequest.context.set(IS_EXTERNAL_REQUEST, true);
     }
-    constructor(sessionState, injector, otherInstance, configState) {
-        this.sessionState = sessionState;
-        this.injector = injector;
-        this.configState = configState;
-        this.latestLang = this.sessionState.getLanguage();
-        this._languageChange$ = new Subject();
-        this.uiLocalizations$ = new BehaviorSubject(new Map());
-        this.localizations$ = new BehaviorSubject(new Map());
-        if (otherInstance)
-            throw new Error('LocalizationService should have only one instance.');
-        this.listenToSetLanguage();
-        this.initLocalizationValues();
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ExternalHttpClient, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ExternalHttpClient, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ExternalHttpClient, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class RestService {
+    constructor(options, http, externalHttp, environment, httpErrorReporter) {
+        this.options = options;
+        this.http = http;
+        this.externalHttp = externalHttp;
+        this.environment = environment;
+        this.httpErrorReporter = httpErrorReporter;
     }
-    initLocalizationValues() {
-        localizations$.subscribe(val => this.addLocalization(val));
-        const legacyResources$ = this.configState.getDeep$('localization.values');
-        const remoteLocalizations$ = this.configState.getDeep$('localization.resources');
-        const currentLanguage$ = this.sessionState.getLanguage$();
-        const uiLocalizations$ = combineLatest([currentLanguage$, this.uiLocalizations$]).pipe(map(([currentLang, localizations]) => localizations.get(currentLang)));
-        combineLatest([legacyResources$, remoteLocalizations$, uiLocalizations$])
-            .pipe(map(([legacy, resource, local]) => {
-            if (!resource) {
-                return;
-            }
-            const remote = combineLegacyandNewResources(legacy || {}, resource);
-            if (remote) {
-                if (!local) {
-                    local = new Map();
-                }
-                Object.entries(remote).forEach(entry => {
-                    const resourceName = entry[0];
-                    const remoteTexts = entry[1];
-                    let resource = local?.get(resourceName) || {};
-                    resource = { ...resource, ...remoteTexts };
-                    local?.set(resourceName, resource);
-                });
-            }
-            return local;
-        }), filter(Boolean))
-            .subscribe(val => this.localizations$.next(val));
+    getApiFromStore(apiName) {
+        return this.environment.getApiUrl(apiName);
     }
-    addLocalization(localizations) {
-        if (!localizations)
-            return;
-        const localizationMap = this.uiLocalizations$.value;
-        localizations.forEach(loc => {
-            const cultureMap = localizationMap.get(loc.culture) || new Map();
-            loc.resources.forEach(res => {
-                let resource = cultureMap.get(res.resourceName) || {};
-                resource = { ...resource, ...res.texts };
-                cultureMap.set(res.resourceName, resource);
-            });
-            localizationMap.set(loc.culture, cultureMap);
-        });
-        this.uiLocalizations$.next(localizationMap);
+    handleError(err) {
+        this.httpErrorReporter.reportError(err);
+        return throwError(() => err);
     }
-    listenToSetLanguage() {
-        this.sessionState
-            .onLanguageChange$()
-            .pipe(filter(lang => this.configState.getDeep('localization.currentCulture.cultureName') !== lang), switchMap(lang => this.configState.refreshAppState().pipe(map(() => lang))), filter(Boolean), switchMap(lang => from(this.registerLocale(lang).then(() => lang))))
-            .subscribe(lang => this._languageChange$.next(lang));
+    request(request, config, api) {
+        config = config || {};
+        api = api || this.getApiFromStore(config.apiName);
+        const { method, params, ...options } = request;
+        const { observe = "body" /* Rest.Observe.Body */, skipHandleError } = config;
+        const url = this.removeDuplicateSlashes(api + request.url);
+        const httpClient = this.getHttpClient(config.skipAddingHeader);
+        return httpClient
+            .request(method, url, {
+            observe,
+            ...(params && {
+                params: this.getParams(params, config.httpParamEncoder),
+            }),
+            ...options,
+        })
+            .pipe(catchError(err => (skipHandleError ? throwError(() => err) : this.handleError(err))));
     }
-    registerLocale(locale) {
-        const { registerLocaleFn } = this.injector.get(CORE_OPTIONS);
-        return registerLocaleFn(locale).then(module => {
-            if (module?.default)
-                registerLocaleData(module.default);
-            this.latestLang = locale;
-        });
+    getHttpClient(isExternal) {
+        return isExternal ? this.externalHttp : this.http;
     }
-    /**
-     * Returns an observable localized text with the given interpolation parameters in current language.
-     * @param key Localizaton key to replace with localized text
-     * @param interpolateParams Values to interpolate
-     */
-    get(key, ...interpolateParams) {
-        return this.configState
-            .getAll$()
-            .pipe(map(state => this.getLocalization(state, key, ...interpolateParams)));
+    getParams(params, encoder) {
+        const filteredParams = Object.entries(params).reduce((acc, [key, value]) => {
+            if (isUndefinedOrEmptyString(value))
+                return acc;
+            if (value === null && !this.options.sendNullsAsQueryParam)
+                return acc;
+            acc[key] = value;
+            return acc;
+        }, {});
+        return encoder
+            ? new HttpParams({ encoder, fromObject: filteredParams })
+            : new HttpParams({ fromObject: filteredParams });
     }
-    getResource(resourceName) {
-        return this.localizations$.value.get(resourceName);
+    removeDuplicateSlashes(url) {
+        return url.replace(/([^:]\/)\/+/g, '$1');
     }
-    getResource$(resourceName) {
-        return this.localizations$.pipe(map(res => res.get(resourceName)));
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RestService, deps: [{ token: CORE_OPTIONS }, { token: i1.HttpClient }, { token: ExternalHttpClient }, { token: EnvironmentService }, { token: HttpErrorReporterService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RestService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CORE_OPTIONS]
+                }] }, { type: i1.HttpClient }, { type: ExternalHttpClient }, { type: EnvironmentService }, { type: HttpErrorReporterService }] });
+
+class MultiTenancyService {
+    constructor(restService, sessionState, tenantService, configStateService, tenantKey) {
+        this.restService = restService;
+        this.sessionState = sessionState;
+        this.tenantService = tenantService;
+        this.configStateService = configStateService;
+        this.tenantKey = tenantKey;
+        this.domainTenant = null;
+        this.isTenantBoxVisible = true;
+        this.apiName = 'abp';
+        this.setTenantToState = (tenant) => {
+            this.sessionState.setTenant({ id: tenant.tenantId, name: tenant.name, isAvailable: true });
+            return this.configStateService.refreshAppState().pipe(map(_ => tenant));
+        };
+    }
+    setTenantByName(tenantName) {
+        return this.tenantService
+            .findTenantByName(tenantName)
+            .pipe(switchMap(this.setTenantToState));
+    }
+    setTenantById(tenantId) {
+        return this.tenantService
+            .findTenantById(tenantId)
+            .pipe(switchMap(this.setTenantToState));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: MultiTenancyService, deps: [{ token: RestService }, { token: SessionStateService }, { token: AbpTenantService }, { token: ConfigStateService }, { token: TENANT_KEY }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: MultiTenancyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: MultiTenancyService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: RestService }, { type: SessionStateService }, { type: AbpTenantService }, { type: ConfigStateService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TENANT_KEY]
+                }] }] });
+
+const TENANT_NOT_FOUND_BY_NAME = new InjectionToken('TENANT_NOT_FOUND_BY_NAME');
+
+const tenancyPlaceholder = '{0}';
+function getCurrentTenancyName(appBaseUrl) {
+    if (appBaseUrl.charAt(appBaseUrl.length - 1) !== '/')
+        appBaseUrl += '/';
+    const parseTokens = createTokenParser(appBaseUrl);
+    const token = tenancyPlaceholder.replace(/[}{]/g, '');
+    return parseTokens(window.location.href)[token]?.[0];
+}
+function getCurrentTenancyNameFromUrl(tenantKey) {
+    const urlParams = new URLSearchParams(window.location.search);
+    return urlParams.get(tenantKey);
+}
+async function parseTenantFromUrl(injector) {
+    const environmentService = injector.get(EnvironmentService);
+    const multiTenancyService = injector.get(MultiTenancyService);
+    const tenantNotFoundHandler = injector.get(TENANT_NOT_FOUND_BY_NAME, null);
+    const baseUrl = environmentService.getEnvironment()?.application?.baseUrl || '';
+    const tenancyName = getCurrentTenancyName(baseUrl);
+    const hideTenantBox = () => {
+        multiTenancyService.isTenantBoxVisible = false;
+    };
+    const setDomainTenant = (tenant) => {
+        multiTenancyService.domainTenant = {
+            id: tenant.tenantId,
+            name: tenant.name,
+            isAvailable: true,
+        };
+    };
+    const setEnvironmentWithDomainTenant = (tenant) => {
+        hideTenantBox();
+        setDomainTenant(tenant);
+    };
+    if (tenancyName) {
+        /**
+         * We have to replace tenant name within the urls from environment,
+         * because the code below will make a http request to find information about the domain tenant.
+         * Before this request takes place, we need to replace placeholders aka "{0}".
+         */
+        replaceTenantNameWithinEnvironment(injector, tenancyName);
+        const tenant$ = multiTenancyService.setTenantByName(tenancyName);
+        try {
+            const result = await firstValueFrom(tenant$);
+            setEnvironmentWithDomainTenant(result);
+            return Promise.resolve(result);
+        }
+        catch (httpError) {
+            if (httpError instanceof HttpErrorResponse &&
+                httpError.status === 404 &&
+                tenantNotFoundHandler) {
+                tenantNotFoundHandler(httpError);
+            }
+            return Promise.reject();
+        }
     }
     /**
-     * Returns localized text with the given interpolation parameters in current language.
-     * @param key Localization key to replace with localized text
-     * @param interpolateParams Values to intepolate.
+     * If there is no tenant, we still have to clean up {0}. from baseUrl to avoid incorrect http requests.
      */
-    instant(key, ...interpolateParams) {
-        return this.getLocalization(this.configState.getAll(), key, ...interpolateParams);
+    replaceTenantNameWithinEnvironment(injector, '', tenancyPlaceholder + '.');
+    const tenantIdFromQueryParams = getCurrentTenancyNameFromUrl(multiTenancyService.tenantKey);
+    if (tenantIdFromQueryParams) {
+        const tenantById$ = multiTenancyService.setTenantById(tenantIdFromQueryParams);
+        return firstValueFrom(tenantById$);
     }
-    localize(resourceName, key, defaultValue) {
-        return this.configState.getOne$('localization').pipe(map(createLocalizer), map(localize => localize(resourceName, key, defaultValue)));
+    return Promise.resolve();
+}
+function replaceTenantNameWithinEnvironment(injector, tenancyName, placeholder = tenancyPlaceholder) {
+    const environmentService = injector.get(EnvironmentService);
+    const environment = clone(environmentService.getEnvironment());
+    if (environment.application.baseUrl) {
+        environment.application.baseUrl = environment.application.baseUrl.replace(placeholder, tenancyName);
     }
-    localizeSync(resourceName, key, defaultValue) {
-        const localization = this.configState.getOne('localization');
-        return createLocalizer(localization)(resourceName, key, defaultValue);
+    if (environment.oAuthConfig?.redirectUri) {
+        environment.oAuthConfig.redirectUri = environment.oAuthConfig.redirectUri.replace(placeholder, tenancyName);
     }
-    localizeWithFallback(resourceNames, keys, defaultValue) {
-        return this.configState.getOne$('localization').pipe(map(createLocalizerWithFallback), map(localizeWithFallback => localizeWithFallback(resourceNames, keys, defaultValue)));
+    if (!environment.oAuthConfig) {
+        environment.oAuthConfig = {};
     }
-    localizeWithFallbackSync(resourceNames, keys, defaultValue) {
-        const localization = this.configState.getOne('localization');
-        return createLocalizerWithFallback(localization)(resourceNames, keys, defaultValue);
+    environment.oAuthConfig.issuer = (environment.oAuthConfig.issuer || '').replace(placeholder, tenancyName);
+    Object.keys(environment.apis).forEach(api => {
+        Object.keys(environment.apis[api]).forEach(key => {
+            environment.apis[api][key] = (environment.apis[api][key] || '').replace(placeholder, tenancyName);
+        });
+    });
+    return environmentService.setState(environment);
+}
+
+const CHECK_AUTHENTICATION_STATE_FN_KEY = new InjectionToken('CHECK_AUTHENTICATION_STATE_FN_KEY');
+
+function getInitialData(injector) {
+    const fn = async () => {
+        const environmentService = injector.get(EnvironmentService);
+        const configState = injector.get(ConfigStateService);
+        const options = injector.get(CORE_OPTIONS);
+        environmentService.setState(options.environment);
+        await getRemoteEnv(injector, options.environment);
+        await parseTenantFromUrl(injector);
+        const authService = injector.get(AuthService, undefined, { optional: true });
+        const checkAuthenticationState = injector.get(CHECK_AUTHENTICATION_STATE_FN_KEY, noop, {
+            optional: true,
+        });
+        if (!options.skipInitAuthService && authService) {
+            await authService.init();
+        }
+        if (options.skipGetAppConfiguration)
+            return;
+        const result$ = configState.refreshAppState().pipe(tap(() => checkAuthenticationState(injector)), tap(() => {
+            const currentTenant = configState.getOne('currentTenant');
+            injector.get(SessionStateService).setTenant(currentTenant);
+        }), catchError(error => {
+            const appInitErrorHandlers = injector.get(APP_INIT_ERROR_HANDLERS, null);
+            if (appInitErrorHandlers && appInitErrorHandlers.length) {
+                appInitErrorHandlers.forEach(func => func(error));
+            }
+            return throwError(error);
+        }));
+        await lastValueFrom(result$);
+    };
+    return fn;
+}
+function localeInitializer(injector) {
+    const fn = () => {
+        const sessionState = injector.get(SessionStateService);
+        const { registerLocaleFn } = injector.get(CORE_OPTIONS);
+        const lang = sessionState.getLanguage() || 'en';
+        return new Promise((resolve, reject) => {
+            registerLocaleFn(lang).then(module => {
+                if (module?.default)
+                    registerLocaleData(module.default);
+                return resolve('resolved');
+            }, reject);
+        });
+    };
+    return fn;
+}
+
+class CrossOriginStrategy {
+    constructor(crossorigin, integrity) {
+        this.crossorigin = crossorigin;
+        this.integrity = integrity;
     }
-    getLocalization(state, key, ...interpolateParams) {
-        if (!key)
-            key = '';
-        let defaultValue = '';
-        if (typeof key !== 'string') {
-            defaultValue = key.defaultValue;
-            key = key.key;
+    setCrossOrigin(element) {
+        if (this.integrity)
+            element.setAttribute('integrity', this.integrity);
+        if (this.crossorigin) {
+            element.setAttribute('crossorigin', this.crossorigin);
         }
-        const keys = key.split('::');
-        const warn = (message) => {
-            if (isDevMode())
-                console.warn(message);
+    }
+}
+class NoCrossOriginStrategy extends CrossOriginStrategy {
+    setCrossOrigin() { }
+}
+const CROSS_ORIGIN_STRATEGY = {
+    Anonymous(integrity) {
+        return new CrossOriginStrategy('anonymous', integrity);
+    },
+    UseCredentials(integrity) {
+        return new CrossOriginStrategy('use-credentials', integrity);
+    },
+    None() {
+        return new NoCrossOriginStrategy(null);
+    },
+};
+
+class DomStrategy {
+    constructor(target = document.head, position = 'beforeend') {
+        this.target = target;
+        this.position = position;
+    }
+    insertElement(element) {
+        this.target.insertAdjacentElement(this.position, element);
+    }
+}
+const DOM_STRATEGY = {
+    AfterElement(element) {
+        return new DomStrategy(element, 'afterend');
+    },
+    AppendToBody() {
+        return new DomStrategy(document.body, 'beforeend');
+    },
+    AppendToHead() {
+        return new DomStrategy(document.head, 'beforeend');
+    },
+    BeforeElement(element) {
+        return new DomStrategy(element, 'beforebegin');
+    },
+    PrependToHead() {
+        return new DomStrategy(document.head, 'afterbegin');
+    },
+};
+
+function fromLazyLoad(element, domStrategy = DOM_STRATEGY.AppendToHead(), crossOriginStrategy = CROSS_ORIGIN_STRATEGY.Anonymous()) {
+    crossOriginStrategy.setCrossOrigin(element);
+    domStrategy.insertElement(element);
+    return new Observable((observer) => {
+        element.onload = (event) => {
+            clearCallbacks(element);
+            observer.next(event);
+            observer.complete();
         };
-        if (keys.length < 2) {
-            warn('The localization source separator (::) not found.');
-            return defaultValue || key;
-        }
-        if (!state.localization)
-            return defaultValue || keys[1];
-        const sourceName = keys[0] || state.localization.defaultResourceName;
-        const sourceKey = keys[1];
-        if (sourceName === '_') {
-            return defaultValue || sourceKey;
-        }
-        if (!sourceName) {
-            warn('Localization source name is not specified and the defaultResourceName was not defined!');
-            return defaultValue || sourceKey;
+        const handleError = createErrorHandler(observer, element);
+        element.onerror = handleError;
+        element.onabort = handleError;
+        element.onemptied = handleError;
+        element.onstalled = handleError;
+        element.onsuspend = handleError;
+        return () => {
+            clearCallbacks(element);
+            observer.complete();
+        };
+    });
+}
+function createErrorHandler(observer, element) {
+    return function (event) {
+        clearCallbacks(element);
+        element.parentNode?.removeChild(element);
+        observer.error(event);
+    };
+}
+function clearCallbacks(element) {
+    element.onload = null;
+    element.onerror = null;
+    element.onabort = null;
+    element.onemptied = null;
+    element.onstalled = null;
+    element.onsuspend = null;
+}
+
+class DefaultQueueManager {
+    constructor() {
+        this.queue = [];
+        this.isRunning = false;
+        this.stack = 0;
+        this.interval = 0;
+        this.stackSize = 100;
+    }
+    init(interval, stackSize) {
+        this.interval = interval;
+        this.stackSize = stackSize;
+    }
+    add(fn) {
+        this.queue.push(fn);
+        this.run();
+    }
+    run() {
+        if (this.isRunning)
+            return;
+        this.stack++;
+        this.isRunning = true;
+        const fn = this.queue.shift();
+        if (!fn) {
+            this.isRunning = false;
+            return;
         }
-        const source = this.localizations$.value.get(sourceName);
-        if (!source) {
-            warn('Could not find localization source: ' + sourceName);
-            return defaultValue || sourceKey;
+        fn();
+        if (this.stack > this.stackSize) {
+            setTimeout(() => {
+                this.isRunning = false;
+                this.run();
+                this.stack = 0;
+            }, this.interval);
         }
-        let localization = source[sourceKey];
-        if (typeof localization === 'undefined') {
-            return defaultValue || sourceKey;
+        else {
+            this.isRunning = false;
+            this.run();
         }
-        interpolateParams = interpolateParams.filter(params => params != null);
-        if (localization)
-            localization = interpolate(localization, interpolateParams);
-        if (typeof localization !== 'string')
-            localization = '';
-        return localization || defaultValue || key;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LocalizationService, deps: [{ token: SessionStateService }, { token: i0.Injector }, { token: LocalizationService, optional: true, skipSelf: true }, { token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LocalizationService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LocalizationService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: SessionStateService }, { type: i0.Injector }, { type: LocalizationService, decorators: [{
-                    type: Optional
-                }, {
-                    type: SkipSelf
-                }] }, { type: ConfigStateService }] });
-function recursivelyMergeBaseResources(baseResourceName, source) {
-    const item = source[baseResourceName];
-    if (item.baseResources.length === 0) {
-        return item;
     }
-    return item.baseResources.reduce((acc, baseResource) => {
-        const baseItem = recursivelyMergeBaseResources(baseResource, source);
-        const texts = { ...baseItem.texts, ...item.texts };
-        return { ...acc, texts };
-    }, item);
-}
-function mergeResourcesWithBaseResource(resource) {
-    const entities = Object.keys(resource).map(key => {
-        const newValue = recursivelyMergeBaseResources(key, resource);
-        return [key, newValue];
-    });
-    return entities.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
-}
-function combineLegacyandNewResources(legacy, resource) {
-    const mergedResource = mergeResourcesWithBaseResource(resource);
-    return Object.entries(mergedResource).reduce((acc, [key, value]) => {
-        return { ...acc, [key]: value.texts };
-    }, legacy);
 }
 
 function findRoute(routesService, path) {
@@ -1082,1372 +1168,1343 @@ function reloadRoute(router, ngZone) {
     });
 }
 
-class ReplaceableComponentsService {
-    get replaceableComponents$() {
-        return this.store.sliceState(state => state);
-    }
-    get replaceableComponents() {
-        return this.store.state;
-    }
-    get onUpdate$() {
-        return this.store.sliceUpdate(state => state);
+/* eslint-disable @typescript-eslint/ban-types */
+class BaseTreeNode {
+    constructor(props) {
+        this.children = [];
+        this.isLeaf = true;
+        Object.assign(this, props);
     }
-    constructor(ngZone, router) {
-        this.ngZone = ngZone;
-        this.router = router;
-        this.store = new InternalStore([]);
+    static create(props) {
+        return new BaseTreeNode(props);
     }
-    add(replaceableComponent, reload) {
-        const replaceableComponents = [...this.store.state];
-        const index = replaceableComponents.findIndex(component => component.key === replaceableComponent.key);
-        if (index > -1) {
-            replaceableComponents[index] = replaceableComponent;
+}
+function createTreeFromList(list, keySelector, parentKeySelector, valueMapper) {
+    const map = createMapFromList(list, keySelector, valueMapper);
+    const tree = [];
+    list.forEach(row => {
+        const id = keySelector(row);
+        const parentId = parentKeySelector(row);
+        const node = map.get(id);
+        if (!node)
+            return;
+        if (parentId) {
+            const parent = map.get(parentId);
+            if (!parent)
+                return;
+            parent.children.push(node);
+            parent.isLeaf = false;
+            node.parent = parent;
         }
         else {
-            replaceableComponents.push(replaceableComponent);
+            tree.push(node);
         }
-        this.store.set(replaceableComponents);
-        if (reload)
-            reloadRoute(this.router, this.ngZone);
-    }
-    get(replaceableComponentKey) {
-        return this.replaceableComponents.find(component => component.key === replaceableComponentKey);
-    }
-    get$(replaceableComponentKey) {
-        return this.replaceableComponents$.pipe(map(components => components.find(component => component.key === replaceableComponentKey)));
+    });
+    return tree;
+}
+function createMapFromList(list, keySelector, valueMapper) {
+    const map = new Map();
+    list.forEach(row => map.set(keySelector(row), valueMapper(row)));
+    return map;
+}
+function createTreeNodeFilterCreator(key, mapperFn) {
+    return (search) => {
+        const regex = new RegExp('.*' + search + '.*', 'i');
+        return function collectNodes(nodes, matches = []) {
+            for (const node of nodes) {
+                if (regex.test(mapperFn(node[key])))
+                    matches.push(node);
+                if (node.children.length)
+                    collectNodes(node.children, matches);
+            }
+            return matches;
+        };
+    };
+}
+function createGroupMap(list, othersGroupKey) {
+    if (!isArray(list) || !list.some(node => Boolean(node.group)))
+        return undefined;
+    const mapGroup = new Map();
+    for (const node of list) {
+        const group = node?.group || othersGroupKey;
+        if (typeof group !== 'string') {
+            throw new Error(`Invalid group: ${group}`);
+        }
+        const items = mapGroup.get(group) || [];
+        items.push(node);
+        mapGroup.set(group, items);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ReplaceableComponentsService, deps: [{ token: i0.NgZone }, { token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ReplaceableComponentsService, providedIn: 'root' }); }
+    return mapGroup;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ReplaceableComponentsService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i0.NgZone }, { type: i1$1.Router }] });
 
-const NavigationEvent = {
-    Cancel: NavigationCancel,
-    End: NavigationEnd,
-    Error: NavigationError,
-    Start: NavigationStart,
-};
-class RouterEvents {
-    #previousNavigation;
-    #currentNavigation;
+class DomInsertionService {
     constructor() {
-        this.router = inject(Router);
-        this.#previousNavigation = signal(undefined);
-        this.previousNavigation = this.#previousNavigation.asReadonly();
-        this.#currentNavigation = signal(undefined);
-        this.currentNavigation = this.#currentNavigation.asReadonly();
-        this.listenToNavigation();
-    }
-    listenToNavigation() {
-        const routerEvent$ = this.router.events.pipe(filter(e => e instanceof NavigationEvent.End && !e.url.includes('error')));
-        routerEvent$.subscribe(event => {
-            this.#previousNavigation.set(this.currentNavigation());
-            this.#currentNavigation.set(event.url);
-        });
-    }
-    getEvents(...eventTypes) {
-        const filterRouterEvents = (event) => eventTypes.some(type => event instanceof type);
-        return this.router.events.pipe(filter(filterRouterEvents));
+        this.inserted = new Set();
     }
-    getNavigationEvents(...navigationEventKeys) {
-        const filterNavigationEvents = (event) => navigationEventKeys.some(key => event instanceof NavigationEvent[key]);
-        return this.router.events.pipe(filter(filterNavigationEvents));
+    insertContent(contentStrategy) {
+        const hash = generateHash(contentStrategy.content);
+        if (this.inserted.has(hash))
+            return;
+        const element = contentStrategy.insertElement();
+        this.inserted.add(hash);
+        return element;
     }
-    getAllEvents() {
-        return this.router.events;
+    removeContent(element) {
+        if (element.textContent) {
+            const hash = generateHash(element.textContent);
+            this.inserted.delete(hash);
+            element.parentNode?.removeChild(element);
+        }
     }
-    getAllNavigationEvents() {
-        const keys = Object.keys(NavigationEvent);
-        return this.getNavigationEvents(...keys);
+    has(content) {
+        const hash = generateHash(content);
+        return this.inserted.has(hash);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterEvents, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterEvents, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DomInsertionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DomInsertionService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterEvents, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DomInsertionService, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
-
-const APP_INIT_ERROR_HANDLERS = new InjectionToken('APP_INIT_ERROR_HANDLERS');
-
-const COOKIE_LANGUAGE_KEY = new InjectionToken('COOKIE_LANGUAGE_KEY', {
-    factory: () => '.AspNetCore.Culture',
-});
-
-const LIST_QUERY_DEBOUNCE_TIME = new InjectionToken('LIST_QUERY_DEBOUNCE_TIME');
-
-const LOADER_DELAY = new InjectionToken('LOADER_DELAY');
-
-const NAVIGATE_TO_MANAGE_PROFILE = new InjectionToken('NAVIGATE_TO_MANAGE_PROFILE');
-
-const QUEUE_MANAGER = new InjectionToken("QUEUE_MANAGER");
-
-const TENANT_KEY = new InjectionToken('TENANT_KEY');
-
-const PIPE_TO_LOGIN_FN_KEY = new InjectionToken('PIPE_TO_LOGIN_FN_KEY');
-
-/**
- * @deprecated The token should not be used anymore.
- */
-const SET_TOKEN_RESPONSE_TO_STORAGE_FN_KEY = new InjectionToken('SET_TOKEN_RESPONSE_TO_STORAGE_FN_KEY');
-
-const CHECK_AUTHENTICATION_STATE_FN_KEY = new InjectionToken('CHECK_AUTHENTICATION_STATE_FN_KEY');
-
-const OTHERS_GROUP = new InjectionToken('OTHERS_GROUP');
+            args: [{ providedIn: 'root' }]
+        }] });
 
-const TENANT_NOT_FOUND_BY_NAME = new InjectionToken('TENANT_NOT_FOUND_BY_NAME');
+const LOADER_DELAY = new InjectionToken('LOADER_DELAY');
 
-class ContentProjectionService {
+class HttpWaitService {
     constructor(injector) {
-        this.injector = injector;
+        this.store = new InternalStore({
+            requests: [],
+            filteredRequests: [],
+        });
+        this.destroy$ = new Subject();
+        this.delay = injector.get(LOADER_DELAY, 500);
     }
-    projectContent(projectionStrategy, injector = this.injector) {
-        return projectionStrategy.injectContent(injector);
+    getLoading() {
+        return !!this.applyFilter(this.store.state.requests).length;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ContentProjectionService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ContentProjectionService, providedIn: 'root' }); }
+    getLoading$() {
+        return this.store
+            .sliceState(({ requests }) => requests)
+            .pipe(map(requests => !!this.applyFilter(requests).length), switchMap(condition => condition
+            ? this.delay === 0
+                ? of(true)
+                : timer(this.delay).pipe(mapTo(true), takeUntil(this.destroy$))
+            : of(false)), tap(() => this.destroy$.next()));
+    }
+    updateLoading$() {
+        return this.store.sliceUpdate(({ requests }) => !!this.applyFilter(requests).length);
+    }
+    clearLoading() {
+        this.store.patch({ requests: [] });
+    }
+    addRequest(request) {
+        this.store.patch({ requests: [...this.store.state.requests, request] });
+    }
+    deleteRequest(request) {
+        const requests = this.store.state.requests.filter(r => r !== request);
+        this.store.patch({ requests });
+    }
+    addFilter(request) {
+        const requests = Array.isArray(request) ? request : [request];
+        const filteredRequests = [
+            ...this.store.state.filteredRequests.filter(f => !requests.some(r => this.isSameRequest(f, r))),
+            ...requests,
+        ];
+        this.store.patch({ filteredRequests });
+    }
+    removeFilter(request) {
+        const requests = Array.isArray(request) ? request : [request];
+        const filteredRequests = this.store.state.filteredRequests.filter(f => !requests.some(r => this.isSameRequest(f, r)));
+        this.store.patch({ filteredRequests });
+    }
+    applyFilter(requests) {
+        if (!requests) {
+            return [];
+        }
+        const { filteredRequests } = this.store.state;
+        return requests.filter(({ method, url }) => !filteredRequests.find(filteredRequest => this.isSameRequest(filteredRequest, { method, endpoint: getPathName(url) })));
+    }
+    isSameRequest(filteredRequest, request) {
+        const { method, endpoint } = filteredRequest;
+        return endpoint === request.endpoint && method === request.method;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: HttpWaitService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: HttpWaitService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ContentProjectionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: HttpWaitService, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
+            args: [{
+                    providedIn: 'root',
+                }]
         }], ctorParameters: () => [{ type: i0.Injector }] });
 
-function pushValueTo(array) {
-    return (element) => {
-        array.push(element);
-        return array;
-    };
-}
-
-function getShortDateFormat(configStateService) {
-    const dateTimeFormat = configStateService.getDeep('localization.currentCulture.dateTimeFormat');
-    return dateTimeFormat.shortDatePattern;
-}
-function getShortTimeFormat(configStateService) {
-    const dateTimeFormat = configStateService.getDeep('localization.currentCulture.dateTimeFormat');
-    return dateTimeFormat?.shortTimePattern?.replace('tt', 'a');
-}
-function getShortDateShortTimeFormat(configStateService) {
-    const dateTimeFormat = configStateService.getDeep('localization.currentCulture.dateTimeFormat');
-    return `${dateTimeFormat.shortDatePattern} ${dateTimeFormat?.shortTimePattern?.replace('tt', 'a')}`;
-}
-
-function getRemoteEnv(injector, environment) {
-    const environmentService = injector.get(EnvironmentService);
-    const { remoteEnv } = environment;
-    const { headers = {}, method = 'GET', url } = remoteEnv || {};
-    if (!url)
-        return Promise.resolve();
-    const http = injector.get(HttpClient);
-    const httpErrorReporter = injector.get(HttpErrorReporterService);
-    return http
-        .request(method, url, { headers })
-        .pipe(catchError(err => {
-        httpErrorReporter.reportError(err);
-        return of(null);
-    }), // TODO: Consider get handle function from a provider
-    tap(env => environmentService.setState(mergeEnvironments(environment, env || {}, remoteEnv))))
-        .toPromise();
-}
-function mergeEnvironments(local, remote, config) {
-    switch (config.mergeStrategy) {
-        case 'deepmerge':
-            return deepMerge(local, remote);
-        case 'overwrite':
-        case null:
-        case undefined:
-            return remote;
-        default:
-            return config.mergeStrategy(local, remote);
+class ResourceWaitService {
+    constructor() {
+        this.store = new InternalStore({ resources: new Set() });
     }
-}
-
-class LazyModuleFactory extends NgModuleFactory {
-    get moduleType() {
-        return this.moduleWithProviders.ngModule;
+    getLoading() {
+        return !!this.store.state.resources.size;
     }
-    constructor(moduleWithProviders) {
-        super();
-        this.moduleWithProviders = moduleWithProviders;
+    getLoading$() {
+        return this.store.sliceState(({ resources }) => !!resources.size);
     }
-    create(parentInjector) {
-        const injector = Injector.create({
-            ...(parentInjector && { parent: parentInjector }),
-            providers: this.moduleWithProviders.providers,
-        });
-        const compiler = injector.get(Compiler);
-        const factory = compiler.compileModuleSync(this.moduleType);
-        return factory.create(injector);
+    updateLoading$() {
+        return this.store.sliceUpdate(({ resources }) => !!resources?.size);
     }
-}
-function featuresFactory(configState, featureKeys, mapFn = features => features) {
-    return configState.getFeatures$(featureKeys).pipe(filter(Boolean), map(mapFn));
-}
-
-/** @deprecated the method will change in v8.0 */
-function downloadBlob(blob, filename) {
-    const blobUrl = URL.createObjectURL(blob);
-    const link = document.createElement('a');
-    link.href = blobUrl;
-    link.download = filename;
-    document.body.appendChild(link);
-    link.dispatchEvent(new MouseEvent('click', {
-        bubbles: true,
-        cancelable: true,
-        view: window,
-    }));
-    document.body.removeChild(link);
-}
-
-function isNumber(value) {
-    return value == Number(value);
-}
-
-function mapEnumToOptions(_enum) {
-    const options = [];
-    for (const member in _enum)
-        if (!isNumber(member))
-            options.push({
-                key: member,
-                value: _enum[member],
-            });
-    return options;
-}
-
-function uuid(a) {
-    return a
-        ? (a ^ ((Math.random() * 16) >> (a / 4))).toString(16)
-        : ('' + 1e7 + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, uuid);
-}
-function generateHash(value) {
-    let hashed = 0;
-    let charCode;
-    for (let i = 0; i < value.length; i++) {
-        charCode = value.charCodeAt(i);
-        hashed = (hashed << 5) - hashed + charCode;
-        hashed |= 0;
+    clearLoading() {
+        this.store.patch({ resources: new Set() });
     }
-    return hashed;
-}
-function generatePassword(length = 8) {
-    length = Math.min(Math.max(4, length), 128);
-    const lowers = 'abcdefghijklmnopqrstuvwxyz';
-    const uppers = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-    const numbers = '0123456789';
-    const specials = '!@#$%&*()_+{}<>?[]./';
-    const all = lowers + uppers + numbers + specials;
-    const getRandom = (chrSet) => chrSet[Math.floor(Math.random() * chrSet.length)];
-    const password = Array({ length });
-    password[0] = getRandom(lowers);
-    password[1] = getRandom(uppers);
-    password[2] = getRandom(numbers);
-    password[3] = getRandom(specials);
-    for (let i = 4; i < length; i++) {
-        password[i] = getRandom(all);
+    addResource(resource) {
+        const resources = this.store.state.resources;
+        resources.add(resource);
+        this.store.patch({ resources });
     }
-    return password.sort(() => 0.5 - Math.random()).join('');
+    deleteResource(resource) {
+        const resources = this.store.state.resources;
+        resources.delete(resource);
+        this.store.patch({ resources });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ResourceWaitService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ResourceWaitService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ResourceWaitService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
 
-function getPathName(url) {
-    const { pathname } = new URL(url, window.location.origin);
-    return pathname;
-}
-class WebHttpUrlEncodingCodec {
-    encodeKey(k) {
-        return encodeURIComponent(k);
-    }
-    encodeValue(v) {
-        return encodeURIComponent(v);
-    }
-    decodeKey(k) {
-        return decodeURIComponent(k);
+class LazyLoadService {
+    constructor(resourceWaitService) {
+        this.resourceWaitService = resourceWaitService;
+        this.loaded = new Map();
     }
-    decodeValue(v) {
-        return decodeURIComponent(v);
+    load(strategy, retryTimes, retryDelay) {
+        if (this.loaded.has(strategy.path))
+            return of(new CustomEvent('load'));
+        this.resourceWaitService.addResource(strategy.path);
+        const delayOperator = retryDelay ? pipe(delay(retryDelay)) : pipe();
+        const takeOp = retryTimes ? pipe(take(retryTimes)) : pipe();
+        return strategy.createStream().pipe(retryWhen(error$ => concat(error$.pipe(delayOperator, takeOp), throwError(() => new CustomEvent('error')))), tap(() => {
+            this.loaded.set(strategy.path, strategy.element);
+            this.resourceWaitService.deleteResource(strategy.path);
+        }), delay(100), shareReplay({ bufferSize: 1, refCount: true }));
     }
-}
-
-class AbpTenantService {
-    constructor(restService) {
-        this.restService = restService;
-        this.apiName = 'abp';
-        this.findTenantById = (id) => this.restService.request({
-            method: 'GET',
-            url: `/api/abp/multi-tenancy/tenants/by-id/${id}`,
-        }, { apiName: this.apiName });
-        this.findTenantByName = (name) => this.restService.request({
-            method: 'GET',
-            url: `/api/abp/multi-tenancy/tenants/by-name/${name}`,
-        }, { apiName: this.apiName });
+    remove(path) {
+        const element = this.loaded.get(path);
+        if (!element)
+            return false;
+        element.parentNode?.removeChild(element);
+        this.loaded.delete(path);
+        return true;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpTenantService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpTenantService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LazyLoadService, deps: [{ token: ResourceWaitService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LazyLoadService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpTenantService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LazyLoadService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [{ type: RestService }] });
+        }], ctorParameters: () => [{ type: ResourceWaitService }] });
 
-class MultiTenancyService {
-    constructor(restService, sessionState, tenantService, configStateService, tenantKey) {
-        this.restService = restService;
-        this.sessionState = sessionState;
-        this.tenantService = tenantService;
-        this.configStateService = configStateService;
-        this.tenantKey = tenantKey;
-        this.domainTenant = null;
-        this.isTenantBoxVisible = true;
-        this.apiName = 'abp';
-        this.setTenantToState = (tenant) => {
-            this.sessionState.setTenant({ id: tenant.tenantId, name: tenant.name, isAvailable: true });
-            return this.configStateService.refreshAppState().pipe(map(_ => tenant));
-        };
+const LIST_QUERY_DEBOUNCE_TIME = new InjectionToken('LIST_QUERY_DEBOUNCE_TIME');
+
+class ListService {
+    set filter(value) {
+        this._filter = value;
+        this.get();
     }
-    setTenantByName(tenantName) {
-        return this.tenantService
-            .findTenantByName(tenantName)
-            .pipe(switchMap(this.setTenantToState));
+    get filter() {
+        return this._filter;
     }
-    setTenantById(tenantId) {
-        return this.tenantService
-            .findTenantById(tenantId)
-            .pipe(switchMap(this.setTenantToState));
+    set maxResultCount(value) {
+        this._maxResultCount = value;
+        this.get();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: MultiTenancyService, deps: [{ token: RestService }, { token: SessionStateService }, { token: AbpTenantService }, { token: ConfigStateService }, { token: TENANT_KEY }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: MultiTenancyService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: MultiTenancyService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: RestService }, { type: SessionStateService }, { type: AbpTenantService }, { type: ConfigStateService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [TENANT_KEY]
-                }] }] });
-
-const tenancyPlaceholder = '{0}';
-function getCurrentTenancyName(appBaseUrl) {
-    if (appBaseUrl.charAt(appBaseUrl.length - 1) !== '/')
-        appBaseUrl += '/';
-    const parseTokens = createTokenParser(appBaseUrl);
-    const token = tenancyPlaceholder.replace(/[}{]/g, '');
-    return parseTokens(window.location.href)[token]?.[0];
-}
-function getCurrentTenancyNameFromUrl(tenantKey) {
-    const urlParams = new URLSearchParams(window.location.search);
-    return urlParams.get(tenantKey);
-}
-async function parseTenantFromUrl(injector) {
-    const environmentService = injector.get(EnvironmentService);
-    const multiTenancyService = injector.get(MultiTenancyService);
-    const tenantNotFoundHandler = injector.get(TENANT_NOT_FOUND_BY_NAME, null);
-    const baseUrl = environmentService.getEnvironment()?.application?.baseUrl || '';
-    const tenancyName = getCurrentTenancyName(baseUrl);
-    const hideTenantBox = () => {
-        multiTenancyService.isTenantBoxVisible = false;
-    };
-    const setDomainTenant = (tenant) => {
-        multiTenancyService.domainTenant = {
-            id: tenant.tenantId,
-            name: tenant.name,
-            isAvailable: true,
-        };
-    };
-    const setEnvironmentWithDomainTenant = (tenant) => {
-        hideTenantBox();
-        setDomainTenant(tenant);
-    };
-    if (tenancyName) {
-        /**
-         * We have to replace tenant name within the urls from environment,
-         * because the code below will make a http request to find information about the domain tenant.
-         * Before this request takes place, we need to replace placeholders aka "{0}".
-         */
-        replaceTenantNameWithinEnvironment(injector, tenancyName);
-        const tenant$ = multiTenancyService.setTenantByName(tenancyName);
-        try {
-            const result = await firstValueFrom(tenant$);
-            setEnvironmentWithDomainTenant(result);
-            return Promise.resolve(result);
-        }
-        catch (httpError) {
-            if (httpError instanceof HttpErrorResponse &&
-                httpError.status === 404 &&
-                tenantNotFoundHandler) {
-                tenantNotFoundHandler(httpError);
-            }
-            return Promise.reject();
-        }
+    get maxResultCount() {
+        return this._maxResultCount;
     }
-    /**
-     * If there is no tenant, we still have to clean up {0}. from baseUrl to avoid incorrect http requests.
-     */
-    replaceTenantNameWithinEnvironment(injector, '', tenancyPlaceholder + '.');
-    const tenantIdFromQueryParams = getCurrentTenancyNameFromUrl(multiTenancyService.tenantKey);
-    if (tenantIdFromQueryParams) {
-        const tenantById$ = multiTenancyService.setTenantById(tenantIdFromQueryParams);
-        return firstValueFrom(tenantById$);
+    set page(value) {
+        if (value === this._page)
+            return;
+        this._page = value;
+        this.get();
     }
-    return Promise.resolve();
-}
-function replaceTenantNameWithinEnvironment(injector, tenancyName, placeholder = tenancyPlaceholder) {
-    const environmentService = injector.get(EnvironmentService);
-    const environment = clone(environmentService.getEnvironment());
-    if (environment.application.baseUrl) {
-        environment.application.baseUrl = environment.application.baseUrl.replace(placeholder, tenancyName);
+    get page() {
+        return this._page;
     }
-    if (environment.oAuthConfig?.redirectUri) {
-        environment.oAuthConfig.redirectUri = environment.oAuthConfig.redirectUri.replace(placeholder, tenancyName);
+    set totalCount(value) {
+        if (value === this._totalCount)
+            return;
+        this._totalCount = value;
+        this.get();
     }
-    if (!environment.oAuthConfig) {
-        environment.oAuthConfig = {};
+    get totalCount() {
+        return this._totalCount;
     }
-    environment.oAuthConfig.issuer = (environment.oAuthConfig.issuer || '').replace(placeholder, tenancyName);
-    Object.keys(environment.apis).forEach(api => {
-        Object.keys(environment.apis[api]).forEach(key => {
-            environment.apis[api][key] = (environment.apis[api][key] || '').replace(placeholder, tenancyName);
-        });
-    });
-    return environmentService.setState(environment);
-}
-
-function getInitialData(injector) {
-    const fn = async () => {
-        const environmentService = injector.get(EnvironmentService);
-        const configState = injector.get(ConfigStateService);
-        const options = injector.get(CORE_OPTIONS);
-        environmentService.setState(options.environment);
-        await getRemoteEnv(injector, options.environment);
-        await parseTenantFromUrl(injector);
-        const authService = injector.get(AuthService, undefined, { optional: true });
-        const checkAuthenticationState = injector.get(CHECK_AUTHENTICATION_STATE_FN_KEY, noop, {
-            optional: true,
-        });
-        if (authService) {
-            await authService.init();
-        }
-        if (options.skipGetAppConfiguration)
-            return;
-        const result$ = configState.refreshAppState().pipe(tap(() => checkAuthenticationState(injector)), tap(() => {
-            const currentTenant = configState.getOne('currentTenant');
-            injector.get(SessionStateService).setTenant(currentTenant);
-        }), catchError(error => {
-            const appInitErrorHandlers = injector.get(APP_INIT_ERROR_HANDLERS, null);
-            if (appInitErrorHandlers && appInitErrorHandlers.length) {
-                appInitErrorHandlers.forEach(func => func(error));
-            }
-            return throwError(error);
-        }));
-        await lastValueFrom(result$);
-    };
-    return fn;
-}
-function localeInitializer(injector) {
-    const fn = () => {
-        const sessionState = injector.get(SessionStateService);
-        const { registerLocaleFn } = injector.get(CORE_OPTIONS);
-        const lang = sessionState.getLanguage() || 'en';
-        return new Promise((resolve, reject) => {
-            registerLocaleFn(lang).then(module => {
-                if (module?.default)
-                    registerLocaleData(module.default);
-                return resolve('resolved');
-            }, reject);
-        });
-    };
-    return fn;
-}
-
-class CrossOriginStrategy {
-    constructor(crossorigin, integrity) {
-        this.crossorigin = crossorigin;
-        this.integrity = integrity;
+    set sortKey(value) {
+        this._sortKey = value;
+        this.get();
     }
-    setCrossOrigin(element) {
-        if (this.integrity)
-            element.setAttribute('integrity', this.integrity);
-        if (this.crossorigin) {
-            element.setAttribute('crossorigin', this.crossorigin);
-        }
+    get sortKey() {
+        return this._sortKey;
     }
-}
-class NoCrossOriginStrategy extends CrossOriginStrategy {
-    setCrossOrigin() { }
-}
-const CROSS_ORIGIN_STRATEGY = {
-    Anonymous(integrity) {
-        return new CrossOriginStrategy('anonymous', integrity);
-    },
-    UseCredentials(integrity) {
-        return new CrossOriginStrategy('use-credentials', integrity);
-    },
-    None() {
-        return new NoCrossOriginStrategy(null);
-    },
-};
-
-class DomStrategy {
-    constructor(target = document.head, position = 'beforeend') {
-        this.target = target;
-        this.position = position;
+    set sortOrder(value) {
+        this._sortOrder = value;
+        this.get();
+    }
+    get sortOrder() {
+        return this._sortOrder;
+    }
+    get query$() {
+        return this._query$
+            .asObservable()
+            .pipe(this.delay, shareReplay({ bufferSize: 1, refCount: true }));
     }
-    insertElement(element) {
-        this.target.insertAdjacentElement(this.position, element);
+    get isLoading$() {
+        return this._isLoading$.asObservable();
     }
-}
-const DOM_STRATEGY = {
-    AfterElement(element) {
-        return new DomStrategy(element, 'afterend');
-    },
-    AppendToBody() {
-        return new DomStrategy(document.body, 'beforeend');
-    },
-    AppendToHead() {
-        return new DomStrategy(document.head, 'beforeend');
-    },
-    BeforeElement(element) {
-        return new DomStrategy(element, 'beforebegin');
-    },
-    PrependToHead() {
-        return new DomStrategy(document.head, 'afterbegin');
-    },
-};
-
-function fromLazyLoad(element, domStrategy = DOM_STRATEGY.AppendToHead(), crossOriginStrategy = CROSS_ORIGIN_STRATEGY.Anonymous()) {
-    crossOriginStrategy.setCrossOrigin(element);
-    domStrategy.insertElement(element);
-    return new Observable((observer) => {
-        element.onload = (event) => {
-            clearCallbacks(element);
-            observer.next(event);
-            observer.complete();
+    constructor(injector) {
+        this._filter = '';
+        this._maxResultCount = 10;
+        this._skipCount = 0;
+        this._page = 0;
+        this._totalCount = 0;
+        this._sortKey = '';
+        this._sortOrder = '';
+        this._query$ = new ReplaySubject(1);
+        this._isLoading$ = new BehaviorSubject(false);
+        this.destroy$ = new Subject();
+        this.get = () => {
+            this.resetPageWhenUnchanged();
+            this.next();
         };
-        const handleError = createErrorHandler(observer, element);
-        element.onerror = handleError;
-        element.onabort = handleError;
-        element.onemptied = handleError;
-        element.onstalled = handleError;
-        element.onsuspend = handleError;
-        return () => {
-            clearCallbacks(element);
-            observer.complete();
+        this.getWithoutPageReset = () => {
+            this.next();
         };
-    });
-}
-function createErrorHandler(observer, element) {
-    return function (event) {
-        clearCallbacks(element);
-        element.parentNode?.removeChild(element);
-        observer.error(event);
-    };
-}
-function clearCallbacks(element) {
-    element.onload = null;
-    element.onerror = null;
-    element.onabort = null;
-    element.onemptied = null;
-    element.onstalled = null;
-    element.onsuspend = null;
-}
-
-class DefaultQueueManager {
-    constructor() {
-        this.queue = [];
-        this.isRunning = false;
-        this.stack = 0;
-        this.interval = 0;
-        this.stackSize = 100;
+        const delay = injector.get(LIST_QUERY_DEBOUNCE_TIME, 300);
+        this.delay = delay ? debounceTime(delay) : tap();
+        this.get();
     }
-    init(interval, stackSize) {
-        this.interval = interval;
-        this.stackSize = stackSize;
+    hookToQuery(streamCreatorCallback) {
+        return this.query$.pipe(tap(() => this._isLoading$.next(true)), switchMap(query => streamCreatorCallback(query).pipe(catchError(() => of(null)))), filter(Boolean), tap(() => this._isLoading$.next(false)), shareReplay({ bufferSize: 1, refCount: true }), takeUntil(this.destroy$));
     }
-    add(fn) {
-        this.queue.push(fn);
-        this.run();
+    ngOnDestroy() {
+        this.destroy$.next();
     }
-    run() {
-        if (this.isRunning)
-            return;
-        this.stack++;
-        this.isRunning = true;
-        const fn = this.queue.shift();
-        if (!fn) {
-            this.isRunning = false;
+    resetPageWhenUnchanged() {
+        const maxPage = Number(Number(this.totalCount / this._maxResultCount).toFixed());
+        const skipCount = this._page * this._maxResultCount;
+        if (skipCount !== this._totalCount) {
+            this._skipCount = skipCount;
             return;
         }
-        fn();
-        if (this.stack > this.stackSize) {
-            setTimeout(() => {
-                this.isRunning = false;
-                this.run();
-                this.stack = 0;
-            }, this.interval);
-        }
-        else {
-            this.isRunning = false;
-            this.run();
+        if (this.page === maxPage && this.page > 0) {
+            this._skipCount = skipCount - this._maxResultCount;
+            this.page = this.page - 1;
         }
     }
+    next() {
+        this._query$.next({
+            filter: this._filter || undefined,
+            maxResultCount: this._maxResultCount,
+            skipCount: this._page * this._maxResultCount,
+            sorting: this._sortOrder ? `${this._sortKey} ${this._sortOrder}` : undefined,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ListService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ListService }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ListService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
 
-/* eslint-disable @typescript-eslint/ban-types */
-class BaseTreeNode {
-    constructor(props) {
-        this.children = [];
-        this.isLeaf = true;
-        Object.assign(this, props);
+class PermissionService {
+    constructor(configState) {
+        this.configState = configState;
     }
-    static create(props) {
-        return new BaseTreeNode(props);
+    getGrantedPolicy$(key) {
+        return this.getStream().pipe(map(grantedPolicies => this.isPolicyGranted(key, grantedPolicies)));
     }
-}
-function createTreeFromList(list, keySelector, parentKeySelector, valueMapper) {
-    const map = createMapFromList(list, keySelector, valueMapper);
-    const tree = [];
-    list.forEach(row => {
-        const id = keySelector(row);
-        const parentId = parentKeySelector(row);
-        const node = map.get(id);
-        if (!node)
-            return;
-        if (parentId) {
-            const parent = map.get(parentId);
-            if (!parent)
-                return;
-            parent.children.push(node);
-            parent.isLeaf = false;
-            node.parent = parent;
+    getGrantedPolicy(key) {
+        const policies = this.getSnapshot();
+        return this.isPolicyGranted(key, policies);
+    }
+    filterItemsByPolicy(items) {
+        const policies = this.getSnapshot();
+        return items.filter(item => !item.requiredPolicy || this.isPolicyGranted(item.requiredPolicy, policies));
+    }
+    filterItemsByPolicy$(items) {
+        return this.getStream().pipe(map(policies => items.filter(item => !item.requiredPolicy || this.isPolicyGranted(item.requiredPolicy, policies))));
+    }
+    isPolicyGranted(key, grantedPolicies) {
+        if (!key)
+            return true;
+        const orRegexp = /\|\|/g;
+        const andRegexp = /&&/g;
+        // TODO: Allow combination of ANDs & ORs
+        if (orRegexp.test(key)) {
+            const keys = key.split('||').filter(Boolean);
+            if (keys.length < 2)
+                return false;
+            return keys.some(k => this.getPolicy(k.trim(), grantedPolicies));
         }
-        else {
-            tree.push(node);
+        else if (andRegexp.test(key)) {
+            const keys = key.split('&&').filter(Boolean);
+            if (keys.length < 2)
+                return false;
+            return keys.every(k => this.getPolicy(k.trim(), grantedPolicies));
         }
-    });
-    return tree;
-}
-function createMapFromList(list, keySelector, valueMapper) {
-    const map = new Map();
-    list.forEach(row => map.set(keySelector(row), valueMapper(row)));
-    return map;
-}
-function createTreeNodeFilterCreator(key, mapperFn) {
-    return (search) => {
-        const regex = new RegExp('.*' + search + '.*', 'i');
-        return function collectNodes(nodes, matches = []) {
-            for (const node of nodes) {
-                if (regex.test(mapperFn(node[key])))
-                    matches.push(node);
-                if (node.children.length)
-                    collectNodes(node.children, matches);
-            }
-            return matches;
-        };
-    };
+        return this.getPolicy(key, grantedPolicies);
+    }
+    getStream() {
+        return this.configState.getAll$().pipe(map(this.mapToPolicies));
+    }
+    getSnapshot() {
+        return this.mapToPolicies(this.configState.getAll());
+    }
+    mapToPolicies(applicationConfiguration) {
+        return applicationConfiguration?.auth?.grantedPolicies || {};
+    }
+    getPolicy(key, grantedPolicies) {
+        return grantedPolicies[key] || false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PermissionService, deps: [{ token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PermissionService, providedIn: 'root' }); }
 }
-function createGroupMap(list, othersGroupKey) {
-    if (!isArray(list) || !list.some(node => Boolean(node.group)))
-        return undefined;
-    const mapGroup = new Map();
-    for (const node of list) {
-        const group = node?.group || othersGroupKey;
-        if (typeof group !== 'string') {
-            throw new Error(`Invalid group: ${group}`);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PermissionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: ConfigStateService }] });
+
+class ReplaceableComponentsService {
+    get replaceableComponents$() {
+        return this.store.sliceState(state => state);
+    }
+    get replaceableComponents() {
+        return this.store.state;
+    }
+    get onUpdate$() {
+        return this.store.sliceUpdate(state => state);
+    }
+    constructor(ngZone, router) {
+        this.ngZone = ngZone;
+        this.router = router;
+        this.store = new InternalStore([]);
+    }
+    add(replaceableComponent, reload) {
+        const replaceableComponents = [...this.store.state];
+        const index = replaceableComponents.findIndex(component => component.key === replaceableComponent.key);
+        if (index > -1) {
+            replaceableComponents[index] = replaceableComponent;
         }
-        const items = mapGroup.get(group) || [];
-        items.push(node);
-        mapGroup.set(group, items);
+        else {
+            replaceableComponents.push(replaceableComponent);
+        }
+        this.store.set(replaceableComponents);
+        if (reload)
+            reloadRoute(this.router, this.ngZone);
     }
-    return mapGroup;
+    get(replaceableComponentKey) {
+        return this.replaceableComponents.find(component => component.key === replaceableComponentKey);
+    }
+    get$(replaceableComponentKey) {
+        return this.replaceableComponents$.pipe(map(components => components.find(component => component.key === replaceableComponentKey)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ReplaceableComponentsService, deps: [{ token: i0.NgZone }, { token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ReplaceableComponentsService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ReplaceableComponentsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.NgZone }, { type: i1$1.Router }] });
 
-class DomInsertionService {
+const NavigationEvent = {
+    Cancel: NavigationCancel,
+    End: NavigationEnd,
+    Error: NavigationError,
+    Start: NavigationStart,
+};
+class RouterEvents {
+    #previousNavigation;
+    #currentNavigation;
     constructor() {
-        this.inserted = new Set();
+        this.router = inject(Router);
+        this.#previousNavigation = signal(undefined);
+        this.previousNavigation = this.#previousNavigation.asReadonly();
+        this.#currentNavigation = signal(undefined);
+        this.currentNavigation = this.#currentNavigation.asReadonly();
+        this.listenToNavigation();
     }
-    insertContent(contentStrategy) {
-        const hash = generateHash(contentStrategy.content);
-        if (this.inserted.has(hash))
-            return;
-        const element = contentStrategy.insertElement();
-        this.inserted.add(hash);
-        return element;
+    listenToNavigation() {
+        const routerEvent$ = this.router.events.pipe(filter(e => e instanceof NavigationEvent.End && !e.url.includes('error')));
+        routerEvent$.subscribe(event => {
+            this.#previousNavigation.set(this.currentNavigation());
+            this.#currentNavigation.set(event.url);
+        });
     }
-    removeContent(element) {
-        if (element.textContent) {
-            const hash = generateHash(element.textContent);
-            this.inserted.delete(hash);
-            element.parentNode?.removeChild(element);
-        }
+    getEvents(...eventTypes) {
+        const filterRouterEvents = (event) => eventTypes.some(type => event instanceof type);
+        return this.router.events.pipe(filter(filterRouterEvents));
     }
-    has(content) {
-        const hash = generateHash(content);
-        return this.inserted.has(hash);
+    getNavigationEvents(...navigationEventKeys) {
+        const filterNavigationEvents = (event) => navigationEventKeys.some(key => event instanceof NavigationEvent[key]);
+        return this.router.events.pipe(filter(filterNavigationEvents));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DomInsertionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DomInsertionService, providedIn: 'root' }); }
+    getAllEvents() {
+        return this.router.events;
+    }
+    getAllNavigationEvents() {
+        const keys = Object.keys(NavigationEvent);
+        return this.getNavigationEvents(...keys);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterEvents, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterEvents, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DomInsertionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterEvents, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }] });
+        }], ctorParameters: () => [] });
 
-class HttpWaitService {
-    constructor(injector) {
-        this.store = new InternalStore({
-            requests: [],
-            filteredRequests: [],
-        });
+class RouterWaitService {
+    constructor(routerEvents, injector) {
+        this.routerEvents = routerEvents;
+        this.store = new InternalStore({ loading: false });
         this.destroy$ = new Subject();
         this.delay = injector.get(LOADER_DELAY, 500);
+        this.updateLoadingStatusOnNavigationEvents();
     }
-    getLoading() {
-        return !!this.applyFilter(this.store.state.requests).length;
-    }
-    getLoading$() {
-        return this.store
-            .sliceState(({ requests }) => requests)
-            .pipe(map(requests => !!this.applyFilter(requests).length), switchMap(condition => condition
+    updateLoadingStatusOnNavigationEvents() {
+        this.routerEvents
+            .getAllNavigationEvents()
+            .pipe(map(event => event instanceof NavigationStart), switchMap(condition => condition
             ? this.delay === 0
                 ? of(true)
-                : timer(this.delay).pipe(mapTo(true), takeUntil(this.destroy$))
-            : of(false)), tap(() => this.destroy$.next()));
-    }
-    updateLoading$() {
-        return this.store.sliceUpdate(({ requests }) => !!this.applyFilter(requests).length);
-    }
-    clearLoading() {
-        this.store.patch({ requests: [] });
-    }
-    addRequest(request) {
-        this.store.patch({ requests: [...this.store.state.requests, request] });
-    }
-    deleteRequest(request) {
-        const requests = this.store.state.requests.filter(r => r !== request);
-        this.store.patch({ requests });
+                : timer(this.delay || 0).pipe(mapTo(true), takeUntil(this.destroy$))
+            : of(false)), tap(() => this.destroy$.next()))
+            .subscribe(status => {
+            this.setLoading(status);
+        });
     }
-    addFilter(request) {
-        const requests = Array.isArray(request) ? request : [request];
-        const filteredRequests = [
-            ...this.store.state.filteredRequests.filter(f => !requests.some(r => this.isSameRequest(f, r))),
-            ...requests,
-        ];
-        this.store.patch({ filteredRequests });
+    getLoading() {
+        return this.store.state.loading;
     }
-    removeFilter(request) {
-        const requests = Array.isArray(request) ? request : [request];
-        const filteredRequests = this.store.state.filteredRequests.filter(f => !requests.some(r => this.isSameRequest(f, r)));
-        this.store.patch({ filteredRequests });
+    getLoading$() {
+        return this.store.sliceState(({ loading }) => loading);
     }
-    applyFilter(requests) {
-        if (!requests) {
-            return [];
-        }
-        const { filteredRequests } = this.store.state;
-        return requests.filter(({ method, url }) => !filteredRequests.find(filteredRequest => this.isSameRequest(filteredRequest, { method, endpoint: getPathName(url) })));
+    updateLoading$() {
+        return this.store.sliceUpdate(({ loading }) => loading);
     }
-    isSameRequest(filteredRequest, request) {
-        const { method, endpoint } = filteredRequest;
-        return endpoint === request.endpoint && method === request.method;
+    setLoading(loading) {
+        this.store.patch({ loading });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: HttpWaitService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: HttpWaitService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterWaitService, deps: [{ token: RouterEvents }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterWaitService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: HttpWaitService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterWaitService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [{ type: i0.Injector }] });
+        }], ctorParameters: () => [{ type: RouterEvents }, { type: i0.Injector }] });
 
-class ResourceWaitService {
+const COOKIE_LANGUAGE_KEY = new InjectionToken('COOKIE_LANGUAGE_KEY', {
+    factory: () => '.AspNetCore.Culture',
+});
+
+const NAVIGATE_TO_MANAGE_PROFILE = new InjectionToken('NAVIGATE_TO_MANAGE_PROFILE');
+
+const QUEUE_MANAGER = new InjectionToken("QUEUE_MANAGER");
+
+const INCUDE_LOCALIZATION_RESOURCES_TOKEN = new InjectionToken('INCUDE_LOCALIZATION_RESOURCES_TOKEN');
+
+const PIPE_TO_LOGIN_FN_KEY = new InjectionToken('PIPE_TO_LOGIN_FN_KEY');
+
+/**
+ * @deprecated The token should not be used anymore.
+ */
+const SET_TOKEN_RESPONSE_TO_STORAGE_FN_KEY = new InjectionToken('SET_TOKEN_RESPONSE_TO_STORAGE_FN_KEY');
+
+const OTHERS_GROUP = new InjectionToken('OTHERS_GROUP');
+
+const SORT_COMPARE_FUNC = new InjectionToken('SORT_COMPARE_FUNC');
+function compareFuncFactory() {
+    const localizationService = inject(LocalizationService);
+    const fn = (a, b) => {
+        const aNumber = a.order;
+        const bNumber = b.order;
+        if (aNumber > bNumber)
+            return 1;
+        if (aNumber < bNumber)
+            return -1;
+        if (a.id > b.id)
+            return 1;
+        if (a.id < b.id)
+            return -1;
+        if (!Number.isInteger(aNumber))
+            return 1;
+        if (!Number.isInteger(bNumber))
+            return -1;
+        const aName = localizationService.instant(a.name);
+        const bName = localizationService.instant(b.name);
+        if (aName > bName)
+            return 1;
+        if (aName < bName)
+            return -1;
+        return 0;
+    };
+    return fn;
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+class AbstractTreeService {
     constructor() {
-        this.store = new InternalStore({ resources: new Set() });
+        this._flat$ = new BehaviorSubject([]);
+        this._tree$ = new BehaviorSubject([]);
+        this._visible$ = new BehaviorSubject([]);
+        this.shouldSingularizeRoutes = true;
     }
-    getLoading() {
-        return !!this.store.state.resources.size;
+    get flat() {
+        return this._flat$.value;
     }
-    getLoading$() {
-        return this.store.sliceState(({ resources }) => !!resources.size);
+    get flat$() {
+        return this._flat$.asObservable();
     }
-    updateLoading$() {
-        return this.store.sliceUpdate(({ resources }) => !!resources?.size);
+    get tree() {
+        return this._tree$.value;
+    }
+    get tree$() {
+        return this._tree$.asObservable();
+    }
+    get visible() {
+        return this._visible$.value;
+    }
+    get visible$() {
+        return this._visible$.asObservable();
+    }
+    filterWith(setOrMap) {
+        return this._flat$.value.filter(item => !setOrMap.has(item[this.id]));
+    }
+    findItemsToRemove(set) {
+        return this._flat$.value.reduce((acc, item) => {
+            if (!acc.has(item[this.parentId])) {
+                return acc;
+            }
+            const childSet = new Set([item[this.id]]);
+            const children = this.findItemsToRemove(childSet);
+            return new Set([...acc, ...children]);
+        }, set);
     }
-    clearLoading() {
-        this.store.patch({ resources: new Set() });
+    publish(flatItems) {
+        this._flat$.next(flatItems);
+        this._tree$.next(this.createTree(flatItems));
+        this._visible$.next(this.createTree(flatItems.filter(item => !this.hide(item))));
+        return flatItems;
     }
-    addResource(resource) {
-        const resources = this.store.state.resources;
-        resources.add(resource);
-        this.store.patch({ resources });
+    createTree(items) {
+        return createTreeFromList(items, item => item[this.id], item => item[this.parentId], item => BaseTreeNode.create(item));
     }
-    deleteResource(resource) {
-        const resources = this.store.state.resources;
-        resources.delete(resource);
-        this.store.patch({ resources });
+    createGroupedTree(list) {
+        const map = createGroupMap(list, this.othersGroup);
+        if (!map) {
+            return undefined;
+        }
+        return Array.from(map, ([key, items]) => ({ group: key, items }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ResourceWaitService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ResourceWaitService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ResourceWaitService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class LazyLoadService {
-    constructor(resourceWaitService) {
-        this.resourceWaitService = resourceWaitService;
-        this.loaded = new Map();
+    add(items) {
+        let flatItems = [];
+        if (!this.shouldSingularizeRoutes) {
+            flatItems = [...this.flat, ...items];
+        }
+        if (this.shouldSingularizeRoutes) {
+            const map = new Map();
+            items.forEach(item => map.set(item[this.id], item));
+            flatItems = this.filterWith(map);
+            map.forEach(pushValueTo(flatItems));
+        }
+        flatItems.sort(this.sort);
+        return this.publish(flatItems);
     }
-    load(strategy, retryTimes, retryDelay) {
-        if (this.loaded.has(strategy.path))
-            return of(new CustomEvent('load'));
-        this.resourceWaitService.addResource(strategy.path);
-        const delayOperator = retryDelay ? pipe(delay(retryDelay)) : pipe();
-        const takeOp = retryTimes ? pipe(take(retryTimes)) : pipe();
-        return strategy.createStream().pipe(retryWhen(error$ => concat(error$.pipe(delayOperator, takeOp), throwError(() => new CustomEvent('error')))), tap(() => {
-            this.loaded.set(strategy.path, strategy.element);
-            this.resourceWaitService.deleteResource(strategy.path);
-        }), delay(100), shareReplay({ bufferSize: 1, refCount: true }));
+    find(predicate, tree = this.tree) {
+        return tree.reduce((acc, node) => {
+            if (acc) {
+                return acc;
+            }
+            if (predicate(node)) {
+                return node;
+            }
+            return this.find(predicate, node.children);
+        }, null);
     }
-    remove(path) {
-        const element = this.loaded.get(path);
-        if (!element)
+    patch(identifier, props) {
+        const flatItems = this._flat$.value;
+        const index = flatItems.findIndex(item => item[this.id] === identifier);
+        if (index < 0) {
             return false;
-        element.parentNode?.removeChild(element);
-        this.loaded.delete(path);
-        return true;
+        }
+        flatItems[index] = { ...flatItems[index], ...props };
+        flatItems.sort(this.sort);
+        return this.publish(flatItems);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LazyLoadService, deps: [{ token: ResourceWaitService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LazyLoadService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LazyLoadService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: ResourceWaitService }] });
-
-class ListService {
-    set filter(value) {
-        this._filter = value;
-        this.get();
+    refresh() {
+        return this.add([]);
     }
-    get filter() {
-        return this._filter;
+    remove(identifiers) {
+        const set = new Set();
+        identifiers.forEach(id => set.add(id));
+        const setToRemove = this.findItemsToRemove(set);
+        const flatItems = this.filterWith(setToRemove);
+        return this.publish(flatItems);
     }
-    set maxResultCount(value) {
-        this._maxResultCount = value;
-        this.get();
+    removeByParam(params) {
+        if (!params) {
+            return null;
+        }
+        const keys = Object.keys(params);
+        if (keys.length === 0) {
+            return null;
+        }
+        const excludedList = this.flat.filter(item => keys.every(key => item[key] === params[key]));
+        if (!excludedList?.length) {
+            return null;
+        }
+        for (const item of excludedList) {
+            this.removeByParam({ [this.parentId]: item[this.id] });
+        }
+        const flatItems = this.flat.filter(item => !excludedList.includes(item));
+        return this.publish(flatItems);
     }
-    get maxResultCount() {
-        return this._maxResultCount;
+    search(params, tree = this.tree) {
+        const searchKeys = Object.keys(params);
+        return tree.reduce((acc, node) => {
+            if (acc) {
+                return acc;
+            }
+            if (searchKeys.every(key => node[key] === params[key])) {
+                return node;
+            }
+            return this.search(params, node.children);
+        }, null);
     }
-    set page(value) {
-        if (value === this._page)
-            return;
-        this._page = value;
-        this.get();
+    setSingularizeStatus(singularize = true) {
+        this.shouldSingularizeRoutes = singularize;
     }
-    get page() {
-        return this._page;
+}
+class AbstractNavTreeService extends AbstractTreeService {
+    constructor(injector) {
+        super();
+        this.injector = injector;
+        this.id = 'name';
+        this.parentId = 'parentName';
+        this.hide = (item) => item.invisible || !this.isGranted(item);
+        this.sort = (a, b) => {
+            return this.compareFunc(a, b);
+        };
+        const configState = this.injector.get(ConfigStateService);
+        this.subscription = configState
+            .createOnUpdateStream(state => state)
+            .subscribe(() => this.refresh());
+        this.permissionService = injector.get(PermissionService);
+        this.othersGroup = injector.get(OTHERS_GROUP);
+        this.compareFunc = injector.get(SORT_COMPARE_FUNC);
     }
-    set totalCount(value) {
-        if (value === this._totalCount)
-            return;
-        this._totalCount = value;
-        this.get();
+    isGranted({ requiredPolicy }) {
+        return this.permissionService.getGrantedPolicy(requiredPolicy);
     }
-    get totalCount() {
-        return this._totalCount;
+    hasChildren(identifier) {
+        const node = this.find(item => item[this.id] === identifier);
+        return Boolean(node?.children?.length);
     }
-    set sortKey(value) {
-        this._sortKey = value;
-        this.get();
+    hasInvisibleChild(identifier) {
+        const node = this.find(item => item[this.id] === identifier);
+        return node?.children?.some(child => child.invisible) || false;
     }
-    get sortKey() {
-        return this._sortKey;
+    /* istanbul ignore next */
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
     }
-    set sortOrder(value) {
-        this._sortOrder = value;
-        this.get();
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbstractNavTreeService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbstractNavTreeService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbstractNavTreeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+class RoutesService extends AbstractNavTreeService {
+    hasPathOrChild(item) {
+        return Boolean(item.path) || this.hasChildren(item.name);
     }
-    get sortOrder() {
-        return this._sortOrder;
+    get groupedVisible() {
+        return this.createGroupedTree(this.visible.filter(item => this.hasPathOrChild(item)));
     }
-    get query$() {
-        return this._query$
-            .asObservable()
-            .pipe(this.delay, shareReplay({ bufferSize: 1, refCount: true }));
+    get groupedVisible$() {
+        return this.visible$.pipe(map$1(items => items.filter(item => this.hasPathOrChild(item))), map$1(visible => this.createGroupedTree(visible)));
     }
-    get isLoading$() {
-        return this._isLoading$.asObservable();
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RoutesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RoutesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RoutesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class SubscriptionService {
+    constructor() {
+        this.subscription = new Subscription();
     }
-    constructor(injector) {
-        this._filter = '';
-        this._maxResultCount = 10;
-        this._skipCount = 0;
-        this._page = 0;
-        this._totalCount = 0;
-        this._sortKey = '';
-        this._sortOrder = '';
-        this._query$ = new ReplaySubject(1);
-        this._isLoading$ = new BehaviorSubject(false);
-        this.destroy$ = new Subject();
-        this.get = () => {
-            this.resetPageWhenUnchanged();
-            this.next();
-        };
-        this.getWithoutPageReset = () => {
-            this.next();
-        };
-        const delay = injector.get(LIST_QUERY_DEBOUNCE_TIME, 300);
-        this.delay = delay ? debounceTime(delay) : tap();
-        this.get();
+    get isClosed() {
+        return this.subscription.closed;
     }
-    hookToQuery(streamCreatorCallback) {
-        return this.query$.pipe(tap(() => this._isLoading$.next(true)), switchMap(query => streamCreatorCallback(query).pipe(catchError(() => of(null)))), filter(Boolean), tap(() => this._isLoading$.next(false)), shareReplay({ bufferSize: 1, refCount: true }), takeUntil(this.destroy$));
+    addOne(source$, nextOrObserver, error) {
+        const subscription = source$.subscribe(nextOrObserver, error);
+        this.subscription.add(subscription);
+        return subscription;
+    }
+    closeAll() {
+        this.subscription.unsubscribe();
+    }
+    closeOne(subscription) {
+        this.removeOne(subscription);
+        if (subscription) {
+            subscription.unsubscribe();
+        }
     }
     ngOnDestroy() {
-        this.destroy$.next();
+        this.subscription.unsubscribe();
     }
-    resetPageWhenUnchanged() {
-        const maxPage = Number(Number(this.totalCount / this._maxResultCount).toFixed());
-        const skipCount = this._page * this._maxResultCount;
-        if (skipCount !== this._totalCount) {
-            this._skipCount = skipCount;
+    removeOne(subscription) {
+        if (!subscription)
             return;
-        }
-        if (this.page === maxPage && this.page > 0) {
-            this._skipCount = skipCount - this._maxResultCount;
-            this.page = this.page - 1;
-        }
+        this.subscription.remove(subscription);
     }
-    next() {
-        this._query$.next({
-            filter: this._filter || undefined,
-            maxResultCount: this._maxResultCount,
-            skipCount: this._page * this._maxResultCount,
-            sorting: this._sortOrder ? `${this._sortKey} ${this._sortOrder}` : undefined,
-        });
+    reset() {
+        this.subscription.unsubscribe();
+        this.subscription = new Subscription();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ListService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ListService }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: SubscriptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: SubscriptionService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ListService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: SubscriptionService, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: i0.Injector }] });
+        }] });
 
-class PermissionService {
-    constructor(configState) {
-        this.configState = configState;
-    }
-    getGrantedPolicy$(key) {
-        return this.getStream().pipe(map(grantedPolicies => this.isPolicyGranted(key, grantedPolicies)));
-    }
-    getGrantedPolicy(key) {
-        const policies = this.getSnapshot();
-        return this.isPolicyGranted(key, policies);
-    }
-    filterItemsByPolicy(items) {
-        const policies = this.getSnapshot();
-        return items.filter(item => !item.requiredPolicy || this.isPolicyGranted(item.requiredPolicy, policies));
-    }
-    filterItemsByPolicy$(items) {
-        return this.getStream().pipe(map(policies => items.filter(item => !item.requiredPolicy || this.isPolicyGranted(item.requiredPolicy, policies))));
+const trackBy = (key) => (_, item) => item[key];
+const trackByDeep = (
+// eslint-disable-next-line @typescript-eslint/ban-types
+...keys) => (_, item) => keys.reduce((acc, key) => acc[key], item);
+class TrackByService {
+    constructor() {
+        this.by = trackBy;
+        this.byDeep = trackByDeep;
     }
-    isPolicyGranted(key, grantedPolicies) {
-        if (!key)
-            return true;
-        const orRegexp = /\|\|/g;
-        const andRegexp = /&&/g;
-        // TODO: Allow combination of ANDs & ORs
-        if (orRegexp.test(key)) {
-            const keys = key.split('||').filter(Boolean);
-            if (keys.length < 2)
-                return false;
-            return keys.some(k => this.getPolicy(k.trim(), grantedPolicies));
-        }
-        else if (andRegexp.test(key)) {
-            const keys = key.split('&&').filter(Boolean);
-            if (keys.length < 2)
-                return false;
-            return keys.every(k => this.getPolicy(k.trim(), grantedPolicies));
-        }
-        return this.getPolicy(key, grantedPolicies);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: TrackByService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: TrackByService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: TrackByService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AbpWindowService {
+    constructor() {
+        this.document = inject(DOCUMENT);
+        this.window = this.document.defaultView;
+        this.navigator = this.window.navigator;
     }
-    getStream() {
-        return this.configState.getAll$().pipe(map(this.mapToPolicies));
+    copyToClipboard(text) {
+        return this.navigator.clipboard.writeText(text);
     }
-    getSnapshot() {
-        return this.mapToPolicies(this.configState.getAll());
+    open(url, target, features) {
+        return this.window.open(url, target, features);
     }
-    mapToPolicies(applicationConfiguration) {
-        return applicationConfiguration?.auth?.grantedPolicies || {};
+    reloadPage() {
+        this.window.location.reload();
     }
-    getPolicy(key, grantedPolicies) {
-        return grantedPolicies[key] || false;
+    downloadBlob(blob, fileName) {
+        const blobUrl = this.window.URL.createObjectURL(blob);
+        const a = this.document.createElement('a');
+        a.style.display = 'none';
+        a.href = blobUrl;
+        a.download = fileName;
+        this.document.body.appendChild(a);
+        a.dispatchEvent(new MouseEvent('click', {
+            bubbles: true,
+            cancelable: true,
+            view: this.window,
+        }));
+        this.window.URL.revokeObjectURL(blobUrl);
+        this.document.body.removeChild(a);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PermissionService, deps: [{ token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PermissionService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpWindowService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpWindowService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PermissionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpWindowService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: ConfigStateService }] });
+        }] });
 
-class RouterWaitService {
-    constructor(routerEvents, injector) {
-        this.routerEvents = routerEvents;
-        this.store = new InternalStore({ loading: false });
-        this.destroy$ = new Subject();
-        this.delay = injector.get(LOADER_DELAY, 500);
-        this.updateLoadingStatusOnNavigationEvents();
+class InternetConnectionService {
+    constructor() {
+        this.document = inject(DOCUMENT);
+        this.window = this.document.defaultView;
+        this.navigator = this.window.navigator;
+        this.status$ = new BehaviorSubject(this.navigator.onLine);
+        this.status = signal(this.navigator.onLine);
+        this.networkStatus = computed(() => this.status());
+        this.window.addEventListener('offline', () => this.setStatus(false));
+        this.window.addEventListener('online', () => this.setStatus(true));
     }
-    updateLoadingStatusOnNavigationEvents() {
-        this.routerEvents
-            .getAllNavigationEvents()
-            .pipe(map(event => event instanceof NavigationStart), switchMap(condition => condition
-            ? this.delay === 0
-                ? of(true)
-                : timer(this.delay || 0).pipe(mapTo(true), takeUntil(this.destroy$))
-            : of(false)), tap(() => this.destroy$.next()))
-            .subscribe(status => {
-            this.setLoading(status);
-        });
+    setStatus(val) {
+        this.status.set(val);
+        this.status$.next(val);
     }
-    getLoading() {
-        return this.store.state.loading;
+    get networkStatus$() {
+        return this.status$.asObservable();
     }
-    getLoading$() {
-        return this.store.sliceState(({ loading }) => loading);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: InternetConnectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: InternetConnectionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: InternetConnectionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class LocalStorageListenerService {
+    constructor() {
+        this.window = inject(DOCUMENT).defaultView;
+        this.window.addEventListener('storage', event => {
+            if (event.key === 'access_token' && event.newValue === null) {
+                this.window.location.reload();
+            }
+        });
     }
-    updateLoading$() {
-        return this.store.sliceUpdate(({ loading }) => loading);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LocalStorageListenerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LocalStorageListenerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LocalStorageListenerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class AbpApplicationConfigurationService {
+    constructor(restService) {
+        this.restService = restService;
+        this.apiName = 'abp';
+        this.get = (options, config) => this.restService.request({
+            method: 'GET',
+            url: '/api/abp/application-configuration',
+            params: { includeLocalizationResources: options.includeLocalizationResources },
+        }, { apiName: this.apiName, ...config });
     }
-    setLoading(loading) {
-        this.store.patch({ loading });
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationConfigurationService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationConfigurationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: RestService }] });
+
+class AbpApplicationLocalizationService {
+    constructor(restService) {
+        this.restService = restService;
+        this.apiName = 'abp';
+        this.get = (input, config) => this.restService.request({
+            method: 'GET',
+            url: '/api/abp/application-localization',
+            params: { cultureName: input.cultureName, onlyDynamics: input.onlyDynamics },
+        }, { apiName: this.apiName, ...config });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterWaitService, deps: [{ token: RouterEvents }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterWaitService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationLocalizationService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationLocalizationService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RouterWaitService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApplicationLocalizationService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [{ type: RouterEvents }, { type: i0.Injector }] });
+        }], ctorParameters: () => [{ type: RestService }] });
 
-class SubscriptionService {
-    constructor() {
-        this.subscription = new Subscription();
+class ConfigStateService {
+    setState(config) {
+        this.store.set(config);
     }
-    get isClosed() {
-        return this.subscription.closed;
+    get createOnUpdateStream() {
+        return this.store.sliceUpdate;
     }
-    addOne(source$, nextOrObserver, error) {
-        const subscription = source$.subscribe(nextOrObserver, error);
-        this.subscription.add(subscription);
-        return subscription;
+    constructor(abpConfigService, abpApplicationLocalizationService, includeLocalizationResources) {
+        this.abpConfigService = abpConfigService;
+        this.abpApplicationLocalizationService = abpApplicationLocalizationService;
+        this.includeLocalizationResources = includeLocalizationResources;
+        this.updateSubject = new Subject();
+        this.store = new InternalStore({});
+        this.initUpdateStream();
+    }
+    initUpdateStream() {
+        this.updateSubject
+            .pipe(switchMap(() => this.abpConfigService.get({
+            includeLocalizationResources: !!this.includeLocalizationResources,
+        })))
+            .pipe(switchMap(appState => this.getLocalizationAndCombineWithAppState(appState)))
+            .subscribe(res => this.store.set(res));
+    }
+    getLocalizationAndCombineWithAppState(appState) {
+        if (!appState.localization.currentCulture.cultureName) {
+            throw new Error('culture name should defined');
+        }
+        return this.getlocalizationResource(appState.localization.currentCulture.cultureName).pipe(map(result => ({ ...appState, localization: { ...appState.localization, ...result } })));
+    }
+    getlocalizationResource(cultureName) {
+        return this.abpApplicationLocalizationService.get({
+            cultureName: cultureName,
+            onlyDynamics: false,
+        });
+    }
+    refreshAppState() {
+        this.updateSubject.next();
+        return this.createOnUpdateStream(state => state).pipe(take(1));
+    }
+    refreshLocalization(lang) {
+        if (this.includeLocalizationResources) {
+            return this.refreshAppState().pipe(map(() => null));
+        }
+        return this.getlocalizationResource(lang)
+            .pipe(tap(result => this.store.patch({ localization: { ...this.store.state.localization, ...result } })))
+            .pipe(map(() => null));
+    }
+    getOne$(key) {
+        return this.store.sliceState(state => state[key]);
+    }
+    getOne(key) {
+        return this.store.state[key];
+    }
+    getAll$() {
+        return this.store.sliceState(state => state);
+    }
+    getAll() {
+        return this.store.state;
     }
-    closeAll() {
-        this.subscription.unsubscribe();
+    getDeep$(keys) {
+        keys = splitKeys(keys);
+        return this.store
+            .sliceState(state => state)
+            .pipe(map(state => {
+            return keys.reduce((acc, val) => {
+                if (acc) {
+                    return acc[val];
+                }
+                return undefined;
+            }, state);
+        }));
     }
-    closeOne(subscription) {
-        this.removeOne(subscription);
-        if (subscription) {
-            subscription.unsubscribe();
-        }
+    getDeep(keys) {
+        keys = splitKeys(keys);
+        return keys.reduce((acc, val) => {
+            if (acc) {
+                return acc[val];
+            }
+            return undefined;
+        }, this.store.state);
     }
-    ngOnDestroy() {
-        this.subscription.unsubscribe();
+    getFeature(key) {
+        return this.store.state.features?.values?.[key];
     }
-    removeOne(subscription) {
-        if (!subscription)
+    getFeature$(key) {
+        return this.store.sliceState(state => state.features?.values?.[key]);
+    }
+    getFeatures(keys) {
+        const { features } = this.store.state;
+        if (!features)
             return;
-        this.subscription.remove(subscription);
+        return keys.reduce((acc, key) => ({ ...acc, [key]: features.values[key] }), {});
     }
-    reset() {
-        this.subscription.unsubscribe();
-        this.subscription = new Subscription();
+    getFeatures$(keys) {
+        return this.store.sliceState(({ features }) => {
+            if (!features?.values)
+                return;
+            return keys.reduce((acc, key) => ({ ...acc, [key]: features.values[key] }), {});
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: SubscriptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: SubscriptionService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: SubscriptionService, decorators: [{
-            type: Injectable
-        }] });
-
-const trackBy = (key) => (_, item) => item[key];
-const trackByDeep = (
-// eslint-disable-next-line @typescript-eslint/ban-types
-...keys) => (_, item) => keys.reduce((acc, key) => acc[key], item);
-class TrackByService {
-    constructor() {
-        this.by = trackBy;
-        this.byDeep = trackByDeep;
+    getSetting(key) {
+        return this.store.state.setting?.values?.[key];
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: TrackByService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: TrackByService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: TrackByService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class AbpWindowService {
-    constructor() {
-        this.document = inject(DOCUMENT);
-        this.window = this.document.defaultView;
-        this.navigator = this.window.navigator;
+    getSetting$(key) {
+        return this.store.sliceState(state => state.setting?.values?.[key]);
     }
-    copyToClipboard(text) {
-        return this.navigator.clipboard.writeText(text);
+    getSettings(keyword) {
+        const settings = this.store.state.setting?.values || {};
+        if (!keyword)
+            return settings;
+        const keysFound = Object.keys(settings).filter(key => key.indexOf(keyword) > -1);
+        return keysFound.reduce((acc, key) => {
+            acc[key] = settings[key];
+            return acc;
+        }, {});
     }
-    open(url, target, features) {
-        return this.window.open(url, target, features);
+    getSettings$(keyword) {
+        return this.store
+            .sliceState(state => state.setting?.values)
+            .pipe(map((settings = {}) => {
+            if (!keyword)
+                return settings;
+            const keysFound = Object.keys(settings).filter(key => key.indexOf(keyword) > -1);
+            return keysFound.reduce((acc, key) => {
+                acc[key] = settings[key];
+                return acc;
+            }, {});
+        }));
     }
-    reloadPage() {
-        this.window.location.reload();
+    getGlobalFeatures() {
+        return this.store.state.globalFeatures;
     }
-    downloadBlob(blob, fileName) {
-        const blobUrl = this.window.URL.createObjectURL(blob);
-        const a = this.document.createElement('a');
-        a.style.display = 'none';
-        a.href = blobUrl;
-        a.download = fileName;
-        this.document.body.appendChild(a);
-        a.dispatchEvent(new MouseEvent('click', {
-            bubbles: true,
-            cancelable: true,
-            view: this.window,
-        }));
-        this.window.URL.revokeObjectURL(blobUrl);
-        this.document.body.removeChild(a);
+    getGlobalFeatures$() {
+        return this.store.sliceState(state => state.globalFeatures);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpWindowService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpWindowService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpWindowService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-class InternetConnectionService {
-    constructor() {
-        this.document = inject(DOCUMENT);
-        this.window = this.document.defaultView;
-        this.navigator = this.window.navigator;
-        this.status$ = new BehaviorSubject(this.navigator.onLine);
-        this.status = signal(this.navigator.onLine);
-        this.networkStatus = computed(() => this.status());
-        this.window.addEventListener('offline', () => this.setStatus(false));
-        this.window.addEventListener('online', () => this.setStatus(true));
+    isGlobalFeatureEnabled(key, globalFeatures) {
+        const features = globalFeatures.enabledFeatures || [];
+        return features.some(f => key === f);
     }
-    setStatus(val) {
-        this.status.set(val);
-        this.status$.next(val);
+    getGlobalFeatureIsEnabled(key) {
+        return this.isGlobalFeatureEnabled(key, this.store.state.globalFeatures);
     }
-    get networkStatus$() {
-        return this.status$.asObservable();
+    getGlobalFeatureIsEnabled$(key) {
+        return this.store.sliceState(state => this.isGlobalFeatureEnabled(key, state.globalFeatures));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: InternetConnectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: InternetConnectionService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ConfigStateService, deps: [{ token: AbpApplicationConfigurationService }, { token: AbpApplicationLocalizationService }, { token: INCUDE_LOCALIZATION_RESOURCES_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ConfigStateService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: InternetConnectionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ConfigStateService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [] });
-
-const SORT_COMPARE_FUNC = new InjectionToken('SORT_COMPARE_FUNC');
-function compareFuncFactory() {
-    const localizationService = inject(LocalizationService);
-    const fn = (a, b) => {
-        const aName = localizationService.instant(a.name);
-        const bName = localizationService.instant(b.name);
-        const aNumber = a.order;
-        const bNumber = b.order;
-        if (!Number.isInteger(aNumber))
-            return 1;
-        if (!Number.isInteger(bNumber))
-            return -1;
-        if (aNumber > bNumber)
-            return 1;
-        if (aNumber < bNumber)
-            return -1;
-        if (aName > bName)
-            return 1;
-        if (aName < bName)
-            return -1;
-        if (a.id > b.id)
-            return 1;
-        if (a.id < b.id)
-            return -1;
-        return 0;
-    };
-    return fn;
-}
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-class AbstractTreeService {
-    constructor() {
-        this._flat$ = new BehaviorSubject([]);
-        this._tree$ = new BehaviorSubject([]);
-        this._visible$ = new BehaviorSubject([]);
-    }
-    get flat() {
-        return this._flat$.value;
-    }
-    get flat$() {
-        return this._flat$.asObservable();
-    }
-    get tree() {
-        return this._tree$.value;
-    }
-    get tree$() {
-        return this._tree$.asObservable();
-    }
-    get visible() {
-        return this._visible$.value;
-    }
-    get visible$() {
-        return this._visible$.asObservable();
-    }
-    createTree(items) {
-        return createTreeFromList(items, item => item[this.id], item => item[this.parentId], item => BaseTreeNode.create(item));
+        }], ctorParameters: () => [{ type: AbpApplicationConfigurationService }, { type: AbpApplicationLocalizationService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [INCUDE_LOCALIZATION_RESOURCES_TOKEN]
+                }] }] });
+function splitKeys(keys) {
+    if (typeof keys === 'string') {
+        keys = keys.split('.');
     }
-    createGroupedTree(list) {
-        const map = createGroupMap(list, this.othersGroup);
-        if (!map) {
-            return undefined;
-        }
-        return Array.from(map, ([key, items]) => ({ group: key, items }));
+    if (!Array.isArray(keys)) {
+        throw new Error('The argument must be a dot string or an string array.');
     }
-    filterWith(setOrMap) {
-        return this._flat$.value.filter(item => !setOrMap.has(item[this.id]));
+    return keys;
+}
+
+class LocalizationService {
+    /**
+     * Returns currently selected language
+     * Even though this looks like it's redundant to return the same value as `getLanguage()`,
+     * it's actually not. This could be invoked any time, and the latestLang could be different from the
+     * sessionState.getLanguage() value.
+     */
+    get currentLang() {
+        return this.latestLang || this.sessionState.getLanguage();
     }
-    findItemsToRemove(set) {
-        return this._flat$.value.reduce((acc, item) => {
-            if (!acc.has(item[this.parentId]))
-                return acc;
-            const childSet = new Set([item[this.id]]);
-            const children = this.findItemsToRemove(childSet);
-            return new Set([...acc, ...children]);
-        }, set);
+    get currentLang$() {
+        return this.sessionState.getLanguage$();
     }
-    publish(flatItems, visibleItems) {
-        this._flat$.next(flatItems);
-        this._tree$.next(this.createTree(flatItems));
-        this._visible$.next(this.createTree(visibleItems));
-        return flatItems;
+    get languageChange$() {
+        return this._languageChange$.asObservable();
     }
-    add(items) {
-        const map = new Map();
-        items.forEach(item => map.set(item[this.id], item));
-        const flatItems = this.filterWith(map);
-        map.forEach(pushValueTo(flatItems));
-        flatItems.sort(this.sort);
-        const visibleItems = flatItems.filter(item => !this.hide(item));
-        return this.publish(flatItems, visibleItems);
+    constructor(sessionState, injector, otherInstance, configState) {
+        this.sessionState = sessionState;
+        this.injector = injector;
+        this.configState = configState;
+        this.latestLang = this.sessionState.getLanguage();
+        this._languageChange$ = new Subject();
+        this.uiLocalizations$ = new BehaviorSubject(new Map());
+        this.localizations$ = new BehaviorSubject(new Map());
+        if (otherInstance)
+            throw new Error('LocalizationService should have only one instance.');
+        this.listenToSetLanguage();
+        this.initLocalizationValues();
     }
-    find(predicate, tree = this.tree) {
-        return tree.reduce((acc, node) => (acc ? acc : predicate(node) ? node : this.find(predicate, node.children)), null);
+    initLocalizationValues() {
+        localizations$.subscribe(val => this.addLocalization(val));
+        const legacyResources$ = this.configState.getDeep$('localization.values');
+        const remoteLocalizations$ = this.configState.getDeep$('localization.resources');
+        const currentLanguage$ = this.sessionState.getLanguage$();
+        const uiLocalizations$ = combineLatest([currentLanguage$, this.uiLocalizations$]).pipe(map(([currentLang, localizations]) => localizations.get(currentLang)));
+        combineLatest([legacyResources$, remoteLocalizations$, uiLocalizations$])
+            .pipe(map(([legacy, resource, local]) => {
+            if (!resource) {
+                return;
+            }
+            const remote = combineLegacyandNewResources(legacy || {}, resource);
+            if (remote) {
+                if (!local) {
+                    local = new Map();
+                }
+                Object.entries(remote).forEach(entry => {
+                    const resourceName = entry[0];
+                    const remoteTexts = entry[1];
+                    let resource = local?.get(resourceName) || {};
+                    resource = { ...resource, ...remoteTexts };
+                    local?.set(resourceName, resource);
+                });
+            }
+            return local;
+        }), filter(Boolean))
+            .subscribe(val => this.localizations$.next(val));
     }
-    patch(identifier, props) {
-        const flatItems = this._flat$.value;
-        const index = flatItems.findIndex(item => item[this.id] === identifier);
-        if (index < 0)
-            return false;
-        flatItems[index] = { ...flatItems[index], ...props };
-        flatItems.sort(this.sort);
-        const visibleItems = flatItems.filter(item => !this.hide(item));
-        return this.publish(flatItems, visibleItems);
+    addLocalization(localizations) {
+        if (!localizations)
+            return;
+        const localizationMap = this.uiLocalizations$.value;
+        localizations.forEach(loc => {
+            const cultureMap = localizationMap.get(loc.culture) || new Map();
+            loc.resources.forEach(res => {
+                let resource = cultureMap.get(res.resourceName) || {};
+                resource = { ...resource, ...res.texts };
+                cultureMap.set(res.resourceName, resource);
+            });
+            localizationMap.set(loc.culture, cultureMap);
+        });
+        this.uiLocalizations$.next(localizationMap);
     }
-    refresh() {
-        return this.add([]);
+    listenToSetLanguage() {
+        this.sessionState
+            .onLanguageChange$()
+            .pipe(filter(lang => this.configState.getDeep('localization.currentCulture.cultureName') !== lang), switchMap(lang => this.configState.refreshLocalization(lang).pipe(map(() => lang))), filter(Boolean), switchMap(lang => from(this.registerLocale(lang).then(() => lang))))
+            .subscribe(lang => this._languageChange$.next(lang));
     }
-    remove(identifiers) {
-        const set = new Set();
-        identifiers.forEach(id => set.add(id));
-        const setToRemove = this.findItemsToRemove(set);
-        const flatItems = this.filterWith(setToRemove);
-        const visibleItems = flatItems.filter(item => !this.hide(item));
-        return this.publish(flatItems, visibleItems);
+    registerLocale(locale) {
+        const { registerLocaleFn } = this.injector.get(CORE_OPTIONS);
+        return registerLocaleFn(locale).then(module => {
+            if (module?.default)
+                registerLocaleData(module.default);
+            this.latestLang = locale;
+        });
     }
-    search(params, tree = this.tree) {
-        const searchKeys = Object.keys(params);
-        return tree.reduce((acc, node) => acc
-            ? acc
-            : searchKeys.every(key => node[key] === params[key])
-                ? node
-                : this.search(params, node.children), null);
+    /**
+     * Returns an observable localized text with the given interpolation parameters in current language.
+     * @param key Localizaton key to replace with localized text
+     * @param interpolateParams Values to interpolate
+     */
+    get(key, ...interpolateParams) {
+        return this.configState
+            .getAll$()
+            .pipe(map(state => this.getLocalization(state, key, ...interpolateParams)));
     }
-}
-class AbstractNavTreeService extends AbstractTreeService {
-    constructor(injector) {
-        super();
-        this.injector = injector;
-        this.id = 'name';
-        this.parentId = 'parentName';
-        this.hide = (item) => item.invisible || !this.isGranted(item);
-        this.sort = (a, b) => {
-            return this.compareFunc(a, b);
-        };
-        const configState = this.injector.get(ConfigStateService);
-        this.subscription = configState
-            .createOnUpdateStream(state => state)
-            .subscribe(() => this.refresh());
-        this.permissionService = injector.get(PermissionService);
-        this.othersGroup = injector.get(OTHERS_GROUP);
-        this.compareFunc = injector.get(SORT_COMPARE_FUNC);
+    getResource(resourceName) {
+        return this.localizations$.value.get(resourceName);
     }
-    isGranted({ requiredPolicy }) {
-        return this.permissionService.getGrantedPolicy(requiredPolicy);
+    getResource$(resourceName) {
+        return this.localizations$.pipe(map(res => res.get(resourceName)));
     }
-    hasChildren(identifier) {
-        const node = this.find(item => item[this.id] === identifier);
-        return Boolean(node?.children?.length);
+    /**
+     * Returns localized text with the given interpolation parameters in current language.
+     * @param key Localization key to replace with localized text
+     * @param interpolateParams Values to intepolate.
+     */
+    instant(key, ...interpolateParams) {
+        return this.getLocalization(this.configState.getAll(), key, ...interpolateParams);
     }
-    hasInvisibleChild(identifier) {
-        const node = this.find(item => item[this.id] === identifier);
-        return node?.children?.some(child => child.invisible) || false;
+    localize(resourceName, key, defaultValue) {
+        return this.configState.getOne$('localization').pipe(map(createLocalizer), map(localize => localize(resourceName, key, defaultValue)));
     }
-    /* istanbul ignore next */
-    ngOnDestroy() {
-        this.subscription.unsubscribe();
+    localizeSync(resourceName, key, defaultValue) {
+        const localization = this.configState.getOne('localization');
+        return createLocalizer(localization)(resourceName, key, defaultValue);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbstractNavTreeService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbstractNavTreeService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbstractNavTreeService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i0.Injector }] });
-class RoutesService extends AbstractNavTreeService {
-    hasPathOrChild(item) {
-        return Boolean(item.path) || this.hasChildren(item.name);
+    localizeWithFallback(resourceNames, keys, defaultValue) {
+        return this.configState.getOne$('localization').pipe(map(createLocalizerWithFallback), map(localizeWithFallback => localizeWithFallback(resourceNames, keys, defaultValue)));
     }
-    get groupedVisible() {
-        return this.createGroupedTree(this.visible.filter(item => this.hasPathOrChild(item)));
+    localizeWithFallbackSync(resourceNames, keys, defaultValue) {
+        const localization = this.configState.getOne('localization');
+        return createLocalizerWithFallback(localization)(resourceNames, keys, defaultValue);
     }
-    get groupedVisible$() {
-        return this.visible$.pipe(map$1(items => items.filter(item => this.hasPathOrChild(item))), map$1(visible => this.createGroupedTree(visible)));
+    getLocalization(state, key, ...interpolateParams) {
+        let defaultValue = '';
+        if (!key) {
+            return defaultValue;
+        }
+        if (typeof key !== 'string') {
+            defaultValue = key.defaultValue;
+            key = key.key;
+        }
+        const keys = key.split('::');
+        const warn = (message) => {
+            if (isDevMode())
+                console.warn(message);
+        };
+        if (keys.length < 2) {
+            warn('The localization source separator (::) not found.');
+            return defaultValue || key;
+        }
+        if (!state.localization)
+            return defaultValue || keys[1];
+        const sourceName = keys[0] || state.localization.defaultResourceName;
+        const sourceKey = keys[1];
+        if (sourceName === '_') {
+            return defaultValue || sourceKey;
+        }
+        if (!sourceName) {
+            warn('Localization source name is not specified and the defaultResourceName was not defined!');
+            return defaultValue || sourceKey;
+        }
+        const source = this.localizations$.value.get(sourceName);
+        if (!source) {
+            warn('Could not find localization source: ' + sourceName);
+            return defaultValue || sourceKey;
+        }
+        let localization = source[sourceKey];
+        if (typeof localization === 'undefined') {
+            return defaultValue || sourceKey;
+        }
+        interpolateParams = interpolateParams.filter(params => params != null);
+        if (localization)
+            localization = interpolate(localization, interpolateParams);
+        if (typeof localization !== 'string')
+            localization = '';
+        return localization || defaultValue || key;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RoutesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RoutesService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LocalizationService, deps: [{ token: SessionStateService }, { token: i0.Injector }, { token: LocalizationService, optional: true, skipSelf: true }, { token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LocalizationService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: RoutesService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: LocalizationService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }] });
+        }], ctorParameters: () => [{ type: SessionStateService }, { type: i0.Injector }, { type: LocalizationService, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: ConfigStateService }] });
+function recursivelyMergeBaseResources(baseResourceName, source) {
+    const item = source[baseResourceName];
+    if (item.baseResources.length === 0) {
+        return item;
+    }
+    return item.baseResources.reduce((acc, baseResource) => {
+        const baseItem = recursivelyMergeBaseResources(baseResource, source);
+        const texts = { ...baseItem.texts, ...item.texts };
+        return { ...acc, texts };
+    }, item);
+}
+function mergeResourcesWithBaseResource(resource) {
+    const entities = Object.keys(resource).map(key => {
+        const newValue = recursivelyMergeBaseResources(key, resource);
+        return [key, newValue];
+    });
+    return entities.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+}
+function combineLegacyandNewResources(legacy, resource) {
+    const mergedResource = mergeResourcesWithBaseResource(resource);
+    return Object.entries(mergedResource).reduce((acc, [key, value]) => {
+        return { ...acc, [key]: value.texts };
+    }, legacy);
+}
 
 const DYNAMIC_LAYOUTS_TOKEN = new InjectionToken('DYNAMIC_LAYOUTS');
 
@@ -2462,6 +2519,7 @@ class DynamicLayoutComponent {
         this.replaceableComponents = inject(ReplaceableComponentsService);
         this.subscription = inject(SubscriptionService);
         this.routerEvents = inject(RouterEvents);
+        this.environment = inject(EnvironmentService);
         if (dynamicLayoutComponent) {
             if (isDevMode())
                 console.warn('DynamicLayoutComponent must be used only in AppComponent.');
@@ -2474,7 +2532,10 @@ class DynamicLayoutComponent {
         if (this.layout) {
             return;
         }
-        this.getLayout();
+        const { oAuthConfig } = this.environment.getEnvironment();
+        if (oAuthConfig.responseType === 'code') {
+            this.getLayout();
+        }
     }
     checkLayoutOnNavigationEnd() {
         const navigationEnd$ = this.routerEvents.getNavigationEvents('End');
@@ -2496,11 +2557,8 @@ class DynamicLayoutComponent {
         }
     }
     getExtractedLayout() {
-        const routeData = (this.route.snapshot.data || {});
+        const routeData = this.route.snapshot.data || {};
         let expectedLayout = routeData['layout'];
-        if (expectedLayout) {
-            return expectedLayout;
-        }
         let node = findRoute(this.routes, getRoutePath(this.router));
         node = { parent: node };
         while (node.parent) {
@@ -2515,7 +2573,8 @@ class DynamicLayoutComponent {
     showLayoutNotFoundError(layoutName) {
         let message = `Layout ${layoutName} not found.`;
         if (layoutName === 'account') {
-            message = 'Account layout not found. Please check your configuration. If you are using LeptonX, please make sure you have added "AccountLayoutModule.forRoot()" to your app.module configuration.';
+            message =
+                'Account layout not found. Please check your configuration. If you are using LeptonX, please make sure you have added "AccountLayoutModule.forRoot()" to your app.module configuration.';
         }
         console.warn(message);
     }
@@ -2529,15 +2588,21 @@ class DynamicLayoutComponent {
         return this.replaceableComponents.get(key);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DynamicLayoutComponent, deps: [{ token: DynamicLayoutComponent, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.3", type: DynamicLayoutComponent, selector: "abp-dynamic-layout", providers: [SubscriptionService], ngImport: i0, template: `
-    <ng-container *ngIf="isLayoutVisible" [ngComponentOutlet]="layout"></ng-container> `, isInline: true, dependencies: [{ kind: "directive", type: i1$2.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "directive", type: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.1.3", type: DynamicLayoutComponent, selector: "abp-dynamic-layout", providers: [SubscriptionService], ngImport: i0, template: `
+    @if (isLayoutVisible) {
+      <ng-container [ngComponentOutlet]="layout"></ng-container>
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1$2.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DynamicLayoutComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'abp-dynamic-layout',
                     template: `
-    <ng-container *ngIf="isLayoutVisible" [ngComponentOutlet]="layout"></ng-container> `,
+    @if (isLayoutVisible) {
+      <ng-container [ngComponentOutlet]="layout"></ng-container>
+    }
+  `,
                     providers: [SubscriptionService],
                 }]
         }], ctorParameters: () => [{ type: DynamicLayoutComponent, decorators: [{
@@ -3994,6 +4059,12 @@ class CoreModule {
                     deps: [LocalizationService],
                     useFactory: noop,
                 },
+                {
+                    provide: APP_INITIALIZER,
+                    multi: true,
+                    deps: [LocalStorageListenerService],
+                    useFactory: noop,
+                },
                 {
                     provide: APP_INITIALIZER,
                     multi: true,
@@ -4342,11 +4413,11 @@ class AbpApiDefinitionService {
     constructor(restService) {
         this.restService = restService;
         this.apiName = 'abp';
-        this.getByModel = (model) => this.restService.request({
+        this.getByModel = (model, config) => this.restService.request({
             method: 'GET',
             url: '/api/abp/api-definition',
             params: { includeTypes: model.includeTypes },
-        }, { apiName: this.apiName });
+        }, { apiName: this.apiName, ...config });
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApiDefinitionService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AbpApiDefinitionService, providedIn: 'root' }); }
@@ -4806,5 +4877,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { APP_INIT_ERROR_HANDLERS, AbpApiDefinitionService, AbpApplicationConfigurationService, AbpApplicationLocalizationService, AbpLocalStorageService, AbpTenantService, AbpValidators, AbpWindowService, AbstractAuthErrorFilter, AbstractNavTreeService, AbstractNgModelComponent, AbstractTreeService, ApiInterceptor, AuditedEntityDto, AuditedEntityWithUserDto, AuthErrorEvent, AuthErrorFilterService, AuthEvent, AuthGuard, AuthInfoEvent, AuthService, AuthSuccessEvent, AutofocusDirective, BaseCoreModule, BaseTreeNode, CHECK_AUTHENTICATION_STATE_FN_KEY, CONTAINER_STRATEGY, CONTENT_SECURITY_STRATEGY, CONTENT_STRATEGY, CONTEXT_STRATEGY, COOKIE_LANGUAGE_KEY, CORE_OPTIONS, CROSS_ORIGIN_STRATEGY, ClearContainerStrategy, ComponentContextStrategy, ComponentProjectionStrategy, ConfigStateService, ContainerStrategy, ContentProjectionService, ContentSecurityStrategy, ContentStrategy, ContextStrategy, CoreModule, CreationAuditedEntityDto, CreationAuditedEntityWithUserDto, CrossOriginStrategy, DEFAULT_DYNAMIC_LAYOUTS, DOM_STRATEGY, DefaultQueueManager, DomInsertionService, DomStrategy, DynamicLayoutComponent, EntityDto, EnvironmentService, ExtensibleAuditedEntityDto, ExtensibleAuditedEntityWithUserDto, ExtensibleCreationAuditedEntityDto, ExtensibleCreationAuditedEntityWithUserDto, ExtensibleEntityDto, ExtensibleFullAuditedEntityDto, ExtensibleFullAuditedEntityWithUserDto, ExtensibleLimitedResultRequestDto, ExtensibleObject, ExtensiblePagedAndSortedResultRequestDto, ExtensiblePagedResultRequestDto, ExternalHttpClient, ForDirective, FormSubmitDirective, FullAuditedEntityDto, FullAuditedEntityWithUserDto, HttpErrorReporterService, HttpWaitService, INCUDE_LOCALIZATION_RESOURCES_TOKEN, INJECTOR_PIPE_DATA_TOKEN, IS_EXTERNAL_REQUEST, InitDirective, InputEventDebounceDirective, InsertIntoContainerStrategy, InternalStore, InternetConnectionService, LIST_QUERY_DEBOUNCE_TIME, LOADER_DELAY, LOADING_STRATEGY, LOCALIZATIONS, LazyLoadService, LazyModuleFactory, LimitedResultRequestDto, ListResultDto, ListService, LoadingStrategy, LocalizationModule, LocalizationPipe, LocalizationService, LooseContentSecurityStrategy, MultiTenancyService, NAVIGATE_TO_MANAGE_PROFILE, NavigationEvent, NoContentSecurityStrategy, NoContextStrategy, NoCrossOriginStrategy, OTHERS_GROUP, index as ObjectExtending, PIPE_TO_LOGIN_FN_KEY, PROJECTION_STRATEGY, PagedAndSortedResultRequestDto, PagedResultDto, PagedResultRequestDto, PermissionDirective, PermissionGuard, PermissionService, ProjectionStrategy, QUEUE_MANAGER, ReplaceableComponentsService, ReplaceableRouteContainerComponent, ReplaceableTemplateDirective, ResourceWaitService, RestService, RootComponentProjectionStrategy, RootCoreModule, RouterEvents, RouterOutletComponent, RouterWaitService, RoutesService, SET_TOKEN_RESPONSE_TO_STORAGE_FN_KEY, SORT_COMPARE_FUNC, SafeHtmlPipe, ScriptContentStrategy, ScriptLoadingStrategy, SessionStateService, ShortDatePipe, ShortDateTimePipe, ShortTimePipe, ShowPasswordDirective, SortPipe, StopPropagationDirective, StyleContentStrategy, StyleLoadingStrategy, SubscriptionService, TENANT_KEY, TENANT_NOT_FOUND_BY_NAME, TemplateContextStrategy, TemplateProjectionStrategy, ToInjectorPipe, TrackByService, TrackCapsLockDirective, WebHttpUrlEncodingCodec, authGuard, checkHasProp, compareFuncFactory, coreOptionsFactory, createGroupMap, createLocalizationPipeKeyGenerator, createLocalizer, createLocalizerWithFallback, createMapFromList, createTokenParser, createTreeFromList, createTreeNodeFilterCreator, deepMerge, differentLocales, downloadBlob, escapeHtmlChars, exists, featuresFactory, findRoute, fromLazyLoad, generateHash, generatePassword, getInitialData, getLocaleDirection, getPathName, getRemoteEnv, getRoutePath, getShortDateFormat, getShortDateShortTimeFormat, getShortTimeFormat, interpolate, isArray, isNode, isNullOrEmpty, isNullOrUndefined, isNumber, isObject, isObjectAndNotArray, isObjectAndNotArrayNotNode, isUndefinedOrEmptyString, localeInitializer, localizationContributor, localizations$, mapEnumToOptions, noop, parseTenantFromUrl, permissionGuard, pushValueTo, reloadRoute, trackBy, trackByDeep, uuid, validateCreditCard, validateMinAge, validateRange, validateRequired, validateStringLength, validateUniqueCharacter, validateUrl };
+export { APP_INIT_ERROR_HANDLERS, AbpApiDefinitionService, AbpApplicationConfigurationService, AbpApplicationLocalizationService, AbpLocalStorageService, AbpTenantService, AbpValidators, AbpWindowService, AbstractAuthErrorFilter, AbstractNavTreeService, AbstractNgModelComponent, AbstractTreeService, ApiInterceptor, AuditedEntityDto, AuditedEntityWithUserDto, AuthErrorEvent, AuthErrorFilterService, AuthEvent, AuthGuard, AuthInfoEvent, AuthService, AuthSuccessEvent, AutofocusDirective, BaseCoreModule, BaseTreeNode, CHECK_AUTHENTICATION_STATE_FN_KEY, CONTAINER_STRATEGY, CONTENT_SECURITY_STRATEGY, CONTENT_STRATEGY, CONTEXT_STRATEGY, COOKIE_LANGUAGE_KEY, CORE_OPTIONS, CROSS_ORIGIN_STRATEGY, ClearContainerStrategy, ComponentContextStrategy, ComponentProjectionStrategy, ConfigStateService, ContainerStrategy, ContentProjectionService, ContentSecurityStrategy, ContentStrategy, ContextStrategy, CoreModule, CreationAuditedEntityDto, CreationAuditedEntityWithUserDto, CrossOriginStrategy, DEFAULT_DYNAMIC_LAYOUTS, DOM_STRATEGY, DefaultQueueManager, DomInsertionService, DomStrategy, DynamicLayoutComponent, EntityDto, EnvironmentService, ExtensibleAuditedEntityDto, ExtensibleAuditedEntityWithUserDto, ExtensibleCreationAuditedEntityDto, ExtensibleCreationAuditedEntityWithUserDto, ExtensibleEntityDto, ExtensibleFullAuditedEntityDto, ExtensibleFullAuditedEntityWithUserDto, ExtensibleLimitedResultRequestDto, ExtensibleObject, ExtensiblePagedAndSortedResultRequestDto, ExtensiblePagedResultRequestDto, ExternalHttpClient, ForDirective, FormSubmitDirective, FullAuditedEntityDto, FullAuditedEntityWithUserDto, HttpErrorReporterService, HttpWaitService, INCUDE_LOCALIZATION_RESOURCES_TOKEN, INJECTOR_PIPE_DATA_TOKEN, IS_EXTERNAL_REQUEST, InitDirective, InputEventDebounceDirective, InsertIntoContainerStrategy, InternalStore, InternetConnectionService, LIST_QUERY_DEBOUNCE_TIME, LOADER_DELAY, LOADING_STRATEGY, LOCALIZATIONS, LazyLoadService, LazyModuleFactory, LimitedResultRequestDto, ListResultDto, ListService, LoadingStrategy, LocalStorageListenerService, LocalizationModule, LocalizationPipe, LocalizationService, LooseContentSecurityStrategy, MultiTenancyService, NAVIGATE_TO_MANAGE_PROFILE, NavigationEvent, NoContentSecurityStrategy, NoContextStrategy, NoCrossOriginStrategy, OTHERS_GROUP, index as ObjectExtending, PIPE_TO_LOGIN_FN_KEY, PROJECTION_STRATEGY, PagedAndSortedResultRequestDto, PagedResultDto, PagedResultRequestDto, PermissionDirective, PermissionGuard, PermissionService, ProjectionStrategy, QUEUE_MANAGER, ReplaceableComponentsService, ReplaceableRouteContainerComponent, ReplaceableTemplateDirective, ResourceWaitService, RestService, RootComponentProjectionStrategy, RootCoreModule, RouterEvents, RouterOutletComponent, RouterWaitService, RoutesService, SET_TOKEN_RESPONSE_TO_STORAGE_FN_KEY, SORT_COMPARE_FUNC, SafeHtmlPipe, ScriptContentStrategy, ScriptLoadingStrategy, SessionStateService, ShortDatePipe, ShortDateTimePipe, ShortTimePipe, ShowPasswordDirective, SortPipe, StopPropagationDirective, StyleContentStrategy, StyleLoadingStrategy, SubscriptionService, TENANT_KEY, TENANT_NOT_FOUND_BY_NAME, TemplateContextStrategy, TemplateProjectionStrategy, ToInjectorPipe, TrackByService, TrackCapsLockDirective, WebHttpUrlEncodingCodec, authGuard, checkHasProp, compareFuncFactory, coreOptionsFactory, createGroupMap, createLocalizationPipeKeyGenerator, createLocalizer, createLocalizerWithFallback, createMapFromList, createTokenParser, createTreeFromList, createTreeNodeFilterCreator, deepMerge, differentLocales, downloadBlob, escapeHtmlChars, exists, featuresFactory, findRoute, fromLazyLoad, generateHash, generatePassword, getInitialData, getLocaleDirection, getPathName, getRemoteEnv, getRoutePath, getShortDateFormat, getShortDateShortTimeFormat, getShortTimeFormat, interpolate, isArray, isNode, isNullOrEmpty, isNullOrUndefined, isNumber, isObject, isObjectAndNotArray, isObjectAndNotArrayNotNode, isUndefinedOrEmptyString, localeInitializer, localizationContributor, localizations$, mapEnumToOptions, noop, parseTenantFromUrl, permissionGuard, pushValueTo, reloadRoute, trackBy, trackByDeep, uuid, validateCreditCard, validateMinAge, validateRange, validateRequired, validateStringLength, validateUniqueCharacter, validateUrl };
 //# sourceMappingURL=abp-ng.core.mjs.map