{"version":3,"file":"govx-9901.2107ac1f5ff523b2d4fa.js","mappings":"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","sources":["webpack://@govx/govx-shop/./node_modules/react-number-format/lib/number_format.js","webpack://@govx/govx-shop/./node_modules/react-number-format/lib/utils.js"],"sourcesContent":["'use strict';\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _utils = require('./utils');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar propTypes = {\n  thousandSeparator: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.oneOf([true])]),\n  decimalSeparator: _propTypes2.default.string,\n  decimalScale: _propTypes2.default.number,\n  fixedDecimalScale: _propTypes2.default.bool,\n  displayType: _propTypes2.default.oneOf(['input', 'text']),\n  prefix: _propTypes2.default.string,\n  suffix: _propTypes2.default.string,\n  format: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),\n  removeFormatting: _propTypes2.default.func,\n  mask: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.arrayOf(_propTypes2.default.string)]),\n  value: _propTypes2.default.oneOfType([_propTypes2.default.number, _propTypes2.default.string]),\n  isNumericString: _propTypes2.default.bool,\n  customInput: _propTypes2.default.func,\n  allowNegative: _propTypes2.default.bool,\n  allowEmptyFormatting: _propTypes2.default.bool,\n  onValueChange: _propTypes2.default.func,\n  onKeyDown: _propTypes2.default.func,\n  onMouseUp: _propTypes2.default.func,\n  onChange: _propTypes2.default.func,\n  onFocus: _propTypes2.default.func,\n  onBlur: _propTypes2.default.func,\n  type: _propTypes2.default.oneOf(['text', 'tel']),\n  isAllowed: _propTypes2.default.func,\n  renderText: _propTypes2.default.func,\n  getInputRef: _propTypes2.default.func\n};\n\nvar defaultProps = {\n  displayType: 'input',\n  decimalSeparator: '.',\n  fixedDecimalScale: false,\n  prefix: '',\n  suffix: '',\n  allowNegative: true,\n  allowEmptyFormatting: false,\n  isNumericString: false,\n  type: 'text',\n  onValueChange: _utils.noop,\n  onChange: _utils.noop,\n  onKeyDown: _utils.noop,\n  onMouseUp: _utils.noop,\n  onFocus: _utils.noop,\n  onBlur: _utils.noop,\n  isAllowed: _utils.returnTrue,\n  getInputRef: _utils.noop\n};\n\nvar NumberFormat = function (_React$Component) {\n  _inherits(NumberFormat, _React$Component);\n\n  function NumberFormat(props) {\n    _classCallCheck(this, NumberFormat);\n\n    //validate props\n    var _this = _possibleConstructorReturn(this, (NumberFormat.__proto__ || Object.getPrototypeOf(NumberFormat)).call(this, props));\n\n    _this.validateProps();\n\n    var formattedValue = _this.formatValueProp();\n\n    _this.state = {\n      value: formattedValue,\n      numAsString: _this.removeFormatting(formattedValue)\n    };\n\n    _this.selectionBeforeInput = {\n      selectionStart: 0,\n      selectionEnd: 0\n    };\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    return _this;\n  }\n\n  _createClass(NumberFormat, [{\n    key: 'componentDidUpdate',\n    value: function componentDidUpdate(prevProps) {\n      this.updateValueIfRequired(prevProps);\n    }\n  }, {\n    key: 'updateValueIfRequired',\n    value: function updateValueIfRequired(prevProps) {\n      var props = this.props,\n          state = this.state;\n\n\n      if (prevProps !== props) {\n        //validate props\n        this.validateProps();\n\n        var stateValue = state.value;\n\n        var lastNumStr = state.numAsString || '';\n\n        var formattedValue = props.value === undefined ? this.formatNumString(lastNumStr) : this.formatValueProp();\n\n        if (formattedValue !== stateValue) {\n          this.setState({\n            value: formattedValue,\n            numAsString: this.removeFormatting(formattedValue)\n          });\n        }\n      }\n    }\n\n    /** Misc methods **/\n\n  }, {\n    key: 'getFloatString',\n    value: function getFloatString() {\n      var num = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n\n      var _getSeparators = this.getSeparators(),\n          decimalSeparator = _getSeparators.decimalSeparator;\n\n      var numRegex = this.getNumberRegex(true);\n\n      //remove negation for regex check\n      var hasNegation = num[0] === '-';\n      if (hasNegation) num = num.replace('-', '');\n\n      num = (num.match(numRegex) || []).join('').replace(decimalSeparator, '.');\n\n      //remove extra decimals\n      var firstDecimalIndex = num.indexOf('.');\n\n      if (firstDecimalIndex !== -1) {\n        num = num.substring(0, firstDecimalIndex) + '.' + num.substring(firstDecimalIndex + 1, num.length).replace(new RegExp((0, _utils.escapeRegExp)(decimalSeparator), 'g'), '');\n      }\n\n      //add negation back\n      if (hasNegation) num = '-' + num;\n\n      return num;\n    }\n\n    //returned regex assumes decimalSeparator is as per prop\n\n  }, {\n    key: 'getNumberRegex',\n    value: function getNumberRegex(g, ignoreDecimalSeparator) {\n      var _props = this.props,\n          format = _props.format,\n          decimalScale = _props.decimalScale;\n\n      var _getSeparators2 = this.getSeparators(),\n          decimalSeparator = _getSeparators2.decimalSeparator;\n\n      return new RegExp('\\\\d' + (decimalSeparator && decimalScale !== 0 && !ignoreDecimalSeparator && !format ? '|' + (0, _utils.escapeRegExp)(decimalSeparator) : ''), g ? 'g' : undefined);\n    }\n  }, {\n    key: 'getSeparators',\n    value: function getSeparators() {\n      var decimalSeparator = this.props.decimalSeparator;\n      var thousandSeparator = this.props.thousandSeparator;\n\n\n      if (thousandSeparator === true) {\n        thousandSeparator = ',';\n      }\n\n      return {\n        decimalSeparator: decimalSeparator,\n        thousandSeparator: thousandSeparator\n      };\n    }\n  }, {\n    key: 'getMaskAtIndex',\n    value: function getMaskAtIndex(index) {\n      var _props$mask = this.props.mask,\n          mask = _props$mask === undefined ? ' ' : _props$mask;\n\n      if (typeof mask === 'string') {\n        return mask;\n      }\n\n      return mask[index] || ' ';\n    }\n  }, {\n    key: 'validateProps',\n    value: function validateProps() {\n      var mask = this.props.mask;\n\n      //validate decimalSeparator and thousandSeparator\n\n      var _getSeparators3 = this.getSeparators(),\n          decimalSeparator = _getSeparators3.decimalSeparator,\n          thousandSeparator = _getSeparators3.thousandSeparator;\n\n      if (decimalSeparator === thousandSeparator) {\n        throw new Error('\\n          Decimal separator can\\'t be same as thousand separator.\\n\\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\n  }, {\n    key: 'setPatchedCaretPosition',\n    value: 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      (0, _utils.setCaretPosition)(el, caretPos);\n      setTimeout(function () {\n        if (el.value === currentValue) (0, _utils.setCaretPosition)(el, caretPos);\n      }, 0);\n    }\n\n    /* This keeps the caret within typing area so people can't type in between prefix or suffix */\n\n  }, {\n    key: 'correctCaretPosition',\n    value: function correctCaretPosition(value, caretPos, direction) {\n      var _props2 = this.props,\n          prefix = _props2.prefix,\n          suffix = _props2.suffix,\n          format = _props2.format;\n\n      //caret position should be between 0 and value length\n\n      caretPos = (0, _utils.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 (0, _utils.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') return caretPos;\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] === '#' && (0, _utils.charIsNumber)(value[caretPos])) return caretPos;\n\n      //if caretPos is just after input value don't do anything\n      if (format[caretPos - 1] === '#' && (0, _utils.charIsNumber)(value[caretPos - 1])) return caretPos;\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 = (0, _utils.clamp)(caretPos, firstHashPosition, lastHashPosition + 1);\n\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] !== '#' || !(0, _utils.charIsNumber)(value[caretLeftBound]))) {\n        caretLeftBound -= 1;\n      }\n\n      var goToLeft = !(0, _utils.charIsNumber)(value[caretRightBound]) || direction === 'left' && caretPos !== firstHashPosition || caretPos - caretLeftBound < caretRightBound - caretPos;\n\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 (0, _utils.charIsNumber)(value[caretLeftBound]) ? caretLeftBound + 1 : caretLeftBound;\n      }\n\n      return caretRightBound;\n    }\n  }, {\n    key: 'getCaretPosition',\n    value: function getCaretPosition(inputValue, formattedValue, caretPos) {\n      var format = this.props.format;\n\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 = void 0,\n          i = void 0;\n\n      j = 0;\n\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) continue;\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) continue;\n\n        //we are not using currentFormatChar because j can change here\n        while (currentInputChar !== formattedValue[j] && j < formattedValue.length) {\n          j++;\n        }j++;\n      }\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\n      return j;\n    }\n    /** caret specific methods ends **/\n\n    /** methods to remove formattting **/\n\n  }, {\n    key: 'removePrefixAndSuffix',\n    value: function removePrefixAndSuffix(val) {\n      var _props3 = this.props,\n          format = _props3.format,\n          prefix = _props3.prefix,\n          suffix = _props3.suffix;\n\n      //remove prefix and suffix\n\n      if (!format && val) {\n        var isNegative = val[0] === '-';\n\n        //remove negation sign\n        if (isNegative) val = val.substring(1, val.length);\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) val = '-' + val;\n      }\n\n      return val;\n    }\n  }, {\n    key: 'removePatternFormatting',\n    value: function removePatternFormatting(val) {\n      var format = this.props.format;\n\n      var formatArray = format.split('#').filter(function (str) {\n        return str !== '';\n      });\n      var start = 0;\n      var numStr = '';\n\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\n      return (numStr.match(/\\d/g) || []).join('');\n    }\n  }, {\n    key: 'removeFormatting',\n    value: function removeFormatting(val) {\n      var _props4 = this.props,\n          format = _props4.format,\n          removeFormatting = _props4.removeFormatting;\n\n      if (!val) 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(/\\d/g) || []).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\n  }, {\n    key: 'formatWithPattern',\n    value: function formatWithPattern(numStr) {\n      var format = this.props.format;\n\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\n  }, {\n    key: 'formatAsNumber',\n    value: function formatAsNumber(numStr) {\n      var _props5 = this.props,\n          decimalScale = _props5.decimalScale,\n          fixedDecimalScale = _props5.fixedDecimalScale,\n          prefix = _props5.prefix,\n          suffix = _props5.suffix,\n          allowNegative = _props5.allowNegative;\n\n      var _getSeparators4 = this.getSeparators(),\n          thousandSeparator = _getSeparators4.thousandSeparator,\n          decimalSeparator = _getSeparators4.decimalSeparator;\n\n      var hasDecimalSeparator = numStr.indexOf('.') !== -1 || decimalScale && fixedDecimalScale;\n\n      var _splitDecimal = (0, _utils.splitDecimal)(numStr, allowNegative),\n          beforeDecimal = _splitDecimal.beforeDecimal,\n          afterDecimal = _splitDecimal.afterDecimal,\n          addNegation = _splitDecimal.addNegation; // eslint-disable-line prefer-const\n\n      //apply decimal precision if its defined\n\n\n      if (decimalScale !== undefined) afterDecimal = (0, _utils.limitToScale)(afterDecimal, decimalScale, fixedDecimalScale);\n\n      if (thousandSeparator) {\n        beforeDecimal = beforeDecimal.replace(/(\\d)(?=(\\d{3})+(?!\\d))/g, '$1' + thousandSeparator);\n      }\n\n      //add prefix and suffix\n      if (prefix) beforeDecimal = prefix + beforeDecimal;\n      if (suffix) afterDecimal = afterDecimal + suffix;\n\n      //restore negation sign\n      if (addNegation) beforeDecimal = '-' + beforeDecimal;\n\n      numStr = beforeDecimal + (hasDecimalSeparator && decimalSeparator || '') + afterDecimal;\n\n      return numStr;\n    }\n  }, {\n    key: 'formatNumString',\n    value: function formatNumString() {\n      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n      var _props6 = this.props,\n          format = _props6.format,\n          allowEmptyFormatting = _props6.allowEmptyFormatting;\n\n      var formattedValue = value;\n\n      if (value === '' && !allowEmptyFormatting) {\n        formattedValue = '';\n      } else if (value === '-' && !format) {\n        formattedValue = '-';\n        value = '';\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\n      return formattedValue;\n    }\n  }, {\n    key: 'formatValueProp',\n    value: function formatValueProp() {\n      var _props7 = this.props,\n          format = _props7.format,\n          decimalScale = _props7.decimalScale,\n          fixedDecimalScale = _props7.fixedDecimalScale,\n          allowEmptyFormatting = _props7.allowEmptyFormatting;\n      var _props8 = this.props,\n          value = _props8.value,\n          isNumericString = _props8.isNumericString;\n\n\n      if (value === undefined && allowEmptyFormatting) {\n        value = '';\n      }\n\n      // if value is not defined return empty string\n      if (value === undefined && !allowEmptyFormatting) return '';\n\n      if (typeof value === 'number') {\n        value = value.toString();\n        isNumericString = true;\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 = (0, _utils.roundToPrecision)(value, decimalScale, fixedDecimalScale);\n      }\n\n      var formattedValue = isNumericString ? this.formatNumString(value) : this.formatInput(value);\n\n      return formattedValue;\n    }\n  }, {\n    key: 'formatNegation',\n    value: function formatNegation() {\n      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n      var allowNegative = this.props.allowNegative;\n\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\n      if (hasNegation && !removeNegation && allowNegative) {\n        value = '-' + value;\n      }\n\n      return value;\n    }\n  }, {\n    key: 'formatInput',\n    value: function formatInput() {\n      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n      var format = this.props.format;\n\n      //format negation only if we are formatting as number\n\n      if (!format) {\n        value = this.formatNegation(value);\n      }\n\n      //remove formatting from number\n      value = this.removeFormatting(value);\n\n      return this.formatNumString(value);\n    }\n\n    /*** format specific methods end ***/\n\n  }, {\n    key: 'isCharacterAFormat',\n    value: function isCharacterAFormat(caretPos, value) {\n      var _props9 = this.props,\n          format = _props9.format,\n          prefix = _props9.prefix,\n          suffix = _props9.suffix,\n          decimalScale = _props9.decimalScale,\n          fixedDecimalScale = _props9.fixedDecimalScale;\n\n      var _getSeparators5 = this.getSeparators(),\n          decimalSeparator = _getSeparators5.decimalSeparator;\n\n      //check within format pattern\n\n\n      if (typeof format === 'string' && format[caretPos] !== '#') return true;\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\n      return false;\n    }\n  }, {\n    key: 'checkIfFormatGotDeleted',\n    value: function checkIfFormatGotDeleted(start, end, value) {\n      for (var i = start; i < end; i++) {\n        if (this.isCharacterAFormat(i, value)) 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\n  }, {\n    key: 'correctInputValue',\n    value: function correctInputValue(caretPos, lastValue, value) {\n      var _props10 = this.props,\n          format = _props10.format,\n          decimalSeparator = _props10.decimalSeparator,\n          allowNegative = _props10.allowNegative;\n\n      var lastNumStr = this.state.numAsString || '';\n      var _selectionBeforeInput = this.selectionBeforeInput,\n          selectionStart = _selectionBeforeInput.selectionStart,\n          selectionEnd = _selectionBeforeInput.selectionEnd;\n\n      var _findChangedIndex = (0, _utils.findChangedIndex)(lastValue, value),\n          start = _findChangedIndex.start,\n          end = _findChangedIndex.end;\n\n      /* don't do anyhting if something got added,\n       or if value is empty string (when whole input is cleared)\n       or whole input is replace with a number\n      */\n\n\n      if (value.length > lastValue.length || !value.length || start === end || start === 0 && end === lastValue.length || selectionStart === 0 && selectionEnd === lastValue.length) {\n        return value;\n      }\n\n      //if format got deleted reset the value to last value\n      if (this.checkIfFormatGotDeleted(start, end, lastValue)) {\n        value = lastValue;\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\n        var _splitDecimal2 = (0, _utils.splitDecimal)(numericString, allowNegative),\n            beforeDecimal = _splitDecimal2.beforeDecimal,\n            afterDecimal = _splitDecimal2.afterDecimal,\n            addNegation = _splitDecimal2.addNegation; // eslint-disable-line prefer-const\n\n        //clear only if something got deleted\n\n\n        var isBeforeDecimalPoint = caretPos < value.indexOf(decimalSeparator) + 1;\n        if (numericString.length < lastNumStr.length && isBeforeDecimalPoint && beforeDecimal === '' && !parseFloat(afterDecimal)) {\n          return addNegation ? '-' : '';\n        }\n      }\n\n      return value;\n    }\n  }, {\n    key: 'onChange',\n    value: function onChange(e) {\n      e.persist();\n      var el = e.target;\n      var inputValue = el.value;\n      var state = this.state,\n          props = this.props;\n      var isAllowed = props.isAllowed;\n\n      var lastValue = state.value || '';\n\n      /*Max of selectionStart and selectionEnd is taken for the patch of pixel and other mobile device caret bug*/\n      var currentCaretPosition = Math.max(el.selectionStart, el.selectionEnd);\n\n      inputValue = this.correctInputValue(currentCaretPosition, lastValue, inputValue);\n\n      var formattedValue = this.formatInput(inputValue) || '';\n      var numAsString = this.removeFormatting(formattedValue);\n\n      var valueObj = {\n        formattedValue: formattedValue,\n        value: numAsString,\n        floatValue: parseFloat(numAsString)\n      };\n\n      if (!isAllowed(valueObj)) {\n        formattedValue = lastValue;\n      }\n\n      //set the value imperatively, this is required for IE fix\n      el.value = formattedValue;\n\n      //get the caret position\n      var caretPos = this.getCaretPosition(inputValue, formattedValue, currentCaretPosition);\n\n      //set caret position\n      this.setPatchedCaretPosition(el, caretPos, formattedValue);\n\n      //change the state\n      if (formattedValue !== lastValue) {\n        this.setState({ value: formattedValue, numAsString: numAsString }, function () {\n          props.onValueChange(valueObj, e);\n          props.onChange(e);\n        });\n      } else {\n        props.onChange(e);\n      }\n    }\n  }, {\n    key: 'onBlur',\n    value: function onBlur(e) {\n      var props = this.props,\n          state = this.state;\n      var format = props.format,\n          onBlur = props.onBlur;\n      var numAsString = state.numAsString;\n\n      var lastValue = state.value;\n      if (!format) {\n        numAsString = (0, _utils.fixLeadingZero)(numAsString);\n        var formattedValue = this.formatNumString(numAsString);\n        var valueObj = {\n          formattedValue: formattedValue,\n          value: numAsString,\n          floatValue: parseFloat(numAsString)\n        };\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          e.persist();\n          this.setState({ value: formattedValue, numAsString: numAsString }, function () {\n            props.onValueChange(valueObj, e);\n            onBlur(e);\n          });\n          return;\n        }\n      }\n      onBlur(e);\n    }\n  }, {\n    key: 'onKeyDown',\n    value: function onKeyDown(e) {\n      var el = e.target;\n      var key = e.key;\n      var selectionStart = el.selectionStart,\n          selectionEnd = el.selectionEnd,\n          value = el.value;\n\n      var expectedCaretPosition = void 0;\n      var _props11 = this.props,\n          decimalScale = _props11.decimalScale,\n          fixedDecimalScale = _props11.fixedDecimalScale,\n          prefix = _props11.prefix,\n          suffix = _props11.suffix,\n          format = _props11.format,\n          onKeyDown = _props11.onKeyDown;\n\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\n      this.selectionBeforeInput = {\n        selectionStart: selectionStart,\n        selectionEnd: selectionEnd\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\n      var newCaretPosition = expectedCaretPosition;\n      var leftBound = isPatternFormat ? format.indexOf('#') : prefix.length;\n      var rightBound = isPatternFormat ? format.lastIndexOf('#') + 1 : value.length - suffix.length;\n\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]) && !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\n      this.props.onKeyDown(e);\n    }\n\n    /** required to handle the caret position when click anywhere within the input **/\n\n  }, {\n    key: 'onMouseUp',\n    value: function onMouseUp(e) {\n      var el = e.target;\n      var selectionStart = el.selectionStart,\n          selectionEnd = el.selectionEnd,\n          value = el.value;\n\n\n      if (selectionStart === selectionEnd) {\n        var caretPostion = this.correctCaretPosition(value, selectionStart);\n        if (caretPostion !== selectionStart) {\n          this.setPatchedCaretPosition(el, caretPostion, value);\n        }\n      }\n\n      this.props.onMouseUp(e);\n    }\n  }, {\n    key: 'onFocus',\n    value: function onFocus(e) {\n      var _this2 = 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      setTimeout(function () {\n        var el = e.target;\n        var selectionStart = el.selectionStart,\n            value = el.value;\n\n\n        var caretPosition = _this2.correctCaretPosition(value, selectionStart);\n        if (caretPosition !== selectionStart) {\n          _this2.setPatchedCaretPosition(el, caretPosition, value);\n        }\n\n        _this2.props.onFocus(e);\n      }, 0);\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _props12 = this.props,\n          type = _props12.type,\n          displayType = _props12.displayType,\n          customInput = _props12.customInput,\n          renderText = _props12.renderText,\n          getInputRef = _props12.getInputRef;\n      var value = this.state.value;\n\n\n      var otherProps = (0, _utils.omit)(this.props, propTypes);\n\n      var inputProps = _extends({}, 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\n      if (displayType === 'text') {\n        return renderText ? renderText(value) || null : _react2.default.createElement(\n          'span',\n          _extends({}, otherProps, { ref: getInputRef }),\n          value\n        );\n      } else if (customInput) {\n        var CustomInput = customInput;\n        return _react2.default.createElement(CustomInput, inputProps);\n      }\n\n      return _react2.default.createElement('input', _extends({}, inputProps, {\n        ref: getInputRef\n      }));\n    }\n  }]);\n\n  return NumberFormat;\n}(_react2.default.Component);\n\nNumberFormat.propTypes = propTypes;\nNumberFormat.defaultProps = defaultProps;\n\nmodule.exports = NumberFormat;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.noop = noop;\nexports.returnTrue = returnTrue;\nexports.charIsNumber = charIsNumber;\nexports.escapeRegExp = escapeRegExp;\nexports.splitDecimal = splitDecimal;\nexports.fixLeadingZero = fixLeadingZero;\nexports.limitToScale = limitToScale;\nexports.roundToPrecision = roundToPrecision;\nexports.omit = omit;\nexports.setCaretPosition = setCaretPosition;\nexports.findChangedIndex = findChangedIndex;\nexports.clamp = clamp;\n\n\n// basic noop function\nfunction noop() {}\nfunction returnTrue() {\n  return true;\n}\n\nfunction charIsNumber(char) {\n  return !!(char || '').match(/\\d/);\n}\n\nfunction escapeRegExp(str) {\n  return str.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n}\n\n//spilt a float number into different parts beforeDecimal, afterDecimal, and negation\nfunction splitDecimal(numStr) {\n  var allowNegative = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n  var hasNagation = numStr[0] === '-';\n  var addNegation = hasNagation && allowNegative;\n  numStr = numStr.replace('-', '');\n\n  var parts = numStr.split('.');\n  var beforeDecimal = parts[0];\n  var afterDecimal = parts[1] || '';\n\n  return {\n    beforeDecimal: beforeDecimal,\n    afterDecimal: afterDecimal,\n    hasNagation: hasNagation,\n    addNegation: addNegation\n  };\n}\n\nfunction fixLeadingZero(numStr) {\n  if (!numStr) return numStr;\n  var isNegative = numStr[0] === '-';\n  if (isNegative) numStr = numStr.substring(1, numStr.length);\n  var parts = numStr.split('.');\n  var beforeDecimal = parts[0].replace(/^0+/, '') || '0';\n  var afterDecimal = parts[1] || '';\n\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}\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  var shoudHaveDecimalSeparator = numStr.indexOf('.') !== -1 && scale;\n\n  var _splitDecimal = splitDecimal(numStr),\n      beforeDecimal = _splitDecimal.beforeDecimal,\n      afterDecimal = _splitDecimal.afterDecimal,\n      hasNagation = _splitDecimal.hasNagation;\n\n  var roundedDecimalParts = parseFloat('0.' + (afterDecimal || '0')).toFixed(scale).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\n  var decimalPart = limitToScale(roundedDecimalParts[1] || '', (afterDecimal || '').length, fixedDecimalScale);\n  var negation = hasNagation ? '-' : '';\n  var decimalSeparator = shoudHaveDecimalSeparator ? '.' : '';\n  return '' + negation + intPart + decimalSeparator + decimalPart;\n}\n\nfunction omit(obj, keyMaps) {\n  var filteredObj = {};\n  Object.keys(obj).forEach(function (key) {\n    if (!keyMaps[key]) filteredObj[key] = obj[key];\n  });\n  return filteredObj;\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  } //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\n  return { start: i, end: prevLength - j };\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}"],"names":["_typeof","o","Symbol","iterator","constructor","prototype","_extends","Object","assign","target","i","arguments","length","source","key","hasOwnProperty","call","_createClass","defineProperties","props","descriptor","enumerable","configurable","writable","defineProperty","Constructor","protoProps","staticProps","_propTypes2","_interopRequireDefault","require","_react2","_utils","obj","__esModule","default","propTypes","thousandSeparator","oneOfType","string","oneOf","decimalSeparator","decimalScale","number","fixedDecimalScale","bool","displayType","prefix","suffix","format","func","removeFormatting","mask","arrayOf","value","isNumericString","customInput","allowNegative","allowEmptyFormatting","onValueChange","onKeyDown","onMouseUp","onChange","onFocus","onBlur","type","isAllowed","renderText","getInputRef","defaultProps","noop","returnTrue","NumberFormat","_React$Component","instance","TypeError","_classCallCheck","this","_this","self","ReferenceError","_possibleConstructorReturn","__proto__","getPrototypeOf","validateProps","formattedValue","formatValueProp","state","numAsString","selectionBeforeInput","selectionStart","selectionEnd","bind","subClass","superClass","create","setPrototypeOf","_inherits","prevProps","updateValueIfRequired","stateValue","lastNumStr","undefined","formatNumString","setState","num","getSeparators","numRegex","getNumberRegex","hasNegation","replace","firstDecimalIndex","match","join","indexOf","substring","RegExp","escapeRegExp","g","ignoreDecimalSeparator","_props","index","_props$mask","_getSeparators3","Error","toString","el","caretPos","currentValue","setCaretPosition","setTimeout","direction","_props2","clamp","charIsNumber","firstHashPosition","lastHashPosition","lastIndexOf","nextPos","caretLeftBound","caretRightBound","inputValue","inputNumber","formattedNumber","j","currentInputChar","currentFormatChar","correctCaretPosition","val","_props3","isNegative","suffixLastIndex","formatArray","split","filter","str","start","numStr","ln","part","_props4","removePatternFormatting","removePrefixAndSuffix","getFloatString","hashCount","formattedNumberAry","getMaskAtIndex","_props5","_getSeparators4","hasDecimalSeparator","_splitDecimal","splitDecimal","beforeDecimal","afterDecimal","addNegation","limitToScale","_props6","formatWithPattern","formatAsNumber","_props7","_props8","roundToPrecision","formatInput","negationRegex","doubleNegationRegex","test","removeNegation","formatNegation","_props9","end","isCharacterAFormat","lastValue","_props10","_selectionBeforeInput","_findChangedIndex","findChangedIndex","checkIfFormatGotDeleted","numericString","_splitDecimal2","isBeforeDecimalPoint","parseFloat","e","persist","currentCaretPosition","Math","max","correctInputValue","valueObj","floatValue","getCaretPosition","setPatchedCaretPosition","fixLeadingZero","expectedCaretPosition","_props11","negativeRegex","isPatternFormat","newCaretPosition","leftBound","rightBound","preventDefault","isUnitTestRun","caretPostion","_this2","caretPosition","_props12","otherProps","omit","inputProps","createElement","ref","CustomInput","Component","module","exports","hasNagation","parts","scale","filler","char","shoudHaveDecimalSeparator","roundedDecimalParts","toFixed","reverse","reduce","roundedStr","current","idx","Number","keyMaps","filteredObj","keys","forEach","createTextRange","range","move","select","focus","setSelectionRange","prevValue","newValue","prevLength","newLength","min"],"sourceRoot":""}