@abp/ng.core 7.3.2 → 7.4.0-rc.2

package/fesm2022/abp-ng.core.mjs

@@ -1,17 +1,17 @@
 import * as i0 from '@angular/core';
-import { ChangeDetectorRef, Component, Input, Injectable, InjectionToken, Inject, Optional, isDevMode, SkipSelf, Directive, EventEmitter, Output, Self, Injector, Pipe, NgModule, APP_INITIALIZER, LOCALE_ID, NgModuleFactory, Compiler, inject, SecurityContext, ElementRef, HostListener, ComponentFactoryResolver, ApplicationRef } from '@angular/core';
-import { of, BehaviorSubject, Subject, throwError, combineLatest, from, map as map$1, Subscription, fromEvent, ReplaySubject, lastValueFrom, Observable, timer, pipe, concat } from 'rxjs';
+import { ChangeDetectorRef, Component, Input, Injectable, InjectionToken, Inject, Optional, isDevMode, SkipSelf, NgModuleFactory, Injector, Compiler, inject, signal, computed, Directive, EventEmitter, Output, Self, Pipe, NgModule, APP_INITIALIZER, LOCALE_ID, SecurityContext, ElementRef, HostListener, ComponentFactoryResolver, ApplicationRef } from '@angular/core';
+import { of, BehaviorSubject, Subject, throwError, combineLatest, from, lastValueFrom, Observable, timer, pipe, concat, ReplaySubject, Subscription, map as map$1, fromEvent } from 'rxjs';
 import * as i1$1 from '@angular/router';
 import { PRIMARY_OUTLET, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, ActivatedRoute, Router, RouterModule } from '@angular/router';
 import * as i5 from '@angular/common';
 import { registerLocaleData, DOCUMENT, DatePipe, DATE_PIPE_DEFAULT_TIMEZONE, CommonModule } from '@angular/common';
-import { map, distinctUntilChanged, filter, catchError, switchMap, take, tap, debounceTime, mapTo, takeUntil, delay, retryWhen, shareReplay, finalize } from 'rxjs/operators';
+import { map, distinctUntilChanged, filter, catchError, switchMap, take, tap, mapTo, takeUntil, delay, retryWhen, shareReplay, debounceTime, finalize } from 'rxjs/operators';
 import * as i1 from '@angular/common/http';
 import { HttpContextToken, HttpClient, HttpContext, HttpParams, HttpClientModule, HttpClientXsrfModule, HttpHeaders } from '@angular/common/http';
 import compare from 'just-compare';
+import clone from 'just-clone';
 import * as i1$2 from '@angular/forms';
 import { FormsModule, ReactiveFormsModule, Validators } from '@angular/forms';
-import clone from 'just-clone';
 import { DomSanitizer } from '@angular/platform-browser';
 import { OAuthService } from 'angular-oauth2-oidc';
 
@@ -1265,2224 +1265,2287 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: ConfigStateService }]; } });
 
-// 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;
+class ContentProjectionService {
+    constructor(injector) {
+        this.injector = injector;
     }
-    get flat$() {
-        return this._flat$.asObservable();
+    projectContent(projectionStrategy, injector = this.injector) {
+        return projectionStrategy.injectContent(injector);
     }
-    get tree() {
-        return this._tree$.value;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ContentProjectionService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ContentProjectionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ContentProjectionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+
+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);
     }
-    get tree$() {
-        return this._tree$.asObservable();
+}
+
+class LazyModuleFactory extends NgModuleFactory {
+    get moduleType() {
+        return this.moduleWithProviders.ngModule;
     }
-    get visible() {
-        return this._visible$.value;
+    constructor(moduleWithProviders) {
+        super();
+        this.moduleWithProviders = moduleWithProviders;
     }
-    get visible$() {
-        return this._visible$.asObservable();
+    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);
     }
-    createTree(items) {
-        return createTreeFromList(items, item => item[this.id], item => item[this.parentId], item => BaseTreeNode.create(item));
+}
+function featuresFactory(configState, featureKeys, mapFn = features => features) {
+    return configState.getFeatures$(featureKeys).pipe(filter(Boolean), map(mapFn));
+}
+
+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;
     }
-    createGroupedTree(list) {
-        const map = createGroupMap(list, this.othersGroup);
-        if (!map) {
-            return undefined;
-        }
-        return Array.from(map, ([key, items]) => ({ group: key, items }));
+    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);
     }
-    filterWith(setOrMap) {
-        return this._flat$.value.filter(item => !setOrMap.has(item[this.id]));
+    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);
     }
-    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);
+    encodeValue(v) {
+        return encodeURIComponent(v);
     }
-    publish(flatItems, visibleItems) {
-        this._flat$.next(flatItems);
-        this._tree$.next(this.createTree(flatItems));
-        this._visible$.next(this.createTree(visibleItems));
-        return flatItems;
+    decodeKey(k) {
+        return decodeURIComponent(k);
     }
-    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);
+    decodeValue(v) {
+        return decodeURIComponent(v);
     }
-    find(predicate, tree = this.tree) {
-        return tree.reduce((acc, node) => (acc ? acc : predicate(node) ? node : this.find(predicate, node.children)), null);
+}
+
+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 });
     }
-    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);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpTenantService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpTenantService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpTenantService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: RestService }]; } });
+
+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));
+        };
     }
-    refresh() {
-        return this.add([]);
+    setTenantByName(tenantName) {
+        return this.tenantService
+            .findTenantByName(tenantName)
+            .pipe(switchMap(this.setTenantToState));
     }
-    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);
-    }
-    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);
+    setTenantById(tenantId) {
+        return this.tenantService
+            .findTenantById(tenantId)
+            .pipe(switchMap(this.setTenantToState));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", 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: "16.0.6", ngImport: i0, type: MultiTenancyService, providedIn: 'root' }); }
 }
-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) => {
-            if (!Number.isInteger(a.order))
-                return 1;
-            if (!Number.isInteger(b.order))
-                return -1;
-            return a.order - b.order;
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: MultiTenancyService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ 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 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 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);
-    }
-    isGranted({ requiredPolicy }) {
-        return this.permissionService.getGrantedPolicy(requiredPolicy);
-    }
-    hasChildren(identifier) {
-        const node = this.find(item => item[this.id] === identifier);
-        return Boolean(node?.children?.length);
-    }
-    hasInvisibleChild(identifier) {
-        const node = this.find(item => item[this.id] === identifier);
-        return node?.children?.some(child => child.invisible) || false;
+    };
+    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);
+        return multiTenancyService
+            .setTenantByName(tenancyName)
+            .pipe(tap(setEnvironmentWithDomainTenant))
+            .toPromise();
     }
