import * as i0 from '@angular/core';
import { Pipe, NgModule } from '@angular/core';
import { isNil, declinationOfNumber, checkValueIsEmpty, isNotNil, isTrue, checkValueIsFilled } from '@angular-ru/cdk/utils';
import { coerceBoolean } from '@angular-ru/cdk/coercion';
import { dateStringToDate } from '@angular-ru/cdk/date';
import { getValueByPath, isObject, isSimpleObject, isIterable } from '@angular-ru/cdk/object';
import { takeSecondItem, takeThirdItem, uniqueArrayOf, takeFirstItem, hasAtMostOneItem, hasItems, hasManyItems, hasNoItems, hasOneItem } from '@angular-ru/cdk/array';
import { isString, toStringValue } from '@angular-ru/cdk/string';
import { DatePipe } from '@angular/common';
import { isFunctionLike } from '@angular-ru/cdk/function';
import * as i1 from '@angular/platform-browser';
import { isRegexpStr, ensureRegexp } from '@angular-ru/cdk/regexp';
import { numberFormat, toNumber } from '@angular-ru/cdk/number';

class AtPipe {
    transform(array, index) {
        if (isNil(array)) {
            return undefined;
        }
        let limitedIndex = index;
        limitedIndex = Math.trunc(limitedIndex) || 0;
        if (limitedIndex < 0) {
            limitedIndex += array.length;
        }
        if (limitedIndex < 0 || limitedIndex >= array.length) {
            return undefined;
        }
        return array[limitedIndex];
    }
}
/** @nocollapse */ AtPipe.ɵfac = function AtPipe_Factory(t) { return new (t || AtPipe)(); };
/** @nocollapse */ AtPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "at", type: AtPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AtPipe, [{
        type: Pipe,
        args: [{ name: 'at' }]
    }], null, null); })();

class AtPipeModule {
}
/** @nocollapse */ AtPipeModule.ɵfac = function AtPipeModule_Factory(t) { return new (t || AtPipeModule)(); };
/** @nocollapse */ AtPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: AtPipeModule });
/** @nocollapse */ AtPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [AtPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AtPipeModule, [{
        type: NgModule,
        args: [{
                declarations: [AtPipe],
                providers: [AtPipe],
                exports: [AtPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(AtPipeModule, { declarations: [AtPipe], exports: [AtPipe] }); })();

class BracePipe {
    transform(value) {
        return `(${value})`;
    }
}
/** @nocollapse */ BracePipe.ɵfac = function BracePipe_Factory(t) { return new (t || BracePipe)(); };
/** @nocollapse */ BracePipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "brace", type: BracePipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BracePipe, [{
        type: Pipe,
        args: [{ name: 'brace' }]
    }], null, null); })();

class BracePipeModule {
}
/** @nocollapse */ BracePipeModule.ɵfac = function BracePipeModule_Factory(t) { return new (t || BracePipeModule)(); };
/** @nocollapse */ BracePipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: BracePipeModule });
/** @nocollapse */ BracePipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [BracePipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BracePipeModule, [{
        type: NgModule,
        args: [{
                exports: [BracePipe],
                providers: [BracePipe],
                declarations: [BracePipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(BracePipeModule, { declarations: [BracePipe], exports: [BracePipe] }); })();

class CoerceBooleanPipe {
    transform(value) {
        return coerceBoolean(value);
    }
}
/** @nocollapse */ CoerceBooleanPipe.ɵfac = function CoerceBooleanPipe_Factory(t) { return new (t || CoerceBooleanPipe)(); };
/** @nocollapse */ CoerceBooleanPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "coerceBoolean", type: CoerceBooleanPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CoerceBooleanPipe, [{
        type: Pipe,
        args: [{ name: 'coerceBoolean' }]
    }], null, null); })();

class CoerceBooleanPipeModule {
}
/** @nocollapse */ CoerceBooleanPipeModule.ɵfac = function CoerceBooleanPipeModule_Factory(t) { return new (t || CoerceBooleanPipeModule)(); };
/** @nocollapse */ CoerceBooleanPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: CoerceBooleanPipeModule });
/** @nocollapse */ CoerceBooleanPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [CoerceBooleanPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CoerceBooleanPipeModule, [{
        type: NgModule,
        args: [{
                exports: [CoerceBooleanPipe],
                providers: [CoerceBooleanPipe],
                declarations: [CoerceBooleanPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CoerceBooleanPipeModule, { declarations: [CoerceBooleanPipe], exports: [CoerceBooleanPipe] }); })();

class DateToNativePipe {
    transform(value) {
        return dateStringToDate(value);
    }
}
/** @nocollapse */ DateToNativePipe.ɵfac = function DateToNativePipe_Factory(t) { return new (t || DateToNativePipe)(); };
/** @nocollapse */ DateToNativePipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "dateNative", type: DateToNativePipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DateToNativePipe, [{
        type: Pipe,
        args: [{ name: 'dateNative' }]
    }], null, null); })();

class DateToNativePipeModule {
}
/** @nocollapse */ DateToNativePipeModule.ɵfac = function DateToNativePipeModule_Factory(t) { return new (t || DateToNativePipeModule)(); };
/** @nocollapse */ DateToNativePipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: DateToNativePipeModule });
/** @nocollapse */ DateToNativePipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [DateToNativePipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DateToNativePipeModule, [{
        type: NgModule,
        args: [{
                exports: [DateToNativePipe],
                providers: [DateToNativePipe],
                declarations: [DateToNativePipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DateToNativePipeModule, { declarations: [DateToNativePipe], exports: [DateToNativePipe] }); })();

class DeclinationOfNumberPipe {
    transform(numberValue, dictionary) {
        return declinationOfNumber(numberValue, dictionary);
    }
}
/** @nocollapse */ DeclinationOfNumberPipe.ɵfac = function DeclinationOfNumberPipe_Factory(t) { return new (t || DeclinationOfNumberPipe)(); };
/** @nocollapse */ DeclinationOfNumberPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "declinationOfNumber", type: DeclinationOfNumberPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DeclinationOfNumberPipe, [{
        type: Pipe,
        args: [{ name: 'declinationOfNumber' }]
    }], null, null); })();

