@fitcoders/shared 1.0.1 → 1.1.0

package/{fesm2015 → fesm2022}/fitcoders-shared.mjs

@@ -1,670 +1,821 @@
 import { FormControl, FormGroup } from '@angular/forms';
-import * as moment from 'moment';
+import moment from 'moment';
 import * as i0 from '@angular/core';
-import { Directive, Input, HostListener, EventEmitter, Output, NgModule, Pipe } from '@angular/core';
+import { HostListener, Input, Directive, EventEmitter, Output, NgModule, Pipe, Inject, Injectable, PLATFORM_ID } from '@angular/core';
 import * as i1 from '@angular/common';
-import { CommonModule, DecimalPipe } from '@angular/common';
+import { CommonModule, DecimalPipe, isPlatformBrowser, DOCUMENT } from '@angular/common';
+import { BehaviorSubject, fromEvent, map } from 'rxjs';
 
-const FitRegexConst = {
-    number: new RegExp(/^[0-9]\d*$/),
-    decimal: new RegExp(/^[0-9]+(\.[0-9]*){0,1}$/),
-    percent: new RegExp(/^[1-9][0-9]*$/),
-    alphabetical: /^[a-zA-Z\u00C0-\u00FF]+$/,
-    alphabeticals: /^[a-zA-Z\u00C0-\u00FF ]+$/,
-    alphanumeric: new RegExp(/^[0-9a-zA-Z\u00C0-\u00FF]+$/),
-    alphanumerics: new RegExp(/^[0-9a-zA-Z\u00C0-\u00FF ]+$/),
-    cell: new RegExp(/^9[0-9]*$/),
-    noSpaces: new RegExp(/^\S*$/gmi)
-};
-const FitCurrencyConst = {
-    AED: 'د.إ',
-    AFN: '؋',
-    ALL: 'L',
-    AMD: '֏',
-    ANG: 'ƒ',
-    AOA: 'Kz',
-    ARS: '$',
-    AUD: '$',
-    AWG: 'ƒ',
-    AZN: '₼',
-    BAM: 'KM',
-    BBD: '$',
-    BDT: '৳',
-    BGN: 'лв',
-    BHD: '.د.ب',
-    BIF: 'FBu',
-    BMD: '$',
-    BND: '$',
-    BOB: '$b',
-    BOV: 'BOV',
-    BRL: 'R$',
-    BSD: '$',
-    BTC: '₿',
-    BTN: 'Nu.',
-    BWP: 'P',
-    BYN: 'Br',
-    BYR: 'Br',
-    BZD: 'BZ$',
-    CAD: '$',
-    CDF: 'FC',
-    CHE: 'CHE',
-    CHF: 'CHF',
-    CHW: 'CHW',
-    CLF: 'CLF',
-    CLP: '$',
-    CNY: '¥',
-    COP: '$',
-    COU: 'COU',
-    CRC: '₡',
-    CUC: '$',
-    CUP: '₱',
-    CVE: '$',
-    CZK: 'Kč',
-    DJF: 'Fdj',
-    DKK: 'kr',
-    DOP: 'RD$',
-    DZD: 'دج',
-    EEK: 'kr',
-    EGP: '£',
-    ERN: 'Nfk',
-    ETB: 'Br',
-    ETH: 'Ξ',
-    EUR: '€',
-    FJD: '$',
-    FKP: '£',
-    GBP: '£',
-    GEL: '₾',
-    GGP: '£',
-    GHC: '₵',
-    GHS: 'GH₵',
-    GIP: '£',
-    GMD: 'D',
-    GNF: 'FG',
-    GTQ: 'Q',
-    GYD: '$',
-    HKD: '$',
-    HNL: 'L',
-    HRK: 'kn',
-    HTG: 'G',
-    HUF: 'Ft',
-    IDR: 'Rp',
-    ILS: '₪',
-    IMP: '£',
-    INR: '₹',
-    IQD: 'ع.د',
-    IRR: '﷼',
-    ISK: 'kr',
-    JEP: '£',
-    JMD: 'J$',
-    JOD: 'JD',
-    JPY: '¥',
-    KES: 'KSh',
-    KGS: 'лв',
-    KHR: '៛',
-    KMF: 'CF',
-    KPW: '₩',
-    KRW: '₩',
-    KWD: 'KD',
-    KYD: '$',
-    KZT: '₸',
-    LAK: '₭',
-    LBP: '£',
-    LKR: '₨',
-    LRD: '$',
-    LSL: 'M',
-    LTC: 'Ł',
-    LTL: 'Lt',
-    LVL: 'Ls',
-    LYD: 'LD',
-    MAD: 'MAD',
-    MDL: 'lei',
-    MGA: 'Ar',
-    MKD: 'ден',
-    MMK: 'K',
-    MNT: '₮',
-    MOP: 'MOP$',
-    MRO: 'UM',
-    MRU: 'UM',
-    MUR: '₨',
-    MVR: 'Rf',
-    MWK: 'MK',
-    MXN: '$',
-    MXV: 'MXV',
-    MYR: 'RM',
-    MZN: 'MT',
-    NAD: '$',
-    NGN: '₦',
-    NIO: 'C$',
-    NOK: 'kr',
-    NPR: '₨',
-    NZD: '$',
-    OMR: '﷼',
-    PAB: 'B/.',
-    PEN: 'S/.',
-    PGK: 'K',
-    PHP: '₱',
-    PKR: '₨',
-    PLN: 'zł',
-    PYG: 'Gs',
-    QAR: '﷼',
-    RMB: '￥',
-    RON: 'lei',
-    RSD: 'Дин.',
-    RUB: '₽',
-    RWF: 'R₣',
-    SAR: '﷼',
-    SBD: '$',
-    SCR: '₨',
-    SDG: 'ج.س.',
-    SEK: 'kr',
-    SGD: 'S$',
-    SHP: '£',
-    SLL: 'Le',
-    SOS: 'S',
-    SRD: '$',
-    SSP: '£',
-    STD: 'Db',
-    STN: 'Db',
-    SVC: '$',
-    SYP: '£',
-    SZL: 'E',
-    THB: '฿',
-    TJS: 'SM',
-    TMT: 'T',
-    TND: 'د.ت',
-    TOP: 'T$',
-    TRL: '₤',
-    TRY: '₺',
-    TTD: 'TT$',
-    TVD: '$',
-    TWD: 'NT$',
-    TZS: 'TSh',
-    UAH: '₴',
-    UGX: 'USh',
-    USD: '$',
-    UYI: 'UYI',
-    UYU: '$U',
-    UYW: 'UYW',
-    UZS: 'лв',
-    VEF: 'Bs',
-    VES: 'Bs.S',
-    VND: '₫',
-    VUV: 'VT',
-    WST: 'WS$',
-    XAF: 'FCFA',
-    XBT: 'Ƀ',
-    XCD: '$',
-    XOF: 'CFA',
-    XPF: '₣',
-    XSU: 'Sucre',
-    XUA: 'XUA',
-    YER: '﷼',
-    ZAR: 'R',
-    ZMW: 'ZK',
-    ZWD: 'Z$',
-    ZWL: '$'
+const FitRegexConst = {
+    number: new RegExp(/^[0-9]\d*$/),
+    decimal: new RegExp(/^[0-9]+(\.[0-9]*){0,1}$/),
+    percent: new RegExp(/^[1-9][0-9]*$/),
+    alphabetical: /^[a-zA-Z\u00C0-\u00FF]+$/,
+    alphabeticals: /^[a-zA-Z\u00C0-\u00FF ]+$/,
+    alphanumeric: new RegExp(/^[0-9a-zA-Z\u00C0-\u00FF]+$/),
+    alphanumerics: new RegExp(/^[0-9a-zA-Z\u00C0-\u00FF ]+$/),
+    cell: new RegExp(/^9[0-9]*$/),
+    noSpaces: new RegExp(/^\S*$/gmi)
+};
+const FitCurrencyConst = {
+    AED: 'د.إ',
+    AFN: '؋',
+    ALL: 'L',
+    AMD: '֏',
+    ANG: 'ƒ',
+    AOA: 'Kz',
+    ARS: '$',
+    AUD: '$',
+    AWG: 'ƒ',
+    AZN: '₼',
+    BAM: 'KM',
+    BBD: '$',
+    BDT: '৳',
+    BGN: 'лв',
+    BHD: '.د.ب',
+    BIF: 'FBu',
+    BMD: '$',
+    BND: '$',
+    BOB: '$b',
+    BOV: 'BOV',
+    BRL: 'R$',
+    BSD: '$',
+    BTC: '₿',
+    BTN: 'Nu.',
+    BWP: 'P',
+    BYN: 'Br',
+    BYR: 'Br',
+    BZD: 'BZ$',
+    CAD: '$',
+    CDF: 'FC',
+    CHE: 'CHE',
+    CHF: 'CHF',
+    CHW: 'CHW',
+    CLF: 'CLF',
+    CLP: '$',
+    CNY: '¥',
+    COP: '$',
+    COU: 'COU',
+    CRC: '₡',
+    CUC: '$',
+    CUP: '₱',
+    CVE: '$',
+    CZK: 'Kč',
+    DJF: 'Fdj',
+    DKK: 'kr',
+    DOP: 'RD$',
+    DZD: 'دج',
+    EEK: 'kr',
+    EGP: '£',
+    ERN: 'Nfk',
+    ETB: 'Br',
+    ETH: 'Ξ',
+    EUR: '€',
+    FJD: '$',
+    FKP: '£',
+    GBP: '£',
+    GEL: '₾',
+    GGP: '£',
+    GHC: '₵',
+    GHS: 'GH₵',
+    GIP: '£',
+    GMD: 'D',
+    GNF: 'FG',
+    GTQ: 'Q',
+    GYD: '$',
+    HKD: '$',
+    HNL: 'L',
+    HRK: 'kn',
+    HTG: 'G',
+    HUF: 'Ft',
+    IDR: 'Rp',
+    ILS: '₪',
+    IMP: '£',
+    INR: '₹',
+    IQD: 'ع.د',
+    IRR: '﷼',
+    ISK: 'kr',
+    JEP: '£',
+    JMD: 'J$',
+    JOD: 'JD',
+    JPY: '¥',
+    KES: 'KSh',
+    KGS: 'лв',
+    KHR: '៛',
+    KMF: 'CF',
+    KPW: '₩',
+    KRW: '₩',
+    KWD: 'KD',
+    KYD: '$',
+    KZT: '₸',
+    LAK: '₭',
+    LBP: '£',
+    LKR: '₨',
+    LRD: '$',
+    LSL: 'M',
+    LTC: 'Ł',
+    LTL: 'Lt',
+    LVL: 'Ls',
+    LYD: 'LD',
+    MAD: 'MAD',
+    MDL: 'lei',
+    MGA: 'Ar',
+    MKD: 'ден',
+    MMK: 'K',
+    MNT: '₮',
+    MOP: 'MOP$',
+    MRO: 'UM',
+    MRU: 'UM',
+    MUR: '₨',
+    MVR: 'Rf',
+    MWK: 'MK',
+    MXN: '$',
+    MXV: 'MXV',
+    MYR: 'RM',
+    MZN: 'MT',
+    NAD: '$',
+    NGN: '₦',
+    NIO: 'C$',
+    NOK: 'kr',
+    NPR: '₨',
+    NZD: '$',
+    OMR: '﷼',
+    PAB: 'B/.',
+    PEN: 'S/.',
+    PGK: 'K',
+    PHP: '₱',
+    PKR: '₨',
+    PLN: 'zł',
+    PYG: 'Gs',
+    QAR: '﷼',
+    RMB: '￥',
+    RON: 'lei',
+    RSD: 'Дин.',
+    RUB: '₽',
+    RWF: 'R₣',
+    SAR: '﷼',
+    SBD: '$',
+    SCR: '₨',
+    SDG: 'ج.س.',
+    SEK: 'kr',
+    SGD: 'S$',
+    SHP: '£',
+    SLL: 'Le',
+    SOS: 'S',
+    SRD: '$',
+    SSP: '£',
+    STD: 'Db',
+    STN: 'Db',
+    SVC: '$',
+    SYP: '£',
+    SZL: 'E',
+    THB: '฿',
+    TJS: 'SM',
+    TMT: 'T',
+    TND: 'د.ت',
+    TOP: 'T$',
+    TRL: '₤',
+    TRY: '₺',
+    TTD: 'TT$',
+    TVD: '$',
+    TWD: 'NT$',
+    TZS: 'TSh',
+    UAH: '₴',
+    UGX: 'USh',
+    USD: '$',
+    UYI: 'UYI',
+    UYU: '$U',
+    UYW: 'UYW',
+    UZS: 'лв',
+    VEF: 'Bs',
+    VES: 'Bs.S',
+    VND: '₫',
+    VUV: 'VT',
+    WST: 'WS$',
+    XAF: 'FCFA',
+    XBT: 'Ƀ',
+    XCD: '$',
+    XOF: 'CFA',
+    XPF: '₣',
+    XSU: 'Sucre',
+    XUA: 'XUA',
+    YER: '﷼',
+    ZAR: 'R',
+    ZMW: 'ZK',
+    ZWD: 'Z$',
+    ZWL: '$'
 };
 
-class FitGeneralUtil {
-    static randomString(_length = 10) {
-        const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZ';
-        const stringLength = _length;
-        let randomstring = '';
-        for (let i = 0; i < stringLength; i++) {
-            const rnum = Math.floor(Math.random() * chars.length);
-            randomstring += chars.substring(rnum, rnum + 1);
-        }
-        return randomstring;
-    }
+class FitGeneralUtil {
+    static randomString(_length = 10) {
+        const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZ';
+        const stringLength = _length;
+        let randomstring = '';
+        for (let i = 0; i < stringLength; i++) {
+            const rnum = Math.floor(Math.random() * chars.length);
+            randomstring += chars.substring(rnum, rnum + 1);
+        }
+        return randomstring;
+    }
 }
 
-class FitFormUtil {
-    static validateAllFormFields(formGroup) {
-        Object.keys(formGroup.controls).forEach(field => {
-            const control = formGroup.get(field);
-            if (control instanceof FormControl) {
-                if (control.errors && control.errors['required']) {
-                    control.markAsDirty({ onlySelf: true });
-                    control.markAsTouched({ onlySelf: true });
-                    control.updateValueAndValidity();
-                }
-            }
-            else if (control instanceof FormGroup) {
-                this.validateAllFormFields(control);
-            }
-        });
-        return formGroup;
-    }
-    static validateFormArray(forms) {
-        forms.controls.forEach(form => {
-            FitFormUtil.validateAllFormFields(form);
-        });
-        return forms;
-    }
-    static validateField(control) {
-        if (control.errors && control.errors['required']) {
-            control.markAsDirty({ onlySelf: true });
-            control.markAsTouched({ onlySelf: true });
-            control.updateValueAndValidity();
-        }
-        return control;
-    }
+class FitFormUtil {
+    static validateAllFormFields(formGroup) {
+        Object.keys(formGroup.controls).forEach(field => {
+            const control = formGroup.get(field);
+            if (control instanceof FormControl) {
+                if (control.errors && control.errors['required']) {
+                    control.markAsDirty({ onlySelf: true });
+                    control.markAsTouched({ onlySelf: true });
+                    control.updateValueAndValidity();
+                }
+            }
+            else if (control instanceof FormGroup) {
+                this.validateAllFormFields(control);
+            }
+        });
+        return formGroup;
+    }
+    static validateFormArray(forms) {
+        forms.controls.forEach(form => {
+            FitFormUtil.validateAllFormFields(form);
+        });
+        return forms;
+    }
+    static validateField(control) {
+        if (control.errors && control.errors['required']) {
+            control.markAsDirty({ onlySelf: true });
+            control.markAsTouched({ onlySelf: true });
+            control.updateValueAndValidity();
+        }
+        return control;
+    }
 }
 
-class FitValidateUtil {
-    static toString(_value, _case = 'standar', _resInvalid = '') {
-        if (_value && _value.toString().trim()) {
-            if (_case === 'upper' || _case === 'lower') {
-                return (_case === 'upper' ? _value.toString().trim().toUpperCase() : _value.toString().trim().toLowerCase());
-            }
-            return _value.toString().trim();
-        }
-        return _resInvalid;
-    }
-    static toNumber(_value, _resInvalid = null) {
-        if (_value && !!Number(_value)) {
-            return Number(_value);
-        }
-        return _resInvalid;
-    }
-    static toBoolean(_value, _resInvalid = false) {
-        if (_value !== undefined && _value !== null) {
-            return _value;
-        }
-        return _resInvalid;
-    }
-    static toDate(_value, _format = '', _resInvalid = null) {
-        if (_value && moment(_value, _format).isValid()) {
-            return moment(_value, _format).toDate();
-        }
-        return _resInvalid;
-    }
-    static toArray(_value, _resInvalid = []) {
-        if (_value instanceof Array) {
-            return _value;
-        }
-        return _resInvalid;
-    }
-    static dateToString(_value, _format = '', _resInvalid = '') {
-        if (_value && moment(_value).isValid()) {
-            if (_format) {
-                return moment(_value).format(_format);
-            }
-            return moment(_value).toISOString();
-        }
-        return _resInvalid;
-    }
-    static charToBoolean(value, charYes = 'S') {
-        return value === charYes;
-    }
-    static booleanToBinary(value) {
-        return value ? 1 : 0;
-    }
-    static booleanToChar(value, charYes = 'S', charNo = 'N') {
-        return value ? charYes : charNo;
-    }
-    static padStart(value, size) {
-        let resp = `${value}`;
-        while (resp.length < size) {
-            resp = `0${resp}`;
-        }
-        return resp;
-    }
-    static numberReduce(value) {
-        if (value >= 1000 && value <= 999999) {
-            return `${Math.round(value / 1000)}K`;
-        }
-        else if (value >= 1000000) {
-            return `${Math.round(value / 1000000)}M`;
-        }
-        return `${value}`;
-    }
+class FitValidateUtil {
+    static toString(_value, _case = 'standar', _resInvalid = '') {
+        if (_value && _value.toString().trim()) {
+            if (_case === 'upper' || _case === 'lower') {
+                return (_case === 'upper' ? _value.toString().trim().toUpperCase() : _value.toString().trim().toLowerCase());
+            }
+            return _value.toString().trim();
+        }
+        return _resInvalid;
+    }
+    static toNumber(_value, _resInvalid = null) {
+        if (_value && !!Number(_value)) {
+            return Number(_value);
+        }
+        return _resInvalid;
+    }
+    static toBoolean(_value, _resInvalid = false) {
+        if (_value !== undefined && _value !== null) {
+            return _value;
+        }
+        return _resInvalid;
+    }
+    static toDate(_value, _format = '', _resInvalid = null) {
+        if (_value && moment(_value, _format).isValid()) {
+            return moment(_value, _format).toDate();
+        }
+        return _resInvalid;
+    }
+    static toArray(_value, _resInvalid = []) {
+        if (_value instanceof Array) {
+            return _value;
+        }
+        return _resInvalid;
+    }
+    static dateToString(_value, _format = '', _resInvalid = '') {
+        if (_value && moment(_value).isValid()) {
+            if (_format) {
+                return moment(_value).format(_format);
+            }
+            return moment(_value).toISOString();
+        }
+        return _resInvalid;
+    }
+    static charToBoolean(value, charYes = 'S') {
+        return value === charYes;
+    }
+    static booleanToBinary(value) {
+        return value ? 1 : 0;
+    }
+    static booleanToChar(value, charYes = 'S', charNo = 'N') {
+        return value ? charYes : charNo;
+    }
+    static padStart(value, size) {
+        let resp = `${value}`;
+        while (resp.length < size) {
+            resp = `0${resp}`;
+        }
+        return resp;
+    }
+    static numberReduce(value) {
+        if (value >= 1000 && value <= 999999) {
+            return `${Math.round(value / 1000)}K`;
+        }
+        else if (value >= 1000000) {
+            return `${Math.round(value / 1000000)}M`;
+        }
+        return `${value}`;
+    }
 }
 
 // helper
 
-class HoverDirective {
-    constructor(elementRef) {
-        this.elementRef = elementRef;
-        this.hover = '';
-    }
-    onMouseEnter() {
-        this.setHoverEffect();
-    }
-    onMouseLeave() {
-        this.removeHoverEffect();
-    }
-    setHoverEffect() {
-        for (const _class of this.hover.split(' ')) {
-            this.elementRef.nativeElement.classList.add(_class);
-        }
-    }
-    removeHoverEffect() {
-        for (const _class of this.hover.split(' ')) {
-            this.elementRef.nativeElement.classList.remove(_class);
-        }
-    }
-}
-HoverDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: HoverDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-HoverDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.3", type: HoverDirective, selector: "[fitHover]", inputs: { hover: ["fitHover", "hover"] }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: HoverDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[fitHover]'
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { hover: [{
-                type: Input,
-                args: ['fitHover']
-            }], onMouseEnter: [{
-                type: HostListener,
-                args: ['mouseenter']
-            }], onMouseLeave: [{
-                type: HostListener,
-                args: ['mouseleave']
+class HoverDirective {
+    elementRef;
+    hover = '';
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    onMouseEnter() {
+        this.setHoverEffect();
+    }
+    onMouseLeave() {
+        this.removeHoverEffect();
+    }
+    setHoverEffect() {
+        for (const _class of this.hover.split(' ')) {
+            this.elementRef.nativeElement.classList.add(_class);
+        }
+    }
+    removeHoverEffect() {
+        for (const _class of this.hover.split(' ')) {
+            this.elementRef.nativeElement.classList.remove(_class);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: HoverDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.18", type: HoverDirective, isStandalone: true, selector: "[fitHover]", inputs: { hover: ["fitHover", "hover"] }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: HoverDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fitHover]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { hover: [{
+                type: Input,
+                args: ['fitHover']
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
             }] } });
 
-class InputDirective {
-    constructor(el) {
-        this.el = el;
-        this.input = '';
-        this.space = false;
-        this._regex = FitRegexConst;
-        this._specialKeys = ['Backspace', 'Tab', 'Enter', 'Escape', 'End', 'Home', 'ArrowLeft', 'ArrowRight', 'Delete'];
-    }
-    onKeyDown(event) {
-        if (!this.input) {
-            return;
-        }
-        if (this._specialKeys.indexOf(event.key) !== -1
-            || (event.keyCode === 65 && event.ctrlKey) // Allow: Ctrl+A
-            || (event.keyCode === 67 && event.ctrlKey) // Allow: Ctrl+C
-            || (event.keyCode === 86 && event.ctrlKey) // Allow: Ctrl+V
-            || (event.keyCode === 88 && event.ctrlKey) // Allow: Ctrl+X
-        ) {
-            return;
-        }
-        const current = this.el.nativeElement.value;
-        const next = current.concat(event.key);
-        const input = this.space && (this.input === 'alphabetical' || this.input === 'alphanumeric') ? `${this.input}s` : this.input;
-        if (next && !String(next).match(this._regex[input])) {
-            event.preventDefault();
-        }
-    }
-}
-InputDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: InputDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-InputDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.3", type: InputDirective, selector: "[fitInput]", inputs: { input: ["fitInput", "input"], space: "space" }, host: { listeners: { "keydown": "onKeyDown($event)" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: InputDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[fitInput]'
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { input: [{
-                type: Input,
-                args: ['fitInput']
-            }], space: [{
-                type: Input
-            }], onKeyDown: [{
-                type: HostListener,
-                args: ['keydown', ['$event']]
+class InputDirective {
+    el;
+    input = '';
+    space = false;
+    _regex = FitRegexConst;
+    _specialKeys = ['Backspace', 'Tab', 'Enter', 'Escape', 'End', 'Home', 'ArrowLeft', 'ArrowRight', 'Delete'];
+    constructor(el) {
+        this.el = el;
+    }
+    onKeyDown(event) {
+        if (!this.input) {
+            return;
+        }
+        if (this._specialKeys.indexOf(event.key) !== -1
+            || (event.keyCode === 65 && event.ctrlKey) // Allow: Ctrl+A
+            || (event.keyCode === 67 && event.ctrlKey) // Allow: Ctrl+C
+            || (event.keyCode === 86 && event.ctrlKey) // Allow: Ctrl+V
+            || (event.keyCode === 88 && event.ctrlKey) // Allow: Ctrl+X
+        ) {
+            return;
+        }
+        const current = this.el.nativeElement.value;
+        const next = current.concat(event.key);
+        const input = this.space && (this.input === 'alphabetical' || this.input === 'alphanumeric') ? `${this.input}s` : this.input;
+        if (next && !String(next).match(this._regex[input])) {
+            event.preventDefault();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: InputDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.18", type: InputDirective, isStandalone: true, selector: "[fitInput]", inputs: { input: ["fitInput", "input"], space: "space" }, host: { listeners: { "keydown": "onKeyDown($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: InputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fitInput]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { input: [{
+                type: Input,
+                args: ['fitInput']
+            }], space: [{
+                type: Input
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
             }] } });
 
-class ScrollDirective {
-    constructor() {
-        this.onScroll = new EventEmitter();
-    }
-    scrolled($event) {
-        this.elementSE($event);
-    }
-    windowScrolled($event) {
-        this.windowSE($event);
-    }
-    windowSE($event) {
-        const target = $event.target;
-        const scrollTop = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
-        const header = scrollTop < 200;
-        const bottom = scrollTop > 200;
-        const emitVal = { header, bottom };
-        this.onScroll.emit(emitVal);
-    }
-    elementSE($event) {
-        const target = $event.target;
-        const header = target.scrollTop < 200;
-        const bottom = target.scrollTop > 200;
-        const emitVal = { header, bottom };
-        this.onScroll.emit(emitVal);
-    }
-}
-ScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: ScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-ScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.3", type: ScrollDirective, selector: "[fitScroll]", outputs: { onScroll: "onScroll" }, host: { listeners: { "scroll": "scrolled($event)", "window:scroll": "windowScrolled($event)" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: ScrollDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[fitScroll]'
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { onScroll: [{
-                type: Output
-            }], scrolled: [{
-                type: HostListener,
-                args: ['scroll', ['$event']]
-            }], windowScrolled: [{
-                type: HostListener,
-                args: ['window:scroll', ['$event']]
+class ScrollDirective {
+    onScroll = new EventEmitter();
+    constructor() {
+    }
+    scrolled($event) {
+        this.elementSE($event);
+    }
+    windowScrolled($event) {
+        this.windowSE($event);
+    }
+    windowSE($event) {
+        const target = $event.target;
+        const scrollTop = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+        const header = scrollTop < 200;
+        const bottom = scrollTop > 200;
+        const emitVal = { header, bottom };
+        this.onScroll.emit(emitVal);
+    }
+    elementSE($event) {
+        const target = $event.target;
+        const header = target.scrollTop < 200;
+        const bottom = target.scrollTop > 200;
+        const emitVal = { header, bottom };
+        this.onScroll.emit(emitVal);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: ScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.18", type: ScrollDirective, isStandalone: true, selector: "[fitScroll]", outputs: { onScroll: "onScroll" }, host: { listeners: { "scroll": "scrolled($event)", "window:scroll": "windowScrolled($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: ScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fitScroll]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { onScroll: [{
+                type: Output
+            }], scrolled: [{
+                type: HostListener,
+                args: ['scroll', ['$event']]
+            }], windowScrolled: [{
+                type: HostListener,
+                args: ['window:scroll', ['$event']]
             }] } });
 
-class SensitiveDirective {
-    constructor(_el) {
-        this._el = _el;
-        this.caseType = '';
-    }
-    onKeyUp(event) {
-        const value = event.target.value;
-        if (this.caseType === 'upper') {
-            event.target.value = value.toUpperCase();
-        }
-        else if (this.caseType === 'lower') {
-            event.target.value = value.toLowerCase();
-        }
-    }
-}
-SensitiveDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: SensitiveDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-SensitiveDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.3", type: SensitiveDirective, selector: "[fitSensitive]", inputs: { caseType: ["fitSensitive", "caseType"] }, host: { listeners: { "input": "onKeyUp($event)" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: SensitiveDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[fitSensitive]'
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { caseType: [{
-                type: Input,
-                args: ['fitSensitive']
-            }], onKeyUp: [{
-                type: HostListener,
-                args: ['input', ['$event']]
+class SensitiveDirective {
+    _el;
+    caseType = '';
+    constructor(_el) {
+        this._el = _el;
+    }
+    onKeyUp(event) {
+        const value = event.target.value;
+        if (this.caseType === 'upper') {
+            event.target.value = value.toUpperCase();
+        }
+        else if (this.caseType === 'lower') {
+            event.target.value = value.toLowerCase();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: SensitiveDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.18", type: SensitiveDirective, isStandalone: true, selector: "[fitSensitive]", inputs: { caseType: ["fitSensitive", "caseType"] }, host: { listeners: { "input": "onKeyUp($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: SensitiveDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fitSensitive]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { caseType: [{
+                type: Input,
+                args: ['fitSensitive']
+            }], onKeyUp: [{
+                type: HostListener,
+                args: ['input', ['$event']]
             }] } });
 
-class ControlErrorDirective {
-    constructor(_elementRef, render2) {
-        this._elementRef = _elementRef;
-        this.render2 = render2;
-        this.FORMAT = 'DD/MM/YYYY';
-        this.msgRequired = 'El campo es obligatorio';
-        this.msgMinlength = 'Ingrese mínimo {requiredLength} caracteres';
-        this.msgMaxlength = 'Ingrese máximo {requiredLength} caracteres';
-        this.msgPattern = 'El formato del valor es inválido';
-        this.msgInvalidDate = 'La fecha es inválida';
-        this.msgMinDate = 'La fecha mínima es {minDate}';
-        this.msgMaxDate = 'La fecha máxima es {maxDate}';
-    }
-    set control(value) {
-        this._control = value;
-        this._control.valueChanges.subscribe(() => {
-            this.loadError();
-        });
-    }
-    get control() {
-        return this._control;
-    }
-    ngAfterViewInit() {
-        this.removeHtml();
-    }
-    loadError() {
-        if (this.control && (this.control.dirty || this.control.touched) && this.control.errors) {
-            this.removeHtml();
-            if (this.control.errors['required'] && !this.control.errors['matDatepickerParse']) {
-                this.createHtml(this.msgRequired);
-            }
-            else if (this.control.errors['minlength']) {
-                this.createHtml(this.msgMinlength.replace('{requiredLength}', this.control.errors['minlength'].requiredLength));
-            }
-            else if (this.control.errors['maxlength'] && !this.control.errors['minlength']) {
-                this.createHtml(this.msgMaxlength.replace('{requiredLength}', this.control.errors['maxlength'].requiredLength));
-            }
-            else if (this.control.errors['pattern'] && !this.control.errors['maxlength'] && !this.control.errors['minlength']) {
-                this.createHtml(this.msgPattern);
-            }
-            else if (this.control.errors['matDatepickerParse'] && this.control.errors['matDatepickerParse'].text) {
-                this.createHtml(this.msgInvalidDate);
-            }
-            else if (this.control.errors['matDatepickerMin'] && this.control.errors['matDatepickerMin'].min) {
-                const minDate = this.control.errors['matDatepickerMin'].min.format(this.FORMAT);
-                this.createHtml(this.msgMinDate.replace('{minDate}', minDate));
-            }
-            else if (this.control.errors['matDatepickerMax'] && this.control.errors['matDatepickerMax'].max) {
-                const maxDate = this.control.errors['matDatepickerMax'].max.format(this.FORMAT);
-                this.createHtml(this.msgMaxDate.replace('{maxDate}', maxDate));
-            }
-        }
-    }
-    removeHtml() {
-        if (this._elementRef.nativeElement.firstChild) {
-            this._elementRef.nativeElement.removeChild(this._elementRef.nativeElement.firstChild);
-        }
-    }
-    createHtml(message) {
-        this.render2.setProperty(this._elementRef.nativeElement, 'innerHTML', message);
-    }
-}
-ControlErrorDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: ControlErrorDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
-ControlErrorDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.3", type: ControlErrorDirective, selector: "[fitControlError]", inputs: { msgRequired: "msgRequired", msgMinlength: "msgMinlength", msgMaxlength: "msgMaxlength", msgPattern: "msgPattern", msgInvalidDate: "msgInvalidDate", msgMinDate: "msgMinDate", msgMaxDate: "msgMaxDate", control: "control" }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: ControlErrorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[fitControlError]'
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { msgRequired: [{
-                type: Input
-            }], msgMinlength: [{
-                type: Input
-            }], msgMaxlength: [{
-                type: Input
-            }], msgPattern: [{
-                type: Input
-            }], msgInvalidDate: [{
-                type: Input
-            }], msgMinDate: [{
-                type: Input
-            }], msgMaxDate: [{
-                type: Input
-            }], control: [{
-                type: Input
+class ControlErrorDirective {
+    _elementRef;
+    render2;
+    FORMAT = 'DD/MM/YYYY';
+    _control;
+    msgRequired = 'El campo es obligatorio';
+    msgMinlength = 'Ingrese mínimo {requiredLength} caracteres';
+    msgMaxlength = 'Ingrese máximo {requiredLength} caracteres';
+    msgPattern = 'El formato del valor es inválido';
+    msgInvalidDate = 'La fecha es inválida';
+    msgMinDate = 'La fecha mínima es {minDate}';
+    msgMaxDate = 'La fecha máxima es {maxDate}';
+    set control(value) {
+        this._control = value;
+        this._control.valueChanges.subscribe(() => {
+            this.loadError();
+        });
+    }
+    get control() {
+        return this._control;
+    }
+    constructor(_elementRef, render2) {
+        this._elementRef = _elementRef;
+        this.render2 = render2;
+    }
+    ngAfterViewInit() {
+        this.removeHtml();
+    }
+    loadError() {
+        if (this.control && (this.control.dirty || this.control.touched) && this.control.errors) {
+            this.removeHtml();
+            if (this.control.errors['required'] && !this.control.errors['matDatepickerParse']) {
+                this.createHtml(this.msgRequired);
+            }
+            else if (this.control.errors['minlength']) {
+                this.createHtml(this.msgMinlength.replace('{requiredLength}', this.control.errors['minlength'].requiredLength));
+            }
+            else if (this.control.errors['maxlength'] && !this.control.errors['minlength']) {
+                this.createHtml(this.msgMaxlength.replace('{requiredLength}', this.control.errors['maxlength'].requiredLength));
+            }
+            else if (this.control.errors['pattern'] && !this.control.errors['maxlength'] && !this.control.errors['minlength']) {
+                this.createHtml(this.msgPattern);
+            }
+            else if (this.control.errors['matDatepickerParse'] && this.control.errors['matDatepickerParse'].text) {
+                this.createHtml(this.msgInvalidDate);
+            }
+            else if (this.control.errors['matDatepickerMin'] && this.control.errors['matDatepickerMin'].min) {
+                const minDate = this.control.errors['matDatepickerMin'].min.format(this.FORMAT);
+                this.createHtml(this.msgMinDate.replace('{minDate}', minDate));
+            }
+            else if (this.control.errors['matDatepickerMax'] && this.control.errors['matDatepickerMax'].max) {
+                const maxDate = this.control.errors['matDatepickerMax'].max.format(this.FORMAT);
+                this.createHtml(this.msgMaxDate.replace('{maxDate}', maxDate));
+            }
+        }
+    }
+    removeHtml() {
+        if (this._elementRef.nativeElement.firstChild) {
+            this._elementRef.nativeElement.removeChild(this._elementRef.nativeElement.firstChild);
+        }
+    }
+    createHtml(message) {
+        this.render2.setProperty(this._elementRef.nativeElement, 'innerHTML', message);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: ControlErrorDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.18", type: ControlErrorDirective, isStandalone: true, selector: "[fitControlError]", inputs: { msgRequired: "msgRequired", msgMinlength: "msgMinlength", msgMaxlength: "msgMaxlength", msgPattern: "msgPattern", msgInvalidDate: "msgInvalidDate", msgMinDate: "msgMinDate", msgMaxDate: "msgMaxDate", control: "control" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: ControlErrorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fitControlError]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { msgRequired: [{
+                type: Input
+            }], msgMinlength: [{
+                type: Input
+            }], msgMaxlength: [{
+                type: Input
+            }], msgPattern: [{
+                type: Input
+            }], msgInvalidDate: [{
+                type: Input
+            }], msgMinDate: [{
+                type: Input
+            }], msgMaxDate: [{
+                type: Input
+            }], control: [{
+                type: Input
             }] } });
 
-class FitDirectiveModule {
-}
-FitDirectiveModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FitDirectiveModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-FitDirectiveModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FitDirectiveModule, declarations: [InputDirective,
-        SensitiveDirective,
-        ControlErrorDirective,
-        ScrollDirective,
-        HoverDirective], imports: [CommonModule], exports: [InputDirective,
-        SensitiveDirective,
-        ControlErrorDirective,
-        ScrollDirective,
-        HoverDirective] });
-FitDirectiveModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FitDirectiveModule, providers: [], imports: [[
-            CommonModule
-        ]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FitDirectiveModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        CommonModule
-                    ],
-                    declarations: [
-                        InputDirective,
-                        SensitiveDirective,
-                        ControlErrorDirective,
-                        ScrollDirective,
-                        HoverDirective
-                    ],
-                    exports: [
-                        InputDirective,
-                        SensitiveDirective,
-                        ControlErrorDirective,
-                        ScrollDirective,
-                        HoverDirective
-                    ],
-                    providers: []
-                }]
+class FitDirectiveModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitDirectiveModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.18", ngImport: i0, type: FitDirectiveModule, imports: [CommonModule,
+            InputDirective,
+            SensitiveDirective,
+            ControlErrorDirective,
+            ScrollDirective,
+            HoverDirective], exports: [InputDirective,
+            SensitiveDirective,
+            ControlErrorDirective,
+            ScrollDirective,
+            HoverDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitDirectiveModule, imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitDirectiveModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        InputDirective,
+                        SensitiveDirective,
+                        ControlErrorDirective,
+                        ScrollDirective,
+                        HoverDirective
+                    ],
+                    exports: [
+                        InputDirective,
+                        SensitiveDirective,
+                        ControlErrorDirective,
+                        ScrollDirective,
+                        HoverDirective
+                    ],
+                    providers: []
+                }]
         }] });
 
 // directives
 
-class FitMoneyPipe {
-    constructor(decimalPipe) {
-        this.decimalPipe = decimalPipe;
-        this._currency = FitCurrencyConst;
-        this._defaultCurrency = 'PEN';
-        this._defaultDecimal = 2;
-    }
-    transform(value, currency = this._defaultCurrency, decimal = this._defaultDecimal) {
-        const format = `.${decimal}-${decimal}`;
-        if (value && `${value}`.match(FitRegexConst.decimal)) {
-            return `${this._currency[currency]} ${this.decimalPipe.transform(Number(value), (format))}`;
-        }
-        return `${this._currency[currency]} ${this.decimalPipe.transform(0, (format))}`;
-    }
-}
-FitMoneyPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FitMoneyPipe, deps: [{ token: i1.DecimalPipe }], target: i0.ɵɵFactoryTarget.Pipe });
-FitMoneyPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FitMoneyPipe, name: "fitMoney" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FitMoneyPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'fitMoney'
-                }]
-        }], ctorParameters: function () { return [{ type: i1.DecimalPipe }]; } });
+class FitMoneyPipe {
+    decimalPipe;
+    _currency = FitCurrencyConst;
+    _defaultCurrency = 'PEN';
+    _defaultDecimal = 2;
+    constructor(decimalPipe) {
+        this.decimalPipe = decimalPipe;
+    }
+    transform(value, currency = this._defaultCurrency, decimal = this._defaultDecimal) {
+        const format = `.${decimal}-${decimal}`;
+        if (value && `${value}`.match(FitRegexConst.decimal)) {
+            return `${this._currency[currency]} ${this.decimalPipe.transform(Number(value), (format))}`;
+        }
+        return `${this._currency[currency]} ${this.decimalPipe.transform(0, (format))}`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitMoneyPipe, deps: [{ token: i1.DecimalPipe }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.18", ngImport: i0, type: FitMoneyPipe, isStandalone: true, name: "fitMoney" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitMoneyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'fitMoney',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.DecimalPipe }] });
 
-class FitPipeModule {
-}
-FitPipeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FitPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-FitPipeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FitPipeModule, declarations: [FitMoneyPipe], imports: [CommonModule], exports: [FitMoneyPipe] });
-FitPipeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FitPipeModule, providers: [
-        DecimalPipe
-    ], imports: [[
-            CommonModule
-        ]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FitPipeModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        CommonModule
-                    ],
-                    declarations: [
-                        FitMoneyPipe
-                    ],
-                    exports: [
-                        FitMoneyPipe
-                    ],
-                    providers: [
-                        DecimalPipe
-                    ]
-                }]
+class FitPipeModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.18", ngImport: i0, type: FitPipeModule, imports: [CommonModule,
+            FitMoneyPipe], exports: [FitMoneyPipe] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitPipeModule, providers: [
+            DecimalPipe
+        ], imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitPipeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FitMoneyPipe
+                    ],
+                    exports: [
+                        FitMoneyPipe
+                    ],
+                    providers: [
+                        DecimalPipe
+                    ]
+                }]
         }] });
 
 // pipes
 