-    /* istanbul ignore next */
-    ngOnDestroy() {
-        this.subscription.unsubscribe();
+    else {
+        /**
+         * 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) {
+            return multiTenancyService.setTenantById(tenantIdFromQueryParams).toPromise();
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbstractNavTreeService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbstractNavTreeService }); }
+    return Promise.resolve();
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbstractNavTreeService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
-class RoutesService extends AbstractNavTreeService {
-    hasPathOrChild(item) {
-        return Boolean(item.path) || this.hasChildren(item.name);
+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 groupedVisible() {
-        return this.createGroupedTree(this.visible.filter(item => this.hasPathOrChild(item)));
+    if (environment.oAuthConfig?.redirectUri) {
+        environment.oAuthConfig.redirectUri = environment.oAuthConfig.redirectUri.replace(placeholder, tenancyName);
     }
-    get groupedVisible$() {
-        return this.visible$.pipe(map$1(items => items.filter(item => this.hasPathOrChild(item))), map$1(visible => this.createGroupedTree(visible)));
+    if (!environment.oAuthConfig) {
+        environment.oAuthConfig = {};
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesService, providedIn: 'root' }); }
+    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);
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
 
-class SubscriptionService {
-    constructor() {
-        this.subscription = new Subscription();
-    }
-    get isClosed() {
-        return this.subscription.closed;
-    }
-    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();
+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();
         }
-    }
-    ngOnDestroy() {
-        this.subscription.unsubscribe();
-    }
-    removeOne(subscription) {
-        if (!subscription)
+        if (options.skipGetAppConfiguration)
             return;
-        this.subscription.remove(subscription);
-    }
-    reset() {
-        this.subscription.unsubscribe();
-        this.subscription = new Subscription();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: SubscriptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: SubscriptionService }); }
+        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;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: SubscriptionService, decorators: [{
-            type: Injectable
-        }] });
 
-class DynamicLayoutComponent {
-    constructor(injector, localizationService, replaceableComponents, subscription, routerEvents, dynamicLayoutComponent) {
-        this.localizationService = localizationService;
-        this.replaceableComponents = replaceableComponents;
-        this.subscription = subscription;
-        this.routerEvents = routerEvents;
-        // TODO: Consider a shared enum (eThemeSharedComponents) for known layouts
-        this.layouts = new Map([
-            ['application', 'Theme.ApplicationLayoutComponent'],
-            ['account', 'Theme.AccountLayoutComponent'],
-            ['empty', 'Theme.EmptyLayoutComponent'],
-        ]);
-        this.isLayoutVisible = true;
-        if (dynamicLayoutComponent) {
-            if (isDevMode())
-                console.warn('DynamicLayoutComponent must be used only in AppComponent.');
-            return;
-        }
-        this.route = injector.get(ActivatedRoute);
-        this.router = injector.get(Router);
-        this.routes = injector.get(RoutesService);
-        this.checkLayoutOnNavigationEnd();
-        this.listenToLanguageChange();
+class CrossOriginStrategy {
+    constructor(crossorigin, integrity) {
+        this.crossorigin = crossorigin;
+        this.integrity = integrity;
     }
-    ngOnInit() {
-        if (this.layout) {
-            return;
+    setCrossOrigin(element) {
+        if (this.integrity)
+            element.setAttribute('integrity', this.integrity);
+        if (this.crossorigin) {
+            element.setAttribute('crossorigin', this.crossorigin);
         }
-        this.getLayout();
     }
-    checkLayoutOnNavigationEnd() {
-        const navigationEnd$ = this.routerEvents.getNavigationEvents('End');
-        this.subscription.addOne(navigationEnd$, () => this.getLayout());
+}
+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;
     }
-    getLayout() {
-        let expectedLayout = (this.route.snapshot.data || {}).layout;
-        if (!expectedLayout) {
-            let node = findRoute(this.routes, getRoutePath(this.router));
-            node = { parent: node };
-            while (node.parent) {
-                node = node.parent;
-                if (node.layout) {
-                    expectedLayout = node.layout;
-                    break;
-                }
-            }
-        }
-        if (!expectedLayout)
-            expectedLayout = "empty" /* eLayoutType.empty */;
-        if (this.layoutKey === expectedLayout)
+    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();
+        };
+        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 key = this.layouts.get(expectedLayout);
-        if (key) {
-            this.layout = this.getComponent(key)?.component;
-            this.layoutKey = expectedLayout;
         }
-        if (!this.layout) {
-            this.showLayoutNotFoundError(expectedLayout);
+        fn();
+        if (this.stack > this.stackSize) {
+            setTimeout(() => {
+                this.isRunning = false;
+                this.run();
+                this.stack = 0;
+            }, this.interval);
+        }
+        else {
+            this.isRunning = false;
+            this.run();
         }
     }
-    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.';
+}
+
+class DomInsertionService {
+    constructor() {
+        this.inserted = new Set();
+    }
+    insertContent(contentStrategy) {
+        const hash = generateHash(contentStrategy.content);
+        if (this.inserted.has(hash))
+            return;
+        const element = contentStrategy.insertElement();
+        this.inserted.add(hash);
+        return element;
+    }
+    removeContent(element) {
+        if (element.textContent) {
+            const hash = generateHash(element.textContent);
+            this.inserted.delete(hash);
+            element.parentNode?.removeChild(element);
         }
-        console.warn(message);
     }
-    listenToLanguageChange() {
-        this.subscription.addOne(this.localizationService.languageChange$, () => {
-            this.isLayoutVisible = false;
-            setTimeout(() => (this.isLayoutVisible = true), 0);
+    has(content) {
+        const hash = generateHash(content);
+        return this.inserted.has(hash);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: DomInsertionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: DomInsertionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: DomInsertionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class HttpWaitService {
+    constructor(injector) {
+        this.store = new InternalStore({
+            requests: [],
+            filteredRequests: [],
         });
+        this.destroy$ = new Subject();
+        this.delay = injector.get(LOADER_DELAY, 500);
     }
-    getComponent(key) {
-        return this.replaceableComponents.get(key);
+    getLoading() {
+        return !!this.applyFilter(this.store.state.requests).length;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: DynamicLayoutComponent, deps: [{ token: i0.Injector }, { token: LocalizationService }, { token: ReplaceableComponentsService }, { token: SubscriptionService }, { token: RouterEvents }, { token: DynamicLayoutComponent, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.6", 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: i5.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+    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: "16.0.6", ngImport: i0, type: HttpWaitService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: HttpWaitService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: DynamicLayoutComponent, decorators: [{
-            type: Component,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: HttpWaitService, decorators: [{
+            type: Injectable,
             args: [{
-                    selector: 'abp-dynamic-layout',
-                    template: ` <ng-container *ngIf="isLayoutVisible" [ngComponentOutlet]="layout"></ng-container> `,
-                    providers: [SubscriptionService],
+                    providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: LocalizationService }, { type: ReplaceableComponentsService }, { type: SubscriptionService }, { type: RouterEvents }, { type: DynamicLayoutComponent, decorators: [{
-                    type: Optional
-                }, {
-                    type: SkipSelf
-                }] }]; } });
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
-class ReplaceableRouteContainerComponent {
-    constructor(route, replaceableComponents, subscription) {
-        this.route = route;
-        this.replaceableComponents = replaceableComponents;
-        this.subscription = subscription;
+class ResourceWaitService {
+    constructor() {
+        this.store = new InternalStore({ resources: new Set() });
     }
-    ngOnInit() {
-        this.defaultComponent = this.route.snapshot.data.replaceableComponent.defaultComponent;
-        this.componentKey = this.route.snapshot.data.replaceableComponent.key;
-        const component$ = this.replaceableComponents
-            .get$(this.componentKey)
-            .pipe(distinctUntilChanged());
-        this.subscription.addOne(component$, (res = {}) => {
-            this.externalComponent = res.component;
-        });
+    getLoading() {
+        return !!this.store.state.resources.size;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ReplaceableRouteContainerComponent, deps: [{ token: i1$1.ActivatedRoute }, { token: ReplaceableComponentsService }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.6", type: ReplaceableRouteContainerComponent, selector: "abp-replaceable-route-container", providers: [SubscriptionService], ngImport: i0, template: `
-    <ng-container *ngComponentOutlet="externalComponent || defaultComponent"></ng-container>
-  `, isInline: true, dependencies: [{ kind: "directive", type: i5.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }] }); }
+    getLoading$() {
+        return this.store.sliceState(({ resources }) => !!resources.size);
+    }
+    updateLoading$() {
+        return this.store.sliceUpdate(({ resources }) => !!resources?.size);
+    }
+    clearLoading() {
+        this.store.patch({ resources: new Set() });
+    }
+    addResource(resource) {
+        const resources = this.store.state.resources;
+        resources.add(resource);
+        this.store.patch({ resources });
+    }
+    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: "16.0.6", ngImport: i0, type: ResourceWaitService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ResourceWaitService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ReplaceableRouteContainerComponent, decorators: [{
-            type: Component,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ResourceWaitService, decorators: [{
+            type: Injectable,
             args: [{
-                    selector: 'abp-replaceable-route-container',
-                    template: `
-    <ng-container *ngComponentOutlet="externalComponent || defaultComponent"></ng-container>
-  `,
-                    providers: [SubscriptionService],
+                    providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i1$1.ActivatedRoute }, { type: ReplaceableComponentsService }, { type: SubscriptionService }]; } });
+        }] });
 
-class RouterOutletComponent {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RouterOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.6", type: RouterOutletComponent, selector: "abp-router-outlet", ngImport: i0, template: ` <router-outlet></router-outlet> `, isInline: true, dependencies: [{ kind: "directive", type: i1$1.RouterOutlet, selector: "router-outlet", inputs: ["name"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] }); }
+class LazyLoadService {
+    constructor(resourceWaitService) {
+        this.resourceWaitService = resourceWaitService;
+        this.loaded = new Map();
+    }
+    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 }));
+    }
+    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: "16.0.6", ngImport: i0, type: LazyLoadService, deps: [{ token: ResourceWaitService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LazyLoadService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RouterOutletComponent, decorators: [{
-            type: Component,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LazyLoadService, decorators: [{
+            type: Injectable,
             args: [{
-                    selector: 'abp-router-outlet',
-                    template: ` <router-outlet></router-outlet> `,
+                    providedIn: 'root',
                 }]
-        }] });
+        }], ctorParameters: function () { return [{ type: ResourceWaitService }]; } });
 
-// Different locales from .NET
-// Key is .NET locale, value is Angular locale
-const differentLocales = {
-    aa: 'en',
-    'aa-DJ': 'en',
-    'aa-ER': 'en',
-    'aa-ET': 'en',
-    'af-ZA': 'af',
-    'agq-CM': 'agq',
-    'ak-GH': 'ak',
-    'am-ET': 'am',
-    'ar-001': 'ar',
-    arn: 'en',
-    'arn-CL': 'en',
-    'as-IN': 'as',
-    'asa-TZ': 'asa',
-    'ast-ES': 'ast',
-    'az-Cyrl-AZ': 'az-Cyrl',
-    'az-Latn-AZ': 'az-Latn',
-    ba: 'ru',
-    'ba-RU': 'ru',
-    'bas-CM': 'bas',
-    'be-BY': 'be',
-    'bem-ZM': 'bem',
-    'bez-TZ': 'bez',
-    'bg-BG': 'bg',
-    bin: 'en',
-    'bin-NG': 'en',
-    'bm-Latn': 'bm',
-    'bm-Latn-ML': 'bm',
-    'bn-BD': 'bn',
-    'bo-CN': 'bo',
-    'br-FR': 'br',
-    'brx-IN': 'brx',
-    'bs-Cyrl-BA': 'bs-Cyrl',
-    'bs-Latn-BA': 'bs-Latn',
-    byn: 'en',
-    'byn-ER': 'en',
-    'ca-ES': 'ca',
-    'ca-ES-valencia': 'ca-ES-VALENCIA',
-    'ce-RU': 'ce',
-    'cgg-UG': 'cgg',
-    'chr-Cher': 'chr',
-    'chr-Cher-US': 'chr',
-    co: 'en',
-    'co-FR': 'fr',
-    'cs-CZ': 'cs',
-    'cu-RU': 'cu',
-    'cy-GB': 'cy',
-    'da-DK': 'da',
-    'dav-KE': 'dav',
-    'de-DE': 'de',
-    'dje-NE': 'dje',
-    'dsb-DE': 'dsb',
-    'dua-CM': 'dua',
-    dv: 'en',
-    'dv-MV': 'en',
-    'dyo-SN': 'dyo',
-    'dz-BT': 'dz',
-    'ebu-KE': 'ebu',
-    'ee-GH': 'ee',
-    'el-GR': 'el',
-    'en-029': 'en',
-    'en-ID': 'en',
-    'en-US': 'en',
-    'eo-001': 'en',
-    'es-ES': 'es',
-    'et-EE': 'et',
-    'eu-ES': 'eu',
-    'ewo-CM': 'ewo',
-    'fa-IR': 'fa',
-    'ff-Latn-SN': 'ff-Latn',
-    'ff-NG': 'ff',
-    'fi-FI': 'fi',
-    'fil-PH': 'fil',
-    'fo-FO': 'fo',
-    'fr-029': 'fr',
-    'fr-FR': 'fr',
-    'fur-IT': 'fur',
-    'fy-NL': 'fy',
-    'ga-IE': 'ga',
-    'gd-GB': 'gd',
-    'gl-ES': 'gl',
-    gn: 'en',
-    'gn-PY': 'en',
-    'gsw-CH': 'gsw',
-    'gu-IN': 'gu',
-    'guz-KE': 'guz',
-    'gv-IM': 'gv',
-    'ha-Latn': 'ha',
-    'ha-Latn-GH': 'ha-GH',
-    'ha-Latn-NE': 'ha-NE',
-    'ha-Latn-NG': 'ha',
-    'haw-US': 'haw',
-    'he-IL': 'he',
-    'hi-IN': 'hi',
-    'hr-HR': 'hr',
-    'hsb-DE': 'hsb',
-    'hu-HU': 'hu',
-    'hy-AM': 'hy',
-    'ia-001': 'ia',
-    'ia-FR': 'ia',
-    ibb: 'en',
-    'ibb-NG': 'en',
-    'id-ID': 'id',
-    'ig-NG': 'ig',
-    'ii-CN': 'ii',
-    'is-IS': 'is',
-    'it-IT': 'it',
-    iu: 'en',
-    'iu-Cans': 'en',
-    'iu-Cans-CA': 'en',
-    'iu-Latn': 'en',
-    'iu-Latn-CA': 'en',
-    'ja-JP': 'ja',
-    'jgo-CM': 'jgo',
-    'jmc-TZ': 'jmc',
-    'jv-Java': 'jv',
-    'jv-Java-ID': 'jv',
-    'jv-Latn': 'jv',
-    'jv-Latn-ID': 'jv',
-    'ka-GE': 'ka',
-    'kab-DZ': 'kab',
-    'kam-KE': 'kam',
-    'kde-TZ': 'kde',
-    'kea-CV': 'kea',
-    'khq-ML': 'khq',
-    'ki-KE': 'ki',
-    'kk-KZ': 'kk',
-    'kkj-CM': 'kkj',
-    'kl-GL': 'kl',
-    'kln-KE': 'kln',
-    'km-KH': 'km',
-    'kn-IN': 'kn',
-    'ko-KR': 'ko',
-    'kok-IN': 'kok',
-    kr: 'en',
-    'kr-NG': 'en',
-    'ks-Arab': 'ks',
-    'ks-Arab-IN': 'ks',
-    'ks-Deva': 'ks',
-    'ks-Deva-IN': 'ks',
-    'ksb-TZ': 'ksb',
-    'ksf-CM': 'ksf',
-    'ksh-DE': 'ksh',
-    'ku-Arab': 'ku',
-    'ku-Arab-IQ': 'ku',
-    'ku-Arab-IR': 'ku',
-    'kw-GB': 'kw',
-    'ky-KG': 'ky',
-    la: 'en',
-    'la-001': 'en',
-    'lag-TZ': 'lag',
-    'lb-LU': 'lb',
-    'lg-UG': 'lg',
-    'lkt-US': 'lkt',
-    'ln-CD': 'ln',
-    'lo-LA': 'lo',
-    'lrc-IR': 'lrc',
-    'lt-LT': 'lt',
-    'lu-CD': 'lu',
-    'luo-KE': 'luo',
-    'luy-KE': 'luy',
-    'lv-LV': 'lv',
-    'mas-KE': 'mas',
-    'mer-KE': 'mer',
-    'mfe-MU': 'mfe',
-    'mg-MG': 'mg',
-    'mgh-MZ': 'mgh',
-    'mgo-CM': 'mgo',
-    'mi-NZ': 'mi',
-    'mk-MK': 'mk',
-    'ml-IN': 'ml',
-    'mn-Cyrl': 'mn',
-    'mn-MN': 'mn',
-    'mn-Mong': 'mn',
-    'mn-Mong-CN': 'mn',
-    'mn-Mong-MN': 'mn',
-    mni: 'en',
-    'mni-IN': 'en',
-    moh: 'en',
-    'moh-CA': 'en',
-    'mr-IN': 'mr',
-    'ms-MY': 'ms',
-    'mt-MT': 'mt',
-    'mua-CM': 'mua',
-    'my-MM': 'my',
-    'mzn-IR': 'mzn',
-    'naq-NA': 'naq',
-    'nb-NO': 'nb',
-    'nd-ZW': 'nd',
-    'ne-NP': 'ne',
-    'nl-NL': 'nl',
-    'nmg-CM': 'ngm',
-    'nn-NO': 'nn',
-    'nnh-CM': 'nnh',
-    no: 'en',
-    nqo: 'en',
-    'nqo-GN': 'en',
-    nr: 'en',
-    'nr-ZA': 'en',
-    nso: 'en',
-    'nso-ZA': 'en',
-    'nus-SS': 'nus',
-    'nyn-UG': 'nyn',
-    oc: 'en',
-    'oc-FR': 'fr',
-    'om-ET': 'om',
-    'or-IN': 'or',
-    'os-GE': 'os',
-    'pa-Arab-PK': 'pa-Arab',
-    'pa-IN': 'pa',
-    pap: 'en',
-    'pap-029': 'en',
-    'pl-PL': 'pl',
-    'prg-001': 'prg',
-    prs: 'en',
-    'prs-AF': 'en',
-    'ps-AF': 'ps',
-    'pt-BR': 'pt',
-    quc: 'en',
-    'quc-Latn': 'en',
-    'quc-Latn-GT': 'en',
-    quz: 'en',
-    'quz-BO': 'en',
-    'quz-EC': 'en',
-    'quz-PE': 'en',
-    'rm-CH': 'rm',
-    'rn-BI': 'rn',
-    'ro-RO': 'ro',
-    'rof-TZ': 'rof',
-    'ru-RU': 'ru',
-    'rw-RW': 'rw',
-    'rwk-TZ': 'rwk',
-    sa: 'en',
-    'sa-IN': 'en',
-    'sah-RU': 'sah',
-    'saq-KE': 'saq',
-    'sbp-TZ': 'en',
-    'sd-Arab': 'sd',
-    'sd-Arab-PK': 'sd',
-    'sd-Deva': 'sd',
-    'sd-Deva-IN': 'sd',
-    'se-NO': 'se',
-    'seh-MZ': 'seh',
-    'ses-ML': 'ses',
-    'sg-CF': 'sg',
-    'shi-Latn-MA': 'shi-Latn',
-    'shi-Tfng-MA': 'shi-Tfng',
-    'si-LK': 'si',
-    'sk-SK': 'sk',
-    'sl-SI': 'sl',
-    sma: 'en',
-    'sma-NO': 'en',
-    'sma-SE': 'en',
-    smj: 'en',
-    'smj-NO': 'en',
-    'smj-SE': 'en',
-    'smn-FI': 'en',
-    sms: 'en',
-    'sms-FI': 'en',
-    'sn-Latn': 'sn',
-    'sn-Latn-ZW': 'sn',
-    'so-SO': 'so',
-    'sq-AL': 'so',
-    'sr-Cyrl-RS': 'sr-Cryl',
-    'sr-Latn-RS': 'sr-Latn',
-    ss: 'en',
-    'ss-SZ': 'en',
-    'ss-ZA': 'en',
-    ssy: 'en',
-    'ssy-ER': 'en',
-    st: 'en',
-    'st-LS': 'en',
-    'st-ZA': 'en',
-    'sv-SE': 'sv',
-    'sw-TZ': 'sw',
-    syr: 'en',
-    'syr-SY': 'en',
-    'ta-IN': 'ta',
-    'te-IN': 'te',
-    'teo-UG': 'teo',
-    'tg-Cyrl': 'tg',
-    'tg-Cyrl-TJ': 'tg',
-    'th-TH': 'th',
-    'ti-ET': 'ti',
-    tig: 'en',
-    'tig-ER': 'en',
-    'tk-TM': 'tk',
-    tn: 'en',
-    'tn-BW': 'en',
-    'tn-ZA': 'en',
-    'to-TO': 'to',
-    'tr-TR': 'tr',
-    ts: 'en',
-    'ts-ZA': 'en',
-    'tt-RU': 'tt',
-    'twq-NE': 'twq',
-    'tzm-Arab': 'tzm',
-    'tzm-Arab-MA': 'tzm',
-    'tzm-Latn': 'tzm',
-    'tzm-Latn-DZ': 'tzm',
-    'tzm-Latn-MA': 'tzm',
-    'tzm-Tfng': 'tzm',
-    'tzm-Tfng-MA': 'tzm',
-    'ug-CN': 'ug',
-    'uk-UA': 'uk',
-    'ur-PK': 'ur',
-    'uz-Arab-AF': 'uz-Arab',
-    'uz-Cyrl-UZ': 'uz-Cyrl',
-    'uz-Latn-UZ': 'uz-Latn',
-    'vai-Latn-LR': 'vai-Latn',
-    'vai-Vaii-LR': 'vai-Vaii',
-    ve: 'en',
-    've-ZA': 'en',
-    'vi-VN': 'vi',
-    'vo-001': 'vo',
-    'vun-TZ': 'vun',
-    'wae-CH': 'wae',
-    wal: 'en',
-    'wal-ET': 'en',
-    'wo-SN': 'wo',
-    'xh-ZA': 'xh',
-    'xog-UG': 'xog',
-    'yav-CM': 'yav',
-    'yi-001': 'yi',
-    'yo-NG': 'yo',
-    'zgh-Tfng': 'zgh',
-    'zgh-Tfng-MA': 'zgh',
-    'zh-CN': 'zh',
-    'zh-HK': 'zh',
-    'zh-MO': 'zh',
-    'zh-SG': 'zh',
-    'zh-TW': 'zh',
-    'zu-ZA': 'zu',
-};
-
-class AutofocusDirective {
-    set delay(val) {
-        this._delay = Number(val) || 0;
+class ListService {
+    set filter(value) {
+        this._filter = value;
+        this.get();
     }
-    get delay() {
-        return this._delay;
+    get filter() {
+        return this._filter;
     }
-    constructor(elRef) {
-        this.elRef = elRef;
-        this._delay = 0;
+    set maxResultCount(value) {
+        this._maxResultCount = value;
+        this.get();
     }
-    ngAfterViewInit() {
-        setTimeout(() => this.elRef.nativeElement.focus(), this.delay);
+    get maxResultCount() {
+        return this._maxResultCount;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AutofocusDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: AutofocusDirective, selector: "[autofocus]", inputs: { delay: ["autofocus", "delay"] }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AutofocusDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    // eslint-disable-next-line @angular-eslint/directive-selector
-                    selector: '[autofocus]',
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { delay: [{
-                type: Input,
-                args: ['autofocus']
-            }] } });
-
-class InputEventDebounceDirective {
-    constructor(el, subscription) {
-        this.el = el;
-        this.subscription = subscription;
-        this.debounce = 300;
-        this.debounceEvent = new EventEmitter();
+    set page(value) {
+        if (value === this._page)
+            return;
+        this._page = value;
+        this.get();
     }
-    ngOnInit() {
-        const input$ = fromEvent(this.el.nativeElement, 'input').pipe(debounceTime(this.debounce));
-        this.subscription.addOne(input$, (event) => {
-            this.debounceEvent.emit(event);
-        });
+    get page() {
+        return this._page;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: InputEventDebounceDirective, deps: [{ token: i0.ElementRef }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: InputEventDebounceDirective, selector: "[input.debounce]", inputs: { debounce: "debounce" }, outputs: { debounceEvent: "input.debounce" }, providers: [SubscriptionService], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: InputEventDebounceDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    // eslint-disable-next-line @angular-eslint/directive-selector
-                    selector: '[input.debounce]',
-                    providers: [SubscriptionService],
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: SubscriptionService }]; }, propDecorators: { debounce: [{
-                type: Input
-            }], debounceEvent: [{
-                type: Output,
-                args: ['input.debounce']
-            }] } });
-
-class AbpForContext {
-    constructor($implicit, index, count, list) {
-        this.$implicit = $implicit;
-        this.index = index;
-        this.count = count;
-        this.list = list;
+    set totalCount(value) {
+        if (value === this._totalCount)
+            return;
+        this._totalCount = value;
+        this.get();
     }
-}
-class RecordView {
-    constructor(record, view) {
-        this.record = record;
-        this.view = view;
+    get totalCount() {
+        return this._totalCount;
     }
-}
-class ForDirective {
-    get compareFn() {
-        return this.compareBy || compare;
+    set sortKey(value) {
+        this._sortKey = value;
+        this.get();
     }
-    get trackByFn() {
-        return this.trackBy || ((index, item) => item.id || index);
+    get sortKey() {
+        return this._sortKey;
     }
-    constructor(tempRef, vcRef, differs) {
-        this.tempRef = tempRef;
-        this.vcRef = vcRef;
-        this.differs = differs;
+    set sortOrder(value) {
+        this._sortOrder = value;
+        this.get();
     }
-    iterateOverAppliedOperations(changes) {
-        const rw = [];
-        changes.forEachOperation((record, previousIndex, currentIndex) => {
-            if (record.previousIndex == null) {
-                const view = this.vcRef.createEmbeddedView(this.tempRef, new AbpForContext(null, -1, -1, this.items), currentIndex || 0);
-                rw.push(new RecordView(record, view));
-            }
-            else if (currentIndex == null && previousIndex !== null) {
-                this.vcRef.remove(previousIndex);
-            }
-            else {
-                if (previousIndex !== null) {
-                    const view = this.vcRef.get(previousIndex);
-                    if (view && currentIndex !== null) {
-                        this.vcRef.move(view, currentIndex);
-                        rw.push(new RecordView(record, view));
-                    }
-                }
-            }
-        });
-        for (let i = 0, l = rw.length; i < l; i++) {
-            rw[i].view.context.$implicit = rw[i].record.item;
-        }
+    get sortOrder() {
+        return this._sortOrder;
     }
-    iterateOverAttachedViews(changes) {
-        for (let i = 0, l = this.vcRef.length; i < l; i++) {
-            const viewRef = this.vcRef.get(i);
-            viewRef.context.index = i;
-            viewRef.context.count = l;
-            viewRef.context.list = this.items;
-        }
-        changes.forEachIdentityChange((record) => {
-            if (record.currentIndex !== null) {
-                const viewRef = this.vcRef.get(record.currentIndex);
-                viewRef.context.$implicit = record.item;
-            }
-        });
+    get query$() {
+        return this._query$
+            .asObservable()
+            .pipe(this.delay, shareReplay({ bufferSize: 1, refCount: true }));
     }
-    projectItems(items) {
-        if (!items.length && this.emptyRef) {
-            this.vcRef.clear();
-            this.vcRef.createEmbeddedView(this.emptyRef).rootNodes;
-            this.isShowEmptyRef = true;
-            this.differ = null;
-            return;
-        }
-        if (this.emptyRef && this.isShowEmptyRef) {
-            this.vcRef.clear();
-            this.isShowEmptyRef = false;
-        }
-        if (!this.differ && items) {
-            this.differ = this.differs.find(items).create(this.trackByFn);
-        }
-        if (this.differ) {
-            const changes = this.differ.diff(items);
-            if (changes) {
-                this.iterateOverAppliedOperations(changes);
-                this.iterateOverAttachedViews(changes);
-            }
-        }
+    get isLoading$() {
+        return this._isLoading$.asObservable();
     }
-    sortItems(items) {
-        const orderBy = this.orderBy;
-        if (orderBy) {
-            items.sort((a, b) => (a[orderBy] > b[orderBy] ? 1 : a[orderBy] < b[orderBy] ? -1 : 0));
-        }
-        else {
-            items.sort();
-        }
+    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();
     }
-    ngOnChanges() {
-        let items = clone(this.items);
-        if (!Array.isArray(items))
+    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$));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+    }
+    resetPageWhenUnchanged() {
+        const maxPage = Number(Number(this.totalCount / this._maxResultCount).toFixed());
+        const skipCount = this._page * this._maxResultCount;
+        if (skipCount !== this._totalCount) {
+            this._skipCount = skipCount;
             return;
-        const compareFn = this.compareFn;
-        const filterBy = this.filterBy;
-        if (typeof filterBy !== 'undefined' &&
-            typeof this.filterVal !== 'undefined' &&
-            this.filterVal !== '') {
-            items = items.filter(item => compareFn(item[filterBy], this.filterVal));
         }
-        switch (this.orderDir) {
-            case 'ASC':
-                this.sortItems(items);
-                this.projectItems(items);
-                break;
-            case 'DESC':
-                this.sortItems(items);
-                items.reverse();
-                this.projectItems(items);
-                break;
-            default:
-                this.projectItems(items);
+        if (this.page === maxPage && this.page > 0) {
+            this._skipCount = skipCount - this._maxResultCount;
+            this.page = this.page - 1;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ForDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: ForDirective, selector: "[abpFor]", inputs: { items: ["abpForOf", "items"], orderBy: ["abpForOrderBy", "orderBy"], orderDir: ["abpForOrderDir", "orderDir"], filterBy: ["abpForFilterBy", "filterBy"], filterVal: ["abpForFilterVal", "filterVal"], trackBy: ["abpForTrackBy", "trackBy"], compareBy: ["abpForCompareBy", "compareBy"], emptyRef: ["abpForEmptyRef", "emptyRef"] }, usesOnChanges: true, ngImport: i0 }); }
+    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: "16.0.6", ngImport: i0, type: ListService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ListService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ForDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[abpFor]',
-                }]
-        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: i0.IterableDiffers }]; }, propDecorators: { items: [{
-                type: Input,
-                args: ['abpForOf']
-            }], orderBy: [{
-                type: Input,
-                args: ['abpForOrderBy']
-            }], orderDir: [{
-                type: Input,
-                args: ['abpForOrderDir']
-            }], filterBy: [{
-                type: Input,
-                args: ['abpForFilterBy']
-            }], filterVal: [{
-                type: Input,
-                args: ['abpForFilterVal']
-            }], trackBy: [{
-                type: Input,
-                args: ['abpForTrackBy']
-            }], compareBy: [{
-                type: Input,
-                args: ['abpForCompareBy']
-            }], emptyRef: [{
-                type: Input,
-                args: ['abpForEmptyRef']
-            }] } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ListService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
-/**
- * @deprecated FormSubmitDirective will be removed in V7.0.0. Use `ngSubmit` instead.
- */
-class FormSubmitDirective {
-    constructor(formGroupDirective, host, cdRef, subscription) {
-        this.formGroupDirective = formGroupDirective;
-        this.host = host;
-        this.cdRef = cdRef;
-        this.subscription = subscription;
-        this.debounce = 200;
-        this.markAsDirtyWhenSubmit = true;
-        this.ngSubmit = new EventEmitter();
-        this.executedNgSubmit = false;
+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();
     }
-    ngOnInit() {
-        this.subscription.addOne(this.formGroupDirective.ngSubmit, () => {
-            if (this.markAsDirtyWhenSubmit) {
-                this.markAsDirty();
-            }
-            this.executedNgSubmit = true;
-        });
-        const keyup$ = fromEvent(this.host.nativeElement, 'keyup').pipe(debounceTime(this.debounce), filter(event => !(event.target instanceof HTMLTextAreaElement)), filter(event => event && event.key === 'Enter'));
-        this.subscription.addOne(keyup$, () => {
-            if (!this.executedNgSubmit) {
-                this.host.nativeElement.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }));
-            }
-            this.executedNgSubmit = false;
+    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);
         });
     }
-    markAsDirty() {
-        const { form } = this.formGroupDirective;
-        setDirty(form.controls);
-        form.markAsDirty();
-        this.cdRef.detectChanges();
+    getLoading() {
+        return this.store.state.loading;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: FormSubmitDirective, deps: [{ token: i1$2.FormGroupDirective, self: true }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: FormSubmitDirective, selector: "form[ngSubmit][formGroup]", inputs: { debounce: "debounce", notValidateOnSubmit: "notValidateOnSubmit", markAsDirtyWhenSubmit: "markAsDirtyWhenSubmit" }, outputs: { ngSubmit: "ngSubmit" }, providers: [SubscriptionService], ngImport: i0 }); }
+    getLoading$() {
+        return this.store.sliceState(({ loading }) => loading);
+    }
+    updateLoading$() {
+        return this.store.sliceUpdate(({ loading }) => loading);
+    }
+    setLoading(loading) {
+        this.store.patch({ loading });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RouterWaitService, deps: [{ token: RouterEvents }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RouterWaitService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: FormSubmitDirective, decorators: [{
-            type: Directive,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RouterWaitService, decorators: [{
+            type: Injectable,
             args: [{
-                    // eslint-disable-next-line @angular-eslint/directive-selector
-                    selector: 'form[ngSubmit][formGroup]',
-                    providers: [SubscriptionService],
+                    providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i1$2.FormGroupDirective, decorators: [{
-                    type: Self
-                }] }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: SubscriptionService }]; }, propDecorators: { debounce: [{
-                type: Input
-            }], notValidateOnSubmit: [{
-                type: Input
-            }], markAsDirtyWhenSubmit: [{
-                type: Input
-            }], ngSubmit: [{
-                type: Output
-            }] } });
-function setDirty(controls) {
-    if (Array.isArray(controls)) {
-        controls.forEach(group => {
-            setDirty(group.controls);
-        });
-        return;
-    }
-    Object.keys(controls).forEach(key => {
-        controls[key].markAsDirty();
-        controls[key].updateValueAndValidity();
-    });
-}
+        }], ctorParameters: function () { return [{ type: RouterEvents }, { type: i0.Injector }]; } });
 
-class InitDirective {
-    constructor(elRef) {
-        this.elRef = elRef;
-        this.init = new EventEmitter();
+class SubscriptionService {
+    constructor() {
+        this.subscription = new Subscription();
     }
-    ngAfterViewInit() {
-        this.init.emit(this.elRef);
+    get isClosed() {
+        return this.subscription.closed;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: InitDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: InitDirective, selector: "[abpInit]", outputs: { init: "abpInit" }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: InitDirective, decorators: [{
-            type: Directive,
-            args: [{ selector: '[abpInit]' }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { init: [{
-                type: Output,
-                args: ['abpInit']
-            }] } });
-
-class PermissionDirective {
-    constructor(templateRef, vcRef, permissionService, cdRef, queue) {
-        this.templateRef = templateRef;
-        this.vcRef = vcRef;
-        this.permissionService = permissionService;
-        this.cdRef = cdRef;
-        this.queue = queue;
-        this.runChangeDetection = true;
-        this.cdrSubject = new ReplaySubject();
-        this.rendered = false;
+    addOne(source$, nextOrObserver, error) {
+        const subscription = source$.subscribe(nextOrObserver, error);
+        this.subscription.add(subscription);
+        return subscription;
     }
-    check() {
-        if (this.subscription) {
-            this.subscription.unsubscribe();
+    closeAll() {
+        this.subscription.unsubscribe();
+    }
+    closeOne(subscription) {
+        this.removeOne(subscription);
+        if (subscription) {
+            subscription.unsubscribe();
         }
-        this.subscription = this.permissionService
-            .getGrantedPolicy$(this.condition || '')
-            .pipe(distinctUntilChanged())
-            .subscribe(isGranted => {
-            this.vcRef.clear();
-            if (isGranted)
-                this.vcRef.createEmbeddedView(this.templateRef);
-            if (this.runChangeDetection) {
-                if (!this.rendered) {
-                    this.cdrSubject.next();
-                }
-                else {
-                    this.cdRef.detectChanges();
-                }
-            }
-            else {
-                this.cdRef.markForCheck();
-            }
-        });
     }
     ngOnDestroy() {
-        if (this.subscription)
-            this.subscription.unsubscribe();
+        this.subscription.unsubscribe();
     }
-    ngOnChanges() {
-        this.check();
+    removeOne(subscription) {
+        if (!subscription)
+            return;
+        this.subscription.remove(subscription);
     }
-    ngAfterViewInit() {
-        this.cdrSubject.pipe(take(1)).subscribe(() => this.queue.add(() => this.cdRef.detectChanges()));
-        this.rendered = true;
+    reset() {
+        this.subscription.unsubscribe();
+        this.subscription = new Subscription();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: PermissionDirective, deps: [{ token: i0.TemplateRef, optional: true }, { token: i0.ViewContainerRef }, { token: PermissionService }, { token: i0.ChangeDetectorRef }, { token: QUEUE_MANAGER }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: PermissionDirective, selector: "[abpPermission]", inputs: { condition: ["abpPermission", "condition"], runChangeDetection: ["abpPermissionRunChangeDetection", "runChangeDetection"] }, usesOnChanges: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: SubscriptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: SubscriptionService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: PermissionDirective, decorators: [{
-            type: Directive,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", 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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: TrackByService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: TrackByService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: TrackByService, decorators: [{
+            type: Injectable,
             args: [{
-                    selector: '[abpPermission]',
+                    providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i0.TemplateRef, decorators: [{
-                    type: Optional
-                }] }, { type: i0.ViewContainerRef }, { type: PermissionService }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [QUEUE_MANAGER]
-                }] }]; }, propDecorators: { condition: [{
-                type: Input,
-                args: ['abpPermission']
-            }], runChangeDetection: [{
-                type: Input,
-                args: ['abpPermissionRunChangeDetection']
-            }] } });
+        }] });
 
-class ReplaceableTemplateDirective {
-    constructor(injector, templateRef, vcRef, replaceableComponents, subscription) {
-        this.injector = injector;
-        this.templateRef = templateRef;
-        this.vcRef = vcRef;
-        this.replaceableComponents = replaceableComponents;
-        this.subscription = subscription;
-        this.providedData = {
-            inputs: {},
-            outputs: {},
-        };
-        this.context = {};
-        this.defaultComponentSubscriptions = {};
-        this.initialized = false;
-        this.context = {
-            initTemplate: (ref) => {
-                this.resetDefaultComponent();
-                this.defaultComponentRef = ref;
-                this.setDefaultComponentInputs();
-            },
-        };
-    }
-    ngOnInit() {
-        const component$ = this.replaceableComponents
-            .get$(this.data.componentKey)
-            .pipe(filter((res = {}) => !this.initialized || !compare(res.component, this.externalComponent)));
-        this.subscription.addOne(component$, (res = {}) => {
-            this.vcRef.clear();
-            this.externalComponent = res.component;
-            if (this.defaultComponentRef) {
-                this.resetDefaultComponent();
-            }
-            if (res.component) {
-                this.setProvidedData();
-                const customInjector = Injector.create({
-                    providers: [{ provide: 'REPLACEABLE_DATA', useValue: this.providedData }],
-                    parent: this.injector,
-                });
-                const ref = this.vcRef.createComponent(res.component, {
-                    index: 0,
-                    injector: customInjector,
-                });
-            }
-            else {
-                this.vcRef.createEmbeddedView(this.templateRef, this.context);
-            }
-            this.initialized = true;
-        });
+class AbpWindowService {
+    constructor() {
+        this.window = inject(DOCUMENT).defaultView;
+        this.navigator = this.window.navigator;
     }
-    ngOnChanges(changes) {
-        if (changes?.data?.currentValue?.inputs && this.defaultComponentRef) {
-            this.setDefaultComponentInputs();
-        }
+    copyToClipboard(text) {
+        return this.navigator.clipboard.writeText(text);
     }
-    setDefaultComponentInputs() {
-        if (!this.defaultComponentRef || (!this.data.inputs && !this.data.outputs))
-            return;
-        if (this.data.inputs) {
-            for (const key in this.data.inputs) {
-                if (Object.prototype.hasOwnProperty.call(this.data.inputs, key)) {
-                    if (!compare(this.defaultComponentRef[key], this.data.inputs[key].value)) {
-                        this.defaultComponentRef[key] = this.data.inputs[key].value;
-                    }
-                }
-            }
-        }
-        if (this.data.outputs) {
-            for (const key in this.data.outputs) {
-                if (Object.prototype.hasOwnProperty.call(this.data.outputs, key)) {
-                    if (!this.defaultComponentSubscriptions[key]) {
-                        this.defaultComponentSubscriptions[key] = this.defaultComponentRef[key].subscribe((value) => {
-                            this.data.outputs?.[key](value);
-                        });
-                    }
-                }
-            }
-        }
+    open(url, target, features) {
+        return this.window.open(url, target, features);
     }
-    setProvidedData() {
-        this.providedData = { outputs: {}, ...this.data, inputs: {} };
-        if (!this.data.inputs)
-            return;
-        Object.defineProperties(this.providedData.inputs, {
-            ...Object.keys(this.data.inputs).reduce((acc, key) => ({
-                ...acc,
-                [key]: {
-                    enumerable: true,
-                    configurable: true,
-                    get: () => this.data.inputs?.[key]?.value,
-                    ...(this.data.inputs?.[key]?.twoWay && {
-                        set: (newValue) => {
-                            if (this.data.inputs?.[key]) {
-                                this.data.inputs[key].value = newValue;
-                            }
-                            if (this.data.outputs?.[`${key}Change`]) {
-                                this.data.outputs[`${key}Change`](newValue);
-                            }
-                        },
-                    }),
-                },
-            }), {}),
-        });
+    reloadPage() {
+        this.window.location.reload();
     }
-    resetDefaultComponent() {
-        Object.keys(this.defaultComponentSubscriptions).forEach(key => {
-            this.defaultComponentSubscriptions[key].unsubscribe();
-        });
-        this.defaultComponentSubscriptions = {};
-        this.defaultComponentRef = null;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ReplaceableTemplateDirective, deps: [{ token: i0.Injector }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: ReplaceableComponentsService }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: ReplaceableTemplateDirective, selector: "[abpReplaceableTemplate]", inputs: { data: ["abpReplaceableTemplate", "data"] }, providers: [SubscriptionService], usesOnChanges: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpWindowService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpWindowService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ReplaceableTemplateDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[abpReplaceableTemplate]',
-                    providers: [SubscriptionService],
-                }]
-        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: ReplaceableComponentsService }, { type: SubscriptionService }]; }, propDecorators: { data: [{
-                type: Input,
-                args: ['abpReplaceableTemplate']
-            }] } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpWindowService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
-class StopPropagationDirective {
-    constructor(el, subscription) {
-        this.el = el;
-        this.subscription = subscription;
-        this.stopPropEvent = new EventEmitter();
-    }
-    ngOnInit() {
-        this.subscription.addOne(fromEvent(this.el.nativeElement, 'click'), event => {
-            event.stopPropagation();
-            this.stopPropEvent.emit(event);
-        });
+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));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: StopPropagationDirective, deps: [{ token: i0.ElementRef }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: StopPropagationDirective, selector: "[click.stop]", outputs: { stopPropEvent: "click.stop" }, providers: [SubscriptionService], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: StopPropagationDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    // eslint-disable-next-line @angular-eslint/directive-selector
-                    selector: '[click.stop]',
-                    providers: [SubscriptionService],
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: SubscriptionService }]; }, propDecorators: { stopPropEvent: [{
-                type: Output,
-                args: ['click.stop']
-            }] } });
-
-class RoutesHandler {
-    constructor(routes, router) {
-        this.routes = routes;
-        this.router = router;
-        this.addRoutes();
+    setStatus(val) {
+        this.status.set(val);
+        this.status$.next(val);
     }
-    addRoutes() {
-        this.router?.config?.forEach(({ path = '', data }) => {
-            const routes = data?.routes;
-            if (!routes)
-                return;
-            if (Array.isArray(routes)) {
-                this.routes.add(routes);
-            }
-            else {
-                const routesFlatten = flatRoutes([{ path, ...routes }], { path: '' });
-                this.routes.add(routesFlatten);
-            }
-        });
+    get networkStatus$() {
+        return this.status$.asObservable();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesHandler, deps: [{ token: RoutesService }, { token: i1$1.Router, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesHandler, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: InternetConnectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: InternetConnectionService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesHandler, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: InternetConnectionService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: RoutesService }, { type: i1$1.Router, decorators: [{
-                    type: Optional
-                }] }]; } });
-function flatRoutes(routes, parent) {
-    if (!routes)
-        return [];
-    return routes.reduce((acc, route) => {
-        const { children, ...current } = {
-            ...route,
-            parentName: parent.name,
-            path: (parent.path + '/' + route.path).replace(/\/\//g, '/'),
-        };
-        acc.push(current, ...flatRoutes(children, current));
-        return acc;
-    }, []);
+        }], ctorParameters: function () { return []; } });
+
+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;
+        return 0;
+    };
+    return fn;
 }
 
-class LocalizationPipe {
-    constructor(localization) {
-        this.localization = localization;
+// eslint-disable-next-line @typescript-eslint/ban-types
+class AbstractTreeService {
+    constructor() {
+        this._flat$ = new BehaviorSubject([]);
+        this._tree$ = new BehaviorSubject([]);
+        this._visible$ = new BehaviorSubject([]);
     }
-    transform(value = '', ...interpolateParams) {
-        const params = interpolateParams.reduce((acc, val) => {
-            if (!acc) {
-                return val;
-            }
-            if (!val) {
-                return acc;
-            }
-            return Array.isArray(val) ? [...acc, ...val] : [...acc, val];
-        }, []) || [];
-        return this.localization.instant(value, ...params);
+    get flat() {
+        return this._flat$.value;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationPipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.0.6", ngImport: i0, type: LocalizationPipe, name: "abpLocalization" }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationPipe }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationPipe, decorators: [{
-            type: Injectable
-        }, {
-            type: Pipe,
-            args: [{
-                    name: 'abpLocalization',
-                }]
-        }], ctorParameters: function () { return [{ type: LocalizationService }]; } });
-
-class LocalizationModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.6", ngImport: i0, type: LocalizationModule, declarations: [LocalizationPipe], exports: [LocalizationPipe] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationModule }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    exports: [LocalizationPipe],
-                    declarations: [LocalizationPipe],
-                }]
-        }] });
-
-class SortPipe {
-    transform(value, sortOrder = 'asc', sortKey) {
-        sortOrder = sortOrder && sortOrder.toLowerCase();
-        if (!value || (sortOrder !== 'asc' && sortOrder !== 'desc'))
-            return value;
-        let numberArray = [];
-        let stringArray = [];
-        if (!sortKey) {
-            numberArray = value.filter(item => typeof item === 'number').sort();
-            stringArray = value.filter(item => typeof item === 'string').sort();
-        }
-        else {
-            numberArray = value
-                .filter(item => typeof item[sortKey] === 'number')
-                .sort((a, b) => a[sortKey] - b[sortKey]);
-            stringArray = value
-                .filter(item => typeof item[sortKey] === 'string')
-                .sort((a, b) => {
-                if (a[sortKey] < b[sortKey])
-                    return -1;
-                else if (a[sortKey] > b[sortKey])
-                    return 1;
-                else
-                    return 0;
-            });
-        }
-        const sorted = [
-            ...numberArray,
-            ...stringArray,
-            ...value.filter(item => typeof (sortKey ? item[sortKey] : item) !== 'number' &&
-                typeof (sortKey ? item[sortKey] : item) !== 'string'),
-        ];
-        return sortOrder === 'asc' ? sorted : sorted.reverse();
+    get flat$() {
+        return this._flat$.asObservable();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: SortPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.0.6", ngImport: i0, type: SortPipe, name: "abpSort" }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: SortPipe }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: SortPipe, decorators: [{
-            type: Injectable
-        }, {
-            type: Pipe,
-            args: [{
-                    name: 'abpSort',
-                }]
-        }] });
-
-const INJECTOR_PIPE_DATA_TOKEN = new InjectionToken('INJECTOR_PIPE_DATA_TOKEN');
-class ToInjectorPipe {
-    constructor(injector) {
-        this.injector = injector;
+    get tree() {
+        return this._tree$.value;
     }
-    transform(value, token = INJECTOR_PIPE_DATA_TOKEN, name = 'ToInjectorPipe') {
-        return Injector.create({
-            providers: [
-                {
-                    provide: token,
-                    useValue: value,
-                },
-            ],
-            parent: this.injector,
-            name,
-        });
+    get tree$() {
+        return this._tree$.asObservable();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ToInjectorPipe, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.0.6", ngImport: i0, type: ToInjectorPipe, name: "toInjector" }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ToInjectorPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'toInjector',
-                }]
-        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
-
-function setLanguageToCookie(injector) {
-    return () => {
-        const sessionState = injector.get(SessionStateService);
-        const document = injector.get(DOCUMENT);
-        const cookieLanguageKey = injector.get(COOKIE_LANGUAGE_KEY);
-        sessionState.getLanguage$().subscribe(language => {
-            const cookieValue = encodeURIComponent(`c=${language}|uic=${language}`);
-            document.cookie = `${cookieLanguageKey}=${cookieValue}`;
-        });
-    };
-}
-const CookieLanguageProvider = {
-    provide: APP_INITIALIZER,
-    useFactory: setLanguageToCookie,
-    deps: [Injector],
-    multi: true,
-};
-
-class LocaleId extends String {
-    constructor(localizationService) {
-        super();
-        this.localizationService = localizationService;
+    get visible() {
+        return this._visible$.value;
     }
-    toString() {
-        const { currentLang } = this.localizationService;
-        if (checkHasProp(differentLocales, currentLang)) {
-            return differentLocales[currentLang];
-        }
-        return currentLang;
+    get visible$() {
+        return this._visible$.asObservable();
     }
-    valueOf() {
-        return this.toString();
+    createTree(items) {
+        return createTreeFromList(items, item => item[this.id], item => item[this.parentId], item => BaseTreeNode.create(item));
     }
-}
-const LocaleProvider = {
-    provide: LOCALE_ID,
-    useClass: LocaleId,
-    deps: [LocalizationService],
-};
-
-Date.prototype.toLocalISOString = function () {
-    const timezoneOffset = this.getTimezoneOffset();
-    return new Date(this.getTime() - timezoneOffset * 60000).toISOString();
-};
-
-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);
+    createGroupedTree(list) {
+        const map = createGroupMap(list, this.othersGroup);
+        if (!map) {
+            return undefined;
+        }
+        return Array.from(map, ([key, items]) => ({ group: key, items }));
     }
-}
-
-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 });
+    filterWith(setOrMap) {
+        return this._flat$.value.filter(item => !setOrMap.has(item[this.id]));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpTenantService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpTenantService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpTenantService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: RestService }]; } });
-
-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));
-        };
+    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);
     }
-    setTenantByName(tenantName) {
-        return this.tenantService
-            .findTenantByName(tenantName)
-            .pipe(switchMap(this.setTenantToState));
+    publish(flatItems, visibleItems) {
+        this._flat$.next(flatItems);
+        this._tree$.next(this.createTree(flatItems));
+        this._visible$.next(this.createTree(visibleItems));
+        return flatItems;
     }
-    setTenantById(tenantId) {
-        return this.tenantService
-            .findTenantById(tenantId)
-            .pipe(switchMap(this.setTenantToState));
+    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);
+    }
+    find(predicate, tree = this.tree) {
+        return tree.reduce((acc, node) => (acc ? acc : predicate(node) ? node : this.find(predicate, node.children)), null);
+    }
+    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);
+    }
+    refresh() {
+        return this.add([]);
+    }
+    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);
+    }
+    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);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", 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: "16.0.6", ngImport: i0, type: MultiTenancyService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: MultiTenancyService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ 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 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,
+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 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);
-        return multiTenancyService
-            .setTenantByName(tenancyName)
-            .pipe(tap(setEnvironmentWithDomainTenant))
-            .toPromise();
+        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);
     }
-    else {
-        /**
-         * 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) {
-            return multiTenancyService.setTenantById(tenantIdFromQueryParams).toPromise();
-        }
+    isGranted({ requiredPolicy }) {
+        return this.permissionService.getGrantedPolicy(requiredPolicy);
     }
-    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);
+    hasChildren(identifier) {
+        const node = this.find(item => item[this.id] === identifier);
+        return Boolean(node?.children?.length);
     }
-    if (environment.oAuthConfig?.redirectUri) {
-        environment.oAuthConfig.redirectUri = environment.oAuthConfig.redirectUri.replace(placeholder, tenancyName);
+    hasInvisibleChild(identifier) {
+        const node = this.find(item => item[this.id] === identifier);
+        return node?.children?.some(child => child.invisible) || false;
     }
-    if (!environment.oAuthConfig) {
-        environment.oAuthConfig = {};
+    /* istanbul ignore next */
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
     }
-    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);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbstractNavTreeService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbstractNavTreeService }); }
 }
-
-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 ContentProjectionService {
-    constructor(injector) {
-        this.injector = injector;
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbstractNavTreeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+class RoutesService extends AbstractNavTreeService {
+    hasPathOrChild(item) {
+        return Boolean(item.path) || this.hasChildren(item.name);
     }
-    projectContent(projectionStrategy, injector = this.injector) {
-        return projectionStrategy.injectContent(injector);
+    get groupedVisible() {
+        return this.createGroupedTree(this.visible.filter(item => this.hasPathOrChild(item)));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ContentProjectionService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ContentProjectionService, providedIn: 'root' }); }
+    get groupedVisible$() {
+        return this.visible$.pipe(map$1(items => items.filter(item => this.hasPathOrChild(item))), map$1(visible => this.createGroupedTree(visible)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ContentProjectionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
-
-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')}`;
-}
+        }] });
 
-class LazyModuleFactory extends NgModuleFactory {
-    get moduleType() {
-        return this.moduleWithProviders.ngModule;
+class DynamicLayoutComponent {
+    constructor(injector, localizationService, replaceableComponents, subscription, routerEvents, dynamicLayoutComponent) {
+        this.localizationService = localizationService;
+        this.replaceableComponents = replaceableComponents;
+        this.subscription = subscription;
+        this.routerEvents = routerEvents;
+        // TODO: Consider a shared enum (eThemeSharedComponents) for known layouts
+        this.layouts = new Map([
+            ['application', 'Theme.ApplicationLayoutComponent'],
+            ['account', 'Theme.AccountLayoutComponent'],
+            ['empty', 'Theme.EmptyLayoutComponent'],
+        ]);
+        this.isLayoutVisible = true;
+        if (dynamicLayoutComponent) {
+            if (isDevMode())
+                console.warn('DynamicLayoutComponent must be used only in AppComponent.');
+            return;
+        }
+        this.route = injector.get(ActivatedRoute);
+        this.router = injector.get(Router);
+        this.routes = injector.get(RoutesService);
+        this.checkLayoutOnNavigationEnd();
+        this.listenToLanguageChange();
     }
-    constructor(moduleWithProviders) {
-        super();
-        this.moduleWithProviders = moduleWithProviders;
+    ngOnInit() {
+        if (this.layout) {
+            return;
+        }
+        this.getLayout();
     }
-    create(parentInjector) {
-        const injector = Injector.create({
-            ...(parentInjector && { parent: parentInjector }),
-            providers: this.moduleWithProviders.providers,
+    checkLayoutOnNavigationEnd() {
+        const navigationEnd$ = this.routerEvents.getNavigationEvents('End');
+        this.subscription.addOne(navigationEnd$, () => this.getLayout());
+    }
+    getLayout() {
+        let expectedLayout = (this.route.snapshot.data || {}).layout;
+        if (!expectedLayout) {
+            let node = findRoute(this.routes, getRoutePath(this.router));
+            node = { parent: node };
+            while (node.parent) {
+                node = node.parent;
+                if (node.layout) {
+                    expectedLayout = node.layout;
+                    break;
+                }
+            }
+        }
+        if (!expectedLayout)
+            expectedLayout = "empty" /* eLayoutType.empty */;
+        if (this.layoutKey === expectedLayout)
+            return;
+        const key = this.layouts.get(expectedLayout);
+        if (key) {
+            this.layout = this.getComponent(key)?.component;
+            this.layoutKey = expectedLayout;
+        }
+        if (!this.layout) {
+            this.showLayoutNotFoundError(expectedLayout);
+        }
+    }
+    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.';
+        }
+        console.warn(message);
+    }
+    listenToLanguageChange() {
+        this.subscription.addOne(this.localizationService.languageChange$, () => {
+            this.isLayoutVisible = false;
+            setTimeout(() => (this.isLayoutVisible = true), 0);
         });
-        const compiler = injector.get(Compiler);
-        const factory = compiler.compileModuleSync(this.moduleType);
-        return factory.create(injector);
     }
+    getComponent(key) {
+        return this.replaceableComponents.get(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: DynamicLayoutComponent, deps: [{ token: i0.Injector }, { token: LocalizationService }, { token: ReplaceableComponentsService }, { token: SubscriptionService }, { token: RouterEvents }, { token: DynamicLayoutComponent, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.6", 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: i5.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
 }
-function featuresFactory(configState, featureKeys, mapFn = features => features) {
-    return configState.getFeatures$(featureKeys).pipe(filter(Boolean), map(mapFn));
-}
-
-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: "16.0.6", ngImport: i0, type: DynamicLayoutComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'abp-dynamic-layout',
+                    template: ` <ng-container *ngIf="isLayoutVisible" [ngComponentOutlet]="layout"></ng-container> `,
+                    providers: [SubscriptionService],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: LocalizationService }, { type: ReplaceableComponentsService }, { type: SubscriptionService }, { type: RouterEvents }, { type: DynamicLayoutComponent, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }]; } });
 
-function isNumber(value) {
-    return value == Number(value);
+class ReplaceableRouteContainerComponent {
+    constructor(route, replaceableComponents, subscription) {
+        this.route = route;
+        this.replaceableComponents = replaceableComponents;
+        this.subscription = subscription;
+    }
+    ngOnInit() {
+        this.defaultComponent = this.route.snapshot.data.replaceableComponent.defaultComponent;
+        this.componentKey = this.route.snapshot.data.replaceableComponent.key;
+        const component$ = this.replaceableComponents
+            .get$(this.componentKey)
+            .pipe(distinctUntilChanged());
+        this.subscription.addOne(component$, (res = {}) => {
+            this.externalComponent = res.component;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ReplaceableRouteContainerComponent, deps: [{ token: i1$1.ActivatedRoute }, { token: ReplaceableComponentsService }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.6", type: ReplaceableRouteContainerComponent, selector: "abp-replaceable-route-container", providers: [SubscriptionService], ngImport: i0, template: `
+    <ng-container *ngComponentOutlet="externalComponent || defaultComponent"></ng-container>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i5.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }] }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ReplaceableRouteContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'abp-replaceable-route-container',
+                    template: `
+    <ng-container *ngComponentOutlet="externalComponent || defaultComponent"></ng-container>
+  `,
+                    providers: [SubscriptionService],
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.ActivatedRoute }, { type: ReplaceableComponentsService }, { type: SubscriptionService }]; } });
 
-function mapEnumToOptions(_enum) {
-    const options = [];
-    for (const member in _enum)
-        if (!isNumber(member))
-            options.push({
-                key: member,
-                value: _enum[member],
-            });
-    return options;
+class RouterOutletComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RouterOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.6", type: RouterOutletComponent, selector: "abp-router-outlet", ngImport: i0, template: ` <router-outlet></router-outlet> `, isInline: true, dependencies: [{ kind: "directive", type: i1$1.RouterOutlet, selector: "router-outlet", inputs: ["name"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RouterOutletComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'abp-router-outlet',
+                    template: ` <router-outlet></router-outlet> `,
+                }]
+        }] });
 
-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;
+// Different locales from .NET
+// Key is .NET locale, value is Angular locale
+const differentLocales = {
+    aa: 'en',
+    'aa-DJ': 'en',
+    'aa-ER': 'en',
+    'aa-ET': 'en',
+    'af-ZA': 'af',
+    'agq-CM': 'agq',
+    'ak-GH': 'ak',
+    'am-ET': 'am',
+    'ar-001': 'ar',
+    arn: 'en',
+    'arn-CL': 'en',
+    'as-IN': 'as',
+    'asa-TZ': 'asa',
+    'ast-ES': 'ast',
+    'az-Cyrl-AZ': 'az-Cyrl',
+    'az-Latn-AZ': 'az-Latn',
+    ba: 'ru',
+    'ba-RU': 'ru',
+    'bas-CM': 'bas',
+    'be-BY': 'be',
+    'bem-ZM': 'bem',
+    'bez-TZ': 'bez',
+    'bg-BG': 'bg',
+    bin: 'en',
+    'bin-NG': 'en',
+    'bm-Latn': 'bm',
+    'bm-Latn-ML': 'bm',
+    'bn-BD': 'bn',
+    'bo-CN': 'bo',
+    'br-FR': 'br',
+    'brx-IN': 'brx',
+    'bs-Cyrl-BA': 'bs-Cyrl',
+    'bs-Latn-BA': 'bs-Latn',
+    byn: 'en',
+    'byn-ER': 'en',
+    'ca-ES': 'ca',
+    'ca-ES-valencia': 'ca-ES-VALENCIA',
+    'ce-RU': 'ce',
+    'cgg-UG': 'cgg',
+    'chr-Cher': 'chr',
+    'chr-Cher-US': 'chr',
+    co: 'en',
+    'co-FR': 'fr',
+    'cs-CZ': 'cs',
+    'cu-RU': 'cu',
+    'cy-GB': 'cy',
+    'da-DK': 'da',
+    'dav-KE': 'dav',
+    'de-DE': 'de',
+    'dje-NE': 'dje',
+    'dsb-DE': 'dsb',
+    'dua-CM': 'dua',
+    dv: 'en',
+    'dv-MV': 'en',
+    'dyo-SN': 'dyo',
+    'dz-BT': 'dz',
+    'ebu-KE': 'ebu',
+    'ee-GH': 'ee',
+    'el-GR': 'el',
+    'en-029': 'en',
+    'en-ID': 'en',
+    'en-US': 'en',
+    'eo-001': 'en',
+    'es-ES': 'es',
+    'et-EE': 'et',
+    'eu-ES': 'eu',
+    'ewo-CM': 'ewo',
+    'fa-IR': 'fa',
+    'ff-Latn-SN': 'ff-Latn',
+    'ff-NG': 'ff',
+    'fi-FI': 'fi',
+    'fil-PH': 'fil',
+    'fo-FO': 'fo',
+    'fr-029': 'fr',
+    'fr-FR': 'fr',
+    'fur-IT': 'fur',
+    'fy-NL': 'fy',
+    'ga-IE': 'ga',
+    'gd-GB': 'gd',
+    'gl-ES': 'gl',
+    gn: 'en',
+    'gn-PY': 'en',
+    'gsw-CH': 'gsw',
+    'gu-IN': 'gu',
+    'guz-KE': 'guz',
+    'gv-IM': 'gv',
+    'ha-Latn': 'ha',
+    'ha-Latn-GH': 'ha-GH',
+    'ha-Latn-NE': 'ha-NE',
+    'ha-Latn-NG': 'ha',
+    'haw-US': 'haw',
+    'he-IL': 'he',
+    'hi-IN': 'hi',
+    'hr-HR': 'hr',
+    'hsb-DE': 'hsb',
+    'hu-HU': 'hu',
+    'hy-AM': 'hy',
+    'ia-001': 'ia',
+    'ia-FR': 'ia',
+    ibb: 'en',
+    'ibb-NG': 'en',
+    'id-ID': 'id',
+    'ig-NG': 'ig',
+    'ii-CN': 'ii',
+    'is-IS': 'is',
+    'it-IT': 'it',
+    iu: 'en',
+    'iu-Cans': 'en',
+    'iu-Cans-CA': 'en',
+    'iu-Latn': 'en',
+    'iu-Latn-CA': 'en',
+    'ja-JP': 'ja',
+    'jgo-CM': 'jgo',
+    'jmc-TZ': 'jmc',
+    'jv-Java': 'jv',
+    'jv-Java-ID': 'jv',
+    'jv-Latn': 'jv',
+    'jv-Latn-ID': 'jv',
+    'ka-GE': 'ka',
+    'kab-DZ': 'kab',
+    'kam-KE': 'kam',
+    'kde-TZ': 'kde',
+    'kea-CV': 'kea',
+    'khq-ML': 'khq',
+    'ki-KE': 'ki',
+    'kk-KZ': 'kk',
+    'kkj-CM': 'kkj',
+    'kl-GL': 'kl',
+    'kln-KE': 'kln',
+    'km-KH': 'km',
+    'kn-IN': 'kn',
+    'ko-KR': 'ko',
+    'kok-IN': 'kok',
+    kr: 'en',
+    'kr-NG': 'en',
+    'ks-Arab': 'ks',
+    'ks-Arab-IN': 'ks',
+    'ks-Deva': 'ks',
+    'ks-Deva-IN': 'ks',
+    'ksb-TZ': 'ksb',
+    'ksf-CM': 'ksf',
+    'ksh-DE': 'ksh',
+    'ku-Arab': 'ku',
+    'ku-Arab-IQ': 'ku',
+    'ku-Arab-IR': 'ku',
+    'kw-GB': 'kw',
+    'ky-KG': 'ky',
+    la: 'en',
+    'la-001': 'en',
+    'lag-TZ': 'lag',
+    'lb-LU': 'lb',
+    'lg-UG': 'lg',
+    'lkt-US': 'lkt',
+    'ln-CD': 'ln',
+    'lo-LA': 'lo',
+    'lrc-IR': 'lrc',
+    'lt-LT': 'lt',
+    'lu-CD': 'lu',
+    'luo-KE': 'luo',
+    'luy-KE': 'luy',
+    'lv-LV': 'lv',
+    'mas-KE': 'mas',
+    'mer-KE': 'mer',
+    'mfe-MU': 'mfe',
+    'mg-MG': 'mg',
+    'mgh-MZ': 'mgh',
+    'mgo-CM': 'mgo',
+    'mi-NZ': 'mi',
+    'mk-MK': 'mk',
+    'ml-IN': 'ml',
+    'mn-Cyrl': 'mn',
+    'mn-MN': 'mn',
+    'mn-Mong': 'mn',
+    'mn-Mong-CN': 'mn',
+    'mn-Mong-MN': 'mn',
+    mni: 'en',
+    'mni-IN': 'en',
+    moh: 'en',
+    'moh-CA': 'en',
+    'mr-IN': 'mr',
+    'ms-MY': 'ms',
+    'mt-MT': 'mt',
+    'mua-CM': 'mua',
+    'my-MM': 'my',
+    'mzn-IR': 'mzn',
+    'naq-NA': 'naq',
+    'nb-NO': 'nb',
+    'nd-ZW': 'nd',
+    'ne-NP': 'ne',
+    'nl-NL': 'nl',
+    'nmg-CM': 'ngm',
+    'nn-NO': 'nn',
+    'nnh-CM': 'nnh',
+    no: 'en',
+    nqo: 'en',
+    'nqo-GN': 'en',
+    nr: 'en',
+    'nr-ZA': 'en',
+    nso: 'en',
+    'nso-ZA': 'en',
+    'nus-SS': 'nus',
+    'nyn-UG': 'nyn',
+    oc: 'en',
+    'oc-FR': 'fr',
+    'om-ET': 'om',
+    'or-IN': 'or',
+    'os-GE': 'os',
+    'pa-Arab-PK': 'pa-Arab',
+    'pa-IN': 'pa',
+    pap: 'en',
+    'pap-029': 'en',
+    'pl-PL': 'pl',
+    'prg-001': 'prg',
+    prs: 'en',
+    'prs-AF': 'en',
+    'ps-AF': 'ps',
+    'pt-BR': 'pt',
+    quc: 'en',
+    'quc-Latn': 'en',
+    'quc-Latn-GT': 'en',
+    quz: 'en',
+    'quz-BO': 'en',
+    'quz-EC': 'en',
+    'quz-PE': 'en',
+    'rm-CH': 'rm',
+    'rn-BI': 'rn',
+    'ro-RO': 'ro',
+    'rof-TZ': 'rof',
+    'ru-RU': 'ru',
+    'rw-RW': 'rw',
+    'rwk-TZ': 'rwk',
+    sa: 'en',
+    'sa-IN': 'en',
+    'sah-RU': 'sah',
+    'saq-KE': 'saq',
+    'sbp-TZ': 'en',
+    'sd-Arab': 'sd',
+    'sd-Arab-PK': 'sd',
+    'sd-Deva': 'sd',
+    'sd-Deva-IN': 'sd',
+    'se-NO': 'se',
+    'seh-MZ': 'seh',
+    'ses-ML': 'ses',
+    'sg-CF': 'sg',
+    'shi-Latn-MA': 'shi-Latn',
+    'shi-Tfng-MA': 'shi-Tfng',
+    'si-LK': 'si',
+    'sk-SK': 'sk',
+    'sl-SI': 'sl',
+    sma: 'en',
+    'sma-NO': 'en',
+    'sma-SE': 'en',
+    smj: 'en',
+    'smj-NO': 'en',
+    'smj-SE': 'en',
+    'smn-FI': 'en',
+    sms: 'en',
+    'sms-FI': 'en',
+    'sn-Latn': 'sn',
+    'sn-Latn-ZW': 'sn',
+    'so-SO': 'so',
+    'sq-AL': 'so',
+    'sr-Cyrl-RS': 'sr-Cryl',
+    'sr-Latn-RS': 'sr-Latn',
+    ss: 'en',
+    'ss-SZ': 'en',
+    'ss-ZA': 'en',
+    ssy: 'en',
+    'ssy-ER': 'en',
+    st: 'en',
+    'st-LS': 'en',
+    'st-ZA': 'en',
+    'sv-SE': 'sv',
+    'sw-TZ': 'sw',
+    syr: 'en',
+    'syr-SY': 'en',
+    'ta-IN': 'ta',
+    'te-IN': 'te',
+    'teo-UG': 'teo',
+    'tg-Cyrl': 'tg',
+    'tg-Cyrl-TJ': 'tg',
+    'th-TH': 'th',
+    'ti-ET': 'ti',
+    tig: 'en',
+    'tig-ER': 'en',
+    'tk-TM': 'tk',
+    tn: 'en',
+    'tn-BW': 'en',
+    'tn-ZA': 'en',
+    'to-TO': 'to',
+    'tr-TR': 'tr',
+    ts: 'en',
+    'ts-ZA': 'en',
+    'tt-RU': 'tt',
+    'twq-NE': 'twq',
+    'tzm-Arab': 'tzm',
+    'tzm-Arab-MA': 'tzm',
+    'tzm-Latn': 'tzm',
+    'tzm-Latn-DZ': 'tzm',
+    'tzm-Latn-MA': 'tzm',
+    'tzm-Tfng': 'tzm',
+    'tzm-Tfng-MA': 'tzm',
+    'ug-CN': 'ug',
+    'uk-UA': 'uk',
+    'ur-PK': 'ur',
+    'uz-Arab-AF': 'uz-Arab',
+    'uz-Cyrl-UZ': 'uz-Cyrl',
+    'uz-Latn-UZ': 'uz-Latn',
+    'vai-Latn-LR': 'vai-Latn',
+    'vai-Vaii-LR': 'vai-Vaii',
+    ve: 'en',
+    've-ZA': 'en',
+    'vi-VN': 'vi',
+    'vo-001': 'vo',
+    'vun-TZ': 'vun',
+    'wae-CH': 'wae',
+    wal: 'en',
+    'wal-ET': 'en',
+    'wo-SN': 'wo',
+    'xh-ZA': 'xh',
+    'xog-UG': 'xog',
+    'yav-CM': 'yav',
+    'yi-001': 'yi',
+    'yo-NG': 'yo',
+    'zgh-Tfng': 'zgh',
+    'zgh-Tfng-MA': 'zgh',
+    'zh-CN': 'zh',
+    'zh-HK': 'zh',
+    'zh-MO': 'zh',
+    'zh-SG': 'zh',
+    'zh-TW': 'zh',
+    'zu-ZA': 'zu',
+};
+
+class AutofocusDirective {
+    set delay(val) {
+        this._delay = Number(val) || 0;
     }
-    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);
+    get delay() {
+        return this._delay;
     }
-    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);
+    constructor(elRef) {
+        this.elRef = elRef;
+        this._delay = 0;
     }
-    encodeValue(v) {
-        return encodeURIComponent(v);
+    ngAfterViewInit() {
+        setTimeout(() => this.elRef.nativeElement.focus(), this.delay);
     }
-    decodeKey(k) {
-        return decodeURIComponent(k);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AutofocusDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: AutofocusDirective, selector: "[autofocus]", inputs: { delay: ["autofocus", "delay"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AutofocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[autofocus]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { delay: [{
+                type: Input,
+                args: ['autofocus']
+            }] } });
+
+class InputEventDebounceDirective {
+    constructor(el, subscription) {
+        this.el = el;
+        this.subscription = subscription;
+        this.debounce = 300;
+        this.debounceEvent = new EventEmitter();
     }
-    decodeValue(v) {
-        return decodeURIComponent(v);
+    ngOnInit() {
+        const input$ = fromEvent(this.el.nativeElement, 'input').pipe(debounceTime(this.debounce));
+        this.subscription.addOne(input$, (event) => {
+            this.debounceEvent.emit(event);
+        });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: InputEventDebounceDirective, deps: [{ token: i0.ElementRef }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: InputEventDebounceDirective, selector: "[input.debounce]", inputs: { debounce: "debounce" }, outputs: { debounceEvent: "input.debounce" }, providers: [SubscriptionService], ngImport: i0 }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: InputEventDebounceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[input.debounce]',
+                    providers: [SubscriptionService],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: SubscriptionService }]; }, propDecorators: { debounce: [{
+                type: Input
+            }], debounceEvent: [{
+                type: Output,
+                args: ['input.debounce']
+            }] } });
 
-class CrossOriginStrategy {
-    constructor(crossorigin, integrity) {
-        this.crossorigin = crossorigin;
-        this.integrity = integrity;
-    }
-    setCrossOrigin(element) {
-        if (this.integrity)
-            element.setAttribute('integrity', this.integrity);
-        if (this.crossorigin) {
-            element.setAttribute('crossorigin', this.crossorigin);
-        }
+class AbpForContext {
+    constructor($implicit, index, count, list) {
+        this.$implicit = $implicit;
+        this.index = index;
+        this.count = count;
+        this.list = list;
     }
 }
-class NoCrossOriginStrategy extends CrossOriginStrategy {
-    setCrossOrigin() { }
+class RecordView {
+    constructor(record, view) {
+        this.record = record;
+        this.view = view;
+    }
 }
-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;
+class ForDirective {
+    get compareFn() {
+        return this.compareBy || compare;
     }
-    insertElement(element) {
-        this.target.insertAdjacentElement(this.position, element);
+    get trackByFn() {
+        return this.trackBy || ((index, item) => item.id || index);
     }
-}
-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();
-        };
-        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;
+    constructor(tempRef, vcRef, differs) {
+        this.tempRef = tempRef;
+        this.vcRef = vcRef;
+        this.differs = differs;
     }
-    init(interval, stackSize) {
-        this.interval = interval;
-        this.stackSize = stackSize;
+    iterateOverAppliedOperations(changes) {
+        const rw = [];
+        changes.forEachOperation((record, previousIndex, currentIndex) => {
+            if (record.previousIndex == null) {
+                const view = this.vcRef.createEmbeddedView(this.tempRef, new AbpForContext(null, -1, -1, this.items), currentIndex || 0);
+                rw.push(new RecordView(record, view));
+            }
+            else if (currentIndex == null && previousIndex !== null) {
+                this.vcRef.remove(previousIndex);
+            }
+            else {
+                if (previousIndex !== null) {
+                    const view = this.vcRef.get(previousIndex);
+                    if (view && currentIndex !== null) {
+                        this.vcRef.move(view, currentIndex);
+                        rw.push(new RecordView(record, view));
+                    }
+                }
+            }
+        });
+        for (let i = 0, l = rw.length; i < l; i++) {
+            rw[i].view.context.$implicit = rw[i].record.item;
+        }
     }
-    add(fn) {
-        this.queue.push(fn);
-        this.run();
+    iterateOverAttachedViews(changes) {
+        for (let i = 0, l = this.vcRef.length; i < l; i++) {
+            const viewRef = this.vcRef.get(i);
+            viewRef.context.index = i;
+            viewRef.context.count = l;
+            viewRef.context.list = this.items;
+        }
+        changes.forEachIdentityChange((record) => {
+            if (record.currentIndex !== null) {
+                const viewRef = this.vcRef.get(record.currentIndex);
+                viewRef.context.$implicit = record.item;
+            }
+        });
     }
-    run() {
-        if (this.isRunning)
-            return;
-        this.stack++;
-        this.isRunning = true;
-        const fn = this.queue.shift();
-        if (!fn) {
-            this.isRunning = false;
+    projectItems(items) {
+        if (!items.length && this.emptyRef) {
+            this.vcRef.clear();
+            this.vcRef.createEmbeddedView(this.emptyRef).rootNodes;
+            this.isShowEmptyRef = true;
+            this.differ = null;
             return;
         }
-        fn();
-        if (this.stack > this.stackSize) {
-            setTimeout(() => {
-                this.isRunning = false;
-                this.run();
-                this.stack = 0;
-            }, this.interval);
+        if (this.emptyRef && this.isShowEmptyRef) {
+            this.vcRef.clear();
+            this.isShowEmptyRef = false;
         }
-        else {
-            this.isRunning = false;
-            this.run();
+        if (!this.differ && items) {
+            this.differ = this.differs.find(items).create(this.trackByFn);
+        }
+        if (this.differ) {
+            const changes = this.differ.diff(items);
+            if (changes) {
+                this.iterateOverAppliedOperations(changes);
+                this.iterateOverAttachedViews(changes);
+            }
         }
     }
-}
-
-class DomInsertionService {
-    constructor() {
-        this.inserted = new Set();
+    sortItems(items) {
+        const orderBy = this.orderBy;
+        if (orderBy) {
+            items.sort((a, b) => (a[orderBy] > b[orderBy] ? 1 : a[orderBy] < b[orderBy] ? -1 : 0));
+        }
+        else {
+            items.sort();
+        }
     }
-    insertContent(contentStrategy) {
-        const hash = generateHash(contentStrategy.content);
-        if (this.inserted.has(hash))
+    ngOnChanges() {
+        let items = clone(this.items);
+        if (!Array.isArray(items))
             return;
-        const element = contentStrategy.insertElement();
-        this.inserted.add(hash);
-        return element;
-    }
-    removeContent(element) {
-        if (element.textContent) {
-            const hash = generateHash(element.textContent);
-            this.inserted.delete(hash);
-            element.parentNode?.removeChild(element);
+        const compareFn = this.compareFn;
+        const filterBy = this.filterBy;
+        if (typeof filterBy !== 'undefined' &&
+            typeof this.filterVal !== 'undefined' &&
+            this.filterVal !== '') {
+            items = items.filter(item => compareFn(item[filterBy], this.filterVal));
+        }
+        switch (this.orderDir) {
+            case 'ASC':
+                this.sortItems(items);
+                this.projectItems(items);
+                break;
+            case 'DESC':
+                this.sortItems(items);
+                items.reverse();
+                this.projectItems(items);
+                break;
+            default:
+                this.projectItems(items);
         }
     }
-    has(content) {
-        const hash = generateHash(content);
-        return this.inserted.has(hash);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: DomInsertionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: DomInsertionService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ForDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: ForDirective, selector: "[abpFor]", inputs: { items: ["abpForOf", "items"], orderBy: ["abpForOrderBy", "orderBy"], orderDir: ["abpForOrderDir", "orderDir"], filterBy: ["abpForFilterBy", "filterBy"], filterVal: ["abpForFilterVal", "filterVal"], trackBy: ["abpForTrackBy", "trackBy"], compareBy: ["abpForCompareBy", "compareBy"], emptyRef: ["abpForEmptyRef", "emptyRef"] }, usesOnChanges: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: DomInsertionService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ForDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[abpFor]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: i0.IterableDiffers }]; }, propDecorators: { items: [{
+                type: Input,
+                args: ['abpForOf']
+            }], orderBy: [{
+                type: Input,
+                args: ['abpForOrderBy']
+            }], orderDir: [{
+                type: Input,
+                args: ['abpForOrderDir']
+            }], filterBy: [{
+                type: Input,
+                args: ['abpForFilterBy']
+            }], filterVal: [{
+                type: Input,
+                args: ['abpForFilterVal']
+            }], trackBy: [{
+                type: Input,
+                args: ['abpForTrackBy']
+            }], compareBy: [{
+                type: Input,
+                args: ['abpForCompareBy']
+            }], emptyRef: [{
+                type: Input,
+                args: ['abpForEmptyRef']
+            }] } });
 
-class HttpWaitService {
-    constructor(injector) {
-        this.store = new InternalStore({
-            requests: [],
-            filteredRequests: [],
-        });
-        this.destroy$ = new Subject();
-        this.delay = injector.get(LOADER_DELAY, 500);
+/**
+ * @deprecated FormSubmitDirective will be removed in V7.0.0. Use `ngSubmit` instead.
+ */
+class FormSubmitDirective {
+    constructor(formGroupDirective, host, cdRef, subscription) {
+        this.formGroupDirective = formGroupDirective;
+        this.host = host;
+        this.cdRef = cdRef;
+        this.subscription = subscription;
+        this.debounce = 200;
+        this.markAsDirtyWhenSubmit = true;
+        this.ngSubmit = new EventEmitter();
+        this.executedNgSubmit = false;
     }
-    getLoading() {
-        return !!this.applyFilter(this.store.state.requests).length;
+    ngOnInit() {
+        this.subscription.addOne(this.formGroupDirective.ngSubmit, () => {
+            if (this.markAsDirtyWhenSubmit) {
+                this.markAsDirty();
+            }
+            this.executedNgSubmit = true;
+        });
+        const keyup$ = fromEvent(this.host.nativeElement, 'keyup').pipe(debounceTime(this.debounce), filter(event => !(event.target instanceof HTMLTextAreaElement)), filter(event => event && event.key === 'Enter'));
+        this.subscription.addOne(keyup$, () => {
+            if (!this.executedNgSubmit) {
+                this.host.nativeElement.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }));
+            }
+            this.executedNgSubmit = false;
+        });
     }
-    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()));
+    markAsDirty() {
+        const { form } = this.formGroupDirective;
+        setDirty(form.controls);
+        form.markAsDirty();
+        this.cdRef.detectChanges();
     }
-    updateLoading$() {
-        return this.store.sliceUpdate(({ requests }) => !!this.applyFilter(requests).length);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: FormSubmitDirective, deps: [{ token: i1$2.FormGroupDirective, self: true }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: FormSubmitDirective, selector: "form[ngSubmit][formGroup]", inputs: { debounce: "debounce", notValidateOnSubmit: "notValidateOnSubmit", markAsDirtyWhenSubmit: "markAsDirtyWhenSubmit" }, outputs: { ngSubmit: "ngSubmit" }, providers: [SubscriptionService], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: FormSubmitDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'form[ngSubmit][formGroup]',
+                    providers: [SubscriptionService],
+                }]
+        }], ctorParameters: function () { return [{ type: i1$2.FormGroupDirective, decorators: [{
+                    type: Self
+                }] }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: SubscriptionService }]; }, propDecorators: { debounce: [{
+                type: Input
+            }], notValidateOnSubmit: [{
+                type: Input
+            }], markAsDirtyWhenSubmit: [{
+                type: Input
+            }], ngSubmit: [{
+                type: Output
+            }] } });
+function setDirty(controls) {
+    if (Array.isArray(controls)) {
+        controls.forEach(group => {
+            setDirty(group.controls);
+        });
+        return;
     }
-    clearLoading() {
-        this.store.patch({ requests: [] });
+    Object.keys(controls).forEach(key => {
+        controls[key].markAsDirty();
+        controls[key].updateValueAndValidity();
+    });
+}
+
+class InitDirective {
+    constructor(elRef) {
+        this.elRef = elRef;
+        this.init = new EventEmitter();
     }
-    addRequest(request) {
-        this.store.patch({ requests: [...this.store.state.requests, request] });
+    ngAfterViewInit() {
+        this.init.emit(this.elRef);
     }
-    deleteRequest(request) {
-        const requests = this.store.state.requests.filter(r => r !== request);
-        this.store.patch({ requests });
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: InitDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: InitDirective, selector: "[abpInit]", outputs: { init: "abpInit" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: InitDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[abpInit]' }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { init: [{
+                type: Output,
+                args: ['abpInit']
+            }] } });
+
+class PermissionDirective {
+    constructor(templateRef, vcRef, permissionService, cdRef, queue) {
+        this.templateRef = templateRef;
+        this.vcRef = vcRef;
+        this.permissionService = permissionService;
+        this.cdRef = cdRef;
+        this.queue = queue;
+        this.runChangeDetection = true;
+        this.cdrSubject = new ReplaySubject();
+        this.rendered = false;
     }
-    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 });
+    check() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+        this.subscription = this.permissionService
+            .getGrantedPolicy$(this.condition || '')
+            .pipe(distinctUntilChanged())
+            .subscribe(isGranted => {
+            this.vcRef.clear();
+            if (isGranted)
+                this.vcRef.createEmbeddedView(this.templateRef);
+            if (this.runChangeDetection) {
+                if (!this.rendered) {
+                    this.cdrSubject.next();
+                }
+                else {
+                    this.cdRef.detectChanges();
+                }
+            }
+            else {
+                this.cdRef.markForCheck();
+            }
+        });
     }
-    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 });
+    ngOnDestroy() {
+        if (this.subscription)
+            this.subscription.unsubscribe();
     }
-    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) })));
+    ngOnChanges() {
+        this.check();
     }