class DeclinationOfNumberPipeModule {
}
/** @nocollapse */ DeclinationOfNumberPipeModule.ɵfac = function DeclinationOfNumberPipeModule_Factory(t) { return new (t || DeclinationOfNumberPipeModule)(); };
/** @nocollapse */ DeclinationOfNumberPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: DeclinationOfNumberPipeModule });
/** @nocollapse */ DeclinationOfNumberPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [DeclinationOfNumberPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DeclinationOfNumberPipeModule, [{
        type: NgModule,
        args: [{
                exports: [DeclinationOfNumberPipe],
                providers: [DeclinationOfNumberPipe],
                declarations: [DeclinationOfNumberPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DeclinationOfNumberPipeModule, { declarations: [DeclinationOfNumberPipe], exports: [DeclinationOfNumberPipe] }); })();

class DeepPathPipe {
    transform(item, path, fallback = '') {
        const result = getValueByPath(item, path);
        return checkValueIsEmpty(result) ? fallback ?? '' : result;
    }
}
/** @nocollapse */ DeepPathPipe.ɵfac = function DeepPathPipe_Factory(t) { return new (t || DeepPathPipe)(); };
/** @nocollapse */ DeepPathPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "deepPath", type: DeepPathPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DeepPathPipe, [{
        type: Pipe,
        args: [{ name: 'deepPath' }]
    }], null, null); })();

class DeepPathPipeModule {
}
/** @nocollapse */ DeepPathPipeModule.ɵfac = function DeepPathPipeModule_Factory(t) { return new (t || DeepPathPipeModule)(); };
/** @nocollapse */ DeepPathPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: DeepPathPipeModule });
/** @nocollapse */ DeepPathPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [DeepPathPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DeepPathPipeModule, [{
        type: NgModule,
        args: [{
                exports: [DeepPathPipe],
                providers: [DeepPathPipe],
                declarations: [DeepPathPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DeepPathPipeModule, { declarations: [DeepPathPipe], exports: [DeepPathPipe] }); })();

class DefaultValuePipe {
    transform(item, fallback = '-') {
        return checkValueIsEmpty(item) ? fallback : item;
    }
}
/** @nocollapse */ DefaultValuePipe.ɵfac = function DefaultValuePipe_Factory(t) { return new (t || DefaultValuePipe)(); };
/** @nocollapse */ DefaultValuePipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "defaultValue", type: DefaultValuePipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DefaultValuePipe, [{
        type: Pipe,
        args: [{ name: 'defaultValue' }]
    }], null, null); })();

class DefaultValuePipeModule {
}
/** @nocollapse */ DefaultValuePipeModule.ɵfac = function DefaultValuePipeModule_Factory(t) { return new (t || DefaultValuePipeModule)(); };
/** @nocollapse */ DefaultValuePipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: DefaultValuePipeModule });
/** @nocollapse */ DefaultValuePipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [DefaultValuePipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DefaultValuePipeModule, [{
        type: NgModule,
        args: [{
                exports: [DefaultValuePipe],
                providers: [DefaultValuePipe],
                declarations: [DefaultValuePipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DefaultValuePipeModule, { declarations: [DefaultValuePipe], exports: [DefaultValuePipe] }); })();

class DetectBrowserPipe {
    static getBrowserMatchers(userAgent) {
        const ua = userAgent ?? navigator.userAgent;
        return ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) ?? [];
    }
    static ensureInternetExplorer(ua) {
        const matcher = /\brv[ :]+(\d+)/g.exec(ua) || [];
        return `IE ${takeSecondItem(matcher)}` ?? '';
    }
    static ensureChrome(ua) {
        return ua
            .match(/\b(OPR|Edge?)\/(\d+)/)
            .slice(1)
            .join(' ')
            .replace('OPR', 'Opera')
            .replace('Edg ', 'Edge ');
    }
    static ensureOtherBrowser(matchers, ua) {
        const matcher = ua.match(/version\/(\d+)/i);
        const otherMatchers = isNotNil(takeThirdItem(matchers))
            ? [takeSecondItem(matchers), takeThirdItem(matchers)]
            : // TODO: need refactor deprecated method
                // eslint-disable-next-line deprecation/deprecation
                [navigator.appName, navigator.appVersion, '-?'];
        if (matcher !== null) {
            otherMatchers?.splice(1, 1, takeSecondItem(matcher));
        }
        return otherMatchers?.join(' ') ?? '';
    }
    transform(userAgent, options) {
        let browser;
        const ua = userAgent ?? navigator.userAgent;
        const matchers = DetectBrowserPipe.getBrowserMatchers(ua);
        if (/trident/i.test(takeSecondItem(matchers))) {
            browser = DetectBrowserPipe.ensureInternetExplorer(ua);
        }
        else if (takeSecondItem(matchers) === 'Chrome' && ua.match(/\b(OPR|Edge?)\/(\d+)/) !== null) {
            browser = DetectBrowserPipe.ensureChrome(ua);
        }
        else {
            browser = DetectBrowserPipe.ensureOtherBrowser(matchers, ua);
        }
        return isTrue(options?.kebabCase)
            ? browser?.toLowerCase().replace(/\d+/, '').trim().replace(/\s/, '-')
            : browser;
    }
}
/** @nocollapse */ DetectBrowserPipe.ɵfac = function DetectBrowserPipe_Factory(t) { return new (t || DetectBrowserPipe)(); };
/** @nocollapse */ DetectBrowserPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "detectBrowser", type: DetectBrowserPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DetectBrowserPipe, [{
        type: Pipe,
        args: [{ name: 'detectBrowser' }]
    }], null, null); })();

class DetectBrowserPipeModule {
}
/** @nocollapse */ DetectBrowserPipeModule.ɵfac = function DetectBrowserPipeModule_Factory(t) { return new (t || DetectBrowserPipeModule)(); };
/** @nocollapse */ DetectBrowserPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: DetectBrowserPipeModule });
/** @nocollapse */ DetectBrowserPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [DetectBrowserPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DetectBrowserPipeModule, [{
        type: NgModule,
        args: [{
                exports: [DetectBrowserPipe],
                providers: [DetectBrowserPipe],
                declarations: [DetectBrowserPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DetectBrowserPipeModule, { declarations: [DetectBrowserPipe], exports: [DetectBrowserPipe] }); })();

class DisplayItemPipe {
    static invalidDisplayKey(displayKey) {
        return Boolean(checkValueIsEmpty(displayKey)) || typeof displayKey !== 'string';
    }
    static parseObject(item, displayKey) {
        if (DisplayItemPipe.invalidDisplayKey(displayKey)) {
            throw new Error('attribute "displayKey" can not be empty if input item has "object" type');
        }
        const value = getValueByPath(item, displayKey) ?? '';
        return Array.isArray(value) ? '' : value;
    }
    static parseNotObject(item) {
        return isString(item) ? item : '';
    }
    transform(item, displayKey) {
        return Boolean(isObject(item)) && !Array.isArray(item)
            ? DisplayItemPipe.parseObject(item, displayKey)
            : DisplayItemPipe.parseNotObject(item);
    }
}
/** @nocollapse */ DisplayItemPipe.ɵfac = function DisplayItemPipe_Factory(t) { return new (t || DisplayItemPipe)(); };
/** @nocollapse */ DisplayItemPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "displayItem", type: DisplayItemPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DisplayItemPipe, [{
        type: Pipe,
        args: [{ name: 'displayItem' }]
    }], null, null); })();

