{"version":3,"file":"4409.513c65f4b68eefe7.js","mappings":"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","names":["NGX_MASK_CONFIG","InjectionToken","NEW_CONFIG","INITIAL_CONFIG","initialConfig","suffix","prefix","thousandSeparator","decimalMarker","clearIfNotMatch","showTemplate","showMaskTyped","placeHolderCharacter","dropSpecialCharacters","hiddenInput","undefined","shownMaskExpression","separatorLimit","allowNegativeNumbers","validation","specialCharacters","leadZeroDateTime","apm","leadZero","keepCharacterPositions","triggerOnMaskChange","inputTransformFn","value","outputTransformFn","maskFilled","EventEmitter","patterns","pattern","RegExp","optional","X","symbol","A","S","U","L","d","m","M","H","h","s","timeMasks","withoutValidation","NgxMaskApplierService","constructor","_config","this","_shift","Set","plusOnePosition","maskExpression","actualValue","showKeepCharacterExp","deletedSpecialCharacter","_formatWithSeparators","str","thousandSeparatorChar","decimalChars","precision","_a","_b","_c","x","decimalChar","Array","isArray","regExp","map","v","indexOf","join","split","match","decimals","length","res","replace","slice","rgx","test","substring","percentage","sanitizedStr","Number","isNaN","getPrecision","Infinity","checkAndRemoveSuffix","inputValue","_d","i","substr","includes","checkInputPrecision","marker","find","dm","precisionRegEx","_charToRegExpExpression","precisionMatch","precisionMatchLength","_compareOrIncludes","applyMaskWithPattern","maskAndPattern","mask","customPattern","applyMask","position","justPasted","backspaced","cb","_e","_f","_g","_h","_j","_k","_l","_m","_o","_p","_q","_r","_s","cursor","result","multi","backspaceShift","shift","stepBack","inputArray","toString","valuesIP","ipError","_validIP","arr","push","cpfCnpjError","G","startsWith","_stripToDecimal","base","_splitPercentZero","thousandSeparatorCharEscaped","invalidChars","invalidCharRegexp","strForSep","commaShift","shiftStep","add","clear","inputSymbol","symbolStarInPattern","_checkSymbolMask","_shiftStep","daysCount","inputValueCursor","inputValueCursorPlusOne","inputValueCursorPlusTwo","inputValueCursorMinusOne","inputValueCursorMinusTwo","inputValueCursorMinusThree","inputValueSliceMinusThreeMinusOne","inputValueSliceMinusOnePlusOne","inputValueSliceCursorPlusTwo","inputValueSliceMinusTwoCursor","maskStartWithMonth","startWithMonthInput","withoutDays","monthsCount","specialChart","day1monthInput","day2monthInput","day2monthInputDot","day1monthPaste","day2monthPaste","t","_findSpecialChar","newPosition","has","actualShift","onlySpecial","every","char","_findDropSpecialChar","val","maskSymbol","filter","idx","isDecimalMarker","charsToEscape","inputLength","comparedValue","excludedValue","some","index","decimalIndex","parsedValue","parseInt","integerPart","decimalPart","integerString","decimal","ɵfac","i0","ɵprov","factory","NgxMaskService","document","_elementRef","_renderer","super","isNumberValue","maskIsShown","selStart","selEnd","writingValue","maskChanged","_maskExpressionArray","_emitValue","_previousValue","_currentValue","onChange","_","showMaskInInput","formControlResult","getSymbol","newInputValue","actualResult","splice","removeMask","shiftTypedSymbols","Boolean","getActualValue","item","hideInput","resLen","prefNmask","countSkipedSymbol","_numberSkipedSymbols","regex","exec","applyValueChanges","formElement","nativeElement","_getActiveElement","clearIfNotMatchFn","curr","compare","maskChar","symbolToReplace","currSymbol","replaceSymbol","numberToString","String","toLocaleString","useGrouping","maximumFractionDigits","inputVal","Error","_checkForIp","_checkForCpfCnpj","formElementProperty","name","Promise","resolve","then","setProperty","checkDropSpecialCharAmount","chars","_removeMask","_removeSuffix","_removePrefix","concat","cpf","cnpj","shadowRootEl","activeElement","shadowRoot","_toNumber","_checkSymbols","num","specialCharactersForRemove","_regExpForRemove","_retrieveSeparatorValue","_checkPatternForSpace","_replaceDecimalMarkerToDot","markers","separatorPrecision","_retrieveSeparatorPrecision","separatorValue","_checkPrecision","key","hasOwnProperty","patternString","maskExpretion","matcher","separatorExpression","toFixed","_repeatPatternSymbols","maskExp","reduce","accum","currVal","_start","_end","repeatNumber","replaceWith","symbols","currentLocaleDecimalMarker","DOCUMENT","NgxMaskDirective","_maskService","_maskValue","_isFocused","_position","_justPasted","_isComposing","onTouch","ngOnChanges","changes","currentValue","previousValue","firstChange","sort","a","b","_setMask","c","requestAnimationFrame","click","_applyMask","validate","_createValidationError","_validateTime","counterOfOpt","lastIndexOf","opt","array","lastIndexArray","special","emit","onPaste","onFocus","onModelChange","onInput","e","el","target","transformedValue","type","_inputValue","selectionStart","prefixLength","checkSymbols","checkSpecialCharacter","selectRangeBackspace","_code","part1","part2","y","caretShift","_backspaceShift","positionToApply","_getActualInputLength","setSelectionRange","console","warn","onCompositionStart","onCompositionEnd","onBlur","repeat","onClick","selectionEnd","keyCode","focus","nextValue","onKeyDown","code","preventDefault","checkSelectionOnDeletion","cursorStart","readOnly","ctrlKey","metaKey","writeValue","controlValue","__awaiter","setDisabledState","disable","localeDecimalMarker","registerOnChange","fn","registerOnTouched","Math","min","max","isDisabled","rowMaskLen","requiredMask","expression","check","character","indexMask","charAt","ɵdir","selectors","inputs","provide","NG_VALUE_ACCESSOR","useExisting","forwardRef","NG_VALIDATORS","initConfig","configValue","Object","assign","Function","NgxMaskModule","static","ngModule","providers","useValue","useFactory","_configFactory","deps","ɵmod","ɵinj"],"sourceRoot":"webpack:///","sources":["./node_modules/ngx-mask/fesm2015/ngx-mask.mjs"],"sourcesContent":["import * as i0 from '@angular/core';\nimport { InjectionToken, EventEmitter, Injectable, Inject, Optional, forwardRef, Directive, Input, Output, HostListener, Pipe, NgModule } from '@angular/core';\nimport { __awaiter, __rest } from 'tslib';\nimport { DOCUMENT } from '@angular/common';\nimport { NG_VALUE_ACCESSOR, NG_VALIDATORS } from '@angular/forms';\n\nconst NGX_MASK_CONFIG = new InjectionToken('ngx-mask config');\nconst NEW_CONFIG = new InjectionToken('new ngx-mask config');\nconst INITIAL_CONFIG = new InjectionToken('initial ngx-mask config');\nconst initialConfig = {\n    suffix: '',\n    prefix: '',\n    thousandSeparator: ' ',\n    decimalMarker: ['.', ','],\n    clearIfNotMatch: false,\n    showTemplate: false,\n    showMaskTyped: false,\n    placeHolderCharacter: '_',\n    dropSpecialCharacters: true,\n    hiddenInput: undefined,\n    shownMaskExpression: '',\n    separatorLimit: '',\n    allowNegativeNumbers: false,\n    validation: true,\n    // eslint-disable-next-line @typescript-eslint/quotes\n    specialCharacters: ['-', '/', '(', ')', '.', ':', ' ', '+', ',', '@', '[', ']', '\"', \"'\"],\n    leadZeroDateTime: false,\n    apm: false,\n    leadZero: false,\n    keepCharacterPositions: false,\n    triggerOnMaskChange: false,\n    inputTransformFn: (value) => value,\n    outputTransformFn: (value) => value,\n    maskFilled: new EventEmitter(),\n    patterns: {\n        '0': {\n            pattern: new RegExp('\\\\d'),\n        },\n        '9': {\n            pattern: new RegExp('\\\\d'),\n            optional: true,\n        },\n        X: {\n            pattern: new RegExp('\\\\d'),\n            symbol: '*',\n        },\n        A: {\n            pattern: new RegExp('[a-zA-Z0-9]'),\n        },\n        S: {\n            pattern: new RegExp('[a-zA-Z]'),\n        },\n        U: {\n            pattern: new RegExp('[A-Z]'),\n        },\n        L: {\n            pattern: new RegExp('[a-z]'),\n        },\n        d: {\n            pattern: new RegExp('\\\\d'),\n        },\n        m: {\n            pattern: new RegExp('\\\\d'),\n        },\n        M: {\n            pattern: new RegExp('\\\\d'),\n        },\n        H: {\n            pattern: new RegExp('\\\\d'),\n        },\n        h: {\n            pattern: new RegExp('\\\\d'),\n        },\n        s: {\n            pattern: new RegExp('\\\\d'),\n        },\n    },\n};\nconst timeMasks = [\n    \"Hh:m0:s0\" /* HOURS_MINUTES_SECONDS */,\n    \"Hh:m0\" /* HOURS_MINUTES */,\n    \"m0:s0\" /* MINUTES_SECONDS */,\n];\nconst withoutValidation = [\n    \"percent\" /* PERCENT */,\n    \"Hh\" /* HOURS_HOUR */,\n    \"s0\" /* SECONDS */,\n    \"m0\" /* MINUTES */,\n    \"separator\" /* SEPARATOR */,\n    \"d0/M0/0000\" /* DAYS_MONTHS_YEARS */,\n    \"d0/M0\" /* DAYS_MONTHS */,\n    \"d0\" /* DAYS */,\n    \"M0\" /* MONTHS */,\n];\n\nclass NgxMaskApplierService {\n    constructor(_config) {\n        this._config = _config;\n        this._shift = new Set();\n        this.plusOnePosition = false;\n        this.maskExpression = '';\n        this.actualValue = '';\n        this.showKeepCharacterExp = '';\n        this.shownMaskExpression = '';\n        this.deletedSpecialCharacter = false;\n        this._formatWithSeparators = (str, thousandSeparatorChar, decimalChars, precision) => {\n            var _a, _b, _c;\n            let x = [];\n            let decimalChar = '';\n            if (Array.isArray(decimalChars)) {\n                const regExp = new RegExp(decimalChars.map((v) => ('[\\\\^$.|?*+()'.indexOf(v) >= 0 ? `\\\\${v}` : v)).join('|'));\n                x = str.split(regExp);\n                decimalChar = (_b = (_a = str.match(regExp)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : \"\" /* EMPTY_STRING */;\n            }\n            else {\n                x = str.split(decimalChars);\n                decimalChar = decimalChars;\n            }\n            const decimals = x.length > 1 ? `${decimalChar}${x[1]}` : \"\" /* EMPTY_STRING */;\n            let res = (_c = x[0]) !== null && _c !== void 0 ? _c : \"\" /* EMPTY_STRING */;\n            const separatorLimit = this.separatorLimit.replace(/\\s/g, \"\" /* EMPTY_STRING */);\n            if (separatorLimit && +separatorLimit) {\n                if (res[0] === \"-\" /* MINUS */) {\n                    res = `-${res.slice(1, res.length).slice(0, separatorLimit.length)}`;\n                }\n                else {\n                    res = res.slice(0, separatorLimit.length);\n                }\n            }\n            const rgx = /(\\d+)(\\d{3})/;\n            while (thousandSeparatorChar && rgx.test(res)) {\n                res = res.replace(rgx, '$1' + thousandSeparatorChar + '$2');\n            }\n            if (precision === undefined) {\n                return res + decimals;\n            }\n            else if (precision === 0) {\n                return res;\n            }\n            return res + decimals.substring(0, precision + 1);\n        };\n        this.percentage = (str) => {\n            const sanitizedStr = str.replace(',', '.');\n            const value = Number(sanitizedStr);\n            return !isNaN(value) && value >= 0 && value <= 100;\n        };\n        this.getPrecision = (maskExpression) => {\n            const x = maskExpression.split(\".\" /* DOT */);\n            if (x.length > 1) {\n                return Number(x[x.length - 1]);\n            }\n            return Infinity;\n        };\n        this.checkAndRemoveSuffix = (inputValue) => {\n            var _a, _b, _c, _d;\n            for (let i = ((_a = this.suffix) === null || _a === void 0 ? void 0 : _a.length) - 1; i >= 0; i--) {\n                const substr = this.suffix.substring(i, (_b = this.suffix) === null || _b === void 0 ? void 0 : _b.length);\n                if (inputValue.includes(substr) &&\n                    i !== ((_c = this.suffix) === null || _c === void 0 ? void 0 : _c.length) - 1 &&\n                    (i - 1 < 0 ||\n                        !inputValue.includes(this.suffix.substring(i - 1, (_d = this.suffix) === null || _d === void 0 ? void 0 : _d.length)))) {\n                    return inputValue.replace(substr, \"\" /* EMPTY_STRING */);\n                }\n            }\n            return inputValue;\n        };\n        this.checkInputPrecision = (inputValue, precision, decimalMarker) => {\n            var _a, _b;\n            if (precision < Infinity) {\n                // TODO need think about decimalMarker\n                if (Array.isArray(decimalMarker)) {\n                    const marker = decimalMarker.find((dm) => dm !== this.thousandSeparator);\n                    // eslint-disable-next-line no-param-reassign\n                    decimalMarker = marker ? marker : decimalMarker[0];\n                }\n                const precisionRegEx = new RegExp(this._charToRegExpExpression(decimalMarker) + `\\\\d{${precision}}.*$`);\n                const precisionMatch = inputValue.match(precisionRegEx);\n                const precisionMatchLength = (_b = (precisionMatch && ((_a = precisionMatch[0]) === null || _a === void 0 ? void 0 : _a.length))) !== null && _b !== void 0 ? _b : 0;\n                if (precisionMatchLength - 1 > precision) {\n                    const diff = precisionMatchLength - 1 - precision;\n                    // eslint-disable-next-line no-param-reassign\n                    inputValue = inputValue.substring(0, inputValue.length - diff);\n                }\n                if (precision === 0 &&\n                    this._compareOrIncludes(inputValue[inputValue.length - 1], decimalMarker, this.thousandSeparator)) {\n                    // eslint-disable-next-line no-param-reassign\n                    inputValue = inputValue.substring(0, inputValue.length - 1);\n                }\n            }\n            return inputValue;\n        };\n        this.dropSpecialCharacters = this._config.dropSpecialCharacters;\n        this.hiddenInput = this._config.hiddenInput;\n        this.clearIfNotMatch = this._config.clearIfNotMatch;\n        this.specialCharacters = this._config.specialCharacters;\n        this.patterns = this._config.patterns;\n        this.prefix = this._config.prefix;\n        this.suffix = this._config.suffix;\n        this.thousandSeparator = this._config.thousandSeparator;\n        this.decimalMarker = this._config.decimalMarker;\n        this.showMaskTyped = this._config.showMaskTyped;\n        this.placeHolderCharacter = this._config.placeHolderCharacter;\n        this.validation = this._config.validation;\n        this.separatorLimit = this._config.separatorLimit;\n        this.allowNegativeNumbers = this._config.allowNegativeNumbers;\n        this.leadZeroDateTime = this._config.leadZeroDateTime;\n        this.leadZero = this._config.leadZero;\n        this.apm = this._config.apm;\n        this.inputTransformFn = this._config.inputTransformFn;\n        this.outputTransformFn = this._config.outputTransformFn;\n        this.keepCharacterPositions = this._config.keepCharacterPositions;\n    }\n    applyMaskWithPattern(inputValue, maskAndPattern) {\n        const [mask, customPattern] = maskAndPattern;\n        this.customPattern = customPattern;\n        return this.applyMask(inputValue, mask);\n    }\n    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, \n    // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-explicit-any\n    cb = () => { }) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;\n        if (!maskExpression || typeof inputValue !== 'string') {\n            return \"\" /* EMPTY_STRING */;\n        }\n        let cursor = 0;\n        let result = '';\n        let multi = false;\n        let backspaceShift = false;\n        let shift = 1;\n        let stepBack = false;\n        if (inputValue.slice(0, this.prefix.length) === this.prefix) {\n            // eslint-disable-next-line no-param-reassign\n            inputValue = inputValue.slice(this.prefix.length, inputValue.length);\n        }\n        if (!!this.suffix && (inputValue === null || inputValue === void 0 ? void 0 : inputValue.length) > 0) {\n            // eslint-disable-next-line no-param-reassign\n            inputValue = this.checkAndRemoveSuffix(inputValue);\n        }\n        if (inputValue === '(' && this.prefix) {\n            // eslint-disable-next-line no-param-reassign\n            inputValue = '';\n        }\n        const inputArray = inputValue.toString().split(\"\" /* EMPTY_STRING */);\n        if (this.allowNegativeNumbers &&\n            inputValue.slice(cursor, cursor + 1) === \"-\" /* MINUS */) {\n            // eslint-disable-next-line no-param-reassign\n            result += inputValue.slice(cursor, cursor + 1);\n        }\n        if (maskExpression === \"IP\" /* IP */) {\n            const valuesIP = inputValue.split(\".\" /* DOT */);\n            this.ipError = this._validIP(valuesIP);\n            // eslint-disable-next-line no-param-reassign\n            maskExpression = '099.099.099.099';\n        }\n        const arr = [];\n        for (let i = 0; i < inputValue.length; i++) {\n            if ((_a = inputValue[i]) === null || _a === void 0 ? void 0 : _a.match('\\\\d')) {\n                arr.push((_b = inputValue[i]) !== null && _b !== void 0 ? _b : \"\" /* EMPTY_STRING */);\n            }\n        }\n        if (maskExpression === \"CPF_CNPJ\" /* CPF_CNPJ */) {\n            this.cpfCnpjError = arr.length !== 11 && arr.length !== 14;\n            if (arr.length > 11) {\n                // eslint-disable-next-line no-param-reassign\n                maskExpression = '00.000.000/0000-00';\n            }\n            else {\n                // eslint-disable-next-line no-param-reassign\n                maskExpression = '000.000.000-00';\n            }\n        }\n        if (maskExpression.startsWith(\"percent\" /* PERCENT */)) {\n            if (inputValue.match('[a-z]|[A-Z]') ||\n                // eslint-disable-next-line no-useless-escape\n                (inputValue.match(/[-!$%^&*()_+|~=`{}\\[\\]:\";'<>?,\\/.]/) && !backspaced)) {\n                // eslint-disable-next-line no-param-reassign\n                inputValue = this._stripToDecimal(inputValue);\n                const precision = this.getPrecision(maskExpression);\n                // eslint-disable-next-line no-param-reassign\n                inputValue = this.checkInputPrecision(inputValue, precision, this.decimalMarker);\n            }\n            const decimalMarker = typeof this.decimalMarker === 'string' ? this.decimalMarker : \".\" /* DOT */;\n            if (inputValue.indexOf(decimalMarker) > 0 &&\n                !this.percentage(inputValue.substring(0, inputValue.indexOf(decimalMarker)))) {\n                let base = inputValue.substring(0, inputValue.indexOf(decimalMarker) - 1);\n                if (this.allowNegativeNumbers &&\n                    inputValue.slice(cursor, cursor + 1) === \"-\" /* MINUS */ &&\n                    !backspaced) {\n                    base = inputValue.substring(0, inputValue.indexOf(decimalMarker));\n                }\n                // eslint-disable-next-line no-param-reassign\n                inputValue = `${base}${inputValue.substring(inputValue.indexOf(decimalMarker), inputValue.length)}`;\n            }\n            let value = '';\n            this.allowNegativeNumbers &&\n                inputValue.slice(cursor, cursor + 1) === \"-\" /* MINUS */\n                ? (value = inputValue.slice(cursor + 1, cursor + inputValue.length))\n                : (value = inputValue);\n            if (this.percentage(value)) {\n                result = this._splitPercentZero(inputValue);\n            }\n            else {\n                result = this._splitPercentZero(inputValue.substring(0, inputValue.length - 1));\n            }\n        }\n        else if (maskExpression.startsWith(\"separator\" /* SEPARATOR */)) {\n            if (inputValue.match('[wа-яА-Я]') ||\n                inputValue.match('[ЁёА-я]') ||\n                inputValue.match('[a-z]|[A-Z]') ||\n                inputValue.match(/[-@#!$%\\\\^&*()_£¬'+|~=`{}\\]:\";<>.?/]/) ||\n                inputValue.match('[^A-Za-z0-9,]')) {\n                // eslint-disable-next-line no-param-reassign\n                inputValue = this._stripToDecimal(inputValue);\n            }\n            const precision = this.getPrecision(maskExpression);\n            const decimalMarker = Array.isArray(this.decimalMarker)\n                ? \".\" /* DOT */\n                : this.decimalMarker;\n            if (precision === 0) {\n                // eslint-disable-next-line no-param-reassign\n                inputValue = this.allowNegativeNumbers\n                    ? inputValue.length > 2 &&\n                        inputValue[0] === \"-\" /* MINUS */ &&\n                        inputValue[1] === \"0\" /* NUMBER_ZERO */ &&\n                        inputValue[2] !== this.thousandSeparator &&\n                        inputValue[2] !== \",\" /* COMMA */ &&\n                        inputValue[2] !== \".\" /* DOT */\n                        ? '-' + inputValue.slice(2, inputValue.length)\n                        : inputValue[0] === \"0\" /* NUMBER_ZERO */ &&\n                            inputValue.length > 1 &&\n                            inputValue[1] !== this.thousandSeparator &&\n                            inputValue[1] !== \",\" /* COMMA */ &&\n                            inputValue[1] !== \".\" /* DOT */\n                            ? inputValue.slice(1, inputValue.length)\n                            : inputValue\n                    : inputValue.length > 1 &&\n                        inputValue[0] === \"0\" /* NUMBER_ZERO */ &&\n                        inputValue[1] !== this.thousandSeparator &&\n                        inputValue[1] !== \",\" /* COMMA */ &&\n                        inputValue[1] !== \".\" /* DOT */\n                        ? inputValue.slice(1, inputValue.length)\n                        : inputValue;\n            }\n            else {\n                // eslint-disable-next-line no-param-reassign\n                if (inputValue[0] === decimalMarker && inputValue.length > 1) {\n                    // eslint-disable-next-line no-param-reassign\n                    inputValue =\n                        \"0\" /* NUMBER_ZERO */ + inputValue.slice(0, inputValue.length + 1);\n                    this.plusOnePosition = true;\n                }\n                if (inputValue[0] === \"0\" /* NUMBER_ZERO */ &&\n                    inputValue[1] !== decimalMarker &&\n                    inputValue[1] !== this.thousandSeparator) {\n                    // eslint-disable-next-line no-param-reassign\n                    inputValue =\n                        inputValue.length > 1\n                            ? inputValue.slice(0, 1) +\n                                decimalMarker +\n                                inputValue.slice(1, inputValue.length + 1)\n                            : inputValue;\n                    this.plusOnePosition = true;\n                }\n                if (this.allowNegativeNumbers &&\n                    inputValue[0] === \"-\" /* MINUS */ &&\n                    (inputValue[1] === decimalMarker ||\n                        inputValue[1] === \"0\" /* NUMBER_ZERO */)) {\n                    // eslint-disable-next-line no-param-reassign\n                    inputValue =\n                        inputValue[1] === decimalMarker && inputValue.length > 2\n                            ? inputValue.slice(0, 1) +\n                                \"0\" /* NUMBER_ZERO */ +\n                                inputValue.slice(1, inputValue.length)\n                            : inputValue[1] === \"0\" /* NUMBER_ZERO */ &&\n                                inputValue.length > 2 &&\n                                inputValue[2] !== decimalMarker\n                                ? inputValue.slice(0, 2) +\n                                    decimalMarker +\n                                    inputValue.slice(2, inputValue.length)\n                                : inputValue;\n                    this.plusOnePosition = true;\n                }\n            }\n            if (backspaced) {\n                if (inputValue[0] === \"0\" /* NUMBER_ZERO */ &&\n                    inputValue[1] === this.decimalMarker &&\n                    (inputValue[position] === \"0\" /* NUMBER_ZERO */ ||\n                        inputValue[position] === this.decimalMarker)) {\n                    // eslint-disable-next-line no-param-reassign\n                    inputValue = inputValue.slice(2, inputValue.length);\n                }\n                if (inputValue[0] === \"-\" /* MINUS */ &&\n                    inputValue[1] === \"0\" /* NUMBER_ZERO */ &&\n                    inputValue[2] === this.decimalMarker &&\n                    (inputValue[position] === \"0\" /* NUMBER_ZERO */ ||\n                        inputValue[position] === this.decimalMarker)) {\n                    // eslint-disable-next-line no-param-reassign\n                    inputValue = \"-\" /* MINUS */ + inputValue.slice(3, inputValue.length);\n                }\n                // eslint-disable-next-line no-param-reassign\n                inputValue = this._compareOrIncludes(inputValue[inputValue.length - 1], this.decimalMarker, this.thousandSeparator)\n                    ? inputValue.slice(0, inputValue.length - 1)\n                    : inputValue;\n            }\n            // TODO: we had different rexexps here for the different cases... but tests dont seam to bother - check this\n            //  separator: no COMMA, dot-sep: no SPACE, COMMA OK, comma-sep: no SPACE, COMMA OK\n            const thousandSeparatorCharEscaped = this._charToRegExpExpression(this.thousandSeparator);\n            let invalidChars = '@#!$%^&*()_+|~=`{}\\\\[\\\\]:\\\\s,\\\\.\";<>?\\\\/'.replace(thousandSeparatorCharEscaped, '');\n            //.replace(decimalMarkerEscaped, '');\n            if (Array.isArray(this.decimalMarker)) {\n                for (const marker of this.decimalMarker) {\n                    invalidChars = invalidChars.replace(this._charToRegExpExpression(marker), \"\" /* EMPTY_STRING */);\n                }\n            }\n            else {\n                invalidChars = invalidChars.replace(this._charToRegExpExpression(this.decimalMarker), '');\n            }\n            const invalidCharRegexp = new RegExp('[' + invalidChars + ']');\n            if (inputValue.match(invalidCharRegexp)) {\n                // eslint-disable-next-line no-param-reassign\n                inputValue = inputValue.substring(0, inputValue.length - 1);\n            }\n            // eslint-disable-next-line no-param-reassign\n            inputValue = this.checkInputPrecision(inputValue, precision, this.decimalMarker);\n            const strForSep = inputValue.replace(new RegExp(thousandSeparatorCharEscaped, 'g'), '');\n            result = this._formatWithSeparators(strForSep, this.thousandSeparator, this.decimalMarker, precision);\n            const commaShift = result.indexOf(\",\" /* COMMA */) - inputValue.indexOf(\",\" /* COMMA */);\n            const shiftStep = result.length - inputValue.length;\n            if (shiftStep > 0 && result[position] !== this.thousandSeparator) {\n                backspaceShift = true;\n                let _shift = 0;\n                do {\n                    this._shift.add(position + _shift);\n                    _shift++;\n                } while (_shift < shiftStep);\n            }\n            else if (result[position - 1] === this.decimalMarker ||\n                shiftStep === -4 ||\n                shiftStep === -3 ||\n                result[position] === \",\" /* COMMA */) {\n                this._shift.clear();\n                this._shift.add(position - 1);\n            }\n            else if ((commaShift !== 0 &&\n                position > 0 &&\n                !(result.indexOf(\",\" /* COMMA */) >= position && position > 3)) ||\n                (!(result.indexOf(\".\" /* DOT */) >= position && position > 3) &&\n                    shiftStep <= 0)) {\n                this._shift.clear();\n                backspaceShift = true;\n                shift = shiftStep;\n                // eslint-disable-next-line no-param-reassign\n                position += shiftStep;\n                this._shift.add(position);\n            }\n            else {\n                this._shift.clear();\n            }\n        }\n        else {\n            for (\n            // eslint-disable-next-line\n            let i = 0, inputSymbol = inputArray[0]; i < inputArray.length; i++, inputSymbol = (_c = inputArray[i]) !== null && _c !== void 0 ? _c : \"\" /* EMPTY_STRING */) {\n                if (cursor === maskExpression.length) {\n                    break;\n                }\n                const symbolStarInPattern = \"*\" /* SYMBOL_STAR */ in this.patterns;\n                if (this._checkSymbolMask(inputSymbol, (_d = maskExpression[cursor]) !== null && _d !== void 0 ? _d : \"\" /* EMPTY_STRING */) &&\n                    maskExpression[cursor + 1] === \"?\" /* SYMBOL_QUESTION */) {\n                    result += inputSymbol;\n                    cursor += 2;\n                }\n                else if (maskExpression[cursor + 1] === \"*\" /* SYMBOL_STAR */ &&\n                    multi &&\n                    this._checkSymbolMask(inputSymbol, (_e = maskExpression[cursor + 2]) !== null && _e !== void 0 ? _e : \"\" /* EMPTY_STRING */)) {\n                    result += inputSymbol;\n                    cursor += 3;\n                    multi = false;\n                }\n                else if (this._checkSymbolMask(inputSymbol, (_f = maskExpression[cursor]) !== null && _f !== void 0 ? _f : \"\" /* EMPTY_STRING */) &&\n                    maskExpression[cursor + 1] === \"*\" /* SYMBOL_STAR */ &&\n                    !symbolStarInPattern) {\n                    result += inputSymbol;\n                    multi = true;\n                }\n                else if (maskExpression[cursor + 1] === \"?\" /* SYMBOL_QUESTION */ &&\n                    this._checkSymbolMask(inputSymbol, (_g = maskExpression[cursor + 2]) !== null && _g !== void 0 ? _g : \"\" /* EMPTY_STRING */)) {\n                    result += inputSymbol;\n                    cursor += 3;\n                }\n                else if (this._checkSymbolMask(inputSymbol, (_h = maskExpression[cursor]) !== null && _h !== void 0 ? _h : \"\" /* EMPTY_STRING */)) {\n                    if (maskExpression[cursor] === \"H\" /* HOURS */) {\n                        if (this.apm ? Number(inputSymbol) > 9 : Number(inputSymbol) > 2) {\n                            // eslint-disable-next-line no-param-reassign\n                            position = !this.leadZeroDateTime ? position + 1 : position;\n                            cursor += 1;\n                            this._shiftStep(maskExpression, cursor, inputArray.length);\n                            i--;\n                            if (this.leadZeroDateTime) {\n                                result += '0';\n                            }\n                            continue;\n                        }\n                    }\n                    if (maskExpression[cursor] === \"h\" /* HOUR */) {\n                        if (this.apm\n                            ? (result.length === 1 && Number(result) > 1) ||\n                                (result === '1' && Number(inputSymbol) > 2) ||\n                                (inputValue.slice(cursor - 1, cursor).length === 1 &&\n                                    Number(inputValue.slice(cursor - 1, cursor)) > 2) ||\n                                (inputValue.slice(cursor - 1, cursor) === '1' &&\n                                    Number(inputSymbol) > 2)\n                            : (result === '2' && Number(inputSymbol) > 3) ||\n                                ((result.slice(cursor - 2, cursor) === '2' ||\n                                    result.slice(cursor - 3, cursor) === '2' ||\n                                    result.slice(cursor - 4, cursor) === '2' ||\n                                    result.slice(cursor - 1, cursor) === '2') &&\n                                    Number(inputSymbol) > 3 &&\n                                    cursor > 10)) {\n                            // eslint-disable-next-line no-param-reassign\n                            position = position + 1;\n                            cursor += 1;\n                            i--;\n                            continue;\n                        }\n                    }\n                    if (maskExpression[cursor] === \"m\" /* MINUTE */ ||\n                        maskExpression[cursor] === \"s\" /* SECOND */) {\n                        if (Number(inputSymbol) > 5) {\n                            // eslint-disable-next-line no-param-reassign\n                            position = !this.leadZeroDateTime ? position + 1 : position;\n                            cursor += 1;\n                            this._shiftStep(maskExpression, cursor, inputArray.length);\n                            i--;\n                            if (this.leadZeroDateTime) {\n                                result += '0';\n                            }\n                            continue;\n                        }\n                    }\n                    const daysCount = 31;\n                    const inputValueCursor = inputValue[cursor];\n                    const inputValueCursorPlusOne = inputValue[cursor + 1];\n                    const inputValueCursorPlusTwo = inputValue[cursor + 2];\n                    const inputValueCursorMinusOne = inputValue[cursor - 1];\n                    const inputValueCursorMinusTwo = inputValue[cursor - 2];\n                    const inputValueCursorMinusThree = inputValue[cursor - 3];\n                    const inputValueSliceMinusThreeMinusOne = inputValue.slice(cursor - 3, cursor - 1);\n                    const inputValueSliceMinusOnePlusOne = inputValue.slice(cursor - 1, cursor + 1);\n                    const inputValueSliceCursorPlusTwo = inputValue.slice(cursor, cursor + 2);\n                    const inputValueSliceMinusTwoCursor = inputValue.slice(cursor - 2, cursor);\n                    if (maskExpression[cursor] === \"d\" /* DAY */) {\n                        const maskStartWithMonth = maskExpression.slice(0, 2) === \"M0\" /* MONTHS */;\n                        const startWithMonthInput = maskExpression.slice(0, 2) === \"M0\" /* MONTHS */ &&\n                            this.specialCharacters.includes(inputValueCursorMinusTwo);\n                        if ((Number(inputSymbol) > 3 && this.leadZeroDateTime) ||\n                            (!maskStartWithMonth &&\n                                (Number(inputValueSliceCursorPlusTwo) > daysCount ||\n                                    Number(inputValueSliceMinusOnePlusOne) > daysCount ||\n                                    this.specialCharacters.includes(inputValueCursorPlusOne))) ||\n                            (startWithMonthInput\n                                ? Number(inputValueSliceMinusOnePlusOne) > daysCount ||\n                                    (!this.specialCharacters.includes(inputValueCursor) &&\n                                        this.specialCharacters.includes(inputValueCursorPlusTwo)) ||\n                                    this.specialCharacters.includes(inputValueCursor)\n                                : Number(inputValueSliceCursorPlusTwo) > daysCount ||\n                                    this.specialCharacters.includes(inputValueCursorPlusOne))) {\n                            // eslint-disable-next-line no-param-reassign\n                            position = !this.leadZeroDateTime ? position + 1 : position;\n                            cursor += 1;\n                            this._shiftStep(maskExpression, cursor, inputArray.length);\n                            i--;\n                            if (this.leadZeroDateTime) {\n                                result += '0';\n                            }\n                            continue;\n                        }\n                    }\n                    if (maskExpression[cursor] === \"M\" /* MONTH */) {\n                        const monthsCount = 12;\n                        // mask without day\n                        const withoutDays = cursor === 0 &&\n                            (Number(inputSymbol) > 2 ||\n                                Number(inputValueSliceCursorPlusTwo) > monthsCount ||\n                                this.specialCharacters.includes(inputValueCursorPlusOne));\n                        // day<10 && month<12 for input\n                        const specialChart = maskExpression.slice(cursor + 2, cursor + 3);\n                        const day1monthInput = inputValueSliceMinusThreeMinusOne.includes(specialChart) &&\n                            ((this.specialCharacters.includes(inputValueCursorMinusTwo) &&\n                                Number(inputValueSliceMinusOnePlusOne) > monthsCount &&\n                                !this.specialCharacters.includes(inputValueCursor)) ||\n                                this.specialCharacters.includes(inputValueCursor) ||\n                                (this.specialCharacters.includes(inputValueCursorMinusThree) &&\n                                    Number(inputValueSliceMinusTwoCursor) > monthsCount &&\n                                    !this.specialCharacters.includes(inputValueCursorMinusOne)) ||\n                                this.specialCharacters.includes(inputValueCursorMinusOne));\n                        //  month<12 && day<10 for input\n                        const day2monthInput = Number(inputValueSliceMinusThreeMinusOne) <= daysCount &&\n                            !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&\n                            this.specialCharacters.includes(inputValueCursorMinusOne) &&\n                            (Number(inputValueSliceCursorPlusTwo) > monthsCount ||\n                                this.specialCharacters.includes(inputValueCursorPlusOne));\n                        // cursor === 5 && without days\n                        const day2monthInputDot = (Number(inputValueSliceCursorPlusTwo) > monthsCount && cursor === 5) ||\n                            (this.specialCharacters.includes(inputValueCursorPlusOne) &&\n                                cursor === 5);\n                        // // day<10 && month<12 for paste whole data\n                        const day1monthPaste = Number(inputValueSliceMinusThreeMinusOne) > daysCount &&\n                            !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&\n                            !this.specialCharacters.includes(inputValueSliceMinusTwoCursor) &&\n                            Number(inputValueSliceMinusTwoCursor) > monthsCount;\n                        // 10<day<31 && month<12 for paste whole data\n                        const day2monthPaste = Number(inputValueSliceMinusThreeMinusOne) <= daysCount &&\n                            !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&\n                            !this.specialCharacters.includes(inputValueCursorMinusOne) &&\n                            Number(inputValueSliceMinusOnePlusOne) > monthsCount;\n                        if ((Number(inputSymbol) > 1 && this.leadZeroDateTime) ||\n                            withoutDays ||\n                            day1monthInput ||\n                            day2monthPaste ||\n                            day1monthPaste ||\n                            day2monthInput ||\n                            (day2monthInputDot && !this.leadZeroDateTime)) {\n                            // eslint-disable-next-line no-param-reassign\n                            position = !this.leadZeroDateTime ? position + 1 : position;\n                            cursor += 1;\n                            this._shiftStep(maskExpression, cursor, inputArray.length);\n                            i--;\n                            if (this.leadZeroDateTime) {\n                                result += '0';\n                            }\n                            continue;\n                        }\n                    }\n                    result += inputSymbol;\n                    cursor++;\n                }\n                else if ((inputSymbol === \" \" /* WHITE_SPACE */ &&\n                    maskExpression[cursor] === \" \" /* WHITE_SPACE */) ||\n                    (inputSymbol === \"/\" /* SLASH */ &&\n                        maskExpression[cursor] === \"/\" /* SLASH */)) {\n                    result += inputSymbol;\n                    cursor++;\n                }\n                else if (this.specialCharacters.indexOf((_j = maskExpression[cursor]) !== null && _j !== void 0 ? _j : \"\" /* EMPTY_STRING */) !== -1) {\n                    result += maskExpression[cursor];\n                    cursor++;\n                    this._shiftStep(maskExpression, cursor, inputArray.length);\n                    i--;\n                }\n                else if (maskExpression[cursor] === \"9\" /* NUMBER_NINE */ &&\n                    this.showMaskTyped) {\n                    this._shiftStep(maskExpression, cursor, inputArray.length);\n                }\n                else if (this.patterns[(_k = maskExpression[cursor]) !== null && _k !== void 0 ? _k : \"\" /* EMPTY_STRING */] &&\n                    ((_m = this.patterns[(_l = maskExpression[cursor]) !== null && _l !== void 0 ? _l : \"\" /* EMPTY_STRING */]) === null || _m === void 0 ? void 0 : _m.optional)) {\n                    if (!!inputArray[cursor] &&\n                        maskExpression !== '099.099.099.099' &&\n                        maskExpression !== '000.000.000-00' &&\n                        maskExpression !== '00.000.000/0000-00' &&\n                        !maskExpression.match(/^9+\\.0+$/) &&\n                        !((_p = this.patterns[(_o = maskExpression[cursor]) !== null && _o !== void 0 ? _o : \"\" /* EMPTY_STRING */]) === null || _p === void 0 ? void 0 : _p.optional)) {\n                        result += inputArray[cursor];\n                    }\n                    if (maskExpression.includes(\"9\" /* NUMBER_NINE */ + \"*\" /* SYMBOL_STAR */) &&\n                        maskExpression.includes(\"0\" /* NUMBER_ZERO */ + \"*\" /* SYMBOL_STAR */)) {\n                        cursor++;\n                    }\n                    cursor++;\n                    i--;\n                }\n                else if (this.maskExpression[cursor + 1] === \"*\" /* SYMBOL_STAR */ &&\n                    this._findSpecialChar((_q = this.maskExpression[cursor + 2]) !== null && _q !== void 0 ? _q : \"\" /* EMPTY_STRING */) &&\n                    this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2] &&\n                    multi) {\n                    cursor += 3;\n                    result += inputSymbol;\n                }\n                else if (this.maskExpression[cursor + 1] === \"?\" /* SYMBOL_QUESTION */ &&\n                    this._findSpecialChar((_r = this.maskExpression[cursor + 2]) !== null && _r !== void 0 ? _r : \"\" /* EMPTY_STRING */) &&\n                    this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2] &&\n                    multi) {\n                    cursor += 3;\n                    result += inputSymbol;\n                }\n                else if (this.showMaskTyped &&\n                    this.specialCharacters.indexOf(inputSymbol) < 0 &&\n                    inputSymbol !== this.placeHolderCharacter &&\n                    this.placeHolderCharacter.length === 1) {\n                    stepBack = true;\n                }\n            }\n        }\n        if (result.length + 1 === maskExpression.length &&\n            this.specialCharacters.indexOf((_s = maskExpression[maskExpression.length - 1]) !== null && _s !== void 0 ? _s : \"\" /* EMPTY_STRING */) !== -1) {\n            result += maskExpression[maskExpression.length - 1];\n        }\n        let newPosition = position + 1;\n        while (this._shift.has(newPosition)) {\n            shift++;\n            newPosition++;\n        }\n        let actualShift = justPasted && !maskExpression.startsWith(\"separator\" /* SEPARATOR */)\n            ? cursor\n            : this._shift.has(position)\n                ? shift\n                : 0;\n        if (stepBack) {\n            actualShift--;\n        }\n        cb(actualShift, backspaceShift);\n        if (shift < 0) {\n            this._shift.clear();\n        }\n        let onlySpecial = false;\n        if (backspaced) {\n            onlySpecial = inputArray.every((char) => this.specialCharacters.includes(char));\n        }\n        let res = `${this.prefix}${onlySpecial ? \"\" /* EMPTY_STRING */ : result}${this.showMaskTyped ? '' : this.suffix}`;\n        if (result.length === 0) {\n            res = !this.dropSpecialCharacters ? `${this.prefix}${result}` : `${result}`;\n        }\n        if (result.includes(\"-\" /* MINUS */) && this.prefix && this.allowNegativeNumbers) {\n            if (backspaced && result === \"-\" /* MINUS */) {\n                return '';\n            }\n            res = `${\"-\" /* MINUS */}${this.prefix}${result\n                .split(\"-\" /* MINUS */)\n                .join(\"\" /* EMPTY_STRING */)}${this.suffix}`;\n        }\n        return res;\n    }\n    _findDropSpecialChar(inputSymbol) {\n        if (Array.isArray(this.dropSpecialCharacters)) {\n            return this.dropSpecialCharacters.find((val) => val === inputSymbol);\n        }\n        return this._findSpecialChar(inputSymbol);\n    }\n    _findSpecialChar(inputSymbol) {\n        return this.specialCharacters.find((val) => val === inputSymbol);\n    }\n    _checkSymbolMask(inputSymbol, maskSymbol) {\n        var _a, _b, _c;\n        this.patterns = this.customPattern ? this.customPattern : this.patterns;\n        return ((_c = (((_a = this.patterns[maskSymbol]) === null || _a === void 0 ? void 0 : _a.pattern) &&\n            ((_b = this.patterns[maskSymbol]) === null || _b === void 0 ? void 0 : _b.pattern.test(inputSymbol)))) !== null && _c !== void 0 ? _c : false);\n    }\n    _stripToDecimal(str) {\n        return str\n            .split(\"\" /* EMPTY_STRING */)\n            .filter((i, idx) => {\n            const isDecimalMarker = typeof this.decimalMarker === 'string'\n                ? i === this.decimalMarker\n                : // TODO (inepipenko) use utility type\n                    this.decimalMarker.includes(i);\n            return (i.match('^-?\\\\d') ||\n                i === this.thousandSeparator ||\n                isDecimalMarker ||\n                (i === \"-\" /* MINUS */ && idx === 0 && this.allowNegativeNumbers));\n        })\n            .join(\"\" /* EMPTY_STRING */);\n    }\n    _charToRegExpExpression(char) {\n        // if (Array.isArray(char)) {\n        // \treturn char.map((v) => ('[\\\\^$.|?*+()'.indexOf(v) >= 0 ? `\\\\${v}` : v)).join('|');\n        // }\n        if (char) {\n            const charsToEscape = '[\\\\^$.|?*+()';\n            return char === ' ' ? '\\\\s' : charsToEscape.indexOf(char) >= 0 ? `\\\\${char}` : char;\n        }\n        return char;\n    }\n    _shiftStep(maskExpression, cursor, inputLength) {\n        const shiftStep = /[*?]/g.test(maskExpression.slice(0, cursor))\n            ? inputLength\n            : cursor;\n        this._shift.add(shiftStep + this.prefix.length || 0);\n    }\n    _compareOrIncludes(value, comparedValue, excludedValue) {\n        return Array.isArray(comparedValue)\n            ? comparedValue.filter((v) => v !== excludedValue).includes(value)\n            : value === comparedValue;\n    }\n    _validIP(valuesIP) {\n        return !(valuesIP.length === 4 &&\n            !valuesIP.some((value, index) => {\n                if (valuesIP.length !== index + 1) {\n                    return value === \"\" /* EMPTY_STRING */ || Number(value) > 255;\n                }\n                return value === \"\" /* EMPTY_STRING */ || Number(value.substring(0, 3)) > 255;\n            }));\n    }\n    _splitPercentZero(value) {\n        const decimalIndex = typeof this.decimalMarker === 'string'\n            ? value.indexOf(this.decimalMarker)\n            : value.indexOf(\".\" /* DOT */);\n        if (decimalIndex === -1) {\n            const parsedValue = parseInt(value, 10);\n            return isNaN(parsedValue) ? \"\" /* EMPTY_STRING */ : parsedValue.toString();\n        }\n        else {\n            const integerPart = parseInt(value.substring(0, decimalIndex), 10);\n            const decimalPart = value.substring(decimalIndex + 1);\n            const integerString = isNaN(integerPart) ? '' : integerPart.toString();\n            const decimal = typeof this.decimalMarker === 'string' ? this.decimalMarker : \".\" /* DOT */;\n            return integerString === \"\" /* EMPTY_STRING */\n                ? \"\" /* EMPTY_STRING */\n                : integerString + decimal + decimalPart;\n        }\n    }\n}\nNgxMaskApplierService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskApplierService, deps: [{ token: NGX_MASK_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });\nNgxMaskApplierService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskApplierService });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskApplierService, decorators: [{\n            type: Injectable\n        }], ctorParameters: function () {\n        return [{ type: undefined, decorators: [{\n                        type: Inject,\n                        args: [NGX_MASK_CONFIG]\n                    }] }];\n    } });\n\nclass NgxMaskService extends NgxMaskApplierService {\n    constructor(document, _config, _elementRef, _renderer) {\n        super(_config);\n        this.document = document;\n        this._config = _config;\n        this._elementRef = _elementRef;\n        this._renderer = _renderer;\n        this.isNumberValue = false;\n        this.maskIsShown = '';\n        this.selStart = null;\n        this.selEnd = null;\n        /**\n         * Whether we are currently in writeValue function, in this case when applying the mask we don't want to trigger onChange function,\n         * since writeValue should be a one way only process of writing the DOM value based on the Angular model value.\n         */\n        this.writingValue = false;\n        this.maskChanged = false;\n        this._maskExpressionArray = [];\n        this.triggerOnMaskChange = false;\n        this._emitValue = false;\n        this._previousValue = '';\n        this._currentValue = '';\n        // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-explicit-any\n        this.onChange = (_) => { };\n    }\n    // eslint-disable-next-line complexity\n    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, \n    // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-explicit-any\n    cb = () => { }) {\n        var _a, _b;\n        if (!maskExpression) {\n            return inputValue !== this.actualValue ? this.actualValue : inputValue;\n        }\n        this.maskIsShown = this.showMaskTyped\n            ? this.showMaskInInput()\n            : \"\" /* EMPTY_STRING */;\n        if (this.maskExpression === \"IP\" /* IP */ && this.showMaskTyped) {\n            this.maskIsShown = this.showMaskInInput(inputValue || \"#\" /* HASH */);\n        }\n        if (this.maskExpression === \"CPF_CNPJ\" /* CPF_CNPJ */ && this.showMaskTyped) {\n            this.maskIsShown = this.showMaskInInput(inputValue || \"#\" /* HASH */);\n        }\n        if (!inputValue && this.showMaskTyped) {\n            this.formControlResult(this.prefix);\n            return this.prefix + this.maskIsShown + this.suffix;\n        }\n        const getSymbol = !!inputValue && typeof this.selStart === 'number'\n            ? (_a = inputValue[this.selStart]) !== null && _a !== void 0 ? _a : \"\" /* EMPTY_STRING */\n            : \"\" /* EMPTY_STRING */;\n        let newInputValue = '';\n        if (this.hiddenInput !== undefined && !this.writingValue) {\n            let actualResult = inputValue && inputValue.length === 1\n                ? inputValue.split(\"\" /* EMPTY_STRING */)\n                : this.actualValue.split(\"\" /* EMPTY_STRING */);\n            // eslint-disable  @typescript-eslint/no-unused-expressions\n            // eslint-disable-next-line @typescript-eslint/no-unused-expressions\n            if (typeof this.selStart === 'object' && typeof this.selEnd === 'object') {\n                this.selStart = Number(this.selStart);\n                this.selEnd = Number(this.selEnd);\n            }\n            else {\n                inputValue !== \"\" /* EMPTY_STRING */ && actualResult.length\n                    ? typeof this.selStart === 'number' && typeof this.selEnd === 'number'\n                        ? inputValue.length > actualResult.length\n                            ? actualResult.splice(this.selStart, 0, getSymbol)\n                            : inputValue.length < actualResult.length\n                                ? actualResult.length - inputValue.length === 1\n                                    ? backspaced\n                                        ? actualResult.splice(this.selStart - 1, 1)\n                                        : actualResult.splice(inputValue.length - 1, 1)\n                                    : actualResult.splice(this.selStart, this.selEnd - this.selStart)\n                                : null\n                        : null\n                    : (actualResult = []);\n            }\n            if (this.showMaskTyped) {\n                if (!this.hiddenInput) {\n                    // eslint-disable-next-line no-param-reassign\n                    inputValue = this.removeMask(inputValue);\n                }\n            }\n            // eslint-enable  @typescript-eslint/no-unused-expressions\n            newInputValue =\n                this.actualValue.length && actualResult.length <= inputValue.length\n                    ? this.shiftTypedSymbols(actualResult.join(\"\" /* EMPTY_STRING */))\n                    : inputValue;\n        }\n        if (justPasted && (this.hiddenInput || !this.hiddenInput)) {\n            newInputValue = inputValue;\n        }\n        if (backspaced &&\n            this.specialCharacters.indexOf((_b = this.maskExpression[position]) !== null && _b !== void 0 ? _b : \"\" /* EMPTY_STRING */) !== -1 &&\n            this.showMaskTyped) {\n            newInputValue = this._currentValue;\n        }\n        if (this.deletedSpecialCharacter && position) {\n            if (this.specialCharacters.includes(this.actualValue.slice(position, position + 1))) {\n                // eslint-disable-next-line no-param-reassign\n                position = position + 1;\n            }\n            else if (maskExpression.slice(position - 1, position + 1) !== \"M0\" /* MONTHS */) {\n                // eslint-disable-next-line no-param-reassign\n                position = position - 2;\n            }\n            // eslint-disable-next-line no-param-reassign\n            this.deletedSpecialCharacter = false;\n        }\n        if (this.showMaskTyped &&\n            this.placeHolderCharacter.length === 1 &&\n            !this.leadZeroDateTime) {\n            // eslint-disable-next-line no-param-reassign\n            inputValue = this.removeMask(inputValue);\n        }\n        if (this.maskChanged) {\n            newInputValue = inputValue;\n        }\n        else {\n            newInputValue =\n                Boolean(newInputValue) && newInputValue.length ? newInputValue : inputValue;\n        }\n        if (this.showMaskTyped && this.keepCharacterPositions && this.actualValue && !justPasted) {\n            const value = this.dropSpecialCharacters\n                ? this.removeMask(this.actualValue)\n                : this.actualValue;\n            this.formControlResult(value);\n            return this.actualValue\n                ? this.actualValue\n                : this.prefix + this.maskIsShown + this.suffix;\n        }\n        const result = super.applyMask(newInputValue, maskExpression, position, justPasted, backspaced, cb);\n        this.actualValue = this.getActualValue(result);\n        // handle some separator implications:\n        // a.) adjust decimalMarker default (. -> ,) if thousandSeparator is a dot\n        if (this.thousandSeparator === \".\" /* DOT */ &&\n            this.decimalMarker === \".\" /* DOT */) {\n            this.decimalMarker = \",\" /* COMMA */;\n        }\n        // b) remove decimal marker from list of special characters to mask\n        if (this.maskExpression.startsWith(\"separator\" /* SEPARATOR */) &&\n            this.dropSpecialCharacters === true) {\n            this.specialCharacters = this.specialCharacters.filter((item) => !this._compareOrIncludes(item, this.decimalMarker, this.thousandSeparator) //item !== this.decimalMarker, // !\n            );\n        }\n        if (result || result === '') {\n            this._previousValue = this._currentValue;\n            this._currentValue = result;\n            this._emitValue =\n                this._previousValue !== this._currentValue ||\n                    this.maskChanged ||\n                    (this._previousValue === this._currentValue && justPasted);\n        }\n        this._emitValue ? this.formControlResult(result) : '';\n        if (!this.showMaskTyped || (this.showMaskTyped && this.hiddenInput)) {\n            if (this.hiddenInput) {\n                if (backspaced) {\n                    return this.hideInput(result, this.maskExpression);\n                }\n                return (this.hideInput(result, this.maskExpression) +\n                    this.maskIsShown.slice(result.length));\n            }\n            return result;\n        }\n        const resLen = result.length;\n        const prefNmask = this.prefix + this.maskIsShown + this.suffix;\n        if (this.maskExpression.includes(\"H\" /* HOURS */)) {\n            const countSkipedSymbol = this._numberSkipedSymbols(result);\n            return result + prefNmask.slice(resLen + countSkipedSymbol);\n        }\n        else if (this.maskExpression === \"IP\" /* IP */ ||\n            this.maskExpression === \"CPF_CNPJ\" /* CPF_CNPJ */) {\n            return result + prefNmask;\n        }\n        return result + prefNmask.slice(resLen);\n    }\n    // get the number of characters that were shifted\n    _numberSkipedSymbols(value) {\n        const regex = /(^|\\D)(\\d\\D)/g;\n        let match = regex.exec(value);\n        let countSkipedSymbol = 0;\n        while (match != null) {\n            countSkipedSymbol += 1;\n            match = regex.exec(value);\n        }\n        return countSkipedSymbol;\n    }\n    applyValueChanges(position, justPasted, backspaced, \n    // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-explicit-any\n    cb = () => { }) {\n        var _a;\n        const formElement = (_a = this._elementRef) === null || _a === void 0 ? void 0 : _a.nativeElement;\n        if (!formElement) {\n            return;\n        }\n        formElement.value = this.applyMask(formElement.value, this.maskExpression, position, justPasted, backspaced, cb);\n        if (formElement === this._getActiveElement()) {\n            return;\n        }\n        this.clearIfNotMatchFn();\n    }\n    hideInput(inputValue, maskExpression) {\n        return inputValue\n            .split(\"\" /* EMPTY_STRING */)\n            .map((curr, index) => {\n            var _a, _b, _c, _d, _e;\n            if (this.patterns &&\n                this.patterns[(_a = maskExpression[index]) !== null && _a !== void 0 ? _a : \"\" /* EMPTY_STRING */] &&\n                ((_c = this.patterns[(_b = maskExpression[index]) !== null && _b !== void 0 ? _b : \"\" /* EMPTY_STRING */]) === null || _c === void 0 ? void 0 : _c.symbol)) {\n                return (_e = this.patterns[(_d = maskExpression[index]) !== null && _d !== void 0 ? _d : \"\" /* EMPTY_STRING */]) === null || _e === void 0 ? void 0 : _e.symbol;\n            }\n            return curr;\n        })\n            .join(\"\" /* EMPTY_STRING */);\n    }\n    // this function is not necessary, it checks result against maskExpression\n    getActualValue(res) {\n        const compare = res\n            .split(\"\" /* EMPTY_STRING */)\n            .filter((symbol, i) => {\n            var _a;\n            const maskChar = (_a = this.maskExpression[i]) !== null && _a !== void 0 ? _a : \"\" /* EMPTY_STRING */;\n            return (this._checkSymbolMask(symbol, maskChar) ||\n                (this.specialCharacters.includes(maskChar) && symbol === maskChar));\n        });\n        if (compare.join(\"\" /* EMPTY_STRING */) === res) {\n            return compare.join(\"\" /* EMPTY_STRING */);\n        }\n        return res;\n    }\n    shiftTypedSymbols(inputValue) {\n        let symbolToReplace = '';\n        const newInputValue = (inputValue &&\n            inputValue\n                .split(\"\" /* EMPTY_STRING */)\n                .map((currSymbol, index) => {\n                var _a;\n                if (this.specialCharacters.includes((_a = inputValue[index + 1]) !== null && _a !== void 0 ? _a : \"\" /* EMPTY_STRING */) &&\n                    inputValue[index + 1] !== this.maskExpression[index + 1]) {\n                    symbolToReplace = currSymbol;\n                    return inputValue[index + 1];\n                }\n                if (symbolToReplace.length) {\n                    const replaceSymbol = symbolToReplace;\n                    symbolToReplace = \"\" /* EMPTY_STRING */;\n                    return replaceSymbol;\n                }\n                return currSymbol;\n            })) ||\n            [];\n        return newInputValue.join(\"\" /* EMPTY_STRING */);\n    }\n    /**\n     * Convert number value to string\n     * 3.1415 -> '3.1415'\n     * 1e-7 -> '0.0000001'\n     */\n    numberToString(value) {\n        if ((!value && value !== 0) ||\n            (this.maskExpression.startsWith(\"separator\" /* SEPARATOR */) &&\n                (this.leadZero || !this.dropSpecialCharacters)) ||\n            (this.maskExpression.startsWith(\"separator\" /* SEPARATOR */) &&\n                this.separatorLimit.length > 14 &&\n                String(value).length > 14)) {\n            return String(value);\n        }\n        return Number(value)\n            .toLocaleString('fullwide', {\n            useGrouping: false,\n            maximumFractionDigits: 20,\n        })\n            .replace(`/${\"-\" /* MINUS */}/`, \"-\" /* MINUS */);\n    }\n    showMaskInInput(inputVal) {\n        if (this.showMaskTyped && !!this.shownMaskExpression) {\n            if (this.maskExpression.length !== this.shownMaskExpression.length) {\n                throw new Error('Mask expression must match mask placeholder length');\n            }\n            else {\n                return this.shownMaskExpression;\n            }\n        }\n        else if (this.showMaskTyped) {\n            if (inputVal) {\n                if (this.maskExpression === \"IP\" /* IP */) {\n                    return this._checkForIp(inputVal);\n                }\n                if (this.maskExpression === \"CPF_CNPJ\" /* CPF_CNPJ */) {\n                    return this._checkForCpfCnpj(inputVal);\n                }\n            }\n            if (this.placeHolderCharacter.length === this.maskExpression.length) {\n                return this.placeHolderCharacter;\n            }\n            return this.maskExpression.replace(/\\w/g, this.placeHolderCharacter);\n        }\n        return '';\n    }\n    clearIfNotMatchFn() {\n        var _a;\n        const formElement = (_a = this._elementRef) === null || _a === void 0 ? void 0 : _a.nativeElement;\n        if (!formElement) {\n            return;\n        }\n        if (this.clearIfNotMatch &&\n            this.prefix.length + this.maskExpression.length + this.suffix.length !==\n                formElement.value.replace(this.placeHolderCharacter, \"\" /* EMPTY_STRING */)\n                    .length) {\n            this.formElementProperty = ['value', \"\" /* EMPTY_STRING */];\n            this.applyMask('', this.maskExpression);\n        }\n    }\n    set formElementProperty([name, value]) {\n        if (!this._renderer || !this._elementRef) {\n            return;\n        }\n        Promise.resolve().then(() => { var _a, _b; return (_a = this._renderer) === null || _a === void 0 ? void 0 : _a.setProperty((_b = this._elementRef) === null || _b === void 0 ? void 0 : _b.nativeElement, name, value); });\n    }\n    checkDropSpecialCharAmount(mask) {\n        const chars = mask\n            .split(\"\" /* EMPTY_STRING */)\n            .filter((item) => this._findDropSpecialChar(item));\n        return chars.length;\n    }\n    removeMask(inputValue) {\n        return this._removeMask(this._removeSuffix(this._removePrefix(inputValue)), this.specialCharacters.concat('_').concat(this.placeHolderCharacter));\n    }\n    _checkForIp(inputVal) {\n        var _a;\n        if (inputVal === \"#\" /* HASH */) {\n            return `${this.placeHolderCharacter}.${this.placeHolderCharacter}.${this.placeHolderCharacter}.${this.placeHolderCharacter}`;\n        }\n        const arr = [];\n        for (let i = 0; i < inputVal.length; i++) {\n            const value = (_a = inputVal[i]) !== null && _a !== void 0 ? _a : \"\" /* EMPTY_STRING */;\n            if (!value) {\n                continue;\n            }\n            if (value.match('\\\\d')) {\n                arr.push(value);\n            }\n        }\n        if (arr.length <= 3) {\n            return `${this.placeHolderCharacter}.${this.placeHolderCharacter}.${this.placeHolderCharacter}`;\n        }\n        if (arr.length > 3 && arr.length <= 6) {\n            return `${this.placeHolderCharacter}.${this.placeHolderCharacter}`;\n        }\n        if (arr.length > 6 && arr.length <= 9) {\n            return this.placeHolderCharacter;\n        }\n        if (arr.length > 9 && arr.length <= 12) {\n            return '';\n        }\n        return '';\n    }\n    _checkForCpfCnpj(inputVal) {\n        var _a;\n        const cpf = `${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +\n            `.${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +\n            `.${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +\n            `-${this.placeHolderCharacter}${this.placeHolderCharacter}`;\n        const cnpj = `${this.placeHolderCharacter}${this.placeHolderCharacter}` +\n            `.${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +\n            `.${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +\n            `/${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +\n            `-${this.placeHolderCharacter}${this.placeHolderCharacter}`;\n        if (inputVal === \"#\" /* HASH */) {\n            return cpf;\n        }\n        const arr = [];\n        for (let i = 0; i < inputVal.length; i++) {\n            const value = (_a = inputVal[i]) !== null && _a !== void 0 ? _a : \"\" /* EMPTY_STRING */;\n            if (!value) {\n                continue;\n            }\n            if (value.match('\\\\d')) {\n                arr.push(value);\n            }\n        }\n        if (arr.length <= 3) {\n            return cpf.slice(arr.length, cpf.length);\n        }\n        if (arr.length > 3 && arr.length <= 6) {\n            return cpf.slice(arr.length + 1, cpf.length);\n        }\n        if (arr.length > 6 && arr.length <= 9) {\n            return cpf.slice(arr.length + 2, cpf.length);\n        }\n        if (arr.length > 9 && arr.length < 11) {\n            return cpf.slice(arr.length + 3, cpf.length);\n        }\n        if (arr.length === 11) {\n            return '';\n        }\n        if (arr.length === 12) {\n            if (inputVal.length === 17) {\n                return cnpj.slice(16, cnpj.length);\n            }\n            return cnpj.slice(15, cnpj.length);\n        }\n        if (arr.length > 12 && arr.length <= 14) {\n            return cnpj.slice(arr.length + 4, cnpj.length);\n        }\n        return '';\n    }\n    /**\n     * Recursively determine the current active element by navigating the Shadow DOM until the Active Element is found.\n     */\n    _getActiveElement(document = this.document) {\n        var _a;\n        const shadowRootEl = (_a = document === null || document === void 0 ? void 0 : document.activeElement) === null || _a === void 0 ? void 0 : _a.shadowRoot;\n        if (!(shadowRootEl === null || shadowRootEl === void 0 ? void 0 : shadowRootEl.activeElement)) {\n            return document.activeElement;\n        }\n        else {\n            return this._getActiveElement(shadowRootEl);\n        }\n    }\n    /**\n     * Propogates the input value back to the Angular model by triggering the onChange function. It won't do this if writingValue\n     * is true. If that is true it means we are currently in the writeValue function, which is supposed to only update the actual\n     * DOM element based on the Angular model value. It should be a one way process, i.e. writeValue should not be modifying the Angular\n     * model value too. Therefore, we don't trigger onChange in this scenario.\n     * @param inputValue the current form input value\n     */\n    formControlResult(inputValue) {\n        if (this.writingValue || (!this.triggerOnMaskChange && this.maskChanged)) {\n            this.maskChanged\n                ? this.onChange(this.outputTransformFn(this._toNumber(this._checkSymbols(this._removeSuffix(this._removePrefix(inputValue))))))\n                : '';\n            this.maskChanged = false;\n            return;\n        }\n        if (Array.isArray(this.dropSpecialCharacters)) {\n            this.onChange(this.outputTransformFn(this._toNumber(this._checkSymbols(this._removeMask(this._removeSuffix(this._removePrefix(inputValue)), this.dropSpecialCharacters)))));\n        }\n        else if (this.dropSpecialCharacters ||\n            (!this.dropSpecialCharacters && this.prefix === inputValue)) {\n            this.onChange(this.outputTransformFn(this._toNumber(this._checkSymbols(this._removeSuffix(this._removePrefix(inputValue))))));\n        }\n        else {\n            this.onChange(this.outputTransformFn(this._toNumber(inputValue)));\n        }\n    }\n    _toNumber(value) {\n        if (!this.isNumberValue || value === \"\" /* EMPTY_STRING */) {\n            return value;\n        }\n        if (this.maskExpression.startsWith(\"separator\" /* SEPARATOR */) &&\n            (this.leadZero || !this.dropSpecialCharacters)) {\n            return value;\n        }\n        if (String(value).length > 16 && this.separatorLimit.length > 14) {\n            return String(value);\n        }\n        const num = Number(value);\n        if (this.maskExpression.startsWith(\"separator\" /* SEPARATOR */) && Number.isNaN(num)) {\n            const val = String(value).replace(',', '.');\n            return Number(val);\n        }\n        return Number.isNaN(num) ? value : num;\n    }\n    _removeMask(value, specialCharactersForRemove) {\n        if (this.maskExpression.startsWith(\"percent\" /* PERCENT */) &&\n            value.includes(\".\" /* DOT */)) {\n            return value;\n        }\n        return value\n            ? value.replace(this._regExpForRemove(specialCharactersForRemove), \"\" /* EMPTY_STRING */)\n            : value;\n    }\n    _removePrefix(value) {\n        if (!this.prefix) {\n            return value;\n        }\n        return value ? value.replace(this.prefix, \"\" /* EMPTY_STRING */) : value;\n    }\n    _removeSuffix(value) {\n        if (!this.suffix) {\n            return value;\n        }\n        return value ? value.replace(this.suffix, \"\" /* EMPTY_STRING */) : value;\n    }\n    _retrieveSeparatorValue(result) {\n        let specialCharacters = Array.isArray(this.dropSpecialCharacters)\n            ? this.specialCharacters.filter((v) => {\n                return this.dropSpecialCharacters.includes(v);\n            })\n            : this.specialCharacters;\n        if (!this.deletedSpecialCharacter &&\n            this._checkPatternForSpace() &&\n            result.includes(\" \" /* WHITE_SPACE */) &&\n            this.maskExpression.includes(\"*\" /* SYMBOL_STAR */)) {\n            specialCharacters = specialCharacters.filter((char) => char !== \" \" /* WHITE_SPACE */);\n        }\n        return this._removeMask(result, specialCharacters);\n    }\n    _regExpForRemove(specialCharactersForRemove) {\n        return new RegExp(specialCharactersForRemove.map((item) => `\\\\${item}`).join('|'), 'gi');\n    }\n    _replaceDecimalMarkerToDot(value) {\n        const markers = Array.isArray(this.decimalMarker)\n            ? this.decimalMarker\n            : [this.decimalMarker];\n        return value.replace(this._regExpForRemove(markers), \".\" /* DOT */);\n    }\n    _checkSymbols(result) {\n        if (result === \"\" /* EMPTY_STRING */) {\n            return result;\n        }\n        if (this.maskExpression.startsWith(\"percent\" /* PERCENT */) &&\n            this.decimalMarker === \",\" /* COMMA */) {\n            // eslint-disable-next-line no-param-reassign\n            result = result.replace(\",\" /* COMMA */, \".\" /* DOT */);\n        }\n        const separatorPrecision = this._retrieveSeparatorPrecision(this.maskExpression);\n        const separatorValue = this._replaceDecimalMarkerToDot(this._retrieveSeparatorValue(result));\n        if (!this.isNumberValue) {\n            return separatorValue;\n        }\n        if (separatorPrecision) {\n            if (result === this.decimalMarker) {\n                return null;\n            }\n            if (this.separatorLimit.length > 14) {\n                return String(separatorValue);\n            }\n            return this._checkPrecision(this.maskExpression, separatorValue);\n        }\n        else {\n            return separatorValue;\n        }\n    }\n    _checkPatternForSpace() {\n        var _a, _b, _c;\n        for (const key in this.patterns) {\n            // eslint-disable-next-line no-prototype-builtins\n            if (this.patterns[key] && ((_a = this.patterns[key]) === null || _a === void 0 ? void 0 : _a.hasOwnProperty('pattern'))) {\n                const patternString = (_b = this.patterns[key]) === null || _b === void 0 ? void 0 : _b.pattern.toString();\n                const pattern = (_c = this.patterns[key]) === null || _c === void 0 ? void 0 : _c.pattern;\n                if ((patternString === null || patternString === void 0 ? void 0 : patternString.includes(\" \" /* WHITE_SPACE */)) &&\n                    (pattern === null || pattern === void 0 ? void 0 : pattern.test(this.maskExpression))) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n    // TODO should think about helpers or separting decimal precision to own property\n    _retrieveSeparatorPrecision(maskExpretion) {\n        const matcher = maskExpretion.match(new RegExp(`^separator\\\\.([^d]*)`));\n        return matcher ? Number(matcher[1]) : null;\n    }\n    _checkPrecision(separatorExpression, separatorValue) {\n        const separatorPrecision = separatorExpression.slice(10, 11);\n        if (separatorExpression.indexOf('2') > 0 ||\n            (this.leadZero && Number(separatorPrecision) > 1)) {\n            if (this.decimalMarker === \",\" /* COMMA */ && this.leadZero) {\n                // eslint-disable-next-line no-param-reassign\n                separatorValue = separatorValue.replace(',', '.');\n            }\n            return this.leadZero\n                ? Number(separatorValue).toFixed(Number(separatorPrecision))\n                : Number(separatorValue).toFixed(2);\n        }\n        return this.numberToString(separatorValue);\n    }\n    _repeatPatternSymbols(maskExp) {\n        return ((maskExp.match(/{[0-9]+}/) &&\n            maskExp\n                .split(\"\" /* EMPTY_STRING */)\n                .reduce((accum, currVal, index) => {\n                this._start =\n                    currVal === \"{\" /* CURLY_BRACKETS_LEFT */ ? index : this._start;\n                if (currVal !== \"}\" /* CURLY_BRACKETS_RIGHT */) {\n                    return this._findSpecialChar(currVal) ? accum + currVal : accum;\n                }\n                this._end = index;\n                const repeatNumber = Number(maskExp.slice(this._start + 1, this._end));\n                const replaceWith = new Array(repeatNumber + 1).join(maskExp[this._start - 1]);\n                if (maskExp.slice(0, this._start).length > 1 &&\n                    maskExp.includes(\"S\" /* LETTER_S */)) {\n                    const symbols = maskExp.slice(0, this._start - 1);\n                    return symbols.includes(\"{\" /* CURLY_BRACKETS_LEFT */)\n                        ? accum + replaceWith\n                        : symbols + accum + replaceWith;\n                }\n                else {\n                    return accum + replaceWith;\n                }\n            }, '')) ||\n            maskExp);\n    }\n    currentLocaleDecimalMarker() {\n        return (1.1).toLocaleString().substring(1, 2);\n    }\n}\nNgxMaskService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskService, deps: [{ token: DOCUMENT }, { token: NGX_MASK_CONFIG }, { token: i0.ElementRef, optional: true }, { token: i0.Renderer2, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });\nNgxMaskService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskService });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskService, decorators: [{\n            type: Injectable\n        }], ctorParameters: function () {\n        return [{ type: undefined, decorators: [{\n                        type: Inject,\n                        args: [DOCUMENT]\n                    }] }, { type: undefined, decorators: [{\n                        type: Inject,\n                        args: [NGX_MASK_CONFIG]\n                    }] }, { type: i0.ElementRef, decorators: [{\n                        type: Optional\n                    }] }, { type: i0.Renderer2, decorators: [{\n                        type: Optional\n                    }] }];\n    } });\n\n// tslint:disable deprecation\n// tslint:disable no-input-rename\nclass NgxMaskDirective {\n    constructor(\n    // tslint:disable-next-line\n    document, _config, _maskService) {\n        this.document = document;\n        this._config = _config;\n        this._maskService = _maskService;\n        // eslint-disable-next-line @angular-eslint/no-input-rename\n        this.maskExpression = '';\n        this.specialCharacters = [];\n        this.patterns = {};\n        this.prefix = '';\n        this.suffix = '';\n        this.thousandSeparator = ' ';\n        this.decimalMarker = '.';\n        this.dropSpecialCharacters = null;\n        this.hiddenInput = null;\n        this.showMaskTyped = null;\n        this.placeHolderCharacter = null;\n        this.shownMaskExpression = null;\n        this.showTemplate = null;\n        this.clearIfNotMatch = null;\n        this.validation = null;\n        this.separatorLimit = null;\n        this.allowNegativeNumbers = null;\n        this.leadZeroDateTime = null;\n        this.leadZero = null;\n        this.triggerOnMaskChange = null;\n        this.apm = null;\n        this.inputTransformFn = null;\n        this.outputTransformFn = null;\n        this.keepCharacterPositions = null;\n        this.maskFilled = new EventEmitter();\n        this._maskValue = '';\n        this._isFocused = false;\n        this._position = null;\n        this._maskExpressionArray = [];\n        this._justPasted = false;\n        /**For IME composition event */\n        this._isComposing = false;\n        // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-explicit-any\n        this.onChange = (_) => { };\n        // eslint-disable-next-line @typescript-eslint/no-empty-function\n        this.onTouch = () => { };\n    }\n    ngOnChanges(changes) {\n        const { maskExpression, specialCharacters, patterns, prefix, suffix, thousandSeparator, decimalMarker, dropSpecialCharacters, hiddenInput, showMaskTyped, placeHolderCharacter, shownMaskExpression, showTemplate, clearIfNotMatch, validation, separatorLimit, allowNegativeNumbers, leadZeroDateTime, leadZero, triggerOnMaskChange, apm, inputTransformFn, outputTransformFn, keepCharacterPositions, } = changes;\n        if (maskExpression) {\n            if (maskExpression.currentValue !== maskExpression.previousValue &&\n                !maskExpression.firstChange) {\n                this._maskService.maskChanged = true;\n            }\n            if (maskExpression.currentValue &&\n                maskExpression.currentValue.split(\"||\" /* OR */).length > 1) {\n                this._maskExpressionArray = maskExpression.currentValue\n                    .split(\"||\" /* OR */)\n                    .sort((a, b) => {\n                    return a.length - b.length;\n                });\n                this._setMask();\n            }\n            else {\n                this._maskExpressionArray = [];\n                this._maskValue = maskExpression.currentValue || \"\" /* EMPTY_STRING */;\n                this._maskService.maskExpression = this._maskValue;\n            }\n        }\n        if (specialCharacters) {\n            if (!specialCharacters.currentValue || !Array.isArray(specialCharacters.currentValue)) {\n                return;\n            }\n            else {\n                this._maskService.specialCharacters = specialCharacters.currentValue || [];\n            }\n        }\n        if (allowNegativeNumbers) {\n            this._maskService.allowNegativeNumbers = allowNegativeNumbers.currentValue;\n            if (this._maskService.allowNegativeNumbers) {\n                this._maskService.specialCharacters = this._maskService.specialCharacters.filter((c) => c !== \"-\" /* MINUS */);\n            }\n        }\n        // Only overwrite the mask available patterns if a pattern has actually been passed in\n        if (patterns && patterns.currentValue) {\n            this._maskService.patterns = patterns.currentValue;\n        }\n        if (apm && apm.currentValue) {\n            this._maskService.apm = apm.currentValue;\n        }\n        if (prefix) {\n            this._maskService.prefix = prefix.currentValue;\n        }\n        if (suffix) {\n            this._maskService.suffix = suffix.currentValue;\n        }\n        if (thousandSeparator) {\n            this._maskService.thousandSeparator = thousandSeparator.currentValue;\n        }\n        if (decimalMarker) {\n            this._maskService.decimalMarker = decimalMarker.currentValue;\n        }\n        if (dropSpecialCharacters) {\n            this._maskService.dropSpecialCharacters = dropSpecialCharacters.currentValue;\n        }\n        if (hiddenInput) {\n            this._maskService.hiddenInput = hiddenInput.currentValue;\n        }\n        if (showMaskTyped) {\n            this._maskService.showMaskTyped = showMaskTyped.currentValue;\n            if (showMaskTyped.previousValue === false &&\n                showMaskTyped.currentValue === true &&\n                this._isFocused) {\n                requestAnimationFrame(() => {\n                    var _a;\n                    (_a = this._maskService._elementRef) === null || _a === void 0 ? void 0 : _a.nativeElement.click();\n                });\n            }\n        }\n        if (placeHolderCharacter) {\n            this._maskService.placeHolderCharacter = placeHolderCharacter.currentValue;\n        }\n        if (shownMaskExpression) {\n            this._maskService.shownMaskExpression = shownMaskExpression.currentValue;\n        }\n        if (showTemplate) {\n            this._maskService.showTemplate = showTemplate.currentValue;\n        }\n        if (clearIfNotMatch) {\n            this._maskService.clearIfNotMatch = clearIfNotMatch.currentValue;\n        }\n        if (validation) {\n            this._maskService.validation = validation.currentValue;\n        }\n        if (separatorLimit) {\n            this._maskService.separatorLimit = separatorLimit.currentValue;\n        }\n        if (leadZeroDateTime) {\n            this._maskService.leadZeroDateTime = leadZeroDateTime.currentValue;\n        }\n        if (leadZero) {\n            this._maskService.leadZero = leadZero.currentValue;\n        }\n        if (triggerOnMaskChange) {\n            this._maskService.triggerOnMaskChange = triggerOnMaskChange.currentValue;\n        }\n        if (inputTransformFn) {\n            this._maskService.inputTransformFn = inputTransformFn.currentValue;\n        }\n        if (outputTransformFn) {\n            this._maskService.outputTransformFn = outputTransformFn.currentValue;\n        }\n        if (keepCharacterPositions) {\n            this._maskService.keepCharacterPositions = keepCharacterPositions.currentValue;\n        }\n        this._applyMask();\n    }\n    // eslint-disable-next-line complexity\n    validate({ value }) {\n        var _a, _b, _c;\n        if (!this._maskService.validation || !this._maskValue) {\n            return null;\n        }\n        if (this._maskService.ipError) {\n            return this._createValidationError(value);\n        }\n        if (this._maskService.cpfCnpjError) {\n            return this._createValidationError(value);\n        }\n        if (this._maskValue.startsWith(\"separator\" /* SEPARATOR */)) {\n            return null;\n        }\n        if (withoutValidation.includes(this._maskValue)) {\n            return null;\n        }\n        if (this._maskService.clearIfNotMatch) {\n            return null;\n        }\n        if (timeMasks.includes(this._maskValue)) {\n            return this._validateTime(value);\n        }\n        if (value && value.toString().length >= 1) {\n            let counterOfOpt = 0;\n            if (this._maskValue.startsWith(\"percent\" /* PERCENT */)) {\n                return null;\n            }\n            for (const key in this._maskService.patterns) {\n                if ((_a = this._maskService.patterns[key]) === null || _a === void 0 ? void 0 : _a.optional) {\n                    if (this._maskValue.indexOf(key) !== this._maskValue.lastIndexOf(key)) {\n                        const opt = this._maskValue\n                            .split(\"\" /* EMPTY_STRING */)\n                            .filter((i) => i === key)\n                            .join(\"\" /* EMPTY_STRING */);\n                        counterOfOpt += opt.length;\n                    }\n                    else if (this._maskValue.indexOf(key) !== -1) {\n                        counterOfOpt++;\n                    }\n                    if (this._maskValue.indexOf(key) !== -1 &&\n                        value.toString().length >= this._maskValue.indexOf(key)) {\n                        return null;\n                    }\n                    if (counterOfOpt === this._maskValue.length) {\n                        return null;\n                    }\n                }\n            }\n            if (this._maskValue.indexOf(\"{\" /* CURLY_BRACKETS_LEFT */) === 1 &&\n                value.toString().length ===\n                    this._maskValue.length +\n                        Number(((_b = this._maskValue.split(\"{\" /* CURLY_BRACKETS_LEFT */)[1]) !== null && _b !== void 0 ? _b : \"\" /* EMPTY_STRING */).split(\"}\" /* CURLY_BRACKETS_RIGHT */)[0]) -\n                        4) {\n                return null;\n            }\n            else if ((this._maskValue.indexOf(\"*\" /* SYMBOL_STAR */) > 1 &&\n                value.toString().length <\n                    this._maskValue.indexOf(\"*\" /* SYMBOL_STAR */)) ||\n                (this._maskValue.indexOf(\"?\" /* SYMBOL_QUESTION */) > 1 &&\n                    value.toString().length <\n                        this._maskValue.indexOf(\"?\" /* SYMBOL_QUESTION */)) ||\n                this._maskValue.indexOf(\"{\" /* CURLY_BRACKETS_LEFT */) === 1) {\n                return this._createValidationError(value);\n            }\n            if (this._maskValue.indexOf(\"*\" /* SYMBOL_STAR */) === -1 ||\n                this._maskValue.indexOf(\"?\" /* SYMBOL_QUESTION */) === -1) {\n                // eslint-disable-next-line no-param-reassign\n                value = typeof value === 'number' ? String(value) : value;\n                const array = this._maskValue.split('*');\n                const length = this._maskService.dropSpecialCharacters\n                    ? this._maskValue.length -\n                        this._maskService.checkDropSpecialCharAmount(this._maskValue) -\n                        counterOfOpt\n                    : this.prefix\n                        ? this._maskValue.length + this.prefix.length - counterOfOpt\n                        : this._maskValue.length - counterOfOpt;\n                if (array.length === 1) {\n                    if (value.toString().length < length) {\n                        return this._createValidationError(value);\n                    }\n                }\n                if (array.length > 1) {\n                    const lastIndexArray = array[array.length - 1];\n                    if (lastIndexArray &&\n                        this._maskService.specialCharacters.includes(lastIndexArray[0]) &&\n                        String(value).includes((_c = lastIndexArray[0]) !== null && _c !== void 0 ? _c : '') &&\n                        !this.dropSpecialCharacters) {\n                        const special = value.split(lastIndexArray[0]);\n                        return special[special.length - 1].length === lastIndexArray.length - 1\n                            ? null\n                            : this._createValidationError(value);\n                    }\n                    else if (((lastIndexArray &&\n                        !this._maskService.specialCharacters.includes(lastIndexArray[0])) ||\n                        !lastIndexArray ||\n                        this._maskService.dropSpecialCharacters) &&\n                        value.length >= length - 1) {\n                        return null;\n                    }\n                    else {\n                        return this._createValidationError(value);\n                    }\n                }\n            }\n            if (this._maskValue.indexOf(\"*\" /* SYMBOL_STAR */) === 1 ||\n                this._maskValue.indexOf(\"?\" /* SYMBOL_QUESTION */) === 1) {\n                return null;\n            }\n        }\n        if (value) {\n            this.maskFilled.emit();\n            return null;\n        }\n        return null;\n    }\n    onPaste() {\n        this._justPasted = true;\n    }\n    onFocus() {\n        this._isFocused = true;\n    }\n    onModelChange(value) {\n        // on form reset we need to update the actualValue\n        if ((value === \"\" /* EMPTY_STRING */ || value === null || value === undefined) &&\n            this._maskService.actualValue) {\n            this._maskService.actualValue = this._maskService.getActualValue(\"\" /* EMPTY_STRING */);\n        }\n    }\n    onInput(e) {\n        var _a, _b, _c, _d, _e;\n        // If IME is composing text, we wait for the composed text.\n        if (this._isComposing)\n            return;\n        const el = e.target;\n        const transformedValue = this._maskService.inputTransformFn(el.value);\n        if (el.type !== 'number') {\n            if (typeof transformedValue === 'string' || typeof transformedValue === 'number') {\n                el.value = transformedValue.toString();\n                this._inputValue = el.value;\n                this._setMask();\n                if (!this._maskValue) {\n                    this.onChange(el.value);\n                    return;\n                }\n                let position = el.selectionStart === 1\n                    ? el.selectionStart + this._maskService.prefix.length\n                    : el.selectionStart;\n                if (this.showMaskTyped &&\n                    this.keepCharacterPositions &&\n                    this._maskService.placeHolderCharacter.length === 1) {\n                    const inputSymbol = el.value.slice(position - 1, position);\n                    const prefixLength = this.prefix.length;\n                    const checkSymbols = this._maskService._checkSymbolMask(inputSymbol, (_a = this._maskService.maskExpression[position - 1 - prefixLength]) !== null && _a !== void 0 ? _a : \"\" /* EMPTY_STRING */);\n                    const checkSpecialCharacter = this._maskService._checkSymbolMask(inputSymbol, (_b = this._maskService.maskExpression[position + 1 - prefixLength]) !== null && _b !== void 0 ? _b : \"\" /* EMPTY_STRING */);\n                    const selectRangeBackspace = this._maskService.selStart === this._maskService.selEnd;\n                    const selStart = (_c = Number(this._maskService.selStart) - prefixLength) !== null && _c !== void 0 ? _c : '';\n                    const selEnd = (_d = Number(this._maskService.selEnd) - prefixLength) !== null && _d !== void 0 ? _d : '';\n                    if (this._code === \"Backspace\" /* BACKSPACE */) {\n                        if (!selectRangeBackspace) {\n                            if (this._maskService.selStart === prefixLength) {\n                                this._maskService.actualValue =\n                                    this.prefix +\n                                        this._maskService.maskIsShown.slice(0, selEnd) +\n                                        this._inputValue.split(this.prefix).join('');\n                            }\n                            else if (this._maskService.selStart ===\n                                this._maskService.maskIsShown.length + prefixLength) {\n                                this._maskService.actualValue =\n                                    this._inputValue +\n                                        this._maskService.maskIsShown.slice(selStart, selEnd);\n                            }\n                            else {\n                                this._maskService.actualValue =\n                                    this.prefix +\n                                        this._inputValue\n                                            .split(this.prefix)\n                                            .join('')\n                                            .slice(0, selStart) +\n                                        this._maskService.maskIsShown.slice(selStart, selEnd) +\n                                        this._maskService.actualValue.slice(selEnd + prefixLength, this._maskService.maskIsShown.length + prefixLength) +\n                                        this.suffix;\n                            }\n                        }\n                        else if (!this._maskService.specialCharacters.includes(this._maskService.maskExpression.slice(position - this.prefix.length, position + 1 - this.prefix.length)) &&\n                            selectRangeBackspace) {\n                            if (selStart === 1 && this.prefix) {\n                                this._maskService.actualValue =\n                                    this.prefix +\n                                        this._maskService.placeHolderCharacter +\n                                        el.value\n                                            .split(this.prefix)\n                                            .join('')\n                                            .split(this.suffix)\n                                            .join('') +\n                                        this.suffix;\n                                position = position - 1;\n                            }\n                            else {\n                                const part1 = el.value.substring(0, position);\n                                const part2 = el.value.substring(position);\n                                this._maskService.actualValue =\n                                    part1 + this._maskService.placeHolderCharacter + part2;\n                            }\n                        }\n                    }\n                    if (this._code !== \"Backspace\" /* BACKSPACE */) {\n                        if (!checkSymbols && !checkSpecialCharacter && selectRangeBackspace) {\n                            position = Number(el.selectionStart) - 1;\n                        }\n                        else if (this._maskService.specialCharacters.includes(el.value.slice(position, position + 1)) &&\n                            checkSpecialCharacter &&\n                            !this._maskService.specialCharacters.includes(el.value.slice(position + 1, position + 2))) {\n                            this._maskService.actualValue =\n                                el.value.slice(0, position - 1) +\n                                    el.value.slice(position, position + 1) +\n                                    inputSymbol +\n                                    el.value.slice(position + 2);\n                            position = position + 1;\n                        }\n                        else if (checkSymbols) {\n                            if (el.value.length === 1 && position === 1) {\n                                this._maskService.actualValue =\n                                    this.prefix +\n                                        inputSymbol +\n                                        this._maskService.maskIsShown.slice(1, this._maskService.maskIsShown.length) +\n                                        this.suffix;\n                            }\n                            else {\n                                this._maskService.actualValue =\n                                    el.value.slice(0, position - 1) +\n                                        inputSymbol +\n                                        el.value\n                                            .slice(position + 1)\n                                            .split(this.suffix)\n                                            .join('') +\n                                        this.suffix;\n                            }\n                        }\n                        else if (this.prefix &&\n                            el.value.length === 1 &&\n                            position - prefixLength === 1 &&\n                            this._maskService._checkSymbolMask(el.value, (_e = this._maskService.maskExpression[position - 1 - prefixLength]) !== null && _e !== void 0 ? _e : \"\" /* EMPTY_STRING */)) {\n                            this._maskService.actualValue =\n                                this.prefix +\n                                    el.value +\n                                    this._maskService.maskIsShown.slice(1, this._maskService.maskIsShown.length) +\n                                    this.suffix;\n                        }\n                    }\n                }\n                let caretShift = 0;\n                let backspaceShift = false;\n                if (this._code === \"Delete\" /* DELETE */ && \"separator\" /* SEPARATOR */) {\n                    this._maskService.deletedSpecialCharacter = true;\n                }\n                if (this._inputValue.length >= this._maskService.maskExpression.length - 1 &&\n                    this._code !== \"Backspace\" /* BACKSPACE */ &&\n                    this._maskService.maskExpression === \"d0/M0/0000\" /* DAYS_MONTHS_YEARS */ &&\n                    position < 10) {\n                    const inputSymbol = this._inputValue.slice(position - 1, position);\n                    el.value =\n                        this._inputValue.slice(0, position - 1) +\n                            inputSymbol +\n                            this._inputValue.slice(position + 1);\n                }\n                if (this._maskService.maskExpression === \"d0/M0/0000\" /* DAYS_MONTHS_YEARS */ &&\n                    this.leadZeroDateTime) {\n                    if ((position < 3 && Number(el.value) > 31 && Number(el.value) < 40) ||\n                        (position === 5 && Number(el.value.slice(3, 5)) > 12)) {\n                        position = position + 2;\n                    }\n                }\n                if (this._maskService.maskExpression === \"Hh:m0:s0\" /* HOURS_MINUTES_SECONDS */ &&\n                    this.apm) {\n                    if (this._justPasted && el.value.slice(0, 2) === \"00\" /* DOUBLE_ZERO */) {\n                        el.value = el.value.slice(1, 2) + el.value.slice(2, el.value.length);\n                    }\n                    el.value =\n                        el.value === \"00\" /* DOUBLE_ZERO */\n                            ? \"0\" /* NUMBER_ZERO */\n                            : el.value;\n                }\n                this._maskService.applyValueChanges(position, this._justPasted, this._code === \"Backspace\" /* BACKSPACE */ || this._code === \"Delete\" /* DELETE */, (shift, _backspaceShift) => {\n                    this._justPasted = false;\n                    caretShift = shift;\n                    backspaceShift = _backspaceShift;\n                });\n                // only set the selection if the element is active\n                if (this._getActiveElement() !== el) {\n                    return;\n                }\n                if (this._maskService.plusOnePosition) {\n                    position = position + 1;\n                    this._maskService.plusOnePosition = false;\n                }\n                // update position after applyValueChanges to prevent cursor on wrong position when it has an array of maskExpression\n                if (this._maskExpressionArray.length) {\n                    if (this._code === \"Backspace\" /* BACKSPACE */) {\n                        position = this.specialCharacters.includes(this._inputValue.slice(position - 1, position))\n                            ? position - 1\n                            : position;\n                    }\n                    else {\n                        position =\n                            el.selectionStart === 1\n                                ? el.selectionStart + this._maskService.prefix.length\n                                : el.selectionStart;\n                    }\n                }\n                this._position =\n                    this._position === 1 && this._inputValue.length === 1 ? null : this._position;\n                let positionToApply = this._position\n                    ? this._inputValue.length + position + caretShift\n                    : position +\n                        (this._code === \"Backspace\" /* BACKSPACE */ && !backspaceShift ? 0 : caretShift);\n                if (positionToApply > this._getActualInputLength()) {\n                    positionToApply =\n                        el.value === this._maskService.decimalMarker && el.value.length === 1\n                            ? this._getActualInputLength() + 1\n                            : this._getActualInputLength();\n                }\n                if (positionToApply < 0) {\n                    positionToApply = 0;\n                }\n                el.setSelectionRange(positionToApply, positionToApply);\n                this._position = null;\n            }\n            else {\n                console.warn('Ngx-mask writeValue work with string | number, your current value:', typeof transformedValue);\n            }\n        }\n        else {\n            if (!this._maskValue) {\n                this.onChange(el.value);\n                return;\n            }\n            this._maskService.applyValueChanges(el.value.length, this._justPasted, this._code === \"Backspace\" /* BACKSPACE */ || this._code === \"Delete\" /* DELETE */);\n        }\n    }\n    // IME starts\n    onCompositionStart() {\n        this._isComposing = true;\n    }\n    // IME completes\n    onCompositionEnd(e) {\n        this._isComposing = false;\n        this._justPasted = true;\n        this.onInput(e);\n    }\n    onBlur(e) {\n        if (this._maskValue) {\n            const el = e.target;\n            if (this.leadZero && el.value.length > 0 && typeof this.decimalMarker === 'string') {\n                const maskExpression = this._maskService.maskExpression;\n                const precision = Number(this._maskService.maskExpression.slice(maskExpression.length - 1, maskExpression.length));\n                if (precision > 1) {\n                    el.value = this.suffix ? el.value.split(this.suffix).join('') : el.value;\n                    const decimalPart = el.value.split(this.decimalMarker)[1];\n                    el.value = el.value.includes(this.decimalMarker)\n                        ? el.value +\n                            \"0\" /* NUMBER_ZERO */.repeat(precision - decimalPart.length) +\n                            this.suffix\n                        : el.value +\n                            this.decimalMarker +\n                            \"0\" /* NUMBER_ZERO */.repeat(precision) +\n                            this.suffix;\n                    this._maskService.actualValue = el.value;\n                }\n            }\n            this._maskService.clearIfNotMatchFn();\n        }\n        this._isFocused = false;\n        this.onTouch();\n    }\n    onClick(e) {\n        if (!this._maskValue) {\n            return;\n        }\n        const el = e.target;\n        const posStart = 0;\n        const posEnd = 0;\n        if (el !== null &&\n            el.selectionStart !== null &&\n            el.selectionStart === el.selectionEnd &&\n            el.selectionStart > this._maskService.prefix.length &&\n            // eslint-disable-next-line\n            e.keyCode !== 38) {\n            if (this._maskService.showMaskTyped && !this.keepCharacterPositions) {\n                // We are showing the mask in the input\n                this._maskService.maskIsShown = this._maskService.showMaskInInput();\n                if (el.setSelectionRange &&\n                    this._maskService.prefix + this._maskService.maskIsShown === el.value) {\n                    // the input ONLY contains the mask, so position the cursor at the start\n                    el.focus();\n                    el.setSelectionRange(posStart, posEnd);\n                }\n                else {\n                    // the input contains some characters already\n                    if (el.selectionStart > this._maskService.actualValue.length) {\n                        // if the user clicked beyond our value's length, position the cursor at the end of our value\n                        el.setSelectionRange(this._maskService.actualValue.length, this._maskService.actualValue.length);\n                    }\n                }\n            }\n        }\n        const nextValue = el &&\n            (el.value === this._maskService.prefix\n                ? this._maskService.prefix + this._maskService.maskIsShown\n                : el.value);\n        /** Fix of cursor position jumping to end in most browsers no matter where cursor is inserted onFocus */\n        if (el && el.value !== nextValue) {\n            el.value = nextValue;\n        }\n        /** fix of cursor position with prefix when mouse click occur */\n        if (el &&\n            el.type !== 'number' &&\n            (el.selectionStart || el.selectionEnd) <=\n                this._maskService.prefix.length) {\n            el.selectionStart = this._maskService.prefix.length;\n            return;\n        }\n        /** select only inserted text */\n        if (el && el.selectionEnd > this._getActualInputLength()) {\n            el.selectionEnd = this._getActualInputLength();\n        }\n    }\n    // eslint-disable-next-line complexity\n    onKeyDown(e) {\n        var _a, _b;\n        if (!this._maskValue) {\n            return;\n        }\n        if (this._isComposing) {\n            // User finalize their choice from IME composition, so trigger onInput() for the composed text.\n            if (e.key === 'Enter')\n                this.onCompositionEnd(e);\n            return;\n        }\n        this._code = e.code ? e.code : e.key;\n        const el = e.target;\n        this._inputValue = el.value;\n        this._setMask();\n        if (el.type !== 'number') {\n            if (e.key === \"ArrowUp\" /* ARROW_UP */) {\n                e.preventDefault();\n            }\n            if (e.key === \"ArrowLeft\" /* ARROW_LEFT */ ||\n                e.key === \"Backspace\" /* BACKSPACE */ ||\n                e.key === \"Delete\" /* DELETE */) {\n                if (e.key === \"Backspace\" /* BACKSPACE */ && el.value.length === 0) {\n                    el.selectionStart = el.selectionEnd;\n                }\n                if (e.key === \"Backspace\" /* BACKSPACE */ && el.selectionStart !== 0) {\n                    // If specialChars is false, (shouldn't ever happen) then set to the defaults\n                    this.specialCharacters = ((_a = this.specialCharacters) === null || _a === void 0 ? void 0 : _a.length)\n                        ? this.specialCharacters\n                        : this._config.specialCharacters;\n                    if (this.prefix.length > 1 &&\n                        el.selectionStart <= this.prefix.length) {\n                        el.setSelectionRange(this.prefix.length, el.selectionEnd);\n                    }\n                    else {\n                        if (this._inputValue.length !== el.selectionStart &&\n                            el.selectionStart !== 1) {\n                            while (this.specialCharacters.includes(((_b = this._inputValue[el.selectionStart - 1]) !== null && _b !== void 0 ? _b : \"\" /* EMPTY_STRING */).toString()) &&\n                                ((this.prefix.length >= 1 &&\n                                    el.selectionStart > this.prefix.length) ||\n                                    this.prefix.length === 0)) {\n                                el.setSelectionRange(el.selectionStart - 1, el.selectionEnd);\n                            }\n                        }\n                    }\n                }\n                this.checkSelectionOnDeletion(el);\n                if (this._maskService.prefix.length &&\n                    el.selectionStart <= this._maskService.prefix.length &&\n                    el.selectionEnd <= this._maskService.prefix.length) {\n                    e.preventDefault();\n                }\n                const cursorStart = el.selectionStart;\n                if (e.key === \"Backspace\" /* BACKSPACE */ &&\n                    !el.readOnly &&\n                    cursorStart === 0 &&\n                    el.selectionEnd === el.value.length &&\n                    el.value.length !== 0) {\n                    this._position = this._maskService.prefix ? this._maskService.prefix.length : 0;\n                    this._maskService.applyMask(this._maskService.prefix, this._maskService.maskExpression, this._position);\n                }\n            }\n            if (!!this.suffix &&\n                this.suffix.length > 1 &&\n                this._inputValue.length - this.suffix.length < el.selectionStart) {\n                el.setSelectionRange(this._inputValue.length - this.suffix.length, this._inputValue.length);\n            }\n            else if ((e.code === 'KeyA' && e.ctrlKey) ||\n                (e.code === 'KeyA' && e.metaKey) // Cmd + A (Mac)\n            ) {\n                el.setSelectionRange(0, this._getActualInputLength());\n                e.preventDefault();\n            }\n            this._maskService.selStart = el.selectionStart;\n            this._maskService.selEnd = el.selectionEnd;\n        }\n    }\n    /** It writes the value in the input */\n    writeValue(controlValue) {\n        var _a;\n        return __awaiter(this, void 0, void 0, function* () {\n            if (typeof controlValue === 'object' && controlValue !== null && 'value' in controlValue) {\n                if ('disable' in controlValue) {\n                    this.setDisabledState(Boolean(controlValue.disable));\n                }\n                // eslint-disable-next-line no-param-reassign\n                controlValue = controlValue.value;\n            }\n            if (controlValue !== null) {\n                // eslint-disable-next-line no-param-reassign\n                controlValue = this.inputTransformFn\n                    ? this.inputTransformFn(controlValue)\n                    : controlValue;\n            }\n            if (typeof controlValue === 'string' ||\n                typeof controlValue === 'number' ||\n                controlValue === null ||\n                controlValue === undefined) {\n                if (controlValue === null || controlValue === undefined || controlValue === '') {\n                    this._maskService._currentValue = '';\n                    this._maskService._previousValue = '';\n                }\n                // eslint-disable-next-line no-param-reassign\n                let inputValue = controlValue;\n                if (typeof inputValue === 'number' ||\n                    this._maskValue.startsWith(\"separator\" /* SEPARATOR */)) {\n                    // eslint-disable-next-line no-param-reassign\n                    inputValue = String(inputValue);\n                    const localeDecimalMarker = this._maskService.currentLocaleDecimalMarker();\n                    if (!Array.isArray(this._maskService.decimalMarker)) {\n                        // eslint-disable-next-line no-param-reassign\n                        inputValue =\n                            this._maskService.decimalMarker !== localeDecimalMarker\n                                ? inputValue.replace(localeDecimalMarker, this._maskService.decimalMarker)\n                                : inputValue;\n                    }\n                    if (this._maskService.leadZero &&\n                        inputValue &&\n                        this.maskExpression &&\n                        this.dropSpecialCharacters !== false) {\n                        // eslint-disable-next-line no-param-reassign\n                        inputValue = this._maskService._checkPrecision(this._maskService.maskExpression, inputValue);\n                    }\n                    if (this._maskService.decimalMarker === \",\" /* COMMA */) {\n                        // eslint-disable-next-line no-param-reassign\n                        inputValue = inputValue\n                            .toString()\n                            .replace(\".\" /* DOT */, \",\" /* COMMA */);\n                    }\n                    if (((_a = this.maskExpression) === null || _a === void 0 ? void 0 : _a.startsWith(\"separator\" /* SEPARATOR */)) && this.leadZero) {\n                        requestAnimationFrame(() => {\n                            var _a;\n                            this._maskService.applyMask((_a = inputValue === null || inputValue === void 0 ? void 0 : inputValue.toString()) !== null && _a !== void 0 ? _a : '', this._maskService.maskExpression);\n                        });\n                    }\n                    this._maskService.isNumberValue = true;\n                }\n                if (typeof inputValue !== 'string') {\n                    // eslint-disable-next-line no-param-reassign\n                    inputValue = '';\n                }\n                this._inputValue = inputValue;\n                this._setMask();\n                if ((inputValue && this._maskService.maskExpression) ||\n                    (this._maskService.maskExpression &&\n                        (this._maskService.prefix || this._maskService.showMaskTyped))) {\n                    // Let the service we know we are writing value so that triggering onChange function won't happen during applyMask\n                    typeof this.inputTransformFn !== 'function'\n                        ? (this._maskService.writingValue = true)\n                        : '';\n                    this._maskService.formElementProperty = [\n                        'value',\n                        this._maskService.applyMask(inputValue, this._maskService.maskExpression),\n                    ];\n                    // Let the service know we've finished writing value\n                    typeof this.inputTransformFn !== 'function'\n                        ? (this._maskService.writingValue = false)\n                        : '';\n                }\n                else {\n                    this._maskService.formElementProperty = ['value', inputValue];\n                }\n                this._inputValue = inputValue;\n            }\n            else {\n                console.warn('Ngx-mask writeValue work with string | number, your current value:', typeof controlValue);\n            }\n        });\n    }\n    registerOnChange(fn) {\n        this._maskService.onChange = this.onChange = fn;\n    }\n    registerOnTouched(fn) {\n        this.onTouch = fn;\n    }\n    _getActiveElement(document = this.document) {\n        var _a;\n        const shadowRootEl = (_a = document === null || document === void 0 ? void 0 : document.activeElement) === null || _a === void 0 ? void 0 : _a.shadowRoot;\n        if (!(shadowRootEl === null || shadowRootEl === void 0 ? void 0 : shadowRootEl.activeElement)) {\n            return document.activeElement;\n        }\n        else {\n            return this._getActiveElement(shadowRootEl);\n        }\n    }\n    checkSelectionOnDeletion(el) {\n        el.selectionStart = Math.min(Math.max(this.prefix.length, el.selectionStart), this._inputValue.length - this.suffix.length);\n        el.selectionEnd = Math.min(Math.max(this.prefix.length, el.selectionEnd), this._inputValue.length - this.suffix.length);\n    }\n    /** It disables the input element */\n    setDisabledState(isDisabled) {\n        this._maskService.formElementProperty = ['disabled', isDisabled];\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    _applyMask() {\n        this._maskService.maskExpression = this._maskService._repeatPatternSymbols(this._maskValue || '');\n        this._maskService.formElementProperty = [\n            'value',\n            this._maskService.applyMask(this._inputValue, this._maskService.maskExpression),\n        ];\n    }\n    _validateTime(value) {\n        var _a;\n        const rowMaskLen = this._maskValue\n            .split(\"\" /* EMPTY_STRING */)\n            .filter((s) => s !== ':').length;\n        if (!value) {\n            return null; // Don't validate empty values to allow for optional form control\n        }\n        if ((+((_a = value[value.length - 1]) !== null && _a !== void 0 ? _a : -1) === 0 && value.length < rowMaskLen) ||\n            value.length <= rowMaskLen - 2) {\n            return this._createValidationError(value);\n        }\n        return null;\n    }\n    _getActualInputLength() {\n        return (this._maskService.actualValue.length ||\n            this._maskService.actualValue.length + this._maskService.prefix.length);\n    }\n    _createValidationError(actualValue) {\n        return {\n            mask: {\n                requiredMask: this._maskValue,\n                actualValue,\n            },\n        };\n    }\n    _setMask() {\n        this._maskExpressionArray.some((mask) => {\n            var _a, _b, _c, _d;\n            const specialChart = mask\n                .split(\"\" /* EMPTY_STRING */)\n                .some((char) => this._maskService.specialCharacters.includes(char));\n            if ((specialChart && this._inputValue && !mask.includes(\"S\" /* LETTER_S */)) ||\n                mask.includes(\"{\" /* CURLY_BRACKETS_LEFT */)) {\n                const test = ((_a = this._maskService.removeMask(this._inputValue)) === null || _a === void 0 ? void 0 : _a.length) <=\n                    ((_b = this._maskService.removeMask(mask)) === null || _b === void 0 ? void 0 : _b.length);\n                if (test) {\n                    this._maskValue =\n                        this.maskExpression =\n                            this._maskService.maskExpression =\n                                mask.includes(\"{\" /* CURLY_BRACKETS_LEFT */)\n                                    ? this._maskService._repeatPatternSymbols(mask)\n                                    : mask;\n                    return test;\n                }\n                else {\n                    const expression = (_c = this._maskExpressionArray[this._maskExpressionArray.length - 1]) !== null && _c !== void 0 ? _c : \"\" /* EMPTY_STRING */;\n                    this._maskValue =\n                        this.maskExpression =\n                            this._maskService.maskExpression =\n                                expression.includes(\"{\" /* CURLY_BRACKETS_LEFT */)\n                                    ? this._maskService._repeatPatternSymbols(expression)\n                                    : expression;\n                }\n            }\n            else {\n                const check = (_d = this._maskService\n                    .removeMask(this._inputValue)) === null || _d === void 0 ? void 0 : _d.split(\"\" /* EMPTY_STRING */).every((character, index) => {\n                    const indexMask = mask.charAt(index);\n                    return this._maskService._checkSymbolMask(character, indexMask);\n                });\n                if (check) {\n                    this._maskValue = this.maskExpression = this._maskService.maskExpression = mask;\n                    return check;\n                }\n            }\n        });\n    }\n}\nNgxMaskDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskDirective, deps: [{ token: DOCUMENT }, { token: NGX_MASK_CONFIG }, { token: NgxMaskService }], target: i0.ɵɵFactoryTarget.Directive });\nNgxMaskDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgxMaskDirective, selector: \"input[mask], textarea[mask]\", inputs: { maskExpression: [\"mask\", \"maskExpression\"], specialCharacters: \"specialCharacters\", patterns: \"patterns\", prefix: \"prefix\", suffix: \"suffix\", thousandSeparator: \"thousandSeparator\", decimalMarker: \"decimalMarker\", dropSpecialCharacters: \"dropSpecialCharacters\", hiddenInput: \"hiddenInput\", showMaskTyped: \"showMaskTyped\", placeHolderCharacter: \"placeHolderCharacter\", shownMaskExpression: \"shownMaskExpression\", showTemplate: \"showTemplate\", clearIfNotMatch: \"clearIfNotMatch\", validation: \"validation\", separatorLimit: \"separatorLimit\", allowNegativeNumbers: \"allowNegativeNumbers\", leadZeroDateTime: \"leadZeroDateTime\", leadZero: \"leadZero\", triggerOnMaskChange: \"triggerOnMaskChange\", apm: \"apm\", inputTransformFn: \"inputTransformFn\", outputTransformFn: \"outputTransformFn\", keepCharacterPositions: \"keepCharacterPositions\" }, outputs: { maskFilled: \"maskFilled\" }, host: { listeners: { \"paste\": \"onPaste()\", \"focus\": \"onFocus($event)\", \"ngModelChange\": \"onModelChange($event)\", \"input\": \"onInput($event)\", \"compositionstart\": \"onCompositionStart($event)\", \"compositionend\": \"onCompositionEnd($event)\", \"blur\": \"onBlur($event)\", \"click\": \"onClick($event)\", \"keydown\": \"onKeyDown($event)\" } }, providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => NgxMaskDirective),\n            multi: true,\n        },\n        {\n            provide: NG_VALIDATORS,\n            useExisting: forwardRef(() => NgxMaskDirective),\n            multi: true,\n        },\n        NgxMaskService,\n    ], exportAs: [\"mask\", \"ngxMask\"], usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskDirective, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input[mask], textarea[mask]',\n                    providers: [\n                        {\n                            provide: NG_VALUE_ACCESSOR,\n                            useExisting: forwardRef(() => NgxMaskDirective),\n                            multi: true,\n                        },\n                        {\n                            provide: NG_VALIDATORS,\n                            useExisting: forwardRef(() => NgxMaskDirective),\n                            multi: true,\n                        },\n                        NgxMaskService,\n                    ],\n                    exportAs: 'mask,ngxMask',\n                }]\n        }], ctorParameters: function () {\n        return [{ type: undefined, decorators: [{\n                        type: Inject,\n                        args: [DOCUMENT]\n                    }] }, { type: undefined, decorators: [{\n                        type: Inject,\n                        args: [NGX_MASK_CONFIG]\n                    }] }, { type: NgxMaskService }];\n    }, propDecorators: { maskExpression: [{\n                type: Input,\n                args: ['mask']\n            }], specialCharacters: [{\n                type: Input\n            }], patterns: [{\n                type: Input\n            }], prefix: [{\n                type: Input\n            }], suffix: [{\n                type: Input\n            }], thousandSeparator: [{\n                type: Input\n            }], decimalMarker: [{\n                type: Input\n            }], dropSpecialCharacters: [{\n                type: Input\n            }], hiddenInput: [{\n                type: Input\n            }], showMaskTyped: [{\n                type: Input\n            }], placeHolderCharacter: [{\n                type: Input\n            }], shownMaskExpression: [{\n                type: Input\n            }], showTemplate: [{\n                type: Input\n            }], clearIfNotMatch: [{\n                type: Input\n            }], validation: [{\n                type: Input\n            }], separatorLimit: [{\n                type: Input\n            }], allowNegativeNumbers: [{\n                type: Input\n            }], leadZeroDateTime: [{\n                type: Input\n            }], leadZero: [{\n                type: Input\n            }], triggerOnMaskChange: [{\n                type: Input\n            }], apm: [{\n                type: Input\n            }], inputTransformFn: [{\n                type: Input\n            }], outputTransformFn: [{\n                type: Input\n            }], keepCharacterPositions: [{\n                type: Input\n            }], maskFilled: [{\n                type: Output\n            }], onPaste: [{\n                type: HostListener,\n                args: ['paste']\n            }], onFocus: [{\n                type: HostListener,\n                args: ['focus', ['$event']]\n            }], onModelChange: [{\n                type: HostListener,\n                args: ['ngModelChange', ['$event']]\n            }], onInput: [{\n                type: HostListener,\n                args: ['input', ['$event']]\n            }], onCompositionStart: [{\n                type: HostListener,\n                args: ['compositionstart', ['$event']]\n            }], onCompositionEnd: [{\n                type: HostListener,\n                args: ['compositionend', ['$event']]\n            }], onBlur: [{\n                type: HostListener,\n                args: ['blur', ['$event']]\n            }], onClick: [{\n                type: HostListener,\n                args: ['click', ['$event']]\n            }], onKeyDown: [{\n                type: HostListener,\n                args: ['keydown', ['$event']]\n            }] } });\n\nclass NgxMaskPipe {\n    constructor(_maskService) {\n        this._maskService = _maskService;\n        this.defaultOptions = {};\n        this._maskExpressionArray = [];\n        this.mask = '';\n    }\n    transform(value, mask, _a = {}) {\n        var { patterns } = _a, config = __rest(_a, [\"patterns\"]);\n        const currentConfig = Object.assign(Object.assign(Object.assign({ maskExpression: mask }, this.defaultOptions), config), { patterns: Object.assign(Object.assign({}, this._maskService.patterns), patterns) });\n        Object.entries(currentConfig).forEach(([key, value]) => {\n            //eslint-disable-next-line  @typescript-eslint/no-explicit-any\n            this._maskService[key] = value;\n        });\n        if (mask.includes('||')) {\n            if (mask.split('||').length > 1) {\n                this._maskExpressionArray = mask.split('||').sort((a, b) => {\n                    return a.length - b.length;\n                });\n                this._setMask(value);\n                return this._maskService.applyMask(`${value}`, this.mask);\n            }\n            else {\n                this._maskExpressionArray = [];\n                return this._maskService.applyMask(`${value}`, this.mask);\n            }\n        }\n        if (mask.includes(\"{\" /* CURLY_BRACKETS_LEFT */)) {\n            return this._maskService.applyMask(`${value}`, this._maskService._repeatPatternSymbols(mask));\n        }\n        if (mask.startsWith(\"separator\" /* SEPARATOR */)) {\n            if (config.decimalMarker) {\n                this._maskService.decimalMarker = config.decimalMarker;\n            }\n            if (config.thousandSeparator) {\n                this._maskService.thousandSeparator = config.thousandSeparator;\n            }\n            if (config.leadZero) {\n                // eslint-disable-next-line no-param-reassign\n                this._maskService.leadZero = config.leadZero;\n            }\n            // eslint-disable-next-line no-param-reassign\n            value = String(value);\n            const localeDecimalMarker = this._maskService.currentLocaleDecimalMarker();\n            if (!Array.isArray(this._maskService.decimalMarker)) {\n                // eslint-disable-next-line no-param-reassign\n                value =\n                    this._maskService.decimalMarker !== localeDecimalMarker\n                        ? value.replace(localeDecimalMarker, this._maskService.decimalMarker)\n                        : value;\n            }\n            if (this._maskService.leadZero &&\n                value &&\n                this._maskService.dropSpecialCharacters !== false) {\n                // eslint-disable-next-line no-param-reassign\n                value = this._maskService._checkPrecision(mask, value);\n            }\n            if (this._maskService.decimalMarker === \",\" /* COMMA */) {\n                // eslint-disable-next-line no-param-reassign\n                value = value.toString().replace(\".\" /* DOT */, \",\" /* COMMA */);\n            }\n            this._maskService.isNumberValue = true;\n        }\n        if (value === null || value === undefined) {\n            return this._maskService.applyMask('', mask);\n        }\n        return this._maskService.applyMask(`${value}`, mask);\n    }\n    _setMask(value) {\n        if (this._maskExpressionArray.length > 0) {\n            this._maskExpressionArray.some((mask) => {\n                var _a, _b, _c;\n                const test = ((_a = this._maskService.removeMask(value)) === null || _a === void 0 ? void 0 : _a.length) <=\n                    ((_b = this._maskService.removeMask(mask)) === null || _b === void 0 ? void 0 : _b.length);\n                if (value && test) {\n                    this.mask = mask;\n                    return test;\n                }\n                else {\n                    const expression = (_c = this._maskExpressionArray[this._maskExpressionArray.length - 1]) !== null && _c !== void 0 ? _c : \"\" /* EMPTY_STRING */;\n                    this.mask = expression;\n                }\n            });\n        }\n    }\n}\nNgxMaskPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskPipe, deps: [{ token: NgxMaskService }], target: i0.ɵɵFactoryTarget.Pipe });\nNgxMaskPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskPipe, name: \"mask\" });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskPipe, decorators: [{\n            type: Pipe,\n            args: [{\n                    name: 'mask',\n                    pure: true,\n                }]\n        }], ctorParameters: function () { return [{ type: NgxMaskService }]; } });\n\n/**\n * @internal\n */\nfunction _configFactory(initConfig, configValue) {\n    return configValue instanceof Function\n        ? Object.assign(Object.assign({}, initConfig), configValue()) : Object.assign(Object.assign({}, initConfig), configValue);\n}\nclass NgxMaskModule {\n    static forRoot(configValue) {\n        return {\n            ngModule: NgxMaskModule,\n            providers: [\n                {\n                    provide: NEW_CONFIG,\n                    useValue: configValue,\n                },\n                {\n                    provide: INITIAL_CONFIG,\n                    useValue: initialConfig,\n                },\n                {\n                    provide: NGX_MASK_CONFIG,\n                    useFactory: _configFactory,\n                    deps: [INITIAL_CONFIG, NEW_CONFIG],\n                },\n                NgxMaskService,\n            ],\n        };\n    }\n    static forChild() {\n        return {\n            ngModule: NgxMaskModule,\n        };\n    }\n}\nNgxMaskModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nNgxMaskModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskModule, declarations: [NgxMaskDirective, NgxMaskPipe], exports: [NgxMaskDirective, NgxMaskPipe] });\nNgxMaskModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskModule });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgxMaskModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    exports: [NgxMaskDirective, NgxMaskPipe],\n                    declarations: [NgxMaskDirective, NgxMaskPipe],\n                }]\n        }] });\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { INITIAL_CONFIG, NEW_CONFIG, NGX_MASK_CONFIG, NgxMaskDirective, NgxMaskModule, NgxMaskPipe, NgxMaskService, _configFactory, initialConfig, timeMasks, withoutValidation };\n"]}