-    isSameRequest(filteredRequest, request) {
-        const { method, endpoint } = filteredRequest;
-        return endpoint === request.endpoint && method === request.method;
+    ngAfterViewInit() {
+        this.cdrSubject.pipe(take(1)).subscribe(() => this.queue.add(() => this.cdRef.detectChanges()));
+        this.rendered = true;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: HttpWaitService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: HttpWaitService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: PermissionDirective, deps: [{ token: i0.TemplateRef, optional: true }, { token: i0.ViewContainerRef }, { token: PermissionService }, { token: i0.ChangeDetectorRef }, { token: QUEUE_MANAGER }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: PermissionDirective, selector: "[abpPermission]", inputs: { condition: ["abpPermission", "condition"], runChangeDetection: ["abpPermissionRunChangeDetection", "runChangeDetection"] }, usesOnChanges: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: HttpWaitService, decorators: [{
-            type: Injectable,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: PermissionDirective, decorators: [{
+            type: Directive,
             args: [{
-                    providedIn: 'root',
+                    selector: '[abpPermission]',
                 }]
-        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ViewContainerRef }, { type: PermissionService }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [QUEUE_MANAGER]
+                }] }]; }, propDecorators: { condition: [{
+                type: Input,
+                args: ['abpPermission']
+            }], runChangeDetection: [{
+                type: Input,
+                args: ['abpPermissionRunChangeDetection']
+            }] } });
 