class DisplayItemPipeModule {
}
/** @nocollapse */ DisplayItemPipeModule.ɵfac = function DisplayItemPipeModule_Factory(t) { return new (t || DisplayItemPipeModule)(); };
/** @nocollapse */ DisplayItemPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: DisplayItemPipeModule });
/** @nocollapse */ DisplayItemPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [DisplayItemPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DisplayItemPipeModule, [{
        type: NgModule,
        args: [{
                exports: [DisplayItemPipe],
                providers: [DisplayItemPipe],
                declarations: [DisplayItemPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DisplayItemPipeModule, { declarations: [DisplayItemPipe], exports: [DisplayItemPipe] }); })();

class EntrySingleSetPipe {
    transform(key, listKeys) {
        return isTrue(listKeys?.has(key));
    }
}
/** @nocollapse */ EntrySingleSetPipe.ɵfac = function EntrySingleSetPipe_Factory(t) { return new (t || EntrySingleSetPipe)(); };
/** @nocollapse */ EntrySingleSetPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "entrySingleSet", type: EntrySingleSetPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EntrySingleSetPipe, [{
        type: Pipe,
        args: [{ name: 'entrySingleSet' }]
    }], null, null); })();

class EntrySingleSetPipeModule {
}
/** @nocollapse */ EntrySingleSetPipeModule.ɵfac = function EntrySingleSetPipeModule_Factory(t) { return new (t || EntrySingleSetPipeModule)(); };
/** @nocollapse */ EntrySingleSetPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: EntrySingleSetPipeModule });
/** @nocollapse */ EntrySingleSetPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [EntrySingleSetPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EntrySingleSetPipeModule, [{
        type: NgModule,
        args: [{
                exports: [EntrySingleSetPipe],
                providers: [EntrySingleSetPipe],
                declarations: [EntrySingleSetPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(EntrySingleSetPipeModule, { declarations: [EntrySingleSetPipe], exports: [EntrySingleSetPipe] }); })();

class FileSizePipe {
    constructor() {
        this.units = ['bytes', 'Kb', 'Mb', 'Gb', 'Tb', 'Pb'];
        this.commonPrecision = 2;
        this.byteSize = 1024;
    }
    transform(bytes = 0, precision = this.commonPrecision) {
        let result;
        let calculatedBytes = bytes;
        if (isNaN(parseFloat(String(calculatedBytes))) || !isFinite(calculatedBytes)) {
            result = '?';
        }
        else {
            let unit = 0;
            while (calculatedBytes >= this.byteSize) {
                calculatedBytes /= this.byteSize;
                unit++;
            }
            result = `${calculatedBytes.toFixed(Number(precision))} ${this.units[unit]}`;
        }
        return result;
    }
}
/** @nocollapse */ FileSizePipe.ɵfac = function FileSizePipe_Factory(t) { return new (t || FileSizePipe)(); };
/** @nocollapse */ FileSizePipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "fileSize", type: FileSizePipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FileSizePipe, [{
        type: Pipe,
        args: [{ name: 'fileSize' }]
    }], null, null); })();

class FileSizePipeModule {
}
/** @nocollapse */ FileSizePipeModule.ɵfac = function FileSizePipeModule_Factory(t) { return new (t || FileSizePipeModule)(); };
/** @nocollapse */ FileSizePipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: FileSizePipeModule });
/** @nocollapse */ FileSizePipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [FileSizePipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FileSizePipeModule, [{
        type: NgModule,
        args: [{
                exports: [FileSizePipe],
                providers: [FileSizePipe],
                declarations: [FileSizePipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(FileSizePipeModule, { declarations: [FileSizePipe], exports: [FileSizePipe] }); })();

class FilterUniquePipe {
    transform(values, path = '') {
        return uniqueArrayOf(values, path);
    }
}
/** @nocollapse */ FilterUniquePipe.ɵfac = function FilterUniquePipe_Factory(t) { return new (t || FilterUniquePipe)(); };
/** @nocollapse */ FilterUniquePipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "filterUnique", type: FilterUniquePipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FilterUniquePipe, [{
        type: Pipe,
        args: [{ name: 'filterUnique' }]
    }], null, null); })();

class FilterUniquePipeModule {
}
/** @nocollapse */ FilterUniquePipeModule.ɵfac = function FilterUniquePipeModule_Factory(t) { return new (t || FilterUniquePipeModule)(); };
/** @nocollapse */ FilterUniquePipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: FilterUniquePipeModule });
/** @nocollapse */ FilterUniquePipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [FilterUniquePipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FilterUniquePipeModule, [{
        type: NgModule,
        args: [{
                exports: [FilterUniquePipe],
                providers: [FilterUniquePipe],
                declarations: [FilterUniquePipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(FilterUniquePipeModule, { declarations: [FilterUniquePipe], exports: [FilterUniquePipe] }); })();

class FormatDatePipe {
    transform(value, options) {
        let result = value;
        if (isString(result)) {
            result = takeFirstItem(result.split('+')) ?? '';
        }
        return (new DatePipe(options?.locale ?? 'en-US').transform(result, options?.dateFormat ?? 'dd.MM.yyyy', options?.timezone) ?? '');
    }
}
/** @nocollapse */ FormatDatePipe.ɵfac = function FormatDatePipe_Factory(t) { return new (t || FormatDatePipe)(); };
/** @nocollapse */ FormatDatePipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "formatDate", type: FormatDatePipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormatDatePipe, [{
        type: Pipe,
        args: [{ name: 'formatDate' }]
    }], null, null); })();

class FormatDatePipeModule {
}
/** @nocollapse */ FormatDatePipeModule.ɵfac = function FormatDatePipeModule_Factory(t) { return new (t || FormatDatePipeModule)(); };
/** @nocollapse */ FormatDatePipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: FormatDatePipeModule });
/** @nocollapse */ FormatDatePipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [FormatDatePipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormatDatePipeModule, [{
        type: NgModule,
        args: [{
                exports: [FormatDatePipe],
                providers: [FormatDatePipe],
                declarations: [FormatDatePipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(FormatDatePipeModule, { declarations: [FormatDatePipe], exports: [FormatDatePipe] }); })();

class HasPipe {
    transform(set, entry) {
        return set?.has(entry) ?? false;
    }
}
/** @nocollapse */ HasPipe.ɵfac = function HasPipe_Factory(t) { return new (t || HasPipe)(); };
/** @nocollapse */ HasPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "has", type: HasPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasPipe, [{
        type: Pipe,
        args: [{
                name: 'has'
            }]
    }], null, null); })();

class HasPipeModule {
}
/** @nocollapse */ HasPipeModule.ɵfac = function HasPipeModule_Factory(t) { return new (t || HasPipeModule)(); };
/** @nocollapse */ HasPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: HasPipeModule });
/** @nocollapse */ HasPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [HasPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasPipeModule, [{
        type: NgModule,
        args: [{
                declarations: [HasPipe],
                providers: [HasPipe],
                exports: [HasPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(HasPipeModule, { declarations: [HasPipe], exports: [HasPipe] }); })();

class HasAtMostOneItemPipe {
    transform(array) {
        return hasAtMostOneItem(array);
    }
}
/** @nocollapse */ HasAtMostOneItemPipe.ɵfac = function HasAtMostOneItemPipe_Factory(t) { return new (t || HasAtMostOneItemPipe)(); };
/** @nocollapse */ HasAtMostOneItemPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "hasAtMostOneItem", type: HasAtMostOneItemPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasAtMostOneItemPipe, [{
        type: Pipe,
        args: [{ name: 'hasAtMostOneItem' }]
    }], null, null); })();

class HasAtMostOneItemPipeModule {
}
/** @nocollapse */ HasAtMostOneItemPipeModule.ɵfac = function HasAtMostOneItemPipeModule_Factory(t) { return new (t || HasAtMostOneItemPipeModule)(); };
/** @nocollapse */ HasAtMostOneItemPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: HasAtMostOneItemPipeModule });
/** @nocollapse */ HasAtMostOneItemPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [HasAtMostOneItemPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasAtMostOneItemPipeModule, [{
        type: NgModule,
        args: [{
                declarations: [HasAtMostOneItemPipe],
                providers: [HasAtMostOneItemPipe],
                exports: [HasAtMostOneItemPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(HasAtMostOneItemPipeModule, { declarations: [HasAtMostOneItemPipe], exports: [HasAtMostOneItemPipe] }); })();

class HasItemsPipe {
    transform(array) {
        return hasItems(array);
    }
}
/** @nocollapse */ HasItemsPipe.ɵfac = function HasItemsPipe_Factory(t) { return new (t || HasItemsPipe)(); };
/** @nocollapse */ HasItemsPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "hasItems", type: HasItemsPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasItemsPipe, [{
        type: Pipe,
        args: [{ name: 'hasItems' }]
    }], null, null); })();

class HasItemsPipeModule {
}
/** @nocollapse */ HasItemsPipeModule.ɵfac = function HasItemsPipeModule_Factory(t) { return new (t || HasItemsPipeModule)(); };
/** @nocollapse */ HasItemsPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: HasItemsPipeModule });
/** @nocollapse */ HasItemsPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [HasItemsPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasItemsPipeModule, [{
        type: NgModule,
        args: [{
                declarations: [HasItemsPipe],
                providers: [HasItemsPipe],
                exports: [HasItemsPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(HasItemsPipeModule, { declarations: [HasItemsPipe], exports: [HasItemsPipe] }); })();

class HasManyItemsPipe {
    transform(array) {
        return hasManyItems(array);
    }
}
/** @nocollapse */ HasManyItemsPipe.ɵfac = function HasManyItemsPipe_Factory(t) { return new (t || HasManyItemsPipe)(); };
/** @nocollapse */ HasManyItemsPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "hasManyItems", type: HasManyItemsPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasManyItemsPipe, [{
        type: Pipe,
        args: [{ name: 'hasManyItems' }]
    }], null, null); })();

class HasManyItemsPipeModule {
}
/** @nocollapse */ HasManyItemsPipeModule.ɵfac = function HasManyItemsPipeModule_Factory(t) { return new (t || HasManyItemsPipeModule)(); };
/** @nocollapse */ HasManyItemsPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: HasManyItemsPipeModule });
/** @nocollapse */ HasManyItemsPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [HasManyItemsPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasManyItemsPipeModule, [{
        type: NgModule,
        args: [{
                declarations: [HasManyItemsPipe],
                providers: [HasManyItemsPipe],
                exports: [HasManyItemsPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(HasManyItemsPipeModule, { declarations: [HasManyItemsPipe], exports: [HasManyItemsPipe] }); })();

class HasNoItemsPipe {
    transform(array) {
        return hasNoItems(array);
    }
}
/** @nocollapse */ HasNoItemsPipe.ɵfac = function HasNoItemsPipe_Factory(t) { return new (t || HasNoItemsPipe)(); };
/** @nocollapse */ HasNoItemsPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "hasNoItems", type: HasNoItemsPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasNoItemsPipe, [{
        type: Pipe,
        args: [{ name: 'hasNoItems' }]
    }], null, null); })();

class HasNoItemsPipeModule {
}
/** @nocollapse */ HasNoItemsPipeModule.ɵfac = function HasNoItemsPipeModule_Factory(t) { return new (t || HasNoItemsPipeModule)(); };
/** @nocollapse */ HasNoItemsPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: HasNoItemsPipeModule });
/** @nocollapse */ HasNoItemsPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [HasNoItemsPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasNoItemsPipeModule, [{
        type: NgModule,
        args: [{
                declarations: [HasNoItemsPipe],
                providers: [HasNoItemsPipe],
                exports: [HasNoItemsPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(HasNoItemsPipeModule, { declarations: [HasNoItemsPipe], exports: [HasNoItemsPipe] }); })();

class HasOneItemPipe {
    transform(array) {
        return hasOneItem(array);
    }
}
/** @nocollapse */ HasOneItemPipe.ɵfac = function HasOneItemPipe_Factory(t) { return new (t || HasOneItemPipe)(); };
/** @nocollapse */ HasOneItemPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "hasOneItem", type: HasOneItemPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasOneItemPipe, [{
        type: Pipe,
        args: [{ name: 'hasOneItem' }]
    }], null, null); })();

class HasOneItemPipeModule {
}
/** @nocollapse */ HasOneItemPipeModule.ɵfac = function HasOneItemPipeModule_Factory(t) { return new (t || HasOneItemPipeModule)(); };
/** @nocollapse */ HasOneItemPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: HasOneItemPipeModule });
/** @nocollapse */ HasOneItemPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [HasOneItemPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HasOneItemPipeModule, [{
        type: NgModule,
        args: [{
                declarations: [HasOneItemPipe],
                providers: [HasOneItemPipe],
                exports: [HasOneItemPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(HasOneItemPipeModule, { declarations: [HasOneItemPipe], exports: [HasOneItemPipe] }); })();

class HttpReplacerPipe {
    transform(value) {
        let result = value;
        if (isString(result)) {
            result = result
                ?.replace(/^(http|https):\/\//, '')
                .replace(/\/$/, '')
                .replace('www.', '')
                .replace('/index.php', '')
                .toLocaleLowerCase();
        }
        return result ?? '';
    }
}
/** @nocollapse */ HttpReplacerPipe.ɵfac = function HttpReplacerPipe_Factory(t) { return new (t || HttpReplacerPipe)(); };
/** @nocollapse */ HttpReplacerPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "httpReplacer", type: HttpReplacerPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpReplacerPipe, [{
        type: Pipe,
        args: [{ name: 'httpReplacer' }]
    }], null, null); })();

class HttpReplacerPipeModule {
}
/** @nocollapse */ HttpReplacerPipeModule.ɵfac = function HttpReplacerPipeModule_Factory(t) { return new (t || HttpReplacerPipeModule)(); };
/** @nocollapse */ HttpReplacerPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: HttpReplacerPipeModule });
/** @nocollapse */ HttpReplacerPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [HttpReplacerPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpReplacerPipeModule, [{
        type: NgModule,
        args: [{
                exports: [HttpReplacerPipe],
                providers: [HttpReplacerPipe],
                declarations: [HttpReplacerPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(HttpReplacerPipeModule, { declarations: [HttpReplacerPipe], exports: [HttpReplacerPipe] }); })();

class IncludesPipe {
    transform(array, entry) {
        return array?.includes(entry) ?? false;
    }
}
/** @nocollapse */ IncludesPipe.ɵfac = function IncludesPipe_Factory(t) { return new (t || IncludesPipe)(); };
/** @nocollapse */ IncludesPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "includes", type: IncludesPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IncludesPipe, [{
        type: Pipe,
        args: [{ name: 'includes' }]
    }], null, null); })();

class IncludesPipeModule {
}
/** @nocollapse */ IncludesPipeModule.ɵfac = function IncludesPipeModule_Factory(t) { return new (t || IncludesPipeModule)(); };
/** @nocollapse */ IncludesPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: IncludesPipeModule });
/** @nocollapse */ IncludesPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [IncludesPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IncludesPipeModule, [{
        type: NgModule,
        args: [{
                declarations: [IncludesPipe],
                providers: [IncludesPipe],
                exports: [IncludesPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IncludesPipeModule, { declarations: [IncludesPipe], exports: [IncludesPipe] }); })();

class IsArrayPipe {
    transform(value) {
        return Array.isArray(value);
    }
}
/** @nocollapse */ IsArrayPipe.ɵfac = function IsArrayPipe_Factory(t) { return new (t || IsArrayPipe)(); };
/** @nocollapse */ IsArrayPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "isArray", type: IsArrayPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsArrayPipe, [{
        type: Pipe,
        args: [{ name: 'isArray' }]
    }], null, null); })();

