{"version":3,"sources":["webpack:///./src/components/shared/formTextbox.js","webpack:///./node_modules/react-number-format/dist/react-number-format.es.js","webpack:///./src/components/shared/formFieldDisableAutoComplete.js"],"names":["FormTextbox","props","textDesc","form","field","maxLength","toUpperCase","errorsMsg","getIn","errors","name","React","createElement","className","FormLabel","text","Field","touched","inputName","type","onChange","event","value","target","setFieldValue","onBlur","handleBlur","trim","autoComplete","inputErrorMessage","inputErrorClassName","noop","charIsNumber","char","match","isNil","val","escapeRegExp","str","replace","splitDecimal","numStr","allowNegative","hasNagation","addNegation","parts","split","beforeDecimal","afterDecimal","limitToScale","scale","fixedDecimalScale","filler","i","repeat","count","Array","join","setCaretPosition","el","caretPos","createTextRange","range","move","select","selectionStart","focus","setSelectionRange","clamp","num","min","max","Math","getCurrentCaretPosition","selectionEnd","defaultProps","displayType","decimalSeparator","thousandsGroupStyle","prefix","suffix","allowEmptyFormatting","allowLeadingZeros","isNumericString","onValueChange","onKeyDown","onMouseUp","onFocus","isAllowed","NumberFormat","superclass","call","this","defaultValue","validateProps","formattedValue","formatValueProp","state","numAsString","removeFormatting","mounted","selectionBeforeInput","bind","__proto__","prototype","Object","create","constructor","componentDidMount","setState","componentDidUpdate","prevProps","updateValueIfRequired","componentWillUnmount","clearTimeout","focusTimeout","caretPositionTimeout","focusedElm","stateValue","lastNumStr","lastValueWithNewFormat","formatNumString","floatValue","parseFloat","lastFloatValue","isNaN","updateValue","input","source","getFloatString","decimalScale","getSeparators","numRegex","getNumberRegex","hasNegation","firstDecimalIndex","indexOf","substring","length","RegExp","g","ignoreDecimalSeparator","ref","format","customNumerals","undefined","ref$1","thousandSeparator","allowedDecimalSeparators","getMaskAtIndex","index","mask","getValueObject","Error","toString","setPatchedCaretPosition","currentValue","setTimeout","correctCaretPosition","direction","firstHashPosition","lastIndexOf","nextPos","caretLeftBound","caretRightBound","getCaretPosition","inputValue","j","inputNumber","formattedNumber","currentInputChar","currentFormatChar","removePrefixAndSuffix","isNegative","suffixLastIndex","removePatternFormatting","formatArray","filter","start","ln","part","formatWithPattern","hashCount","formattedNumberAry","formatAsNumber","hasDecimalSeparator","ref$2","thousandsGroupRegex","getThousandsGroupRegex","search","applyThousandSeparator","customNumeralRegex","digit","isNonNumericFalsy","sign","coefficient","exponent","Number","decimalIndex","coffiecientLn","abs","toNumericString","shoudHaveDecimalSeparator","roundedDecimalParts","toFixed","reverse","reduce","roundedStr","current","idx","roundToPrecision","formatInput","formatNegation","negationRegex","doubleNegationRegex","test","removeNegation","isCharacterAFormat","correctInputValue","lastValue","this$1","ref$3","prevValue","newValue","prevLength","newLength","end","findChangedIndex","separator","substr","leftBound","rightBound","deletedValues","concat","find","deletedVal","deletedValuePortion","recordIndexOfFormatCharacters","resolvedPortion","forEach","currentPortion","push","keys","splice","numericString","ref$4","isBeforeDecimalPoint","params","currentCaretPosition","e","isChangeAllowed","fixLeadingZero","expectedCaretPosition","key","negativeRegex","isPatternFormat","newCaretPosition","preventDefault","isUnitTestRun","caretPosition","persist","render","customInput","renderText","getInputRef","otherProps","obj","exclude","k","hasOwnProperty","objectWithoutProperties","inputMode","navigator","platform","addInputMode","inputProps","assign","CustomInput","Component","FormFieldDisableAutoComplete","style","overflow","height","background","data-description","Form","Group","Row","Col","xs","md","readOnly"],"mappings":"6FAAA,iDAgEeA,IA5Df,SAAqBC,GACnB,MAAM,SAAEC,EAAQ,KAAEC,EAAI,MAAEC,EAAK,UAAEC,EAAS,YAAEC,GAAgBL,EAEpDM,EAAYC,YAAML,EAAKM,OAAQL,EAAMM,MAc3C,OACEC,IAAAC,cAAA,OAAKC,UAAU,oBACbF,IAAAC,cAACE,IAAS,CAACC,KAAMb,IACjBS,IAAAC,cAAA,OAAKC,UAAU,iBACbF,IAAAC,cAACI,IAAK,CACJN,KAAMN,EAAMM,KACZG,UACE,qBAnBmBI,EAoBCd,EAAKc,QApBGR,EAoBMN,EAAKM,OApBHS,EAoBWd,EAAMM,KAlBtDD,EAAOS,IAAcD,EAAQC,GAAa,aAAe,MAoB1DC,KAAK,OACLC,SAAUC,IACR,IAAIC,EAAQD,EAAME,OAAOD,OAAS,GAC9BhB,IACFgB,EAAQA,EAAMhB,eAEhBH,EAAKqB,cAAcpB,EAAMM,KAAMY,IAEjCG,OAAQJ,IACNlB,EAAKuB,WAAWL,GAEhB,IAAIC,EAAQD,EAAME,OAAOD,OAAS,GAC9BhB,IACFgB,EAAQA,EAAMhB,eAEhBH,EAAKqB,cAAcpB,EAAMM,KAAMY,EAAMK,SAEvCtB,UAAWA,EACXuB,aAAa,eACbN,MACEhB,EACIF,EAAMkB,MAAMhB,cACZF,EAAMkB,MACNlB,EAAMkB,MACN,KAzCYO,EAACZ,EAASR,EAAQS,IAEnCT,EAAOS,IAAcD,EAAQC,GAClCP,IAAAC,cAAA,QAAMC,UAAU,cAAcN,GAC5B,KAwCCsB,CAAkB1B,EAAKc,QAASd,EAAKM,OAAQL,EAAMM,QAjD9BoB,IAACb,EAASR,EAAQS,I,kCCThD,yBAYA,SAASa,KAIT,SAASC,EAAaC,GACpB,SAAUA,GAAQ,IAAIC,MAAM,MAE9B,SAASC,EAAMC,GACb,OAAOA,QAET,SAASC,EAAaC,GACpB,OAAOA,EAAIC,QAAQ,wBAAyB,QAqB9C,SAASC,EAAaC,EAAQC,QACN,IAAlBA,IAA0BA,GAAgB,GAC9C,IAAIC,EAA4B,MAAdF,EAAO,GACrBG,EAAcD,GAAeD,EAE7BG,GADJJ,EAASA,EAAOF,QAAQ,IAAK,KACVO,MAAM,KAGzB,MAAO,CACLC,cAHkBF,EAAM,GAIxBG,aAHiBH,EAAM,IAAM,GAI7BF,YAAaA,EACbC,YAAaA,GAqBjB,SAASK,EAAaR,EAAQS,EAAOC,GAGnC,IAFA,IAAIb,EAAM,GACNc,EAASD,EAAoB,IAAM,GAC9BE,EAAI,EAAGA,GAAKH,EAAQ,EAAGG,IAC9Bf,GAAOG,EAAOY,IAAMD,EAEtB,OAAOd,EAET,SAASgB,EAAOhB,EAAKiB,GACnB,OAAOC,MAAMD,EAAQ,GAAGE,KAAKnB,GA2E/B,SAASoB,EAAiBC,EAAIC,GAK5B,GAJAD,EAAGrC,MAAQqC,EAAGrC,MAIH,OAAPqC,EAAa,CACf,GAAIA,EAAGE,gBAAiB,CACtB,IAAIC,EAAQH,EAAGE,kBAGf,OAFAC,EAAMC,KAAK,YAAaH,GACxBE,EAAME,UACC,EAGT,OAAIL,EAAGM,gBAAwC,IAAtBN,EAAGM,gBAC1BN,EAAGO,QACHP,EAAGQ,kBAAkBP,EAAUA,IACxB,IAITD,EAAGO,SACI,IAgCX,SAASE,EAAMC,EAAKC,EAAKC,GACvB,OAAOC,KAAKF,IAAIE,KAAKD,IAAIF,EAAKC,GAAMC,GAEtC,SAASE,EAAwBd,GAE/B,OAAOa,KAAKD,IAAIZ,EAAGM,eAAgBN,EAAGe,cAYxC,IAAIC,EAAe,CACjBC,YAAa,QACbC,iBAAkB,IAClBC,oBAAqB,WACrB3B,mBAAmB,EACnB4B,OAAQ,GACRC,OAAQ,GACRtC,eAAe,EACfuC,sBAAsB,EACtBC,mBAAmB,EACnBC,iBAAiB,EACjBhE,KAAM,OACNiE,cAAerD,EACfX,SAAUW,EACVsD,UAAWtD,EACXuD,UAAWvD,EACXwD,QAASxD,EACTN,OAAQM,EACRyD,UA5OF,WACE,OAAO,IA6OLC,EAA4B,SAAUC,GACxC,SAASD,EAAaxF,GACpByF,EAAWC,KAAKC,KAAM3F,GACtB,IAAI4F,EAAe5F,EAAM4F,aAGzBD,KAAKE,gBACL,IAAIC,EAAiBH,KAAKI,gBAAgBH,GAC1CD,KAAKK,MAAQ,CACX3E,MAAOyE,EACPG,YAAaN,KAAKO,iBAAiBJ,GACnCK,SAAS,GAEXR,KAAKS,qBAAuB,CAC1BpC,eAAgB,EAChBS,aAAc,GAEhBkB,KAAKxE,SAAWwE,KAAKxE,SAASkF,KAAKV,MACnCA,KAAKP,UAAYO,KAAKP,UAAUiB,KAAKV,MACrCA,KAAKN,UAAYM,KAAKN,UAAUgB,KAAKV,MACrCA,KAAKL,QAAUK,KAAKL,QAAQe,KAAKV,MACjCA,KAAKnE,OAASmE,KAAKnE,OAAO6E,KAAKV,MAu7BjC,OAr7BIF,IAAYD,EAAac,UAAYb,GACzCD,EAAae,UAAYC,OAAOC,OAAOhB,GAAcA,EAAWc,WAChEf,EAAae,UAAUG,YAAclB,EACrCA,EAAae,UAAUI,kBAAoB,WAGzChB,KAAKiB,SAAS,CACZT,SAAS,KAGbX,EAAae,UAAUM,mBAAqB,SAA4BC,GACtEnB,KAAKoB,sBAAsBD,IAE7BtB,EAAae,UAAUS,qBAAuB,WAC5CC,aAAatB,KAAKuB,cAClBD,aAAatB,KAAKwB,uBAEpB3B,EAAae,UAAUQ,sBAAwB,SAA+BD,GAC5E,IACI9G,EADM2F,KACM3F,MACZgG,EAFML,KAEMK,MACZoB,EAHMzB,KAGWyB,WACjBC,EAAarB,EAAM3E,MACnBiG,EAAatB,EAAMC,YAIvB,QAHmB,IAAfqB,IAAuBA,EAAa,IAGpCR,IAAc9G,EAAO,CAEvB2F,KAAKE,gBACL,IAAI0B,EAAyB5B,KAAK6B,gBAAgBF,GAC9CxB,EAAiB5D,EAAMlC,EAAMqB,OAASkG,EAAyB5B,KAAKI,kBACpEE,EAAcN,KAAKO,iBAAiBJ,GACpC2B,EAAaC,WAAWzB,GACxB0B,EAAiBD,WAAWJ,IAG9BM,MAAMH,IAAgBG,MAAMD,IAAoBF,IAAeE,IAEjEJ,IAA2BF,IAEZ,OAAfD,GAAuBtB,IAAmBuB,IACxC1B,KAAKkC,YAAY,CACf/B,eAAgBA,EAChBG,YAAaA,EACb6B,MAAOV,EACPW,OAAQ,OACR3G,MAAO,SAOfoE,EAAae,UAAUyB,eAAiB,SAAwB5D,QAClD,IAARA,IAAgBA,EAAM,IAC1B,IACI6D,EADMtC,KAAK3F,MACQiI,aAEnBrD,EADQe,KAAKuC,gBACYtD,iBACzBuD,EAAWxC,KAAKyC,gBAAe,GAG/BC,EAAyB,MAAXjE,EAAI,GAClBiE,IACFjE,EAAMA,EAAI9B,QAAQ,IAAK,KAIrBsC,GAAqC,IAAjBqD,IACtB7D,EAAMA,EAAIvB,MAAM+B,GAAkB,IAKpC,IAAI0D,GAHJlE,GAAOA,EAAInC,MAAMkG,IAAa,IAAI3E,KAAK,IAAIlB,QAAQsC,EAAkB,MAGzC2D,QAAQ,KASpC,OAR2B,IAAvBD,IACFlE,EAAMA,EAAIoE,UAAU,EAAGF,GAAqB,IAAMlE,EAAIoE,UAAUF,EAAoB,EAAGlE,EAAIqE,QAAQnG,QAAQ,IAAIoG,OAAOtG,EAAawC,GAAmB,KAAM,KAI1JyD,IACFjE,EAAM,IAAMA,GAEPA,GAIToB,EAAae,UAAU6B,eAAiB,SAAwBO,EAAGC,GACjE,IAAIC,EAAMlD,KAAK3F,MACX8I,EAASD,EAAIC,OACbb,EAAeY,EAAIZ,aACnBc,EAAiBF,EAAIE,eAErBnE,EADQe,KAAKuC,gBACYtD,iBAC7B,OAAO,IAAI8D,OAAO,QAAUK,EAAiBA,EAAevF,KAAK,IAAM,IAAM,MAAOoB,GAAqC,IAAjBqD,GAAuBW,GAA2BE,EAAgD,GAAvC,IAAM1G,EAAawC,IAAyB+D,EAAI,SAAMK,IAE3NxD,EAAae,UAAU2B,cAAgB,WACrC,IACItD,EADMe,KAAK3F,MACY4E,iBACvBqE,EAAQtD,KAAK3F,MACbkJ,EAAoBD,EAAMC,kBAC1BC,EAA2BF,EAAME,yBAOrC,OAN0B,IAAtBD,IACFA,EAAoB,KAEjBC,IACHA,EAA2B,CAACvE,EAAkB,MAEzC,CACLA,iBAAkBA,EAClBsE,kBAAmBA,EACnBC,yBAA0BA,IAG9B3D,EAAae,UAAU6C,eAAiB,SAAwBC,GAC9D,IACIC,EADM3D,KAAK3F,MACAsJ,KAEf,YADa,IAATA,IAAiBA,EAAO,KACR,iBAATA,EACFA,EAEFA,EAAKD,IAAU,KAExB7D,EAAae,UAAUgD,eAAiB,SAAwBzD,EAAgBG,GAC9E,IAAIwB,EAAaC,WAAWzB,GAC5B,MAAO,CACLH,eAAgBA,EAChBzE,MAAO4E,EACPwB,WAAYG,MAAMH,QAAcuB,EAAYvB,IAGhDjC,EAAae,UAAUV,cAAgB,WACrC,IACIyD,EADM3D,KAAK3F,MACAsJ,KAGXL,EAAQtD,KAAKuC,gBACbtD,EAAmBqE,EAAMrE,iBACzBsE,EAAoBD,EAAMC,kBAC9B,GAAItE,IAAqBsE,EACvB,MAAM,IAAIM,MAAM,oGAAsGN,EAAoB,iGAAqGtE,EAAmB,uDAIpQ,GAAI0E,IACuB,WAATA,EAAoBA,EAAOA,EAAKG,YAClCxH,MAAM,OAClB,MAAM,IAAIuH,MAAM,oBAAsBF,EAAO,qDAOnD9D,EAAae,UAAUmD,wBAA0B,SAAiChG,EAAIC,EAAUgG,GAI9FlG,EAAiBC,EAAIC,GACrBgC,KAAKwB,qBAAuByC,YAAW,WACjClG,EAAGrC,QAAUsI,GACflG,EAAiBC,EAAIC,KAEtB,IAIL6B,EAAae,UAAUsD,qBAAuB,SAA8BxI,EAAOsC,EAAUmG,GAC3F,IAAIjB,EAAMlD,KAAK3F,MACX8E,EAAS+D,EAAI/D,OACbC,EAAS8D,EAAI9D,OACb+D,EAASD,EAAIC,OAGjB,GAAc,KAAVzH,EACF,OAAO,EAOT,GAHAsC,EAAWQ,EAAMR,EAAU,EAAGtC,EAAMoH,SAG/BK,EAAQ,CACX,IAAIT,EAA2B,MAAbhH,EAAM,GACxB,OAAO8C,EAAMR,EAAUmB,EAAO2D,QAAUJ,EAAc,EAAI,GAAIhH,EAAMoH,OAAS1D,EAAO0D,QAItF,GAAsB,mBAAXK,EACT,OAAOnF,EAMT,GAAyB,MAArBmF,EAAOnF,IAAqB5B,EAAaV,EAAMsC,IACjD,OAAOA,EAIT,GAA6B,MAAzBmF,EAAOnF,EAAW,IAAc5B,EAAaV,EAAMsC,EAAW,IAChE,OAAOA,EAIT,IAAIoG,EAAoBjB,EAAOP,QAAQ,KAIvC5E,EAAWQ,EAAMR,EAAUoG,EAHJjB,EAAOkB,YAAY,KAGuB,GAMjE,IALA,IAAIC,EAAUnB,EAAON,UAAU7E,EAAUmF,EAAOL,QAAQF,QAAQ,KAC5D2B,EAAiBvG,EACjBwG,EAAkBxG,IAAyB,IAAbsG,EAAiB,EAAIA,GAGhDC,EAAiBH,IAAiD,MAA3BjB,EAAOoB,KAA4BnI,EAAaV,EAAM6I,MAClGA,GAAkB,EAGpB,OADgBnI,EAAaV,EAAM8I,KAAmC,SAAdL,GAAwBnG,IAAaoG,GAAqBpG,EAAWuG,EAAiBC,EAAkBxG,EAIvJ5B,EAAaV,EAAM6I,IAAmBA,EAAiB,EAAIA,EAE7DC,GAET3E,EAAae,UAAU6D,iBAAmB,SAA0BC,EAAYvE,EAAgBnC,GAC9F,IAMI2G,EAAGlH,EALH0F,EADMnD,KAAK3F,MACE8I,OACbzB,EAAa1B,KAAKK,MAAM3E,MACxB8G,EAAWxC,KAAKyC,gBAAe,GAC/BmC,GAAeF,EAAWpI,MAAMkG,IAAa,IAAI3E,KAAK,IACtDgH,GAAmB1E,EAAe7D,MAAMkG,IAAa,IAAI3E,KAAK,IAGlE,IADA8G,EAAI,EACClH,EAAI,EAAGA,EAAIO,EAAUP,IAAK,CAC7B,IAAIqH,EAAmBJ,EAAWjH,IAAM,GACpCsH,EAAoB5E,EAAewE,IAAM,GAG7C,IAAKG,EAAiBxI,MAAMkG,IAAasC,IAAqBC,KAMrC,MAArBD,IAA4BC,EAAkBzI,MAAMkG,IAAmC,MAAtBuC,GAA6BH,EAAY9B,SAAW+B,EAAgB/B,QAAzI,CAKA,KAAOgC,IAAqB3E,EAAewE,IAAMA,EAAIxE,EAAe2C,QAClE6B,IAEFA,KASF,MAPsB,iBAAXxB,GAAwBzB,IAEjCiD,EAAIxE,EAAe2C,QAIrB6B,EAAI3E,KAAKkE,qBAAqB/D,EAAgBwE,IAMhD9E,EAAae,UAAUoE,sBAAwB,SAA+BxI,GAC5E,IAAI0G,EAAMlD,KAAK3F,MACX8I,EAASD,EAAIC,OACbhE,EAAS+D,EAAI/D,OACbC,EAAS8D,EAAI9D,OAGjB,IAAK+D,GAAU3G,EAAK,CAClB,IAAIyI,EAAwB,MAAXzI,EAAI,GAGjByI,IACFzI,EAAMA,EAAIqG,UAAU,EAAGrG,EAAIsG,SAO7B,IAAIoC,GAHJ1I,EAAM2C,GAAkC,IAAxB3C,EAAIoG,QAAQzD,GAAgB3C,EAAIqG,UAAU1D,EAAO2D,OAAQtG,EAAIsG,QAAUtG,GAG7D6H,YAAYjF,GACtC5C,EAAM4C,IAA+B,IAArB8F,GAA0BA,IAAoB1I,EAAIsG,OAAS1D,EAAO0D,OAAStG,EAAIqG,UAAU,EAAGqC,GAAmB1I,EAG3HyI,IACFzI,EAAM,IAAMA,GAGhB,OAAOA,GAETqD,EAAae,UAAUuE,wBAA0B,SAAiC3I,GAQhF,IAPA,IAEI4I,EAFMpF,KAAK3F,MACE8I,OACQjG,MAAM,KAAKmI,QAAO,SAAU3I,GACnD,MAAe,KAARA,KAEL4I,EAAQ,EACRzI,EAAS,GACJY,EAAI,EAAG8H,EAAKH,EAAYtC,OAAQrF,GAAK8H,EAAI9H,IAAK,CACrD,IAAI+H,EAAOJ,EAAY3H,IAAM,GAIzBiG,EAAQjG,IAAM8H,EAAK/I,EAAIsG,OAAStG,EAAIoG,QAAQ4C,EAAMF,GAKtD,IAAe,IAAX5B,EAAc,CAChB7G,EAASL,EACT,MAEAK,GAAUL,EAAIqG,UAAUyC,EAAO5B,GAC/B4B,EAAQ5B,EAAQ8B,EAAK1C,OAGzB,OAAQjG,EAAOP,MAAM0D,KAAKyC,gBAAe,KAAU,IAAI5E,KAAK,KAE9DgC,EAAae,UAAUL,iBAAmB,SAA0B/D,GAClE,IAAI0G,EAAMlD,KAAK3F,MACX8I,EAASD,EAAIC,OACb5C,EAAmB2C,EAAI3C,iBAC3B,OAAK/D,GAGA2G,EAIH3G,EAD2B,iBAAX2G,EACVnD,KAAKmF,wBAAwB3I,GACE,mBAArB+D,EAEVA,EAAiB/D,IAEhBA,EAAIF,MAAM0D,KAAKyC,gBAAe,KAAU,IAAI5E,KAAK,KARxDrB,EAAMwD,KAAKgF,sBAAsBxI,GACjCA,EAAMwD,KAAKqC,eAAe7F,IASrBA,GAbEA,GAuBXqD,EAAae,UAAU6E,kBAAoB,SAA2B5I,GAKpE,IAJA,IACIsG,EADMnD,KAAK3F,MACE8I,OACbuC,EAAY,EACZC,EAAqBxC,EAAOjG,MAAM,IAC7BO,EAAI,EAAG8H,EAAKpC,EAAOL,OAAQrF,EAAI8H,EAAI9H,IACxB,MAAd0F,EAAO1F,KACTkI,EAAmBlI,GAAKZ,EAAO6I,IAAc1F,KAAKyD,eAAeiC,GACjEA,GAAa,GAGjB,OAAOC,EAAmB9H,KAAK,KAMjCgC,EAAae,UAAUgF,eAAiB,SAAwB/I,GAC9D,IAAIqG,EAAMlD,KAAK3F,MACXiI,EAAeY,EAAIZ,aACnB/E,EAAoB2F,EAAI3F,kBACxB4B,EAAS+D,EAAI/D,OACbC,EAAS8D,EAAI9D,OACbtC,EAAgBoG,EAAIpG,cACpBoC,EAAsBgE,EAAIhE,oBAC1BoE,EAAQtD,KAAKuC,gBACbgB,EAAoBD,EAAMC,kBAC1BtE,EAAmBqE,EAAMrE,iBACzB4G,GAA+C,IAAzBhJ,EAAO+F,QAAQ,MAAeN,GAAgB/E,EACpEuI,EAAQlJ,EAAaC,EAAQC,GAC7BK,EAAgB2I,EAAM3I,cACtBC,EAAe0I,EAAM1I,aACrBJ,EAAc8I,EAAM9I,YAuBxB,YApBqBqG,IAAjBf,IACFlF,EAAeC,EAAaD,EAAckF,EAAc/E,IAEtDgG,IACFpG,EAvnBN,SAAgCT,EAAK6G,EAAmBrE,GACtD,IAAI6G,EAZN,SAAgC7G,GAC9B,OAAQA,GACN,IAAK,OACH,MAAO,uCACT,IAAK,MACH,MAAO,0BACT,IAAK,WACL,QACE,MAAO,2BAIe8G,CAAuB9G,GAC7CwE,EAAQhH,EAAIuJ,OAAO,SAEvB,OADAvC,GAAmB,IAAXA,EAAehH,EAAIoG,OAASY,EAC7BhH,EAAImG,UAAU,EAAGa,GAAShH,EAAImG,UAAUa,EAAOhH,EAAIoG,QAAQnG,QAAQoJ,EAAqB,KAAOxC,GAmnBlF2C,CAAuB/I,EAAeoG,EAAmBrE,IAIvEC,IACFhC,EAAgBgC,EAAShC,GAEvBiC,IACFhC,GAA8BgC,GAI5BpC,IACFG,EAAgB,IAAMA,GAExBN,EAASM,GAAiB0I,GAAuB5G,GAAoB,IAAM7B,GAG7EyC,EAAae,UAAUiB,gBAAkB,SAAyBhF,QACjD,IAAXA,IAAmBA,EAAS,IAChC,IAAIqG,EAAMlD,KAAK3F,MACX8I,EAASD,EAAIC,OACb9D,EAAuB6D,EAAI7D,qBAC3B+D,EAAiBF,EAAIE,eACrBjD,EAAiBtD,EACrB,GAAIuG,GAA4C,KAA1BA,EAAeN,OAAe,CAClD,IAAIqD,EAAqB,IAAIpD,OAAO,IAAMK,EAAevF,KAAK,IAAM,IAAK,KACzEsC,EAAiBtD,EAAOF,QAAQwJ,GAAoB,SAAUC,GAC5D,OAAOhD,EAAeR,QAAQwD,GAAOtC,cAczC,OANE3D,EALa,KAAXtD,GAAkBwC,EAEA,MAAXxC,GAAmBsG,EAED,iBAAXA,EACCnD,KAAKyF,kBAAkBtF,GACb,mBAAXgD,EACCA,EAAOhD,GAEPH,KAAK4F,eAAezF,GANpB,IAFA,IAYrBN,EAAae,UAAUR,gBAAkB,SAAyBH,GAChE,IAAIiD,EAAMlD,KAAK3F,MACX8I,EAASD,EAAIC,OACbb,EAAeY,EAAIZ,aACnB/E,EAAoB2F,EAAI3F,kBACxB8B,EAAuB6D,EAAI7D,qBAC3BiE,EAAQtD,KAAK3F,MACbqB,EAAQ4H,EAAM5H,MACd6D,EAAkB+D,EAAM/D,gBAIxB8G,IADJ3K,EAAQa,EAAMb,GAASuE,EAAevE,IACM,IAAVA,EAMlC,OALI2K,GAAqBhH,IACvB3D,EAAQ,IAIN2K,IAAsBhH,EACjB,IAEY,iBAAV3D,IACTA,EAroBN,SAAyB+C,GAIvB,IAAI6H,EAAkB,OAHtB7H,GAAO,IAGQ,GAAa,IAAM,GAC9B6H,IACF7H,EAAMA,EAAIoE,UAAU,IAItB,IAAIK,EAAMzE,EAAIvB,MAAM,SAChBqJ,EAAcrD,EAAI,GAClBsD,EAAWtD,EAAI,GAMnB,KAHAsD,EAAWC,OAAOD,IAIhB,OAAOF,EAAOC,EAQhB,IAAIG,EAAe,EAAIF,EACnBG,GAPJJ,EAAcA,EAAY5J,QAAQ,IAAK,KAOPmG,OAYhC,OAXI4D,EAAe,EAGjBH,EAAc,KAAO7I,EAAO,IAAKkB,KAAKgI,IAAIF,IAAiBH,EAClDG,GAAgBC,EAEzBJ,GAA4B7I,EAAO,IAAKgJ,EAAeC,GAGvDJ,GAAeA,EAAY1D,UAAU,EAAG6D,IAAiB,KAAO,IAAMH,EAAY1D,UAAU6D,GAEvFJ,EAAOC,EA6lBFM,CAAgBnL,GACxB6D,GAAkB,GAIN,aAAV7D,GAAwB6D,IAC1B7D,EAAQ,IAKN6D,IAAoB4D,GAAkC,iBAAjBb,IACvC5G,EAlmBN,SAA0BmB,EAAQS,EAAOC,GAEvC,IAAmC,IAA/B,CAAC,GAAI,KAAKqF,QAAQ/F,GACpB,OAAOA,EAET,IAAIiK,GAAqD,IAAzBjK,EAAO+F,QAAQ,MAAetF,EAC1D4F,EAAMtG,EAAaC,GACnBM,EAAgB+F,EAAI/F,cACpBC,EAAe8F,EAAI9F,aACnBL,EAAcmG,EAAInG,YAClB+E,EAAaC,WAAW,MAAQ3E,GAAgB,MAEhD2J,GADgB3J,EAAa0F,QAAUxF,EAAQ,KAAOF,EAAe0E,EAAWkF,QAAQ1J,IACpDJ,MAAM,KAU9C,MAAO,IAFQH,EAAc,IAAM,IAPrBI,EAAcD,MAAM,IAAI+J,UAAUC,QAAO,SAAUC,EAAYC,EAASC,GACpF,OAAIF,EAAWrE,OAASuE,GACdZ,OAAOU,EAAW,IAAMV,OAAOW,IAAUtD,WAAaqD,EAAWtE,UAAU,EAAGsE,EAAWrE,QAE5FsE,EAAUD,IAChBJ,EAAoB,KAGAD,EAA4B,IAAM,IAFvCzJ,EAAa0J,EAAoB,IAAM,GAAInI,KAAKF,IAAIpB,EAAOF,EAAa0F,QAASvF,GA+kBvF+J,CAAiB5L,EAAO4G,EAAc/E,IAE3BgC,EAAkBS,KAAK6B,gBAAgBnG,GAASsE,KAAKuH,YAAY7L,KAGxFmE,EAAae,UAAU4G,eAAiB,SAAwB9L,QAChD,IAAVA,IAAkBA,EAAQ,IAC9B,IACIoB,EADMkD,KAAK3F,MACSyC,cACpB2K,EAAgB,IAAI1E,OAAO,OAC3B2E,EAAsB,IAAI3E,OAAO,cAGjCL,EAAc+E,EAAcE,KAAKjM,GAGjCkM,EAAiBF,EAAoBC,KAAKjM,GAO9C,OAJAA,EAAQA,EAAMiB,QAAQ,KAAM,IACxB+F,IAAgBkF,GAAkB9K,IACpCpB,EAAQ,IAAMA,GAETA,GAETmE,EAAae,UAAU2G,YAAc,SAAqB7L,GAaxD,YAZc,IAAVA,IAAkBA,EAAQ,IACpBsE,KAAK3F,MACE8I,SAIfzH,EAAQsE,KAAKgF,sBAAsBtJ,GACnCA,EAAQsE,KAAKwH,eAAe9L,IAI9BA,EAAQsE,KAAKO,iBAAiB7E,GACvBsE,KAAK6B,gBAAgBnG,IAI9BmE,EAAae,UAAUiH,mBAAqB,SAA4B7J,EAAUtC,GAChF,IAAIwH,EAAMlD,KAAK3F,MACX8I,EAASD,EAAIC,OACbhE,EAAS+D,EAAI/D,OACbC,EAAS8D,EAAI9D,OACbkD,EAAeY,EAAIZ,aACnB/E,EAAoB2F,EAAI3F,kBAExB0B,EADQe,KAAKuC,gBACYtD,iBAG7B,MAAsB,iBAAXkE,GAA4C,MAArBA,EAAOnF,MAKpCmF,KAAWnF,EAAWmB,EAAO2D,QAAU9E,GAAYtC,EAAMoH,OAAS1D,EAAO0D,QAAUR,GAAgB/E,GAAqB7B,EAAMsC,KAAciB,KAUnJY,EAAae,UAAUkH,kBAAoB,SAA2B9J,EAAU+J,EAAWrM,GACzF,IAAIsM,EAAShI,KACTkD,EAAMlD,KAAK3F,MACX8I,EAASD,EAAIC,OACbrG,EAAgBoG,EAAIpG,cACpBqC,EAAS+D,EAAI/D,OACbC,EAAS8D,EAAI9D,OACbkD,EAAeY,EAAIZ,aACnBgB,EAAQtD,KAAKuC,gBACbiB,EAA2BF,EAAME,yBACjCvE,EAAmBqE,EAAMrE,iBACzB0C,EAAa3B,KAAKK,MAAMC,aAAe,GACvCwF,EAAQ9F,KAAKS,qBACbpC,EAAiByH,EAAMzH,eACvBS,EAAegH,EAAMhH,aACrBmJ,EA5nBR,SAA0BC,EAAWC,GAKnC,IAJA,IAAI1K,EAAI,EACNkH,EAAI,EACFyD,EAAaF,EAAUpF,OACvBuF,EAAYF,EAASrF,OAClBoF,EAAUzK,KAAO0K,EAAS1K,IAAMA,EAAI2K,GACzC3K,IAIF,KAAOyK,EAAUE,EAAa,EAAIzD,KAAOwD,EAASE,EAAY,EAAI1D,IAAM0D,EAAY1D,EAAIlH,GAAK2K,EAAazD,EAAIlH,GAC5GkH,IAEF,MAAO,CACLW,MAAO7H,EACP6K,IAAKF,EAAazD,GA6mBN4D,CAAiBR,EAAWrM,GACpC4J,EAAQ2C,EAAM3C,MACdgD,EAAML,EAAMK,IAGhB,IAAKnF,GAAUmC,IAAUgD,IAAoE,IAA7D9E,EAAyBZ,QAAQlH,EAAM2C,IAAyB,CAC9F,IAAImK,EAA6B,IAAjBlG,EAAqB,GAAKrD,EAC1C,OAAOvD,EAAM+M,OAAO,EAAGpK,GAAkBmK,EAAY9M,EAAM+M,OAAOpK,EAAiB,EAAG3C,EAAMoH,QAE9F,IAAI4F,EAAcvF,EAAS,EAAIhE,EAAO2D,OAClC6F,EAAaZ,EAAUjF,QAAYK,EAAS,EAAI/D,EAAO0D,QAC3D,GAEApH,EAAMoH,OAASiF,EAAUjF,SAExBpH,EAAMoH,QAEPwC,IAAUgD,GAES,IAAnBjK,GAAwBS,IAAiBiJ,EAAUjF,QAEzC,IAAVwC,GAAegD,IAAQP,EAAUjF,QAGjCzE,IAAmBqK,GAAa5J,IAAiB6J,EAC/C,OAAOjN,EAIT,IAAIkN,EAAgBb,EAAUU,OAAOnD,EAAOgD,EAAMhD,GAMlD,KALyB,GAAGuD,OAAOD,GAAeE,MAAK,SAAUC,EAAY1B,GAC3E,OAAOW,EAAOH,mBAAmBR,EAAM/B,EAAOyC,MAI1B,CACpB,IAAIiB,EAAsBjB,EAAUU,OAAOnD,GACvC2D,EAAgC,GAChCC,EAAkB,GACtB,GAAGL,OAAOG,GAAqBG,SAAQ,SAAUC,EAAgB/B,GAC3DW,EAAOH,mBAAmBR,EAAM/B,EAAOyC,GACzCkB,EAA8B5B,GAAO+B,EAC5B/B,EAAMuB,EAAc9F,OAAS,GACtCoG,EAAgBG,KAAKD,MAGzBvI,OAAOyI,KAAKL,GAA+BE,SAAQ,SAAU9B,GACvD6B,EAAgBpG,OAASuE,EAC3B6B,EAAgBK,OAAOlC,EAAK,EAAG4B,EAA8B5B,IAE7D6B,EAAgBG,KAAKJ,EAA8B5B,OAGvD3L,EAAQqM,EAAUU,OAAO,EAAGnD,GAAS4D,EAAgBrL,KAAK,IAK5D,IAAKsF,EAAQ,CACX,IAAIqG,EAAgBxJ,KAAKO,iBAAiB7E,GACtC+N,EAAQ7M,EAAa4M,EAAe1M,GACpCK,EAAgBsM,EAAMtM,cACtBC,EAAeqM,EAAMrM,aACrBJ,EAAcyM,EAAMzM,YAGpB0M,EAAuB1L,EAAWtC,EAAMkH,QAAQ3D,GAAoB,EACxE,GAAIuK,EAAc1G,OAASnB,EAAWmB,QAAU4G,GAA0C,KAAlBvM,IAAyB4E,WAAW3E,GAC1G,OAAOJ,EAAc,IAAM,GAG/B,OAAOtB,GAITmE,EAAae,UAAUsB,YAAc,SAAqByH,GACxD,IAAIxJ,EAAiBwJ,EAAOxJ,eACxBgC,EAAQwH,EAAOxH,MACfrE,EAAmB6L,EAAO7L,sBACL,IAArBA,IAA6BA,GAAmB,GACpD,IAAIsE,EAASuH,EAAOvH,OAChB3G,EAAQkO,EAAOlO,MACf6E,EAAcqJ,EAAOrJ,YACrBtC,EAAW2L,EAAO3L,SAElBwB,EADMQ,KAAK3F,MACSmF,cAEpBuI,EADQ/H,KAAKK,MACK3E,MACtB,GAAIyG,EAAO,CAET,QAAiBkB,IAAbrF,GAA0BF,EAAkB,CAC9C,IAAI4G,EAAaiF,EAAOjF,YAAcvC,EAAMzG,MACxCkO,EAAuB/K,EAAwBsD,GAOnDA,EAAMzG,MAAQyE,EAGdnC,EAAWgC,KAAKyE,iBAAiBC,EAAYvE,EAAgByJ,GAO/DzH,EAAMzG,MAAQyE,EAGVrC,GAEFkC,KAAK+D,wBAAwB5B,EAAOnE,EAAUmC,QAK9BkD,IAAhB/C,IACFA,EAAcN,KAAKO,iBAAiBJ,IAIlCA,IAAmB4H,IACrB/H,KAAKiB,SAAS,CACZvF,MAAOyE,EACPG,YAAaA,IAIfd,EAAcQ,KAAK4D,eAAezD,EAAgBG,GAAc,CAC9D7E,MAAOA,EACP2G,OAAQA,MAIdvC,EAAae,UAAUpF,SAAW,SAAkBqO,GAClD,IAAI9L,EAAK8L,EAAElO,OACP+I,EAAa3G,EAAGrC,MAEhB2E,EADML,KACMK,MACZhG,EAFM2F,KAEM3F,MACZuF,EAAYvF,EAAMuF,UAClBmI,EAAY1H,EAAM3E,OAAS,GAC3BkO,EAAuB/K,EAAwBd,GACnD2G,EAAa1E,KAAK8H,kBAAkB8B,EAAsB7B,EAAWrD,GACrE,IAAIvE,EAAiBH,KAAKuH,YAAY7C,IAAe,GACjDpE,EAAcN,KAAKO,iBAAiBJ,GAEpC2J,EAAkBlK,EADPI,KAAK4D,eAAezD,EAAgBG,IAE9CwJ,IACH3J,EAAiB4H,GAEnB/H,KAAKkC,YAAY,CACf/B,eAAgBA,EAChBG,YAAaA,EACboE,WAAYA,EACZvC,MAAOpE,EACPtC,MAAOoO,EACPzH,OAAQ,UAEN0H,GACFzP,EAAMmB,SAASqO,IAGnBhK,EAAae,UAAU/E,OAAS,SAAgBgO,GAC9C,IACIxP,EADM2F,KACM3F,MACZgG,EAFML,KAEMK,MACZ8C,EAAS9I,EAAM8I,OACftH,EAASxB,EAAMwB,OACfyD,EAAoBjF,EAAMiF,kBAC1BgB,EAAcD,EAAMC,YACpByH,EAAY1H,EAAM3E,MAItB,GAHAsE,KAAKyB,WAAa,KAClBH,aAAatB,KAAKuB,cAClBD,aAAatB,KAAKwB,uBACb2B,EAAQ,CAEPlB,MAAMF,WAAWzB,MACnBA,EAAc,IAEXhB,IACHgB,EAz7BR,SAAwBzD,GACtB,IAAKA,EACH,OAAOA,EAET,IAAIoI,EAA2B,MAAdpI,EAAO,GACpBoI,IACFpI,EAASA,EAAOgG,UAAU,EAAGhG,EAAOiG,SAEtC,IAAI7F,EAAQJ,EAAOK,MAAM,KACrBC,EAAgBF,EAAM,GAAGN,QAAQ,MAAO,KAAO,IAC/CS,EAAeH,EAAM,IAAM,GAC/B,OAAagI,EAAa,IAAM,IAAM9H,GAAiBC,EAAe,IAAMA,EAAe,IA86BvE2M,CAAezJ,IAE/B,IAAIH,EAAiBH,KAAK6B,gBAAgBvB,GAG1C,GAAIH,IAAmB4H,EAWrB,OATA/H,KAAKkC,YAAY,CACf/B,eAAgBA,EAChBG,YAAaA,EACb6B,MAAO0H,EAAElO,OACTmC,kBAAkB,EAClBrC,MAAOoO,EACPzH,OAAQ,eAEVvG,EAAOgO,GAIXhO,EAAOgO,IAEThK,EAAae,UAAUnB,UAAY,SAAmBoK,GACpD,IAMIG,EANAjM,EAAK8L,EAAElO,OACPsO,EAAMJ,EAAEI,IACR5L,EAAiBN,EAAGM,eACpBS,EAAef,EAAGe,aAClBpD,EAAQqC,EAAGrC,WACD,IAAVA,IAAkBA,EAAQ,IAE9B,IAAIwH,EAAMlD,KAAK3F,MACXiI,EAAeY,EAAIZ,aACnB/E,EAAoB2F,EAAI3F,kBACxB4B,EAAS+D,EAAI/D,OACbC,EAAS8D,EAAI9D,OACb+D,EAASD,EAAIC,OACb1D,EAAYyD,EAAIzD,UAChBwD,OAA0CI,IAAjBf,GAA8B/E,EACvDiF,EAAWxC,KAAKyC,gBAAe,EAAOQ,GACtCiH,EAAgB,IAAInH,OAAO,KAC3BoH,EAAoC,iBAAXhH,EAiB7B,GAhBAnD,KAAKS,qBAAuB,CAC1BpC,eAAgBA,EAChBS,aAAcA,GAIJ,cAARmL,GAA+B,cAARA,EACzBD,EAAwB3L,EAAiB,EACxB,eAAR4L,EACTD,EAAwB3L,EAAiB,EACxB,WAAR4L,IACTD,EAAwB3L,QAKIgF,IAA1B2G,GAAuC3L,IAAmBS,EAA9D,CAIA,IAAIsL,EAAmBJ,EACnBtB,EAAYyB,EAAkBhH,EAAOP,QAAQ,KAAOzD,EAAO2D,OAC3D6F,EAAawB,EAAkBhH,EAAOkB,YAAY,KAAO,EAAI3I,EAAMoH,OAAS1D,EAAO0D,OACvF,GAAY,cAARmH,GAA+B,eAARA,EAAsB,CAC/C,IAAI9F,EAAoB,cAAR8F,EAAsB,OAAS,QAC/CG,EAAmBpK,KAAKkE,qBAAqBxI,EAAOsO,EAAuB7F,QACtE,GAAY,WAAR8F,GAAqBzH,EAASmF,KAAKjM,EAAMsO,KAA4BE,EAAcvC,KAAKjM,EAAMsO,KAIlG,GAAY,cAARC,IAAwBzH,EAASmF,KAAKjM,EAAMsO,IAKrD,GAAI3L,GAAkBqK,EAAY,GAAkB,MAAbhN,EAAM,SAAgC,IAAXyH,EAAwB,CACxF,IAAIgF,EAAWzM,EAAMmH,UAAU,GAC/B7C,KAAKkC,YAAY,CACf/B,eAAgBgI,EAChBnK,SAAUoM,EACVjI,MAAOpE,EACPtC,MAAOoO,EACPzH,OAAQ,eAEL,IAAK8H,EAAcvC,KAAKjM,EAAMsO,IAAyB,CAC5D,MAAQxH,EAASmF,KAAKjM,EAAM0O,EAAmB,KAAOA,EAAmB1B,GACvE0B,IAEFA,EAAmBpK,KAAKkE,qBAAqBxI,EAAO0O,EAAkB,cArBxE,MAAQ5H,EAASmF,KAAKjM,EAAM0O,KAAsBA,EAAmBzB,GACnEyB,KAuBAA,IAAqBJ,GAAyBA,EAAwBtB,GAAasB,EAAwBrB,KAC7GkB,EAAEQ,iBACFrK,KAAK+D,wBAAwBhG,EAAIqM,EAAkB1O,IAKjDmO,EAAES,eACJtK,KAAK+D,wBAAwBhG,EAAIqM,EAAkB1O,GAErD+D,EAAUoK,QA5CRpK,EAAUoK,IAgDdhK,EAAae,UAAUlB,UAAY,SAAmBmK,GACpD,IAAI9L,EAAK8L,EAAElO,OAMP0C,EAAiBN,EAAGM,eACpBS,EAAef,EAAGe,aAClBpD,EAAQqC,EAAGrC,MAEf,QADc,IAAVA,IAAkBA,EAAQ,IAC1B2C,IAAmBS,EAAc,CACnC,IAAIyL,EAAgBvK,KAAKkE,qBAAqBxI,EAAO2C,GACjDkM,IAAkBlM,GACpB2B,KAAK+D,wBAAwBhG,EAAIwM,EAAe7O,GAGpDsE,KAAK3F,MAAMqF,UAAUmK,IAEvBhK,EAAae,UAAUjB,QAAU,SAAiBkK,GAChD,IAAI7B,EAAShI,KAIb6J,EAAEW,UACFxK,KAAKyB,WAAaoI,EAAElO,OACpBqE,KAAKuB,aAAe0C,YAAW,WAC7B,IAAIlG,EAAK8L,EAAElO,OACP0C,EAAiBN,EAAGM,eACpBS,EAAef,EAAGe,aAClBpD,EAAQqC,EAAGrC,WACD,IAAVA,IAAkBA,EAAQ,IAC9B,IAAI6O,EAAgBvC,EAAO9D,qBAAqBxI,EAAO2C,GAGnDkM,IAAkBlM,GAAuC,IAAnBA,GAAwBS,IAAiBpD,EAAMoH,QACvFkF,EAAOjE,wBAAwBhG,EAAIwM,EAAe7O,GAEpDsM,EAAO3N,MAAMsF,QAAQkK,KACpB,IAELhK,EAAae,UAAU6J,OAAS,WAC9B,IAAIvH,EAAMlD,KAAK3F,MACXkB,EAAO2H,EAAI3H,KACXyD,EAAckE,EAAIlE,YAClB0L,EAAcxH,EAAIwH,YAClBC,EAAazH,EAAIyH,WACjBC,EAAc1H,EAAI0H,YAClBzH,EAASD,EAAIC,OA0Bb0H,GAzBoB3H,EAAIK,kBACLL,EAAIjE,iBACIiE,EAAIM,yBACTN,EAAIhE,oBACXgE,EAAIZ,aACCY,EAAI3F,kBACf2F,EAAI/D,OACJ+D,EAAI9D,OACM8D,EAAI3C,iBAChB2C,EAAIS,KACIT,EAAIjD,aACDiD,EAAI3D,gBACN2D,EAAIpG,cACGoG,EAAI7D,qBACP6D,EAAI5D,kBACR4D,EAAI1D,cACR0D,EAAItD,UACCsD,EAAIE,eACVF,EAAI1H,SACH0H,EAAIzD,UACJyD,EAAIxD,UACNwD,EAAIvD,QACLuD,EAAIrH,OACDqH,EAAIxH,MAn8BxB,SAAiCoP,EAAKC,GACpC,IAAIpP,EAAS,GACb,IAAK,IAAIqP,KAAKF,EAASjK,OAAOD,UAAUqK,eAAelL,KAAK+K,EAAKE,KAA8B,IAAxBD,EAAQnI,QAAQoI,KAAWrP,EAAOqP,GAAKF,EAAIE,IAClH,OAAOrP,EAi8BMuP,CAAwBhI,EAAK,CAAC,OAAQ,cAAe,cAAe,aAAc,cAAe,SAAU,oBAAqB,mBAAoB,2BAA4B,sBAAuB,eAAgB,oBAAqB,SAAU,SAAU,mBAAoB,OAAQ,eAAgB,kBAAmB,gBAAiB,uBAAwB,oBAAqB,gBAAiB,YAAa,iBAAkB,WAAY,YAAa,YAAa,UAAW,SAAU,WAE/eI,EAAQtD,KAAKK,MACb3E,EAAQ4H,EAAM5H,MAIdyP,EAHU7H,EAAM9C,SA78BxB,SAAsB2C,GACpB,OAAOA,GAA+B,oBAAdiI,aAA+BA,UAAUC,UAAY,cAAc1D,KAAKyD,UAAUC,WA+8B7EC,CAAanI,GAAU,eAAYE,EAC1DkI,EAAa1K,OAAO2K,OAAO,CAC7BL,UAAWA,GACVN,EAAY,CACbtP,KAAMA,EACNG,MAAOA,EACPF,SAAUwE,KAAKxE,SACfiE,UAAWO,KAAKP,UAChBC,UAAWM,KAAKN,UAChBC,QAASK,KAAKL,QACd9D,OAAQmE,KAAKnE,SAEf,GAAoB,SAAhBmD,EACF,OAAO2L,EAAaA,EAAWjP,EAAOmP,IAAe,KAAO,IAAM7P,cAAc,OAAQ6F,OAAO2K,OAAO,GAAIX,EAAY,CACpH3H,IAAK0H,IACHlP,GACC,GAAIgP,EAAa,CACtB,IAAIe,EAAcf,EAClB,OAAO,IAAM1P,cAAcyQ,EAAa5K,OAAO2K,OAAO,GAAID,EAAY,CACpErI,IAAK0H,KAGT,OAAO,IAAM5P,cAAc,QAAS6F,OAAO2K,OAAO,GAAID,EAAY,CAChErI,IAAK0H,MAGF/K,EA58BuB,CA68B9B,IAAM6L,WACR7L,EAAad,aAAeA,EACb,O,kCC1sCf,qFAyEe4M,IApEf,SAAsCtR,GACpC,MAAM,SAAEC,EAAQ,KAAEC,EAAI,MAAEC,EAAK,YAAEE,GAAgBL,EAEzCM,EAAYC,YAAML,EAAKM,OAAQL,EAAMM,MAErCoB,EAAsBA,CAACb,EAASR,EAAQS,IAErCT,EAAOS,IAAcD,EAAQC,GAAa,aAAe,KAUlE,OACEP,IAAAC,cAAA,OACE4Q,MAAO,CAAEC,SAAU,SAAUC,OAAQ,MAAOC,WAAY,eACxDC,mBAAkB,yCAElBjR,IAAAC,cAACiR,IAAKC,MAAK,KACTnR,IAAAC,cAACmR,IAAG,KACFpR,IAAAC,cAACE,IAAS,CAACC,KAAMb,IACjBS,IAAAC,cAACoR,IAAG,CAACC,GAAI,GAAIC,GAAI,EAAGrR,UAAU,iBAC5BF,IAAAC,cAACI,IAAK,CACJN,KAAMN,EAAMM,KAAO,yBACnBG,UACE,YACAiB,EAAoB3B,EAAKc,QAASd,EAAKM,OAAQL,EAAMM,MAEvDS,KAAK,OACLS,aAAa,WACbN,MACEhB,EACIF,EAAMkB,MAAMhB,cACZF,EAAMkB,MACNlB,EAAMkB,MACN,GAEN6Q,UAAQ,IAEVxR,IAAAC,cAACI,IAAK,CACJN,KAAMN,EAAMM,KAAO,yBACnBG,UACE,YACAiB,EAAoB3B,EAAKc,QAASd,EAAKM,OAAQL,EAAMM,MAEvDS,KAAK,WACLS,aAAa,WACbN,MACEhB,EACIF,EAAMkB,MAAMhB,cACZF,EAAMkB,MACNlB,EAAMkB,MACN,GAEN6Q,UAAQ,KAhDOlR,EAkDEd,EAAKc,QAlDER,EAkDON,EAAKM,OAlDJS,EAkDYd,EAAMM,KAhDrDD,EAAOS,IAAcD,EAAQC,GAClCP,IAAAC,cAAA,QAAMC,UAAU,cAAcN,GAC5B,UAJoBsB,IAACZ,EAASR,EAAQS","file":"807ca771df22ee51bfed67b2451c393270fc1684-7e306538ec8ea52d4a47.js","sourcesContent":["import React from \"react\"\r\nimport { Field, getIn } from \"formik\"\r\nimport FormLabel from \"./formLabel\"\r\n\r\nfunction FormTextbox(props) {\r\n  const { textDesc, form, field, maxLength, toUpperCase } = props\r\n\r\n  const errorsMsg = getIn(form.errors, field.name)\r\n\r\n  const inputErrorClassName = (touched, errors, inputName) => {\r\n    //  (clickedNext && errors[inputName]) ||\r\n    return errors[inputName] && touched[inputName] ? \"is-invalid\" : null\r\n  }\r\n\r\n  const inputErrorMessage = (touched, errors, inputName) => {\r\n    //  (clickedNext && errors[inputName]) ||\r\n    return errors[inputName] && touched[inputName] ? (\r\n      <span className=\"InputError\">{errorsMsg}</span>\r\n    ) : null\r\n  }\r\n\r\n  return (\r\n    <div className=\"marginBottom19px\">\r\n      <FormLabel text={textDesc} />\r\n      <div className=\"marginTop10px\">\r\n        <Field\r\n          name={field.name}\r\n          className={\r\n            \"d-block inputbox \" +\r\n            inputErrorClassName(form.touched, form.errors, field.name)\r\n          }\r\n          type=\"text\"\r\n          onChange={event => {\r\n            let value = event.target.value || \"\"\r\n            if (toUpperCase) {\r\n              value = value.toUpperCase()\r\n            }\r\n            form.setFieldValue(field.name, value)\r\n          }}\r\n          onBlur={event => {\r\n            form.handleBlur(event)\r\n\r\n            let value = event.target.value || \"\"\r\n            if (toUpperCase) {\r\n              value = value.toUpperCase()\r\n            }\r\n            form.setFieldValue(field.name, value.trim()) // Trim field value when blur\r\n          }}\r\n          maxLength={maxLength}\r\n          autoComplete=\"new-password\"\r\n          value={\r\n            toUpperCase\r\n              ? field.value.toUpperCase()\r\n              : field.value\r\n              ? field.value\r\n              : \"\"\r\n          }\r\n        />\r\n        {inputErrorMessage(form.touched, form.errors, field.name)}\r\n      </div>\r\n    </div>\r\n  )\r\n}\r\n\r\nexport default FormTextbox\r\n","/**\n * react-number-format - 4.9.4\n * Author : Sudhanshu Yadav\n * Copyright (c) 2016, 2022 to Sudhanshu Yadav, released under the MIT license.\n * https://github.com/s-yadav/react-number-format\n */\n\nimport React from 'react';\n\n//     \n\n// basic noop function\nfunction noop() {}\nfunction returnTrue() {\n  return true;\n}\nfunction charIsNumber(char) {\n  return !!(char || '').match(/\\d/);\n}\nfunction isNil(val) {\n  return val === null || val === undefined;\n}\nfunction escapeRegExp(str) {\n  return str.replace(/[-[\\]/{}()*+?.\\\\^$|]/g, '\\\\$&');\n}\nfunction getThousandsGroupRegex(thousandsGroupStyle) {\n  switch (thousandsGroupStyle) {\n    case 'lakh':\n      return /(\\d+?)(?=(\\d\\d)+(\\d)(?!\\d))(\\.\\d+)?/g;\n    case 'wan':\n      return /(\\d)(?=(\\d{4})+(?!\\d))/g;\n    case 'thousand':\n    default:\n      return /(\\d)(?=(\\d{3})+(?!\\d))/g;\n  }\n}\nfunction applyThousandSeparator(str, thousandSeparator, thousandsGroupStyle) {\n  var thousandsGroupRegex = getThousandsGroupRegex(thousandsGroupStyle);\n  var index = str.search(/[1-9]/);\n  index = index === -1 ? str.length : index;\n  return str.substring(0, index) + str.substring(index, str.length).replace(thousandsGroupRegex, '$1' + thousandSeparator);\n}\n\n//spilt a float number into different parts beforeDecimal, afterDecimal, and negation\nfunction splitDecimal(numStr, allowNegative) {\n  if (allowNegative === void 0) allowNegative = true;\n  var hasNagation = numStr[0] === '-';\n  var addNegation = hasNagation && allowNegative;\n  numStr = numStr.replace('-', '');\n  var parts = numStr.split('.');\n  var beforeDecimal = parts[0];\n  var afterDecimal = parts[1] || '';\n  return {\n    beforeDecimal: beforeDecimal,\n    afterDecimal: afterDecimal,\n    hasNagation: hasNagation,\n    addNegation: addNegation\n  };\n}\nfunction fixLeadingZero(numStr) {\n  if (!numStr) {\n    return numStr;\n  }\n  var isNegative = numStr[0] === '-';\n  if (isNegative) {\n    numStr = numStr.substring(1, numStr.length);\n  }\n  var parts = numStr.split('.');\n  var beforeDecimal = parts[0].replace(/^0+/, '') || '0';\n  var afterDecimal = parts[1] || '';\n  return \"\" + (isNegative ? '-' : '') + beforeDecimal + (afterDecimal ? \".\" + afterDecimal : '');\n}\n\n/**\n * limit decimal numbers to given scale\n * Not used .fixedTo because that will break with big numbers\n */\nfunction limitToScale(numStr, scale, fixedDecimalScale) {\n  var str = '';\n  var filler = fixedDecimalScale ? '0' : '';\n  for (var i = 0; i <= scale - 1; i++) {\n    str += numStr[i] || filler;\n  }\n  return str;\n}\nfunction repeat(str, count) {\n  return Array(count + 1).join(str);\n}\nfunction toNumericString(num) {\n  num += ''; // typecast number to string\n\n  // store the sign and remove it from the number.\n  var sign = num[0] === '-' ? '-' : '';\n  if (sign) {\n    num = num.substring(1);\n  }\n\n  // split the number into cofficient and exponent\n  var ref = num.split(/[eE]/g);\n  var coefficient = ref[0];\n  var exponent = ref[1];\n\n  // covert exponent to number;\n  exponent = Number(exponent);\n\n  // if there is no exponent part or its 0, return the coffiecient with sign\n  if (!exponent) {\n    return sign + coefficient;\n  }\n  coefficient = coefficient.replace('.', '');\n\n  /**\n   * for scientific notation the current decimal index will be after first number (index 0)\n   * So effective decimal index will always be 1 + exponent value\n   */\n  var decimalIndex = 1 + exponent;\n  var coffiecientLn = coefficient.length;\n  if (decimalIndex < 0) {\n    // if decimal index is less then 0 add preceding 0s\n    // add 1 as join will have\n    coefficient = '0.' + repeat('0', Math.abs(decimalIndex)) + coefficient;\n  } else if (decimalIndex >= coffiecientLn) {\n    // if decimal index is less then 0 add leading 0s\n    coefficient = coefficient + repeat('0', decimalIndex - coffiecientLn);\n  } else {\n    // else add decimal point at proper index\n    coefficient = (coefficient.substring(0, decimalIndex) || '0') + '.' + coefficient.substring(decimalIndex);\n  }\n  return sign + coefficient;\n}\n\n/**\n * This method is required to round prop value to given scale.\n * Not used .round or .fixedTo because that will break with big numbers\n */\nfunction roundToPrecision(numStr, scale, fixedDecimalScale) {\n  //if number is empty don't do anything return empty string\n  if (['', '-'].indexOf(numStr) !== -1) {\n    return numStr;\n  }\n  var shoudHaveDecimalSeparator = numStr.indexOf('.') !== -1 && scale;\n  var ref = splitDecimal(numStr);\n  var beforeDecimal = ref.beforeDecimal;\n  var afterDecimal = ref.afterDecimal;\n  var hasNagation = ref.hasNagation;\n  var floatValue = parseFloat(\"0.\" + (afterDecimal || '0'));\n  var floatValueStr = afterDecimal.length <= scale ? \"0.\" + afterDecimal : floatValue.toFixed(scale);\n  var roundedDecimalParts = floatValueStr.split('.');\n  var intPart = beforeDecimal.split('').reverse().reduce(function (roundedStr, current, idx) {\n    if (roundedStr.length > idx) {\n      return (Number(roundedStr[0]) + Number(current)).toString() + roundedStr.substring(1, roundedStr.length);\n    }\n    return current + roundedStr;\n  }, roundedDecimalParts[0]);\n  var decimalPart = limitToScale(roundedDecimalParts[1] || '', Math.min(scale, afterDecimal.length), fixedDecimalScale);\n  var negation = hasNagation ? '-' : '';\n  var decimalSeparator = shoudHaveDecimalSeparator ? '.' : '';\n  return \"\" + negation + intPart + decimalSeparator + decimalPart;\n}\n\n/** set the caret positon in an input field **/\nfunction setCaretPosition(el, caretPos) {\n  el.value = el.value;\n  // ^ this is used to not only get 'focus', but\n  // to make sure we don't have it everything -selected-\n  // (it causes an issue in chrome, and having it doesn't hurt any other browser)\n  if (el !== null) {\n    if (el.createTextRange) {\n      var range = el.createTextRange();\n      range.move('character', caretPos);\n      range.select();\n      return true;\n    }\n    // (el.selectionStart === 0 added for Firefox bug)\n    if (el.selectionStart || el.selectionStart === 0) {\n      el.focus();\n      el.setSelectionRange(caretPos, caretPos);\n      return true;\n    }\n\n    // fail city, fortunately this never happens (as far as I've tested) :)\n    el.focus();\n    return false;\n  }\n}\n\n/**\n  Given previous value and newValue it returns the index\n  start - end to which values have changed.\n  This function makes assumption about only consecutive\n  characters are changed which is correct assumption for caret input.\n*/\nfunction findChangedIndex(prevValue, newValue) {\n  var i = 0,\n    j = 0;\n  var prevLength = prevValue.length;\n  var newLength = newValue.length;\n  while (prevValue[i] === newValue[i] && i < prevLength) {\n    i++;\n  }\n\n  //check what has been changed from last\n  while (prevValue[prevLength - 1 - j] === newValue[newLength - 1 - j] && newLength - j > i && prevLength - j > i) {\n    j++;\n  }\n  return {\n    start: i,\n    end: prevLength - j\n  };\n}\n\n/*\n  Returns a number whose value is limited to the given range\n*/\nfunction clamp(num, min, max) {\n  return Math.min(Math.max(num, min), max);\n}\nfunction getCurrentCaretPosition(el) {\n  /*Max of selectionStart and selectionEnd is taken for the patch of pixel and other mobile device caret bug*/\n  return Math.max(el.selectionStart, el.selectionEnd);\n}\nfunction addInputMode(format) {\n  return format || typeof navigator !== 'undefined' && !(navigator.platform && /iPhone|iPod/.test(navigator.platform));\n}\n\n//     \nfunction objectWithoutProperties(obj, exclude) {\n  var target = {};\n  for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k) && exclude.indexOf(k) === -1) target[k] = obj[k];\n  return target;\n}\nvar defaultProps = {\n  displayType: 'input',\n  decimalSeparator: '.',\n  thousandsGroupStyle: 'thousand',\n  fixedDecimalScale: false,\n  prefix: '',\n  suffix: '',\n  allowNegative: true,\n  allowEmptyFormatting: false,\n  allowLeadingZeros: false,\n  isNumericString: false,\n  type: 'text',\n  onValueChange: noop,\n  onChange: noop,\n  onKeyDown: noop,\n  onMouseUp: noop,\n  onFocus: noop,\n  onBlur: noop,\n  isAllowed: returnTrue\n};\nvar NumberFormat = /*@__PURE__*/function (superclass) {\n  function NumberFormat(props) {\n    superclass.call(this, props);\n    var defaultValue = props.defaultValue;\n\n    //validate props\n    this.validateProps();\n    var formattedValue = this.formatValueProp(defaultValue);\n    this.state = {\n      value: formattedValue,\n      numAsString: this.removeFormatting(formattedValue),\n      mounted: false\n    };\n    this.selectionBeforeInput = {\n      selectionStart: 0,\n      selectionEnd: 0\n    };\n    this.onChange = this.onChange.bind(this);\n    this.onKeyDown = this.onKeyDown.bind(this);\n    this.onMouseUp = this.onMouseUp.bind(this);\n    this.onFocus = this.onFocus.bind(this);\n    this.onBlur = this.onBlur.bind(this);\n  }\n  if (superclass) NumberFormat.__proto__ = superclass;\n  NumberFormat.prototype = Object.create(superclass && superclass.prototype);\n  NumberFormat.prototype.constructor = NumberFormat;\n  NumberFormat.prototype.componentDidMount = function componentDidMount() {\n    // set mounted state\n    // eslint-disable-next-line react/no-did-mount-set-state\n    this.setState({\n      mounted: true\n    });\n  };\n  NumberFormat.prototype.componentDidUpdate = function componentDidUpdate(prevProps) {\n    this.updateValueIfRequired(prevProps);\n  };\n  NumberFormat.prototype.componentWillUnmount = function componentWillUnmount() {\n    clearTimeout(this.focusTimeout);\n    clearTimeout(this.caretPositionTimeout);\n  };\n  NumberFormat.prototype.updateValueIfRequired = function updateValueIfRequired(prevProps) {\n    var ref = this;\n    var props = ref.props;\n    var state = ref.state;\n    var focusedElm = ref.focusedElm;\n    var stateValue = state.value;\n    var lastNumStr = state.numAsString;\n    if (lastNumStr === void 0) lastNumStr = '';\n\n    // If only state changed no need to do any thing\n    if (prevProps !== props) {\n      //validate props\n      this.validateProps();\n      var lastValueWithNewFormat = this.formatNumString(lastNumStr);\n      var formattedValue = isNil(props.value) ? lastValueWithNewFormat : this.formatValueProp();\n      var numAsString = this.removeFormatting(formattedValue);\n      var floatValue = parseFloat(numAsString);\n      var lastFloatValue = parseFloat(lastNumStr);\n      if (\n      //while typing set state only when float value changes\n      (!isNaN(floatValue) || !isNaN(lastFloatValue)) && floatValue !== lastFloatValue ||\n      //can also set state when float value is same and the format props changes\n      lastValueWithNewFormat !== stateValue ||\n      //set state always when not in focus and formatted value is changed\n      focusedElm === null && formattedValue !== stateValue) {\n        this.updateValue({\n          formattedValue: formattedValue,\n          numAsString: numAsString,\n          input: focusedElm,\n          source: 'prop',\n          event: null\n        });\n      }\n    }\n  };\n\n  /** Misc methods **/\n  NumberFormat.prototype.getFloatString = function getFloatString(num) {\n    if (num === void 0) num = '';\n    var ref = this.props;\n    var decimalScale = ref.decimalScale;\n    var ref$1 = this.getSeparators();\n    var decimalSeparator = ref$1.decimalSeparator;\n    var numRegex = this.getNumberRegex(true);\n\n    //remove negation for regex check\n    var hasNegation = num[0] === '-';\n    if (hasNegation) {\n      num = num.replace('-', '');\n    }\n\n    //if decimal scale is zero remove decimal and number after decimalSeparator\n    if (decimalSeparator && decimalScale === 0) {\n      num = num.split(decimalSeparator)[0];\n    }\n    num = (num.match(numRegex) || []).join('').replace(decimalSeparator, '.');\n\n    //remove extra decimals\n    var firstDecimalIndex = num.indexOf('.');\n    if (firstDecimalIndex !== -1) {\n      num = num.substring(0, firstDecimalIndex) + \".\" + num.substring(firstDecimalIndex + 1, num.length).replace(new RegExp(escapeRegExp(decimalSeparator), 'g'), '');\n    }\n\n    //add negation back\n    if (hasNegation) {\n      num = '-' + num;\n    }\n    return num;\n  };\n\n  //returned regex assumes decimalSeparator is as per prop\n  NumberFormat.prototype.getNumberRegex = function getNumberRegex(g, ignoreDecimalSeparator) {\n    var ref = this.props;\n    var format = ref.format;\n    var decimalScale = ref.decimalScale;\n    var customNumerals = ref.customNumerals;\n    var ref$1 = this.getSeparators();\n    var decimalSeparator = ref$1.decimalSeparator;\n    return new RegExp('[0-9' + (customNumerals ? customNumerals.join('') : '') + ']' + (decimalSeparator && decimalScale !== 0 && !ignoreDecimalSeparator && !format ? '|' + escapeRegExp(decimalSeparator) : ''), g ? 'g' : undefined);\n  };\n  NumberFormat.prototype.getSeparators = function getSeparators() {\n    var ref = this.props;\n    var decimalSeparator = ref.decimalSeparator;\n    var ref$1 = this.props;\n    var thousandSeparator = ref$1.thousandSeparator;\n    var allowedDecimalSeparators = ref$1.allowedDecimalSeparators;\n    if (thousandSeparator === true) {\n      thousandSeparator = ',';\n    }\n    if (!allowedDecimalSeparators) {\n      allowedDecimalSeparators = [decimalSeparator, '.'];\n    }\n    return {\n      decimalSeparator: decimalSeparator,\n      thousandSeparator: thousandSeparator,\n      allowedDecimalSeparators: allowedDecimalSeparators\n    };\n  };\n  NumberFormat.prototype.getMaskAtIndex = function getMaskAtIndex(index) {\n    var ref = this.props;\n    var mask = ref.mask;\n    if (mask === void 0) mask = ' ';\n    if (typeof mask === 'string') {\n      return mask;\n    }\n    return mask[index] || ' ';\n  };\n  NumberFormat.prototype.getValueObject = function getValueObject(formattedValue, numAsString) {\n    var floatValue = parseFloat(numAsString);\n    return {\n      formattedValue: formattedValue,\n      value: numAsString,\n      floatValue: isNaN(floatValue) ? undefined : floatValue\n    };\n  };\n  NumberFormat.prototype.validateProps = function validateProps() {\n    var ref = this.props;\n    var mask = ref.mask;\n\n    //validate decimalSeparator and thousandSeparator\n    var ref$1 = this.getSeparators();\n    var decimalSeparator = ref$1.decimalSeparator;\n    var thousandSeparator = ref$1.thousandSeparator;\n    if (decimalSeparator === thousandSeparator) {\n      throw new Error(\"\\n          Decimal separator can't be same as thousand separator.\\n          thousandSeparator: \" + thousandSeparator + \" (thousandSeparator = {true} is same as thousandSeparator = \\\",\\\")\\n          decimalSeparator: \" + decimalSeparator + \" (default value for decimalSeparator is .)\\n       \");\n    }\n\n    //validate mask\n    if (mask) {\n      var maskAsStr = mask === 'string' ? mask : mask.toString();\n      if (maskAsStr.match(/\\d/g)) {\n        throw new Error(\"\\n          Mask \" + mask + \" should not contain numeric character;\\n        \");\n      }\n    }\n  };\n  /** Misc methods end **/\n\n  /** caret specific methods **/\n  NumberFormat.prototype.setPatchedCaretPosition = function setPatchedCaretPosition(el, caretPos, currentValue) {\n    /* setting caret position within timeout of 0ms is required for mobile chrome,\n    otherwise browser resets the caret position after we set it\n    We are also setting it without timeout so that in normal browser we don't see the flickering */\n    setCaretPosition(el, caretPos);\n    this.caretPositionTimeout = setTimeout(function () {\n      if (el.value === currentValue) {\n        setCaretPosition(el, caretPos);\n      }\n    }, 0);\n  };\n\n  /* This keeps the caret within typing area so people can't type in between prefix or suffix */\n  NumberFormat.prototype.correctCaretPosition = function correctCaretPosition(value, caretPos, direction) {\n    var ref = this.props;\n    var prefix = ref.prefix;\n    var suffix = ref.suffix;\n    var format = ref.format;\n\n    //if value is empty return 0\n    if (value === '') {\n      return 0;\n    }\n\n    //caret position should be between 0 and value length\n    caretPos = clamp(caretPos, 0, value.length);\n\n    //in case of format as number limit between prefix and suffix\n    if (!format) {\n      var hasNegation = value[0] === '-';\n      return clamp(caretPos, prefix.length + (hasNegation ? 1 : 0), value.length - suffix.length);\n    }\n\n    //in case if custom format method don't do anything\n    if (typeof format === 'function') {\n      return caretPos;\n    }\n\n    /* in case format is string find the closest # position from the caret position */\n\n    //in case the caretPos have input value on it don't do anything\n    if (format[caretPos] === '#' && charIsNumber(value[caretPos])) {\n      return caretPos;\n    }\n\n    //if caretPos is just after input value don't do anything\n    if (format[caretPos - 1] === '#' && charIsNumber(value[caretPos - 1])) {\n      return caretPos;\n    }\n\n    //find the nearest caret position\n    var firstHashPosition = format.indexOf('#');\n    var lastHashPosition = format.lastIndexOf('#');\n\n    //limit the cursor between the first # position and the last # position\n    caretPos = clamp(caretPos, firstHashPosition, lastHashPosition + 1);\n    var nextPos = format.substring(caretPos, format.length).indexOf('#');\n    var caretLeftBound = caretPos;\n    var caretRightBound = caretPos + (nextPos === -1 ? 0 : nextPos);\n\n    //get the position where the last number is present\n    while (caretLeftBound > firstHashPosition && (format[caretLeftBound] !== '#' || !charIsNumber(value[caretLeftBound]))) {\n      caretLeftBound -= 1;\n    }\n    var goToLeft = !charIsNumber(value[caretRightBound]) || direction === 'left' && caretPos !== firstHashPosition || caretPos - caretLeftBound < caretRightBound - caretPos;\n    if (goToLeft) {\n      //check if number should be taken after the bound or after it\n      //if number preceding a valid number keep it after\n      return charIsNumber(value[caretLeftBound]) ? caretLeftBound + 1 : caretLeftBound;\n    }\n    return caretRightBound;\n  };\n  NumberFormat.prototype.getCaretPosition = function getCaretPosition(inputValue, formattedValue, caretPos) {\n    var ref = this.props;\n    var format = ref.format;\n    var stateValue = this.state.value;\n    var numRegex = this.getNumberRegex(true);\n    var inputNumber = (inputValue.match(numRegex) || []).join('');\n    var formattedNumber = (formattedValue.match(numRegex) || []).join('');\n    var j, i;\n    j = 0;\n    for (i = 0; i < caretPos; i++) {\n      var currentInputChar = inputValue[i] || '';\n      var currentFormatChar = formattedValue[j] || '';\n      //no need to increase new cursor position if formatted value does not have those characters\n      //case inputValue = 1a23 and formattedValue =  123\n      if (!currentInputChar.match(numRegex) && currentInputChar !== currentFormatChar) {\n        continue;\n      }\n\n      //When we are striping out leading zeros maintain the new cursor position\n      //Case inputValue = 00023 and formattedValue = 23;\n      if (currentInputChar === '0' && currentFormatChar.match(numRegex) && currentFormatChar !== '0' && inputNumber.length !== formattedNumber.length) {\n        continue;\n      }\n\n      //we are not using currentFormatChar because j can change here\n      while (currentInputChar !== formattedValue[j] && j < formattedValue.length) {\n        j++;\n      }\n      j++;\n    }\n    if (typeof format === 'string' && !stateValue) {\n      //set it to the maximum value so it goes after the last number\n      j = formattedValue.length;\n    }\n\n    //correct caret position if its outside of editable area\n    j = this.correctCaretPosition(formattedValue, j);\n    return j;\n  };\n  /** caret specific methods ends **/\n\n  /** methods to remove formattting **/\n  NumberFormat.prototype.removePrefixAndSuffix = function removePrefixAndSuffix(val) {\n    var ref = this.props;\n    var format = ref.format;\n    var prefix = ref.prefix;\n    var suffix = ref.suffix;\n\n    //remove prefix and suffix\n    if (!format && val) {\n      var isNegative = val[0] === '-';\n\n      //remove negation sign\n      if (isNegative) {\n        val = val.substring(1, val.length);\n      }\n\n      //remove prefix\n      val = prefix && val.indexOf(prefix) === 0 ? val.substring(prefix.length, val.length) : val;\n\n      //remove suffix\n      var suffixLastIndex = val.lastIndexOf(suffix);\n      val = suffix && suffixLastIndex !== -1 && suffixLastIndex === val.length - suffix.length ? val.substring(0, suffixLastIndex) : val;\n\n      //add negation sign back\n      if (isNegative) {\n        val = '-' + val;\n      }\n    }\n    return val;\n  };\n  NumberFormat.prototype.removePatternFormatting = function removePatternFormatting(val) {\n    var ref = this.props;\n    var format = ref.format;\n    var formatArray = format.split('#').filter(function (str) {\n      return str !== '';\n    });\n    var start = 0;\n    var numStr = '';\n    for (var i = 0, ln = formatArray.length; i <= ln; i++) {\n      var part = formatArray[i] || '';\n\n      //if i is the last fragment take the index of end of the value\n      //For case like +1 (911) 911 91 91 having pattern +1 (###) ### ## ##\n      var index = i === ln ? val.length : val.indexOf(part, start);\n\n      /* in any case if we don't find the pattern part in the value assume the val as numeric string\n      This will be also in case if user has started typing, in any other case it will not be -1\n      unless wrong prop value is provided */\n      if (index === -1) {\n        numStr = val;\n        break;\n      } else {\n        numStr += val.substring(start, index);\n        start = index + part.length;\n      }\n    }\n    return (numStr.match(this.getNumberRegex(true)) || []).join('');\n  };\n  NumberFormat.prototype.removeFormatting = function removeFormatting(val) {\n    var ref = this.props;\n    var format = ref.format;\n    var removeFormatting = ref.removeFormatting;\n    if (!val) {\n      return val;\n    }\n    if (!format) {\n      val = this.removePrefixAndSuffix(val);\n      val = this.getFloatString(val);\n    } else if (typeof format === 'string') {\n      val = this.removePatternFormatting(val);\n    } else if (typeof removeFormatting === 'function') {\n      //condition need to be handled if format method is provide,\n      val = removeFormatting(val);\n    } else {\n      val = (val.match(this.getNumberRegex(true)) || []).join('');\n    }\n    return val;\n  };\n  /** methods to remove formattting end **/\n\n  /*** format specific methods start ***/\n  /**\n   * Format when # based string is provided\n   * @param  {string} numStr Numeric String\n   * @return {string}        formatted Value\n   */\n  NumberFormat.prototype.formatWithPattern = function formatWithPattern(numStr) {\n    var ref = this.props;\n    var format = ref.format;\n    var hashCount = 0;\n    var formattedNumberAry = format.split('');\n    for (var i = 0, ln = format.length; i < ln; i++) {\n      if (format[i] === '#') {\n        formattedNumberAry[i] = numStr[hashCount] || this.getMaskAtIndex(hashCount);\n        hashCount += 1;\n      }\n    }\n    return formattedNumberAry.join('');\n  };\n  /**\n   * @param  {string} numStr Numeric string/floatString] It always have decimalSeparator as .\n   * @return {string} formatted Value\n   */\n  NumberFormat.prototype.formatAsNumber = function formatAsNumber(numStr) {\n    var ref = this.props;\n    var decimalScale = ref.decimalScale;\n    var fixedDecimalScale = ref.fixedDecimalScale;\n    var prefix = ref.prefix;\n    var suffix = ref.suffix;\n    var allowNegative = ref.allowNegative;\n    var thousandsGroupStyle = ref.thousandsGroupStyle;\n    var ref$1 = this.getSeparators();\n    var thousandSeparator = ref$1.thousandSeparator;\n    var decimalSeparator = ref$1.decimalSeparator;\n    var hasDecimalSeparator = numStr.indexOf('.') !== -1 || decimalScale && fixedDecimalScale;\n    var ref$2 = splitDecimal(numStr, allowNegative);\n    var beforeDecimal = ref$2.beforeDecimal;\n    var afterDecimal = ref$2.afterDecimal;\n    var addNegation = ref$2.addNegation; // eslint-disable-line prefer-const\n\n    //apply decimal precision if its defined\n    if (decimalScale !== undefined) {\n      afterDecimal = limitToScale(afterDecimal, decimalScale, fixedDecimalScale);\n    }\n    if (thousandSeparator) {\n      beforeDecimal = applyThousandSeparator(beforeDecimal, thousandSeparator, thousandsGroupStyle);\n    }\n\n    //add prefix and suffix\n    if (prefix) {\n      beforeDecimal = prefix + beforeDecimal;\n    }\n    if (suffix) {\n      afterDecimal = afterDecimal + suffix;\n    }\n\n    //restore negation sign\n    if (addNegation) {\n      beforeDecimal = '-' + beforeDecimal;\n    }\n    numStr = beforeDecimal + (hasDecimalSeparator && decimalSeparator || '') + afterDecimal;\n    return numStr;\n  };\n  NumberFormat.prototype.formatNumString = function formatNumString(numStr) {\n    if (numStr === void 0) numStr = '';\n    var ref = this.props;\n    var format = ref.format;\n    var allowEmptyFormatting = ref.allowEmptyFormatting;\n    var customNumerals = ref.customNumerals;\n    var formattedValue = numStr;\n    if (customNumerals && customNumerals.length === 10) {\n      var customNumeralRegex = new RegExp('[' + customNumerals.join('') + ']', 'g');\n      formattedValue = numStr.replace(customNumeralRegex, function (digit) {\n        return customNumerals.indexOf(digit).toString();\n      });\n    }\n    if (numStr === '' && !allowEmptyFormatting) {\n      formattedValue = '';\n    } else if (numStr === '-' && !format) {\n      formattedValue = '-';\n    } else if (typeof format === 'string') {\n      formattedValue = this.formatWithPattern(formattedValue);\n    } else if (typeof format === 'function') {\n      formattedValue = format(formattedValue);\n    } else {\n      formattedValue = this.formatAsNumber(formattedValue);\n    }\n    return formattedValue;\n  };\n  NumberFormat.prototype.formatValueProp = function formatValueProp(defaultValue) {\n    var ref = this.props;\n    var format = ref.format;\n    var decimalScale = ref.decimalScale;\n    var fixedDecimalScale = ref.fixedDecimalScale;\n    var allowEmptyFormatting = ref.allowEmptyFormatting;\n    var ref$1 = this.props;\n    var value = ref$1.value;\n    var isNumericString = ref$1.isNumericString;\n\n    // if value is undefined or null, use defaultValue instead\n    value = isNil(value) ? defaultValue : value;\n    var isNonNumericFalsy = !value && value !== 0;\n    if (isNonNumericFalsy && allowEmptyFormatting) {\n      value = '';\n    }\n\n    // if value is not defined return empty string\n    if (isNonNumericFalsy && !allowEmptyFormatting) {\n      return '';\n    }\n    if (typeof value === 'number') {\n      value = toNumericString(value);\n      isNumericString = true;\n    }\n\n    //change infinity value to empty string\n    if (value === 'Infinity' && isNumericString) {\n      value = '';\n    }\n\n    //round the number based on decimalScale\n    //format only if non formatted value is provided\n    if (isNumericString && !format && typeof decimalScale === 'number') {\n      value = roundToPrecision(value, decimalScale, fixedDecimalScale);\n    }\n    var formattedValue = isNumericString ? this.formatNumString(value) : this.formatInput(value);\n    return formattedValue;\n  };\n  NumberFormat.prototype.formatNegation = function formatNegation(value) {\n    if (value === void 0) value = '';\n    var ref = this.props;\n    var allowNegative = ref.allowNegative;\n    var negationRegex = new RegExp('(-)');\n    var doubleNegationRegex = new RegExp('(-)(.)*(-)');\n\n    // Check number has '-' value\n    var hasNegation = negationRegex.test(value);\n\n    // Check number has 2 or more '-' values\n    var removeNegation = doubleNegationRegex.test(value);\n\n    //remove negation\n    value = value.replace(/-/g, '');\n    if (hasNegation && !removeNegation && allowNegative) {\n      value = '-' + value;\n    }\n    return value;\n  };\n  NumberFormat.prototype.formatInput = function formatInput(value) {\n    if (value === void 0) value = '';\n    var ref = this.props;\n    var format = ref.format;\n\n    //format negation only if we are formatting as number\n    if (!format) {\n      value = this.removePrefixAndSuffix(value);\n      value = this.formatNegation(value);\n    }\n\n    //remove formatting from number\n    value = this.removeFormatting(value);\n    return this.formatNumString(value);\n  };\n\n  /*** format specific methods end ***/\n  NumberFormat.prototype.isCharacterAFormat = function isCharacterAFormat(caretPos, value) {\n    var ref = this.props;\n    var format = ref.format;\n    var prefix = ref.prefix;\n    var suffix = ref.suffix;\n    var decimalScale = ref.decimalScale;\n    var fixedDecimalScale = ref.fixedDecimalScale;\n    var ref$1 = this.getSeparators();\n    var decimalSeparator = ref$1.decimalSeparator;\n\n    //check within format pattern\n    if (typeof format === 'string' && format[caretPos] !== '#') {\n      return true;\n    }\n\n    //check in number format\n    if (!format && (caretPos < prefix.length || caretPos >= value.length - suffix.length || decimalScale && fixedDecimalScale && value[caretPos] === decimalSeparator)) {\n      return true;\n    }\n    return false;\n  };\n\n  /**\n   * This will check if any formatting got removed by the delete or backspace and reset the value\n   * It will also work as fallback if android chome keyDown handler does not work\n   **/\n  NumberFormat.prototype.correctInputValue = function correctInputValue(caretPos, lastValue, value) {\n    var this$1 = this;\n    var ref = this.props;\n    var format = ref.format;\n    var allowNegative = ref.allowNegative;\n    var prefix = ref.prefix;\n    var suffix = ref.suffix;\n    var decimalScale = ref.decimalScale;\n    var ref$1 = this.getSeparators();\n    var allowedDecimalSeparators = ref$1.allowedDecimalSeparators;\n    var decimalSeparator = ref$1.decimalSeparator;\n    var lastNumStr = this.state.numAsString || '';\n    var ref$2 = this.selectionBeforeInput;\n    var selectionStart = ref$2.selectionStart;\n    var selectionEnd = ref$2.selectionEnd;\n    var ref$3 = findChangedIndex(lastValue, value);\n    var start = ref$3.start;\n    var end = ref$3.end;\n\n    /** Check for any allowed decimal separator is added in the numeric format and replace it with decimal separator */\n    if (!format && start === end && allowedDecimalSeparators.indexOf(value[selectionStart]) !== -1) {\n      var separator = decimalScale === 0 ? '' : decimalSeparator;\n      return value.substr(0, selectionStart) + separator + value.substr(selectionStart + 1, value.length);\n    }\n    var leftBound = !!format ? 0 : prefix.length;\n    var rightBound = lastValue.length - (!!format ? 0 : suffix.length);\n    if (\n    // don't do anything if something got added\n    value.length > lastValue.length ||\n    // or if the new value is an empty string\n    !value.length ||\n    // or if nothing has changed, in which case start will be same as end\n    start === end ||\n    // or in case if whole input is selected and new value is typed\n    selectionStart === 0 && selectionEnd === lastValue.length ||\n    // or in case if the whole content is replaced by browser, example (autocomplete)\n    start === 0 && end === lastValue.length ||\n    // or if charcters between prefix and suffix is selected.\n    // For numeric inputs we apply the format so, prefix and suffix can be ignored\n    selectionStart === leftBound && selectionEnd === rightBound) {\n      return value;\n    }\n\n    // check whether the deleted portion has a character that is part of a format\n    var deletedValues = lastValue.substr(start, end - start);\n    var formatGotDeleted = !![].concat(deletedValues).find(function (deletedVal, idx) {\n      return this$1.isCharacterAFormat(idx + start, lastValue);\n    });\n\n    // if it has, only remove characters that are not part of the format\n    if (formatGotDeleted) {\n      var deletedValuePortion = lastValue.substr(start);\n      var recordIndexOfFormatCharacters = {};\n      var resolvedPortion = [];\n      [].concat(deletedValuePortion).forEach(function (currentPortion, idx) {\n        if (this$1.isCharacterAFormat(idx + start, lastValue)) {\n          recordIndexOfFormatCharacters[idx] = currentPortion;\n        } else if (idx > deletedValues.length - 1) {\n          resolvedPortion.push(currentPortion);\n        }\n      });\n      Object.keys(recordIndexOfFormatCharacters).forEach(function (idx) {\n        if (resolvedPortion.length > idx) {\n          resolvedPortion.splice(idx, 0, recordIndexOfFormatCharacters[idx]);\n        } else {\n          resolvedPortion.push(recordIndexOfFormatCharacters[idx]);\n        }\n      });\n      value = lastValue.substr(0, start) + resolvedPortion.join('');\n    }\n\n    //for numbers check if beforeDecimal got deleted and there is nothing after decimal,\n    //clear all numbers in such case while keeping the - sign\n    if (!format) {\n      var numericString = this.removeFormatting(value);\n      var ref$4 = splitDecimal(numericString, allowNegative);\n      var beforeDecimal = ref$4.beforeDecimal;\n      var afterDecimal = ref$4.afterDecimal;\n      var addNegation = ref$4.addNegation; // eslint-disable-line prefer-const\n\n      //clear only if something got deleted\n      var isBeforeDecimalPoint = caretPos < value.indexOf(decimalSeparator) + 1;\n      if (numericString.length < lastNumStr.length && isBeforeDecimalPoint && beforeDecimal === '' && !parseFloat(afterDecimal)) {\n        return addNegation ? '-' : '';\n      }\n    }\n    return value;\n  };\n\n  /** Update value and caret position */\n  NumberFormat.prototype.updateValue = function updateValue(params) {\n    var formattedValue = params.formattedValue;\n    var input = params.input;\n    var setCaretPosition = params.setCaretPosition;\n    if (setCaretPosition === void 0) setCaretPosition = true;\n    var source = params.source;\n    var event = params.event;\n    var numAsString = params.numAsString;\n    var caretPos = params.caretPos;\n    var ref = this.props;\n    var onValueChange = ref.onValueChange;\n    var ref$1 = this.state;\n    var lastValue = ref$1.value;\n    if (input) {\n      //calculate caret position if not defined\n      if (caretPos === undefined && setCaretPosition) {\n        var inputValue = params.inputValue || input.value;\n        var currentCaretPosition = getCurrentCaretPosition(input);\n\n        /**\n         * set the value imperatively, this is required for IE fix\n         * This is also required as if new caret position is beyond the previous value.\n         * Caret position will not be set correctly\n         */\n        input.value = formattedValue;\n\n        //get the caret position\n        caretPos = this.getCaretPosition(inputValue, formattedValue, currentCaretPosition);\n      }\n\n      /**\n       * set the value imperatively, as we set the caret position as well imperatively.\n       * This is to keep value and caret position in sync\n       */\n      input.value = formattedValue;\n\n      //set caret position, and value imperatively when element is provided\n      if (setCaretPosition) {\n        //set caret position\n        this.setPatchedCaretPosition(input, caretPos, formattedValue);\n      }\n    }\n\n    //calculate numeric string if not passed\n    if (numAsString === undefined) {\n      numAsString = this.removeFormatting(formattedValue);\n    }\n\n    //update state if value is changed\n    if (formattedValue !== lastValue) {\n      this.setState({\n        value: formattedValue,\n        numAsString: numAsString\n      });\n\n      // trigger onValueChange synchronously, so parent is updated along with the number format. Fix for #277, #287\n      onValueChange(this.getValueObject(formattedValue, numAsString), {\n        event: event,\n        source: source\n      });\n    }\n  };\n  NumberFormat.prototype.onChange = function onChange(e) {\n    var el = e.target;\n    var inputValue = el.value;\n    var ref = this;\n    var state = ref.state;\n    var props = ref.props;\n    var isAllowed = props.isAllowed;\n    var lastValue = state.value || '';\n    var currentCaretPosition = getCurrentCaretPosition(el);\n    inputValue = this.correctInputValue(currentCaretPosition, lastValue, inputValue);\n    var formattedValue = this.formatInput(inputValue) || '';\n    var numAsString = this.removeFormatting(formattedValue);\n    var valueObj = this.getValueObject(formattedValue, numAsString);\n    var isChangeAllowed = isAllowed(valueObj);\n    if (!isChangeAllowed) {\n      formattedValue = lastValue;\n    }\n    this.updateValue({\n      formattedValue: formattedValue,\n      numAsString: numAsString,\n      inputValue: inputValue,\n      input: el,\n      event: e,\n      source: 'event'\n    });\n    if (isChangeAllowed) {\n      props.onChange(e);\n    }\n  };\n  NumberFormat.prototype.onBlur = function onBlur(e) {\n    var ref = this;\n    var props = ref.props;\n    var state = ref.state;\n    var format = props.format;\n    var onBlur = props.onBlur;\n    var allowLeadingZeros = props.allowLeadingZeros;\n    var numAsString = state.numAsString;\n    var lastValue = state.value;\n    this.focusedElm = null;\n    clearTimeout(this.focusTimeout);\n    clearTimeout(this.caretPositionTimeout);\n    if (!format) {\n      // if the numAsString is not a valid number reset it to empty\n      if (isNaN(parseFloat(numAsString))) {\n        numAsString = '';\n      }\n      if (!allowLeadingZeros) {\n        numAsString = fixLeadingZero(numAsString);\n      }\n      var formattedValue = this.formatNumString(numAsString);\n\n      //change the state\n      if (formattedValue !== lastValue) {\n        // the event needs to be persisted because its properties can be accessed in an asynchronous way\n        this.updateValue({\n          formattedValue: formattedValue,\n          numAsString: numAsString,\n          input: e.target,\n          setCaretPosition: false,\n          event: e,\n          source: 'event'\n        });\n        onBlur(e);\n        return;\n      }\n    }\n    onBlur(e);\n  };\n  NumberFormat.prototype.onKeyDown = function onKeyDown(e) {\n    var el = e.target;\n    var key = e.key;\n    var selectionStart = el.selectionStart;\n    var selectionEnd = el.selectionEnd;\n    var value = el.value;\n    if (value === void 0) value = '';\n    var expectedCaretPosition;\n    var ref = this.props;\n    var decimalScale = ref.decimalScale;\n    var fixedDecimalScale = ref.fixedDecimalScale;\n    var prefix = ref.prefix;\n    var suffix = ref.suffix;\n    var format = ref.format;\n    var onKeyDown = ref.onKeyDown;\n    var ignoreDecimalSeparator = decimalScale !== undefined && fixedDecimalScale;\n    var numRegex = this.getNumberRegex(false, ignoreDecimalSeparator);\n    var negativeRegex = new RegExp('-');\n    var isPatternFormat = typeof format === 'string';\n    this.selectionBeforeInput = {\n      selectionStart: selectionStart,\n      selectionEnd: selectionEnd\n    };\n\n    //Handle backspace and delete against non numerical/decimal characters or arrow keys\n    if (key === 'ArrowLeft' || key === 'Backspace') {\n      expectedCaretPosition = selectionStart - 1;\n    } else if (key === 'ArrowRight') {\n      expectedCaretPosition = selectionStart + 1;\n    } else if (key === 'Delete') {\n      expectedCaretPosition = selectionStart;\n    }\n\n    //if expectedCaretPosition is not set it means we don't want to Handle keyDown\n    //also if multiple characters are selected don't handle\n    if (expectedCaretPosition === undefined || selectionStart !== selectionEnd) {\n      onKeyDown(e);\n      return;\n    }\n    var newCaretPosition = expectedCaretPosition;\n    var leftBound = isPatternFormat ? format.indexOf('#') : prefix.length;\n    var rightBound = isPatternFormat ? format.lastIndexOf('#') + 1 : value.length - suffix.length;\n    if (key === 'ArrowLeft' || key === 'ArrowRight') {\n      var direction = key === 'ArrowLeft' ? 'left' : 'right';\n      newCaretPosition = this.correctCaretPosition(value, expectedCaretPosition, direction);\n    } else if (key === 'Delete' && !numRegex.test(value[expectedCaretPosition]) && !negativeRegex.test(value[expectedCaretPosition])) {\n      while (!numRegex.test(value[newCaretPosition]) && newCaretPosition < rightBound) {\n        newCaretPosition++;\n      }\n    } else if (key === 'Backspace' && !numRegex.test(value[expectedCaretPosition])) {\n      /* NOTE: This is special case when backspace is pressed on a\n      negative value while the cursor position is after prefix. We can't handle it on onChange because\n      we will not have any information of keyPress\n      */\n      if (selectionStart <= leftBound + 1 && value[0] === '-' && typeof format === 'undefined') {\n        var newValue = value.substring(1);\n        this.updateValue({\n          formattedValue: newValue,\n          caretPos: newCaretPosition,\n          input: el,\n          event: e,\n          source: 'event'\n        });\n      } else if (!negativeRegex.test(value[expectedCaretPosition])) {\n        while (!numRegex.test(value[newCaretPosition - 1]) && newCaretPosition > leftBound) {\n          newCaretPosition--;\n        }\n        newCaretPosition = this.correctCaretPosition(value, newCaretPosition, 'left');\n      }\n    }\n    if (newCaretPosition !== expectedCaretPosition || expectedCaretPosition < leftBound || expectedCaretPosition > rightBound) {\n      e.preventDefault();\n      this.setPatchedCaretPosition(el, newCaretPosition, value);\n    }\n\n    /* NOTE: this is just required for unit test as we need to get the newCaretPosition,\n            Remove this when you find different solution */\n    if (e.isUnitTestRun) {\n      this.setPatchedCaretPosition(el, newCaretPosition, value);\n    }\n    onKeyDown(e);\n  };\n\n  /** required to handle the caret position when click anywhere within the input **/\n  NumberFormat.prototype.onMouseUp = function onMouseUp(e) {\n    var el = e.target;\n\n    /**\n     * NOTE: we have to give default value for value as in case when custom input is provided\n     * value can come as undefined when nothing is provided on value prop.\n     */\n    var selectionStart = el.selectionStart;\n    var selectionEnd = el.selectionEnd;\n    var value = el.value;\n    if (value === void 0) value = '';\n    if (selectionStart === selectionEnd) {\n      var caretPosition = this.correctCaretPosition(value, selectionStart);\n      if (caretPosition !== selectionStart) {\n        this.setPatchedCaretPosition(el, caretPosition, value);\n      }\n    }\n    this.props.onMouseUp(e);\n  };\n  NumberFormat.prototype.onFocus = function onFocus(e) {\n    var this$1 = this;\n\n    // Workaround Chrome and Safari bug https://bugs.chromium.org/p/chromium/issues/detail?id=779328\n    // (onFocus event target selectionStart is always 0 before setTimeout)\n    e.persist();\n    this.focusedElm = e.target;\n    this.focusTimeout = setTimeout(function () {\n      var el = e.target;\n      var selectionStart = el.selectionStart;\n      var selectionEnd = el.selectionEnd;\n      var value = el.value;\n      if (value === void 0) value = '';\n      var caretPosition = this$1.correctCaretPosition(value, selectionStart);\n\n      //setPatchedCaretPosition only when everything is not selected on focus (while tabbing into the field)\n      if (caretPosition !== selectionStart && !(selectionStart === 0 && selectionEnd === value.length)) {\n        this$1.setPatchedCaretPosition(el, caretPosition, value);\n      }\n      this$1.props.onFocus(e);\n    }, 0);\n  };\n  NumberFormat.prototype.render = function render() {\n    var ref = this.props;\n    var type = ref.type;\n    var displayType = ref.displayType;\n    var customInput = ref.customInput;\n    var renderText = ref.renderText;\n    var getInputRef = ref.getInputRef;\n    var format = ref.format;\n    var thousandSeparator = ref.thousandSeparator;\n    var decimalSeparator = ref.decimalSeparator;\n    var allowedDecimalSeparators = ref.allowedDecimalSeparators;\n    var thousandsGroupStyle = ref.thousandsGroupStyle;\n    var decimalScale = ref.decimalScale;\n    var fixedDecimalScale = ref.fixedDecimalScale;\n    var prefix = ref.prefix;\n    var suffix = ref.suffix;\n    var removeFormatting = ref.removeFormatting;\n    var mask = ref.mask;\n    var defaultValue = ref.defaultValue;\n    var isNumericString = ref.isNumericString;\n    var allowNegative = ref.allowNegative;\n    var allowEmptyFormatting = ref.allowEmptyFormatting;\n    var allowLeadingZeros = ref.allowLeadingZeros;\n    var onValueChange = ref.onValueChange;\n    var isAllowed = ref.isAllowed;\n    var customNumerals = ref.customNumerals;\n    var onChange = ref.onChange;\n    var onKeyDown = ref.onKeyDown;\n    var onMouseUp = ref.onMouseUp;\n    var onFocus = ref.onFocus;\n    var onBlur = ref.onBlur;\n    var propValue = ref.value;\n    var rest = objectWithoutProperties(ref, [\"type\", \"displayType\", \"customInput\", \"renderText\", \"getInputRef\", \"format\", \"thousandSeparator\", \"decimalSeparator\", \"allowedDecimalSeparators\", \"thousandsGroupStyle\", \"decimalScale\", \"fixedDecimalScale\", \"prefix\", \"suffix\", \"removeFormatting\", \"mask\", \"defaultValue\", \"isNumericString\", \"allowNegative\", \"allowEmptyFormatting\", \"allowLeadingZeros\", \"onValueChange\", \"isAllowed\", \"customNumerals\", \"onChange\", \"onKeyDown\", \"onMouseUp\", \"onFocus\", \"onBlur\", \"value\"]);\n    var otherProps = rest;\n    var ref$1 = this.state;\n    var value = ref$1.value;\n    var mounted = ref$1.mounted;\n\n    // add input mode on element based on format prop and device once the component is mounted\n    var inputMode = mounted && addInputMode(format) ? 'numeric' : undefined;\n    var inputProps = Object.assign({\n      inputMode: inputMode\n    }, otherProps, {\n      type: type,\n      value: value,\n      onChange: this.onChange,\n      onKeyDown: this.onKeyDown,\n      onMouseUp: this.onMouseUp,\n      onFocus: this.onFocus,\n      onBlur: this.onBlur\n    });\n    if (displayType === 'text') {\n      return renderText ? renderText(value, otherProps) || null : React.createElement('span', Object.assign({}, otherProps, {\n        ref: getInputRef\n      }), value);\n    } else if (customInput) {\n      var CustomInput = customInput;\n      return React.createElement(CustomInput, Object.assign({}, inputProps, {\n        ref: getInputRef\n      }));\n    }\n    return React.createElement('input', Object.assign({}, inputProps, {\n      ref: getInputRef\n    }));\n  };\n  return NumberFormat;\n}(React.Component);\nNumberFormat.defaultProps = defaultProps;\nexport default NumberFormat;","import React from \"react\"\r\nimport { Col, Row, Form } from \"react-bootstrap\"\r\nimport { Field, getIn } from \"formik\"\r\nimport FormLabel from \"./formLabel\"\r\n\r\nfunction FormFieldDisableAutoComplete(props) {\r\n  const { textDesc, form, field, toUpperCase } = props\r\n\r\n  const errorsMsg = getIn(form.errors, field.name)\r\n\r\n  const inputErrorClassName = (touched, errors, inputName) => {\r\n    //  (clickedNext && errors[inputName]) ||\r\n    return errors[inputName] && touched[inputName] ? \"is-invalid\" : null\r\n  }\r\n\r\n  const inputErrorMessage = (touched, errors, inputName) => {\r\n    //  (clickedNext && errors[inputName]) ||\r\n    return errors[inputName] && touched[inputName] ? (\r\n      <span className=\"InputError\">{errorsMsg}</span>\r\n    ) : null\r\n  }\r\n\r\n  return (\r\n    <div\r\n      style={{ overflow: \"hidden\", height: \"0px\", background: \"transparent\" }}\r\n      data-description={\"dummyPanel for Chrome auto-fill issue\"}\r\n    >\r\n      <Form.Group>\r\n        <Row>\r\n          <FormLabel text={textDesc} />\r\n          <Col xs={12} md={6} className=\"marginTop10px\">\r\n            <Field\r\n              name={field.name + \"fakeusernameremembered\"}\r\n              className={\r\n                \"inputbox \" +\r\n                inputErrorClassName(form.touched, form.errors, field.name)\r\n              }\r\n              type=\"text\"\r\n              autoComplete=\"username\"\r\n              value={\r\n                toUpperCase\r\n                  ? field.value.toUpperCase()\r\n                  : field.value\r\n                  ? field.value\r\n                  : \"\"\r\n              }\r\n              readOnly\r\n            />\r\n            <Field\r\n              name={field.name + \"fakepasswordremembered\"}\r\n              className={\r\n                \"inputbox \" +\r\n                inputErrorClassName(form.touched, form.errors, field.name)\r\n              }\r\n              type=\"password\"\r\n              autoComplete=\"password\"\r\n              value={\r\n                toUpperCase\r\n                  ? field.value.toUpperCase()\r\n                  : field.value\r\n                  ? field.value\r\n                  : \"\"\r\n              }\r\n              readOnly\r\n            />\r\n            {inputErrorMessage(form.touched, form.errors, field.name)}\r\n          </Col>\r\n        </Row>\r\n      </Form.Group>\r\n    </div>\r\n  )\r\n}\r\n\r\nexport default FormFieldDisableAutoComplete\r\n"],"sourceRoot":""}