-class ResourceWaitService {
-    constructor() {
-        this.store = new InternalStore({ resources: new Set() });
-    }
-    getLoading() {
-        return !!this.store.state.resources.size;
+class ReplaceableTemplateDirective {
+    constructor(injector, templateRef, vcRef, replaceableComponents, subscription) {
+        this.injector = injector;
+        this.templateRef = templateRef;
+        this.vcRef = vcRef;
+        this.replaceableComponents = replaceableComponents;
+        this.subscription = subscription;
+        this.providedData = {
+            inputs: {},
+            outputs: {},
+        };
+        this.context = {};
+        this.defaultComponentSubscriptions = {};
+        this.initialized = false;
+        this.context = {
+            initTemplate: (ref) => {
+                this.resetDefaultComponent();
+                this.defaultComponentRef = ref;
+                this.setDefaultComponentInputs();
+            },
+        };
     }
-    getLoading$() {
-        return this.store.sliceState(({ resources }) => !!resources.size);
+    ngOnInit() {
+        const component$ = this.replaceableComponents
+            .get$(this.data.componentKey)
+            .pipe(filter((res = {}) => !this.initialized || !compare(res.component, this.externalComponent)));
+        this.subscription.addOne(component$, (res = {}) => {
+            this.vcRef.clear();
+            this.externalComponent = res.component;
+            if (this.defaultComponentRef) {
+                this.resetDefaultComponent();
+            }
+            if (res.component) {
+                this.setProvidedData();
+                const customInjector = Injector.create({
+                    providers: [{ provide: 'REPLACEABLE_DATA', useValue: this.providedData }],
+                    parent: this.injector,
+                });
+                const ref = this.vcRef.createComponent(res.component, {
+                    index: 0,
+                    injector: customInjector,
+                });
+            }
+            else {
+                this.vcRef.createEmbeddedView(this.templateRef, this.context);
+            }
+            this.initialized = true;
+        });
     }
-    updateLoading$() {
-        return this.store.sliceUpdate(({ resources }) => !!resources?.size);
+    ngOnChanges(changes) {
+        if (changes?.data?.currentValue?.inputs && this.defaultComponentRef) {
+            this.setDefaultComponentInputs();
+        }
     }
-    clearLoading() {
-        this.store.patch({ resources: new Set() });
+    setDefaultComponentInputs() {
+        if (!this.defaultComponentRef || (!this.data.inputs && !this.data.outputs))
+            return;
+        if (this.data.inputs) {
+            for (const key in this.data.inputs) {
+                if (Object.prototype.hasOwnProperty.call(this.data.inputs, key)) {
+                    if (!compare(this.defaultComponentRef[key], this.data.inputs[key].value)) {
+                        this.defaultComponentRef[key] = this.data.inputs[key].value;
+                    }
+                }
+            }
+        }
+        if (this.data.outputs) {
+            for (const key in this.data.outputs) {
+                if (Object.prototype.hasOwnProperty.call(this.data.outputs, key)) {
+                    if (!this.defaultComponentSubscriptions[key]) {
+                        this.defaultComponentSubscriptions[key] = this.defaultComponentRef[key].subscribe((value) => {
+                            this.data.outputs?.[key](value);
+                        });
+                    }
+                }
+            }
+        }
     }
-    addResource(resource) {
-        const resources = this.store.state.resources;
-        resources.add(resource);
-        this.store.patch({ resources });
+    setProvidedData() {
+        this.providedData = { outputs: {}, ...this.data, inputs: {} };
+        if (!this.data.inputs)
+            return;
+        Object.defineProperties(this.providedData.inputs, {
+            ...Object.keys(this.data.inputs).reduce((acc, key) => ({
+                ...acc,
+                [key]: {
+                    enumerable: true,
+                    configurable: true,
+                    get: () => this.data.inputs?.[key]?.value,
+                    ...(this.data.inputs?.[key]?.twoWay && {
+                        set: (newValue) => {
+                            if (this.data.inputs?.[key]) {
+                                this.data.inputs[key].value = newValue;
+                            }
+                            if (this.data.outputs?.[`${key}Change`]) {
+                                this.data.outputs[`${key}Change`](newValue);
+                            }
+                        },
+                    }),
+                },
+            }), {}),
+        });
     }
-    deleteResource(resource) {
-        const resources = this.store.state.resources;
-        resources.delete(resource);
-        this.store.patch({ resources });
+    resetDefaultComponent() {
+        Object.keys(this.defaultComponentSubscriptions).forEach(key => {
+            this.defaultComponentSubscriptions[key].unsubscribe();
+        });
+        this.defaultComponentSubscriptions = {};
+        this.defaultComponentRef = null;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ResourceWaitService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ResourceWaitService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ReplaceableTemplateDirective, deps: [{ token: i0.Injector }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: ReplaceableComponentsService }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: ReplaceableTemplateDirective, selector: "[abpReplaceableTemplate]", inputs: { data: ["abpReplaceableTemplate", "data"] }, providers: [SubscriptionService], usesOnChanges: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ResourceWaitService, decorators: [{
-            type: Injectable,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ReplaceableTemplateDirective, decorators: [{
+            type: Directive,
             args: [{
-                    providedIn: 'root',
+                    selector: '[abpReplaceableTemplate]',
+                    providers: [SubscriptionService],
                 }]
-        }] });
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: ReplaceableComponentsService }, { type: SubscriptionService }]; }, propDecorators: { data: [{
+                type: Input,
+                args: ['abpReplaceableTemplate']
+            }] } });
 
-class LazyLoadService {
-    constructor(resourceWaitService) {
-        this.resourceWaitService = resourceWaitService;
-        this.loaded = new Map();
-    }
-    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 StopPropagationDirective {
+    constructor(el, subscription) {
+        this.el = el;
+        this.subscription = subscription;
+        this.stopPropEvent = new EventEmitter();
     }
-    remove(path) {
-        const element = this.loaded.get(path);
-        if (!element)
-            return false;
-        element.parentNode?.removeChild(element);
-        this.loaded.delete(path);
-        return true;
+    ngOnInit() {
+        this.subscription.addOne(fromEvent(this.el.nativeElement, 'click'), event => {
+            event.stopPropagation();
+            this.stopPropEvent.emit(event);
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LazyLoadService, deps: [{ token: ResourceWaitService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LazyLoadService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: StopPropagationDirective, deps: [{ token: i0.ElementRef }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.6", type: StopPropagationDirective, selector: "[click.stop]", outputs: { stopPropEvent: "click.stop" }, providers: [SubscriptionService], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LazyLoadService, decorators: [{
-            type: Injectable,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: StopPropagationDirective, decorators: [{
+            type: Directive,
             args: [{
-                    providedIn: 'root',
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[click.stop]',
+                    providers: [SubscriptionService],
                 }]
-        }], ctorParameters: function () { return [{ type: ResourceWaitService }]; } });
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: SubscriptionService }]; }, propDecorators: { stopPropEvent: [{
+                type: Output,
+                args: ['click.stop']
+            }] } });
 
-class ListService {
-    set filter(value) {
-        this._filter = value;
-        this.get();
-    }
-    get filter() {
-        return this._filter;
-    }
-    set maxResultCount(value) {
-        this._maxResultCount = value;
-        this.get();
-    }
-    get maxResultCount() {
-        return this._maxResultCount;
-    }
-    set page(value) {
-        if (value === this._page)
-            return;
-        this._page = value;
-        this.get();
-    }
-    get page() {
-        return this._page;
-    }
-    set sortKey(value) {
-        this._sortKey = value;
-        this.get();
-    }
-    get sortKey() {
-        return this._sortKey;
-    }
-    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 }));
-    }
-    get isLoading$() {
-        return this._isLoading$.asObservable();
-    }
-    constructor(injector) {
-        this._filter = '';
-        this._maxResultCount = 10;
-        this._skipCount = 0;
-        this._page = 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();
-    }
-    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$));
-    }
-    ngOnDestroy() {
-        this.destroy$.next();
-    }
-    resetPageWhenUnchanged() {
-        const skipCount = this._page * this._maxResultCount;
-        if (skipCount === this._skipCount) {
-            this._page = 0;
-            this._skipCount = 0;
-        }
-        else
-            this._skipCount = skipCount;
+class RoutesHandler {
+    constructor(routes, router) {
+        this.routes = routes;
+        this.router = router;
+        this.addRoutes();
     }
-    next() {
-        this._query$.next({
-            filter: this._filter || undefined,
-            maxResultCount: this._maxResultCount,
-            skipCount: this._page * this._maxResultCount,
-            sorting: this._sortOrder ? `${this._sortKey} ${this._sortOrder}` : undefined,
+    addRoutes() {
+        this.router?.config?.forEach(({ path = '', data }) => {
+            const routes = data?.routes;
+            if (!routes)
+                return;
+            if (Array.isArray(routes)) {
+                this.routes.add(routes);
+            }
+            else {
+                const routesFlatten = flatRoutes([{ path, ...routes }], { path: '' });
+                this.routes.add(routesFlatten);
+            }
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ListService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ListService }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesHandler, deps: [{ token: RoutesService }, { token: i1$1.Router, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesHandler, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RoutesHandler, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: RoutesService }, { type: i1$1.Router, decorators: [{
+                    type: Optional
+                }] }]; } });
+function flatRoutes(routes, parent) {
+    if (!routes)
+        return [];
+    return routes.reduce((acc, route) => {
+        const { children, ...current } = {
+            ...route,
+            parentName: parent.name,
+            path: (parent.path + '/' + route.path).replace(/\/\//g, '/'),
+        };
+        acc.push(current, ...flatRoutes(children, current));
+        return acc;
+    }, []);
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ListService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
-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();
-    }
-    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);
-        });
-    }
-    getLoading() {
-        return this.store.state.loading;
-    }
-    getLoading$() {
-        return this.store.sliceState(({ loading }) => loading);
-    }
-    updateLoading$() {
-        return this.store.sliceUpdate(({ loading }) => loading);
+class LocalizationPipe {
+    constructor(localization) {
+        this.localization = localization;
     }
-    setLoading(loading) {
-        this.store.patch({ loading });
+    transform(value = '', ...interpolateParams) {
+        const params = interpolateParams.reduce((acc, val) => {
+            if (!acc) {
+                return val;
+            }
+            if (!val) {
+                return acc;
+            }
+            return Array.isArray(val) ? [...acc, ...val] : [...acc, val];
+        }, []) || [];
+        return this.localization.instant(value, ...params);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RouterWaitService, deps: [{ token: RouterEvents }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RouterWaitService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationPipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.0.6", ngImport: i0, type: LocalizationPipe, name: "abpLocalization" }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationPipe }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: RouterWaitService, decorators: [{
-            type: Injectable,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationPipe, decorators: [{
+            type: Injectable
+        }, {
+            type: Pipe,
             args: [{
-                    providedIn: 'root',
+                    name: 'abpLocalization',
                 }]
-        }], ctorParameters: function () { return [{ type: RouterEvents }, { type: i0.Injector }]; } });
+        }], ctorParameters: function () { return [{ type: LocalizationService }]; } });
 