class IsArrayPipeModule {
}
/** @nocollapse */ IsArrayPipeModule.ɵfac = function IsArrayPipeModule_Factory(t) { return new (t || IsArrayPipeModule)(); };
/** @nocollapse */ IsArrayPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: IsArrayPipeModule });
/** @nocollapse */ IsArrayPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [IsArrayPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsArrayPipeModule, [{
        type: NgModule,
        args: [{
                exports: [IsArrayPipe],
                providers: [IsArrayPipe],
                declarations: [IsArrayPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IsArrayPipeModule, { declarations: [IsArrayPipe], exports: [IsArrayPipe] }); })();

class IsFilledPipe {
    constructor() {
        this.transform = checkValueIsFilled;
    }
}
/** @nocollapse */ IsFilledPipe.ɵfac = function IsFilledPipe_Factory(t) { return new (t || IsFilledPipe)(); };
/** @nocollapse */ IsFilledPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "isFilled", type: IsFilledPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsFilledPipe, [{
        type: Pipe,
        args: [{ name: 'isFilled' }]
    }], null, null); })();

class IsFilledPipeModule {
}
/** @nocollapse */ IsFilledPipeModule.ɵfac = function IsFilledPipeModule_Factory(t) { return new (t || IsFilledPipeModule)(); };
/** @nocollapse */ IsFilledPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: IsFilledPipeModule });
/** @nocollapse */ IsFilledPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [IsFilledPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsFilledPipeModule, [{
        type: NgModule,
        args: [{
                declarations: [IsFilledPipe],
                providers: [IsFilledPipe],
                exports: [IsFilledPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IsFilledPipeModule, { declarations: [IsFilledPipe], exports: [IsFilledPipe] }); })();

class IsNilPipe {
    transform(value) {
        return isNil(value);
    }
}
/** @nocollapse */ IsNilPipe.ɵfac = function IsNilPipe_Factory(t) { return new (t || IsNilPipe)(); };
/** @nocollapse */ IsNilPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "isNil", type: IsNilPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsNilPipe, [{
        type: Pipe,
        args: [{ name: 'isNil' }]
    }], null, null); })();