-/**
- * Generated bundle index. Do not edit.
+class FitAdapteService {
+    window;
+    sizeChanged;
+    constructor(window) {
+        this.window = window;
+        this.sizeChanged = new BehaviorSubject({
+            width: this.window.innerWidth,
+            height: this.window.innerHeight
+        });
+        fromEvent(window, 'resize').pipe(map(event => ({
+            width: event.currentTarget.innerWidth,
+            height: event.currentTarget.innerHeight
+        }))).subscribe((windowSize) => {
+            this.sizeChanged.next(windowSize);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitAdapteService, deps: [{ token: 'windowObject' }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitAdapteService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitAdapteService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: Window, decorators: [{
+                    type: Inject,
+                    args: ['windowObject']
+                }] }] });
+
+class FitCookiesService {
+    document;
+    platformId;
+    documentIsAccessible;
+    constructor(document, platformId) {
+        this.document = document;
+        this.platformId = platformId;
+        this.documentIsAccessible = isPlatformBrowser(this.platformId);
+    }
+    check(name) {
+        if (!this.documentIsAccessible) {
+            return false;
+        }
+        name = encodeURIComponent(name);
+        const regExp = this.getCookieRegExp(name);
+        const exists = regExp.test(this.document.cookie);
+        return exists;
+    }
+    get(name) {
+        if (this.documentIsAccessible && this.check(name)) {
+            name = encodeURIComponent(name);
+            const regExp = this.getCookieRegExp(name);
+            const result = regExp.exec(this.document.cookie);
+            return this.safeDecodeURIComponent(result[1]);
+        }
+        else {
+            return '';
+        }
+    }
+    getAll() {
+        if (!this.documentIsAccessible) {
+            return {};
+        }
+        const cookies = {};
+        const document = this.document;
+        if (document.cookie && document.cookie !== '') {
+            document.cookie.split(';').forEach((currentCookie) => {
+                const [cookieName, cookieValue] = currentCookie.split('=');
+                cookies[this.safeDecodeURIComponent(cookieName.replace(/^ /, ''))] = this.safeDecodeURIComponent(cookieValue);
+            });
+        }
+        return cookies;
+    }
+    set(name, value, expires, path, domain, secure, sameSite = 'Lax') {
+        if (!this.documentIsAccessible) {
+            return;
+        }
+        let cookieString = encodeURIComponent(name) + '=' + encodeURIComponent(value) + ';';
+        if (expires) {
+            if (typeof expires === 'number') {
+                const dateExpires = new Date(new Date().getTime() + expires * 1000 * 60 * 60 * 24);
+                cookieString += 'expires=' + dateExpires.toUTCString() + ';';
+            }
+            else {
+                cookieString += 'expires=' + expires.toUTCString() + ';';
+            }
+        }
+        if (path) {
+            cookieString += 'path=' + path + ';';
+        }
+        if (domain) {
+            cookieString += 'domain=' + domain + ';';
+        }
+        if (secure === false && sameSite === 'None') {
+            secure = true;
+        }
+        if (secure) {
+            cookieString += 'secure;';
+        }
+        cookieString += 'sameSite=' + sameSite + ';';
+        this.document.cookie = cookieString;
+    }
+    delete(name, path, domain, secure, sameSite = 'Lax') {
+        if (!this.documentIsAccessible) {
+            return;
+        }
+        this.set(name, '', new Date('Thu, 01 Jan 1970 00:00:01 GMT'), path, domain, secure, sameSite);
+    }
+    deleteAll(path, domain, secure, sameSite = 'Lax') {
+        if (!this.documentIsAccessible) {
+            return;
+        }
+        const cookies = this.getAll();
+        for (const cookieName in cookies) {
+            if (cookies.hasOwnProperty(cookieName)) {
+                this.delete(cookieName, path, domain, secure, sameSite);
+            }
+        }
+    }
+    getCookieRegExp(name) {
+        const escapedName = name.replace(/([\[\]\{\}\(\)\|\=\;\+\?\,\.\*\^\$])/gi, '\\$1');
+        return new RegExp('(?:^' + escapedName + '|;\\s*' + escapedName + ')=(.*?)(?:;|$)', 'g');
+    }
+    safeDecodeURIComponent(encodedURIComponent) {
+        try {
+            return decodeURIComponent(encodedURIComponent);
+        }
+        catch {
+            return encodedURIComponent;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitCookiesService, deps: [{ token: DOCUMENT }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitCookiesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: FitCookiesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.InjectionToken, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }] });
+
+// service
+
+/**
+ * Generated bundle index. Do not edit.
  */
 
-export { ControlErrorDirective, FitCurrencyConst, FitDirectiveModule, FitFormUtil, FitGeneralUtil, FitMoneyPipe, FitPipeModule, FitRegexConst, FitValidateUtil, HoverDirective, InputDirective, ScrollDirective, SensitiveDirective };
+export { ControlErrorDirective, FitAdapteService, FitCookiesService, FitCurrencyConst, FitDirectiveModule, FitFormUtil, FitGeneralUtil, FitMoneyPipe, FitPipeModule, FitRegexConst, FitValidateUtil, HoverDirective, InputDirective, ScrollDirective, SensitiveDirective };
 //# sourceMappingURL=fitcoders-shared.mjs.map