-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;
+class LocalizationModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.6", ngImport: i0, type: LocalizationModule, declarations: [LocalizationPipe], exports: [LocalizationPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: LocalizationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [LocalizationPipe],
+                    declarations: [LocalizationPipe],
+                }]
+        }] });
+
+class SortPipe {
+    transform(value, sortOrder = 'asc', sortKey) {
+        sortOrder = sortOrder && sortOrder.toLowerCase();
+        if (!value || (sortOrder !== 'asc' && sortOrder !== 'desc'))
+            return value;
+        let numberArray = [];
+        let stringArray = [];
+        if (!sortKey) {
+            numberArray = value.filter(item => typeof item === 'number').sort();
+            stringArray = value.filter(item => typeof item === 'string').sort();
+        }
+        else {
+            numberArray = value
+                .filter(item => typeof item[sortKey] === 'number')
+                .sort((a, b) => a[sortKey] - b[sortKey]);
+            stringArray = value
+                .filter(item => typeof item[sortKey] === 'string')
+                .sort((a, b) => {
+                if (a[sortKey] < b[sortKey])
+                    return -1;
+                else if (a[sortKey] > b[sortKey])
+                    return 1;
+                else
+                    return 0;
+            });
+        }
+        const sorted = [
+            ...numberArray,
+            ...stringArray,
+            ...value.filter(item => typeof (sortKey ? item[sortKey] : item) !== 'number' &&
+                typeof (sortKey ? item[sortKey] : item) !== 'string'),
+        ];
+        return sortOrder === 'asc' ? sorted : sorted.reverse();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: TrackByService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: TrackByService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: SortPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.0.6", ngImport: i0, type: SortPipe, name: "abpSort" }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: SortPipe }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: TrackByService, decorators: [{
-            type: Injectable,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: SortPipe, decorators: [{
+            type: Injectable
+        }, {
+            type: Pipe,
             args: [{
-                    providedIn: 'root',
+                    name: 'abpSort',
                 }]
         }] });
 