class IsNilPipeModule {
}
/** @nocollapse */ IsNilPipeModule.ɵfac = function IsNilPipeModule_Factory(t) { return new (t || IsNilPipeModule)(); };
/** @nocollapse */ IsNilPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: IsNilPipeModule });
/** @nocollapse */ IsNilPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [IsNilPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsNilPipeModule, [{
        type: NgModule,
        args: [{
                exports: [IsNilPipe],
                providers: [IsNilPipe],
                declarations: [IsNilPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IsNilPipeModule, { declarations: [IsNilPipe], exports: [IsNilPipe] }); })();

class IsNotNullPipe {
    transform(value) {
        return !isNil(value);
    }
}
/** @nocollapse */ IsNotNullPipe.ɵfac = function IsNotNullPipe_Factory(t) { return new (t || IsNotNullPipe)(); };
/** @nocollapse */ IsNotNullPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "isNotNull", type: IsNotNullPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsNotNullPipe, [{
        type: Pipe,
        args: [{ name: 'isNotNull' }]
    }], null, null); })();

class IsNotNullPipeModule {
}
/** @nocollapse */ IsNotNullPipeModule.ɵfac = function IsNotNullPipeModule_Factory(t) { return new (t || IsNotNullPipeModule)(); };
/** @nocollapse */ IsNotNullPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: IsNotNullPipeModule });
/** @nocollapse */ IsNotNullPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [IsNotNullPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsNotNullPipeModule, [{
        type: NgModule,
        args: [{
                exports: [IsNotNullPipe],
                providers: [IsNotNullPipe],
                declarations: [IsNotNullPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IsNotNullPipeModule, { declarations: [IsNotNullPipe], exports: [IsNotNullPipe] }); })();

class IsObjectPipe {
    transform(value) {
        return isSimpleObject(value);
    }
}
/** @nocollapse */ IsObjectPipe.ɵfac = function IsObjectPipe_Factory(t) { return new (t || IsObjectPipe)(); };
/** @nocollapse */ IsObjectPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "isObject", type: IsObjectPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsObjectPipe, [{
        type: Pipe,
        args: [{ name: 'isObject' }]
    }], null, null); })();

class IsObjectPipeModule {
}
/** @nocollapse */ IsObjectPipeModule.ɵfac = function IsObjectPipeModule_Factory(t) { return new (t || IsObjectPipeModule)(); };
/** @nocollapse */ IsObjectPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: IsObjectPipeModule });
/** @nocollapse */ IsObjectPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [IsObjectPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsObjectPipeModule, [{
        type: NgModule,
        args: [{
                exports: [IsObjectPipe],
                providers: [IsObjectPipe],
                declarations: [IsObjectPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IsObjectPipeModule, { declarations: [IsObjectPipe], exports: [IsObjectPipe] }); })();

class IsStringPipe {
    transform(value) {
        return isString(value);
    }
}
/** @nocollapse */ IsStringPipe.ɵfac = function IsStringPipe_Factory(t) { return new (t || IsStringPipe)(); };
/** @nocollapse */ IsStringPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "isString", type: IsStringPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsStringPipe, [{
        type: Pipe,
        args: [{ name: 'isString' }]
    }], null, null); })();

class IsStringPipeModule {
}
/** @nocollapse */ IsStringPipeModule.ɵfac = function IsStringPipeModule_Factory(t) { return new (t || IsStringPipeModule)(); };
/** @nocollapse */ IsStringPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: IsStringPipeModule });
/** @nocollapse */ IsStringPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [IsStringPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsStringPipeModule, [{
        type: NgModule,
        args: [{
                exports: [IsStringPipe],
                providers: [IsStringPipe],
                declarations: [IsStringPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IsStringPipeModule, { declarations: [IsStringPipe], exports: [IsStringPipe] }); })();

class JoinPipe {
    constructor() {
        this.defaultSeparator = ',';
    }
    transform(input, { separator, mapTransformer } = {}) {
        let result = '';
        if (checkValueIsEmpty(input)) {
            return result;
        }
        const currentSeparator = separator ?? this.defaultSeparator;
        if (isFunctionLike(mapTransformer)) {
            // eslint-disable-next-line max-params-no-constructor/max-params-no-constructor
            result = input.reduce((prev, next, index, arr) => {
                const transformed = mapTransformer(next, index, arr);
                const separatorOrEmpty = arr.length - 1 === index ? '' : currentSeparator;
                return prev ? `${prev}${transformed}${separatorOrEmpty}` : `${transformed}${separatorOrEmpty}`;
            }, '');
        }
        else {
            result = input.join(currentSeparator);
        }
        return result;
    }
}
/** @nocollapse */ JoinPipe.ɵfac = function JoinPipe_Factory(t) { return new (t || JoinPipe)(); };
/** @nocollapse */ JoinPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "join", type: JoinPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(JoinPipe, [{
        type: Pipe,
        args: [{ name: 'join' }]
    }], null, null); })();

class JoinPipeModule {
}
/** @nocollapse */ JoinPipeModule.ɵfac = function JoinPipeModule_Factory(t) { return new (t || JoinPipeModule)(); };
/** @nocollapse */ JoinPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: JoinPipeModule });
/** @nocollapse */ JoinPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [JoinPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(JoinPipeModule, [{
        type: NgModule,
        args: [{
                declarations: [JoinPipe],
                providers: [JoinPipe],
                exports: [JoinPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(JoinPipeModule, { declarations: [JoinPipe], exports: [JoinPipe] }); })();

class MarkByFilterPipe {
    constructor(sanitizer) {
        this.sanitizer = sanitizer;
    }
    transform(value, filter, color = '#ffdd2d') {
        return isNotNil(filter) ? this.search(value, filter, color) : value;
    }
    search(value, filter, color) {
        if (isNotNil(value)) {
            const highlighted = this.highLightingString(toStringValue(value), toStringValue(filter), color);
            return this.sanitizer.bypassSecurityTrustHtml(highlighted);
        }
        else {
            return '';
        }
    }
    highLightingString(value, filter, color) {
        try {
            const regexp = isRegexpStr(filter)
                ? new RegExp(ensureRegexp(filter), 'ig')
                : new RegExp(filter, 'i');
            return value
                ?.toString()
                ?.replace(regexp, (founded) => `<span style="background: ${color}">${founded}</span>`);
        }
        catch {
            return value;
        }
    }
}
/** @nocollapse */ MarkByFilterPipe.ɵfac = function MarkByFilterPipe_Factory(t) { return new (t || MarkByFilterPipe)(i0.ɵɵdirectiveInject(i1.DomSanitizer, 16)); };
/** @nocollapse */ MarkByFilterPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "markByFilter", type: MarkByFilterPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MarkByFilterPipe, [{
        type: Pipe,
        args: [{ name: 'markByFilter' }]
    }], function () { return [{ type: i1.DomSanitizer }]; }, null); })();

class MarkByFilterPipeModule {
}
/** @nocollapse */ MarkByFilterPipeModule.ɵfac = function MarkByFilterPipeModule_Factory(t) { return new (t || MarkByFilterPipeModule)(); };
/** @nocollapse */ MarkByFilterPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: MarkByFilterPipeModule });
/** @nocollapse */ MarkByFilterPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [MarkByFilterPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MarkByFilterPipeModule, [{
        type: NgModule,
        args: [{
                exports: [MarkByFilterPipe],
                providers: [MarkByFilterPipe],
                declarations: [MarkByFilterPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(MarkByFilterPipeModule, { declarations: [MarkByFilterPipe], exports: [MarkByFilterPipe] }); })();

class MergeCssClassesPipe {
    transform(...descriptors) {
        return Object.assign({}, ...descriptors.map(this.convertToPlainObject.bind(this)));
    }
    convertToPlainObject(descriptor) {
        if (isNil(descriptor)) {
            return {};
        }
        else if (isString(descriptor)) {
            return this.makePlainObjectOfTrues(descriptor.split(/\s+/));
        }
        else if (isIterable(descriptor)) {
            return this.makePlainObjectOfTrues(Array.from(descriptor));
        }
        return descriptor;
    }
    makePlainObjectOfTrues(array) {
        return array.reduce((object, item) => Object.assign(object, { [item]: true }), {});
    }
}
/** @nocollapse */ MergeCssClassesPipe.ɵfac = function MergeCssClassesPipe_Factory(t) { return new (t || MergeCssClassesPipe)(); };
/** @nocollapse */ MergeCssClassesPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "mergeCssClasses", type: MergeCssClassesPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MergeCssClassesPipe, [{
        type: Pipe,
        args: [{ name: 'mergeCssClasses' }]
    }], null, null); })();

class MergeCssClassesPipeModule {
}
/** @nocollapse */ MergeCssClassesPipeModule.ɵfac = function MergeCssClassesPipeModule_Factory(t) { return new (t || MergeCssClassesPipeModule)(); };
/** @nocollapse */ MergeCssClassesPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: MergeCssClassesPipeModule });
/** @nocollapse */ MergeCssClassesPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [MergeCssClassesPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MergeCssClassesPipeModule, [{
        type: NgModule,
        args: [{
                declarations: [MergeCssClassesPipe],
                exports: [MergeCssClassesPipe],
                providers: [MergeCssClassesPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(MergeCssClassesPipeModule, { declarations: [MergeCssClassesPipe], exports: [MergeCssClassesPipe] }); })();

class MutableTypePipe {
    transform(value) {
        return value;
    }
}
/** @nocollapse */ MutableTypePipe.ɵfac = function MutableTypePipe_Factory(t) { return new (t || MutableTypePipe)(); };
/** @nocollapse */ MutableTypePipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "mutable", type: MutableTypePipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MutableTypePipe, [{
        type: Pipe,
        args: [{ name: 'mutable' }]
    }], null, null); })();

class MutableTypePipeModule {
}
/** @nocollapse */ MutableTypePipeModule.ɵfac = function MutableTypePipeModule_Factory(t) { return new (t || MutableTypePipeModule)(); };
/** @nocollapse */ MutableTypePipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: MutableTypePipeModule });
/** @nocollapse */ MutableTypePipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [MutableTypePipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MutableTypePipeModule, [{
        type: NgModule,
        args: [{
                exports: [MutableTypePipe],
                providers: [MutableTypePipe],
                declarations: [MutableTypePipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(MutableTypePipeModule, { declarations: [MutableTypePipe], exports: [MutableTypePipe] }); })();

class NumberFormatPipe {
    transform(value, options) {
        return numberFormat(value, options);
    }
}
/** @nocollapse */ NumberFormatPipe.ɵfac = function NumberFormatPipe_Factory(t) { return new (t || NumberFormatPipe)(); };
/** @nocollapse */ NumberFormatPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "numberFormat", type: NumberFormatPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NumberFormatPipe, [{
        type: Pipe,
        args: [{ name: 'numberFormat' }]
    }], null, null); })();

class NumberFormatPipeModule {
}
/** @nocollapse */ NumberFormatPipeModule.ɵfac = function NumberFormatPipeModule_Factory(t) { return new (t || NumberFormatPipeModule)(); };
/** @nocollapse */ NumberFormatPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: NumberFormatPipeModule });
/** @nocollapse */ NumberFormatPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [NumberFormatPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NumberFormatPipeModule, [{
        type: NgModule,
        args: [{
                exports: [NumberFormatPipe],
                providers: [NumberFormatPipe],
                declarations: [NumberFormatPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(NumberFormatPipeModule, { declarations: [NumberFormatPipe], exports: [NumberFormatPipe] }); })();

class ObjectSizePipe {
    transform(object) {
        return isNil(object) ? 0 : Object.keys(object).length;
    }
}
/** @nocollapse */ ObjectSizePipe.ɵfac = function ObjectSizePipe_Factory(t) { return new (t || ObjectSizePipe)(); };
/** @nocollapse */ ObjectSizePipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "objectSize", type: ObjectSizePipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ObjectSizePipe, [{
        type: Pipe,
        args: [{ name: 'objectSize' }]
    }], null, null); })();

class ObjectSizePipeModule {
}
/** @nocollapse */ ObjectSizePipeModule.ɵfac = function ObjectSizePipeModule_Factory(t) { return new (t || ObjectSizePipeModule)(); };
/** @nocollapse */ ObjectSizePipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: ObjectSizePipeModule });
/** @nocollapse */ ObjectSizePipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [ObjectSizePipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ObjectSizePipeModule, [{
        type: NgModule,
        args: [{
                exports: [ObjectSizePipe],
                providers: [ObjectSizePipe],
                declarations: [ObjectSizePipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(ObjectSizePipeModule, { declarations: [ObjectSizePipe], exports: [ObjectSizePipe] }); })();

class SafePipe {
    constructor(sanitizer) {
        this.sanitizer = sanitizer;
    }
    // eslint-disable-next-line complexity
    transform(value, type) {
        const prepared = value ?? '';
        switch (type) {
            case "html" /* HTML */:
                return this.sanitizer.bypassSecurityTrustHtml(prepared);
            case "style" /* STYLE */:
                return this.sanitizer.bypassSecurityTrustStyle(prepared);
            case "script" /* SCRIPT */:
                return this.sanitizer.bypassSecurityTrustScript(prepared);
            case "url" /* URL */:
                return this.sanitizer.bypassSecurityTrustUrl(prepared);
            case "resourceUrl" /* RESOURCE_URL */:
                return this.sanitizer.bypassSecurityTrustResourceUrl(prepared);
            default:
                throw new Error(`Invalid safe type specified: ${type}`);
        }
    }
}
/** @nocollapse */ SafePipe.ɵfac = function SafePipe_Factory(t) { return new (t || SafePipe)(i0.ɵɵdirectiveInject(i1.DomSanitizer, 16)); };
/** @nocollapse */ SafePipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "safe", type: SafePipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SafePipe, [{
        type: Pipe,
        args: [{ name: 'safe' }]
    }], function () { return [{ type: i1.DomSanitizer }]; }, null); })();

class SafePipeModule {
}
/** @nocollapse */ SafePipeModule.ɵfac = function SafePipeModule_Factory(t) { return new (t || SafePipeModule)(); };
/** @nocollapse */ SafePipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: SafePipeModule });
/** @nocollapse */ SafePipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [SafePipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SafePipeModule, [{
        type: NgModule,
        args: [{
                exports: [SafePipe],
                providers: [SafePipe],
                declarations: [SafePipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(SafePipeModule, { declarations: [SafePipe], exports: [SafePipe] }); })();

class TakeFirstItemPipe {
    transform(value) {
        return takeFirstItem(value);
    }
}
/** @nocollapse */ TakeFirstItemPipe.ɵfac = function TakeFirstItemPipe_Factory(t) { return new (t || TakeFirstItemPipe)(); };
/** @nocollapse */ TakeFirstItemPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "takeFirstItem", type: TakeFirstItemPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TakeFirstItemPipe, [{
        type: Pipe,
        args: [{ name: 'takeFirstItem' }]
    }], null, null); })();

class TakeFirstItemPipeModule {
}
/** @nocollapse */ TakeFirstItemPipeModule.ɵfac = function TakeFirstItemPipeModule_Factory(t) { return new (t || TakeFirstItemPipeModule)(); };
/** @nocollapse */ TakeFirstItemPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: TakeFirstItemPipeModule });
/** @nocollapse */ TakeFirstItemPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [TakeFirstItemPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TakeFirstItemPipeModule, [{
        type: NgModule,
        args: [{
                exports: [TakeFirstItemPipe],
                providers: [TakeFirstItemPipe],
                declarations: [TakeFirstItemPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(TakeFirstItemPipeModule, { declarations: [TakeFirstItemPipe], exports: [TakeFirstItemPipe] }); })();

class TakeSecondItemPipe {
    transform(value) {
        return takeSecondItem(value);
    }
}
/** @nocollapse */ TakeSecondItemPipe.ɵfac = function TakeSecondItemPipe_Factory(t) { return new (t || TakeSecondItemPipe)(); };
/** @nocollapse */ TakeSecondItemPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "takeSecondItem", type: TakeSecondItemPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TakeSecondItemPipe, [{
        type: Pipe,
        args: [{ name: 'takeSecondItem' }]
    }], null, null); })();

class TakeSecondItemPipeModule {
}
/** @nocollapse */ TakeSecondItemPipeModule.ɵfac = function TakeSecondItemPipeModule_Factory(t) { return new (t || TakeSecondItemPipeModule)(); };
/** @nocollapse */ TakeSecondItemPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: TakeSecondItemPipeModule });
/** @nocollapse */ TakeSecondItemPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [TakeSecondItemPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TakeSecondItemPipeModule, [{
        type: NgModule,
        args: [{
                exports: [TakeSecondItemPipe],
                providers: [TakeSecondItemPipe],
                declarations: [TakeSecondItemPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(TakeSecondItemPipeModule, { declarations: [TakeSecondItemPipe], exports: [TakeSecondItemPipe] }); })();

class ToNumberPipe {
    transform(value, locale = 'ru-RU') {
        return toNumber(value, locale);
    }
}
/** @nocollapse */ ToNumberPipe.ɵfac = function ToNumberPipe_Factory(t) { return new (t || ToNumberPipe)(); };
/** @nocollapse */ ToNumberPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "toNumber", type: ToNumberPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ToNumberPipe, [{
        type: Pipe,
        args: [{ name: 'toNumber' }]
    }], null, null); })();

class ToNumberPipeModule {
}
/** @nocollapse */ ToNumberPipeModule.ɵfac = function ToNumberPipeModule_Factory(t) { return new (t || ToNumberPipeModule)(); };
/** @nocollapse */ ToNumberPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: ToNumberPipeModule });
/** @nocollapse */ ToNumberPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [ToNumberPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ToNumberPipeModule, [{
        type: NgModule,
        args: [{
                exports: [ToNumberPipe],
                providers: [ToNumberPipe],
                declarations: [ToNumberPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(ToNumberPipeModule, { declarations: [ToNumberPipe], exports: [ToNumberPipe] }); })();

class ToStringPipe {
    transform(value, converter) {
        return isNotNil(value) ? toStringValue(value, converter) : '';
    }
}
/** @nocollapse */ ToStringPipe.ɵfac = function ToStringPipe_Factory(t) { return new (t || ToStringPipe)(); };
/** @nocollapse */ ToStringPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "toString", type: ToStringPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ToStringPipe, [{
        type: Pipe,
        args: [{ name: 'toString' }]
    }], null, null); })();

class ToStringPipeModule {
}
/** @nocollapse */ ToStringPipeModule.ɵfac = function ToStringPipeModule_Factory(t) { return new (t || ToStringPipeModule)(); };
/** @nocollapse */ ToStringPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: ToStringPipeModule });
/** @nocollapse */ ToStringPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [ToStringPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ToStringPipeModule, [{
        type: NgModule,
        args: [{
                exports: [ToStringPipe],
                providers: [ToStringPipe],
                declarations: [ToStringPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(ToStringPipeModule, { declarations: [ToStringPipe], exports: [ToStringPipe] }); })();

class TypeAsPipe {
    transform(value, _typedValue) {
        return value;
    }
}
/** @nocollapse */ TypeAsPipe.ɵfac = function TypeAsPipe_Factory(t) { return new (t || TypeAsPipe)(); };
/** @nocollapse */ TypeAsPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "typeAs", type: TypeAsPipe, pure: true });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TypeAsPipe, [{
        type: Pipe,
        args: [{ name: 'typeAs' }]
    }], null, null); })();