-class AbpWindowService {
-    constructor() {
-        this.window = inject(DOCUMENT).defaultView;
-        this.navigator = this.window.navigator;
+const INJECTOR_PIPE_DATA_TOKEN = new InjectionToken('INJECTOR_PIPE_DATA_TOKEN');
+class ToInjectorPipe {
+    constructor(injector) {
+        this.injector = injector;
     }
-    copyToClipboard(text) {
-        return this.navigator.clipboard.writeText(text);
+    transform(value, token = INJECTOR_PIPE_DATA_TOKEN, name = 'ToInjectorPipe') {
+        return Injector.create({
+            providers: [
+                {
+                    provide: token,
+                    useValue: value,
+                },
+            ],
+            parent: this.injector,
+            name,
+        });
     }
-    open(url, target, features) {
-        return this.window.open(url, target, features);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ToInjectorPipe, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.0.6", ngImport: i0, type: ToInjectorPipe, name: "toInjector" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: ToInjectorPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'toInjector',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+
+function setLanguageToCookie(injector) {
+    return () => {
+        const sessionState = injector.get(SessionStateService);
+        const document = injector.get(DOCUMENT);
+        const cookieLanguageKey = injector.get(COOKIE_LANGUAGE_KEY);
+        sessionState.getLanguage$().subscribe(language => {
+            const cookieValue = encodeURIComponent(`c=${language}|uic=${language}`);
+            document.cookie = `${cookieLanguageKey}=${cookieValue}`;
+        });
+    };
+}
+const CookieLanguageProvider = {
+    provide: APP_INITIALIZER,
+    useFactory: setLanguageToCookie,
+    deps: [Injector],
+    multi: true,
+};
+
+class LocaleId extends String {
+    constructor(localizationService) {
+        super();
+        this.localizationService = localizationService;
     }
-    reloadPage() {
-        this.window.location.reload();
+    toString() {
+        const { currentLang } = this.localizationService;
+        if (checkHasProp(differentLocales, currentLang)) {
+            return differentLocales[currentLang];
+        }
+        return currentLang;
+    }
+    valueOf() {
+        return this.toString();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpWindowService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpWindowService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImport: i0, type: AbpWindowService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
+const LocaleProvider = {
+    provide: LOCALE_ID,
+    useClass: LocaleId,
+    deps: [LocalizationService],
+};
+
+Date.prototype.toLocalISOString = function () {
+    const timezoneOffset = this.getTimezoneOffset();
+    return new Date(this.getTime() - timezoneOffset * 60000).toISOString();
+};
 
 class ShortDateTimePipe extends DatePipe {
     constructor(configStateService, locale, defaultTimezone) {
@@ -3797,6 +3860,10 @@ class CoreModule {
                     useValue: localizationContributor(options.localizations),
                     deps: [LocalizationService],
                 },
+                {
+                    provide: SORT_COMPARE_FUNC,
+                    useFactory: compareFuncFactory
+                },
                 {
                     provide: QUEUE_MANAGER,
                     useClass: DefaultQueueManager,
@@ -4530,5 +4597,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { APP_INIT_ERROR_HANDLERS, AbpApiDefinitionService, AbpApplicationConfigurationService, AbpApplicationLocalizationService, AbpLocalStorageService, AbpTenantService, AbpValidators, AbpWindowService, AbstractNavTreeService, AbstractNgModelComponent, AbstractTreeService, ApiInterceptor, AuditedEntityDto, AuditedEntityWithUserDto, AuthGuard, AuthService, 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, 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, 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, SafeHtmlPipe, ScriptContentStrategy, ScriptLoadingStrategy, SessionStateService, ShortDatePipe, ShortDateTimePipe, ShortTimePipe, ShowPasswordDirective, SortPipe, StopPropagationDirective, StyleContentStrategy, StyleLoadingStrategy, SubscriptionService, TENANT_KEY, TemplateContextStrategy, TemplateProjectionStrategy, ToInjectorPipe, TrackByService, TrackCapsLockDirective, WebHttpUrlEncodingCodec, checkHasProp, 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, pushValueTo, reloadRoute, trackBy, trackByDeep, uuid, validateCreditCard, validateMinAge, validateRange, validateRequired, validateStringLength, validateUniqueCharacter, validateUrl };
+export { APP_INIT_ERROR_HANDLERS, AbpApiDefinitionService, AbpApplicationConfigurationService, AbpApplicationLocalizationService, AbpLocalStorageService, AbpTenantService, AbpValidators, AbpWindowService, AbstractNavTreeService, AbstractNgModelComponent, AbstractTreeService, ApiInterceptor, AuditedEntityDto, AuditedEntityWithUserDto, AuthGuard, AuthService, 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, 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, SafeHtmlPipe, ScriptContentStrategy, ScriptLoadingStrategy, SessionStateService, ShortDatePipe, ShortDateTimePipe, ShortTimePipe, ShowPasswordDirective, SortPipe, StopPropagationDirective, StyleContentStrategy, StyleLoadingStrategy, SubscriptionService, TENANT_KEY, TemplateContextStrategy, TemplateProjectionStrategy, ToInjectorPipe, TrackByService, TrackCapsLockDirective, WebHttpUrlEncodingCodec, checkHasProp, 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, pushValueTo, reloadRoute, trackBy, trackByDeep, uuid, validateCreditCard, validateMinAge, validateRange, validateRequired, validateStringLength, validateUniqueCharacter, validateUrl };
 //# sourceMappingURL=abp-ng.core.mjs.map