class TypeAsPipeModule {
}
/** @nocollapse */ TypeAsPipeModule.ɵfac = function TypeAsPipeModule_Factory(t) { return new (t || TypeAsPipeModule)(); };
/** @nocollapse */ TypeAsPipeModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: TypeAsPipeModule });
/** @nocollapse */ TypeAsPipeModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [TypeAsPipe] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TypeAsPipeModule, [{
        type: NgModule,
        args: [{
                exports: [TypeAsPipe],
                providers: [TypeAsPipe],
                declarations: [TypeAsPipe]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(TypeAsPipeModule, { declarations: [TypeAsPipe], exports: [TypeAsPipe] }); })();

/**
 * Generated bundle index. Do not edit.
 */

export { AtPipe, AtPipeModule, BracePipe, BracePipeModule, CoerceBooleanPipe, CoerceBooleanPipeModule, DateToNativePipe, DateToNativePipeModule, DeclinationOfNumberPipe, DeclinationOfNumberPipeModule, DeepPathPipe, DeepPathPipeModule, DefaultValuePipe, DefaultValuePipeModule, DetectBrowserPipe, DetectBrowserPipeModule, DisplayItemPipe, DisplayItemPipeModule, EntrySingleSetPipe, EntrySingleSetPipeModule, FileSizePipe, FileSizePipeModule, FilterUniquePipe, FilterUniquePipeModule, FormatDatePipe, FormatDatePipeModule, HasAtMostOneItemPipe, HasAtMostOneItemPipeModule, HasItemsPipe, HasItemsPipeModule, HasManyItemsPipe, HasManyItemsPipeModule, HasNoItemsPipe, HasNoItemsPipeModule, HasOneItemPipe, HasOneItemPipeModule, HasPipe, HasPipeModule, HttpReplacerPipe, HttpReplacerPipeModule, IncludesPipe, IncludesPipeModule, IsArrayPipe, IsArrayPipeModule, IsFilledPipe, IsFilledPipeModule, IsNilPipe, IsNilPipeModule, IsNotNullPipe, IsNotNullPipeModule, IsObjectPipe, IsObjectPipeModule, IsStringPipe, IsStringPipeModule, JoinPipe, JoinPipeModule, MarkByFilterPipe, MarkByFilterPipeModule, MergeCssClassesPipe, MergeCssClassesPipeModule, MutableTypePipe, MutableTypePipeModule, NumberFormatPipe, NumberFormatPipeModule, ObjectSizePipe, ObjectSizePipeModule, SafePipe, SafePipeModule, TakeFirstItemPipe, TakeFirstItemPipeModule, TakeSecondItemPipe, TakeSecondItemPipeModule, ToNumberPipe, ToNumberPipeModule, ToStringPipe, ToStringPipeModule, TypeAsPipe, TypeAsPipeModule };
//# sourceMappingURL=angular-ru-cdk-pipes.mjs.map
