(function webpackUniversalModuleDefinition(root, factory) {
   if (typeof exports === "object" && typeof module === "object")
      module.exports = factory();
   else if (typeof define === "function" && define.amd) define([], factory);
   else if (typeof exports === "object") exports["Cleave"] = factory();
   else root["Cleave"] = factory();
})(this, function () {
   return /******/ (function (modules) {
      // webpackBootstrap
      /******/ // The module cache
      /******/ var installedModules = {}; // The require function

      /******/ /******/ function __webpack_require__(moduleId) {
         /******/ // Check if module is in cache
         /******/ if (installedModules[moduleId])
            /******/ return installedModules[moduleId].exports; // Create a new module (and put it into the cache)

         /******/ /******/ var module = (installedModules[moduleId] = {
            /******/ exports: {},
            /******/ id: moduleId,
            /******/ loaded: false,
            /******/
         }); // Execute the module function

         /******/ /******/ modules[moduleId].call(
            module.exports,
            module,
            module.exports,
            __webpack_require__
         ); // Flag the module as loaded

         /******/ /******/ module.loaded = true; // Return the exports of the module

         /******/ /******/ return module.exports;
         /******/
      } // expose the modules object (__webpack_modules__)

      /******/ /******/ __webpack_require__.m = modules; // expose the module cache

      /******/ /******/ __webpack_require__.c = installedModules; // __webpack_public_path__

      /******/ /******/ __webpack_require__.p = ""; // Load entry module and return exports

      /******/ /******/ return __webpack_require__(0);
      /******/
   })(
      /************************************************************************/
      /******/ [
         /* 0 */
         /***/ function (module, exports, __webpack_require__) {
            /* WEBPACK VAR INJECTION */ (function (global) {
               "use strict";

               /**
                * Construct a new Cleave instance by passing the configuration object
                *
                * @param {String | HTMLElement} element
                * @param {Object} opts
                */
               var Cleave = function (element, opts) {
                  var owner = this;
                  var hasMultipleElements = false;

                  if (typeof element === "string") {
                     owner.element = document.querySelector(element);
                     hasMultipleElements =
                        document.querySelectorAll(element).length > 1;
                  } else {
                     if (
                        typeof element.length !== "undefined" &&
                        element.length > 0
                     ) {
                        owner.element = element[0];
                        hasMultipleElements = element.length > 1;
                     } else {
                        owner.element = element;
                     }
                  }

                  if (!owner.element) {
                     throw new Error("[cleave.js] Please check the element");
                  }

                  if (hasMultipleElements) {
                     try {
                        // eslint-disable-next-line
                        console.warn(
                           "[cleave.js] Multiple input fields matched, cleave.js will only take the first one."
                        );
                     } catch (e) {
                        // Old IE
                     }
                  }

                  opts.initValue = owner.element.value;

                  owner.properties = Cleave.DefaultProperties.assign({}, opts);

                  owner.init();
               };

               Cleave.prototype = {
                  init: function () {
                     var owner = this,
                        pps = owner.properties;

                     // no need to use this lib
                     if (
                        !pps.numeral &&
                        !pps.phone &&
                        !pps.creditCard &&
                        !pps.time &&
                        !pps.date &&
                        pps.blocksLength === 0 &&
                        !pps.prefix
                     ) {
                        owner.onInput(pps.initValue);

                        return;
                     }

                     pps.maxLength = Cleave.Util.getMaxLength(pps.blocks);

                     owner.isAndroid = Cleave.Util.isAndroid();
                     owner.lastInputValue = "";

                     owner.onChangeListener = owner.onChange.bind(owner);
                     owner.onKeyDownListener = owner.onKeyDown.bind(owner);
                     owner.onFocusListener = owner.onFocus.bind(owner);
                     owner.onCutListener = owner.onCut.bind(owner);
                     owner.onCopyListener = owner.onCopy.bind(owner);

                     owner.element.addEventListener(
                        "input",
                        owner.onChangeListener
                     );
                     owner.element.addEventListener(
                        "keydown",
                        owner.onKeyDownListener
                     );
                     owner.element.addEventListener(
                        "focus",
                        owner.onFocusListener
                     );
                     owner.element.addEventListener("cut", owner.onCutListener);
                     owner.element.addEventListener(
                        "copy",
                        owner.onCopyListener
                     );

                     owner.initPhoneFormatter();
                     owner.initDateFormatter();
                     owner.initTimeFormatter();
                     owner.initNumeralFormatter();

                     // avoid touch input field if value is null
                     // otherwise Firefox will add red box-shadow for <input required />
                     if (
                        pps.initValue ||
                        (pps.prefix && !pps.noImmediatePrefix)
                     ) {
                        owner.onInput(pps.initValue);
                     }
                  },

                  initNumeralFormatter: function () {
                     var owner = this,
                        pps = owner.properties;

                     if (!pps.numeral) {
                        return;
                     }

                     pps.numeralFormatter = new Cleave.NumeralFormatter(
                        pps.numeralDecimalMark,
                        pps.numeralIntegerScale,
                        pps.numeralDecimalScale,
                        pps.numeralThousandsGroupStyle,
                        pps.numeralPositiveOnly,
                        pps.stripLeadingZeroes,
                        pps.delimiter
                     );
                  },

                  initTimeFormatter: function () {
                     var owner = this,
                        pps = owner.properties;

                     if (!pps.time) {
                        return;
                     }

                     pps.timeFormatter = new Cleave.TimeFormatter(
                        pps.timePattern,
                        pps.timeFormat
                     );
                     pps.blocks = pps.timeFormatter.getBlocks();
                     pps.blocksLength = pps.blocks.length;
                     pps.maxLength = Cleave.Util.getMaxLength(pps.blocks);
                  },

                  initDateFormatter: function () {
                     var owner = this,
                        pps = owner.properties;

                     if (!pps.date) {
                        return;
                     }

                     pps.dateFormatter = new Cleave.DateFormatter(
                        pps.datePattern
                     );
                     pps.blocks = pps.dateFormatter.getBlocks();
                     pps.blocksLength = pps.blocks.length;
                     pps.maxLength = Cleave.Util.getMaxLength(pps.blocks);
                  },

                  initPhoneFormatter: function () {
                     var owner = this,
                        pps = owner.properties;

                     if (!pps.phone) {
                        return;
                     }

                     // Cleave.AsYouTypeFormatter should be provided by
                     // external google closure lib
                     try {
                        pps.phoneFormatter = new Cleave.PhoneFormatter(
                           new pps.root.Cleave.AsYouTypeFormatter(
                              pps.phoneRegionCode
                           ),
                           pps.delimiter
                        );
                     } catch (ex) {
                        throw new Error(
                           "[cleave.js] Please include phone-type-formatter.{country}.js lib"
                        );
                     }
                  },

                  onKeyDown: function (event) {
                     var owner = this,
                        pps = owner.properties,
                        charCode = event.which || event.keyCode,
                        Util = Cleave.Util,
                        currentValue = owner.element.value;

                     // if we got any charCode === 8, this means, that this device correctly
                     // sends backspace keys in event, so we do not need to apply any hacks
                     owner.hasBackspaceSupport =
                        owner.hasBackspaceSupport || charCode === 8;
                     if (
                        !owner.hasBackspaceSupport &&
                        Util.isAndroidBackspaceKeydown(
                           owner.lastInputValue,
                           currentValue
                        )
                     ) {
                        charCode = 8;
                     }

                     owner.lastInputValue = currentValue;

                     // hit backspace when last character is delimiter
                     var postDelimiter = Util.getPostDelimiter(
                        currentValue,
                        pps.delimiter,
                        pps.delimiters
                     );
                     if (charCode === 8 && postDelimiter) {
                        pps.postDelimiterBackspace = postDelimiter;
                     } else {
                        pps.postDelimiterBackspace = false;
                     }
                  },

                  onChange: function () {
                     this.onInput(this.element.value);
                  },

                  onFocus: function () {
                     var owner = this,
                        pps = owner.properties;

                     Cleave.Util.fixPrefixCursor(
                        owner.element,
                        pps.prefix,
                        pps.delimiter,
                        pps.delimiters
                     );
                  },

                  onCut: function (e) {
                     this.copyClipboardData(e);
                     this.onInput("");
                  },

                  onCopy: function (e) {
                     this.copyClipboardData(e);
                  },

                  copyClipboardData: function (e) {
                     var owner = this,
                        pps = owner.properties,
                        Util = Cleave.Util,
                        inputValue = owner.element.value,
                        textToCopy = "";

                     if (!pps.copyDelimiter) {
                        textToCopy = Util.stripDelimiters(
                           inputValue,
                           pps.delimiter,
                           pps.delimiters
                        );
                     } else {
                        textToCopy = inputValue;
                     }

                     try {
                        if (e.clipboardData) {
                           e.clipboardData.setData("Text", textToCopy);
                        } else {
                           window.clipboardData.setData("Text", textToCopy);
                        }

                        e.preventDefault();
                     } catch (ex) {
                        //  empty
                     }
                  },

                  onInput: function (value) {
                     var owner = this,
                        pps = owner.properties,
                        Util = Cleave.Util;

                     // case 1: delete one more character "4"
                     // 1234*| -> hit backspace -> 123|
                     // case 2: last character is not delimiter which is:
                     // 12|34* -> hit backspace -> 1|34*
                     // note: no need to apply this for numeral mode
                     var postDelimiterAfter = Util.getPostDelimiter(
                        value,
                        pps.delimiter,
                        pps.delimiters
                     );
                     if (
                        !pps.numeral &&
                        pps.postDelimiterBackspace &&
                        !postDelimiterAfter
                     ) {
                        value = Util.headStr(
                           value,
                           value.length - pps.postDelimiterBackspace.length
                        );
                     }

                     // phone formatter
                     if (pps.phone) {
                        if (
                           pps.prefix &&
                           (!pps.noImmediatePrefix || value.length)
                        ) {
                           pps.result =
                              pps.prefix +
                              pps.phoneFormatter
                                 .format(value)
                                 .slice(pps.prefix.length);
                        } else {
                           pps.result = pps.phoneFormatter.format(value);
                        }
                        owner.updateValueState();

                        return;
                     }

                     // numeral formatter
                     if (pps.numeral) {
                        if (
                           pps.prefix &&
                           (!pps.noImmediatePrefix || value.length)
                        ) {
                           pps.result =
                              pps.prefix + pps.numeralFormatter.format(value);
                        } else {
                           pps.result = pps.numeralFormatter.format(value);
                        }
                        owner.updateValueState();

                        return;
                     }

                     // date
                     if (pps.date) {
                        value = pps.dateFormatter.getValidatedDate(value);
                     }

                     // time
                     if (pps.time) {
                        value = pps.timeFormatter.getValidatedTime(value);
                     }

                     // strip delimiters
                     value = Util.stripDelimiters(
                        value,
                        pps.delimiter,
                        pps.delimiters
                     );

                     // strip prefix
                     // var strippedPreviousResult = Util.stripDelimiters(pps.result, pps.delimiter, pps.delimiters);
                     value = Util.getPrefixStrippedValue(
                        value,
                        pps.prefix,
                        pps.prefixLength,
                        pps.result,
                        pps.delimiter,
                        pps.delimiters
                     );

                     // strip non-numeric characters
                     value = pps.numericOnly
                        ? Util.strip(value, /[^\d]/g)
                        : value;

                     // convert case
                     value = pps.uppercase ? value.toUpperCase() : value;
                     value = pps.lowercase ? value.toLowerCase() : value;

                     // prefix
                     if (
                        pps.prefix &&
                        (!pps.noImmediatePrefix || value.length)
                     ) {
                        value = pps.prefix + value;

                        // no blocks specified, no need to do formatting
                        if (pps.blocksLength === 0) {
                           pps.result = value;
                           owner.updateValueState();

                           return;
                        }
                     }

                     // update credit card props
                     if (pps.creditCard) {
                        owner.updateCreditCardPropsByValue(value);
                     }

                     // strip over length characters
                     value = Util.headStr(value, pps.maxLength);

                     // apply blocks
                     pps.result = Util.getFormattedValue(
                        value,
                        pps.blocks,
                        pps.blocksLength,
                        pps.delimiter,
                        pps.delimiters,
                        pps.delimiterLazyShow
                     );

                     owner.updateValueState();
                  },

                  updateCreditCardPropsByValue: function (value) {
                     var owner = this,
                        pps = owner.properties,
                        Util = Cleave.Util,
                        creditCardInfo;

                     // At least one of the first 4 characters has changed
                     if (
                        Util.headStr(pps.result, 4) === Util.headStr(value, 4)
                     ) {
                        return;
                     }

                     creditCardInfo = Cleave.CreditCardDetector.getInfo(
                        value,
                        pps.creditCardStrictMode
                     );

                     pps.blocks = creditCardInfo.blocks;
                     pps.blocksLength = pps.blocks.length;
                     pps.maxLength = Util.getMaxLength(pps.blocks);

                     // credit card type changed
                     if (pps.creditCardType !== creditCardInfo.type) {
                        pps.creditCardType = creditCardInfo.type;

                        pps.onCreditCardTypeChanged.call(
                           owner,
                           pps.creditCardType
                        );
                     }
                  },

                  updateValueState: function () {
                     var owner = this,
                        Util = Cleave.Util,
                        pps = owner.properties;

                     if (!owner.element) {
                        return;
                     }

                     var endPos = owner.element.selectionEnd;
                     var oldValue = owner.element.value;
                     var newValue = pps.result;

                     endPos = Util.getNextCursorPosition(
                        endPos,
                        oldValue,
                        newValue,
                        pps.delimiter,
                        pps.delimiters
                     );

                     // fix Android browser type="text" input field
                     // cursor not jumping issue
                     if (owner.isAndroid) {
                        window.setTimeout(function () {
                           owner.element.value = newValue;
                           Util.setSelection(
                              owner.element,
                              endPos,
                              pps.document,
                              false
                           );
                           owner.callOnValueChanged();
                        }, 1);

                        return;
                     }

                     owner.element.value = newValue;
                     Util.setSelection(
                        owner.element,
                        endPos,
                        pps.document,
                        false
                     );
                     owner.callOnValueChanged();
                  },

                  callOnValueChanged: function () {
                     var owner = this,
                        pps = owner.properties;

                     pps.onValueChanged.call(owner, {
                        target: {
                           value: pps.result,
                           rawValue: owner.getRawValue(),
                        },
                     });
                  },

                  setPhoneRegionCode: function (phoneRegionCode) {
                     var owner = this,
                        pps = owner.properties;

                     pps.phoneRegionCode = phoneRegionCode;
                     owner.initPhoneFormatter();
                     owner.onChange();
                  },

                  setRawValue: function (value) {
                     var owner = this,
                        pps = owner.properties;

                     value =
                        value !== undefined && value !== null
                           ? value.toString()
                           : "";

                     if (pps.numeral) {
                        value = value.replace(".", pps.numeralDecimalMark);
                     }

                     pps.postDelimiterBackspace = false;

                     owner.element.value = value;
                     owner.onInput(value);
                  },

                  getRawValue: function () {
                     var owner = this,
                        pps = owner.properties,
                        Util = Cleave.Util,
                        rawValue = owner.element.value;

                     if (pps.rawValueTrimPrefix) {
                        rawValue = Util.getPrefixStrippedValue(
                           rawValue,
                           pps.prefix,
                           pps.prefixLength,
                           pps.result,
                           pps.delimiter,
                           pps.delimiters
                        );
                     }

                     if (pps.numeral) {
                        rawValue = pps.numeralFormatter.getRawValue(rawValue);
                     } else {
                        rawValue = Util.stripDelimiters(
                           rawValue,
                           pps.delimiter,
                           pps.delimiters
                        );
                     }

                     return rawValue;
                  },

                  getISOFormatDate: function () {
                     var owner = this,
                        pps = owner.properties;

                     return pps.date
                        ? pps.dateFormatter.getISOFormatDate()
                        : "";
                  },

                  getISOFormatTime: function () {
                     var owner = this,
                        pps = owner.properties;

                     return pps.time
                        ? pps.timeFormatter.getISOFormatTime()
                        : "";
                  },

                  getFormattedValue: function () {
                     return this.element.value;
                  },

                  destroy: function () {
                     var owner = this;

                     owner.element.removeEventListener(
                        "input",
                        owner.onChangeListener
                     );
                     owner.element.removeEventListener(
                        "keydown",
                        owner.onKeyDownListener
                     );
                     owner.element.removeEventListener(
                        "focus",
                        owner.onFocusListener
                     );
                     owner.element.removeEventListener(
                        "cut",
                        owner.onCutListener
                     );
                     owner.element.removeEventListener(
                        "copy",
                        owner.onCopyListener
                     );
                  },

                  toString: function () {
                     return "[Cleave Object]";
                  },
               };

               Cleave.NumeralFormatter = __webpack_require__(1);
               Cleave.DateFormatter = __webpack_require__(2);
               Cleave.TimeFormatter = __webpack_require__(3);
               Cleave.PhoneFormatter = __webpack_require__(4);
               Cleave.CreditCardDetector = __webpack_require__(5);
               Cleave.Util = __webpack_require__(6);
               Cleave.DefaultProperties = __webpack_require__(7);

               // for angular directive
               (typeof global === "object" && global ? global : window)[
                  "Cleave"
               ] = Cleave;

               // CommonJS
               module.exports = Cleave;

               /* WEBPACK VAR INJECTION */
            }.call(
               exports,
               (function () {
                  return this;
               })()
            ));

            /***/
         },
         /* 1 */
         /***/ function (module, exports) {
            "use strict";

            var NumeralFormatter = function (
               numeralDecimalMark,
               numeralIntegerScale,
               numeralDecimalScale,
               numeralThousandsGroupStyle,
               numeralPositiveOnly,
               stripLeadingZeroes,
               delimiter
            ) {
               var owner = this;

               owner.numeralDecimalMark = numeralDecimalMark || ".";
               owner.numeralIntegerScale =
                  numeralIntegerScale > 0 ? numeralIntegerScale : 0;
               owner.numeralDecimalScale =
                  numeralDecimalScale >= 0 ? numeralDecimalScale : 2;
               owner.numeralThousandsGroupStyle =
                  numeralThousandsGroupStyle ||
                  NumeralFormatter.groupStyle.thousand;
               owner.numeralPositiveOnly = !!numeralPositiveOnly;
               owner.stripLeadingZeroes = stripLeadingZeroes !== false;
               owner.delimiter =
                  delimiter || delimiter === "" ? delimiter : ",";
               owner.delimiterRE = delimiter
                  ? new RegExp("\\" + delimiter, "g")
                  : "";
            };

            NumeralFormatter.groupStyle = {
               thousand: "thousand",
               lakh: "lakh",
               wan: "wan",
               none: "none",
            };

            NumeralFormatter.prototype = {
               getRawValue: function (value) {
                  return value
                     .replace(this.delimiterRE, "")
                     .replace(this.numeralDecimalMark, ".");
               },

               format: function (value) {
                  var owner = this,
                     parts,
                     partInteger,
                     partDecimal = "";

                  // strip alphabet letters
                  value = value
                     .replace(/[A-Za-z]/g, "")
                     // replace the first decimal mark with reserved placeholder
                     .replace(owner.numeralDecimalMark, "M")

                     // strip non numeric letters except minus and "M"
                     // this is to ensure prefix has been stripped
                     .replace(/[^\dM-]/g, "")

                     // replace the leading minus with reserved placeholder
                     .replace(/^\-/, "N")

                     // strip the other minus sign (if present)
                     .replace(/\-/g, "")

                     // replace the minus sign (if present)
                     .replace("N", owner.numeralPositiveOnly ? "" : "-")

                     // replace decimal mark
                     .replace("M", owner.numeralDecimalMark);

                  // strip any leading zeros
                  if (owner.stripLeadingZeroes) {
                     value = value.replace(/^(-)?0+(?=\d)/, "$1");
                  }

                  partInteger = value;

                  if (value.indexOf(owner.numeralDecimalMark) >= 0) {
                     parts = value.split(owner.numeralDecimalMark);
                     partInteger = parts[0];
                     partDecimal =
                        owner.numeralDecimalMark +
                        parts[1].slice(0, owner.numeralDecimalScale);
                  }

                  if (owner.numeralIntegerScale > 0) {
                     partInteger = partInteger.slice(
                        0,
                        owner.numeralIntegerScale +
                           (value.slice(0, 1) === "-" ? 1 : 0)
                     );
                  }

                  switch (owner.numeralThousandsGroupStyle) {
                     case NumeralFormatter.groupStyle.lakh:
                        partInteger = partInteger.replace(
                           /(\d)(?=(\d\d)+\d$)/g,
                           "$1" + owner.delimiter
                        );

                        break;

                     case NumeralFormatter.groupStyle.wan:
                        partInteger = partInteger.replace(
                           /(\d)(?=(\d{4})+$)/g,
                           "$1" + owner.delimiter
                        );

                        break;

                     case NumeralFormatter.groupStyle.thousand:
                        partInteger = partInteger.replace(
                           /(\d)(?=(\d{3})+$)/g,
                           "$1" + owner.delimiter
                        );

                        break;
                  }

                  return (
                     partInteger.toString() +
                     (owner.numeralDecimalScale > 0
                        ? partDecimal.toString()
                        : "")
                  );
               },
            };

            module.exports = NumeralFormatter;

            /***/
         },
         /* 2 */
         /***/ function (module, exports) {
            "use strict";

            var DateFormatter = function (datePattern) {
               var owner = this;

               owner.date = [];
               owner.blocks = [];
               owner.datePattern = datePattern;
               owner.initBlocks();
            };

            DateFormatter.prototype = {
               initBlocks: function () {
                  var owner = this;
                  owner.datePattern.forEach(function (value) {
                     if (value === "Y") {
                        owner.blocks.push(4);
                     } else {
                        owner.blocks.push(2);
                     }
                  });
               },

               getISOFormatDate: function () {
                  var owner = this,
                     date = owner.date;

                  return date[2]
                     ? date[2] +
                          "-" +
                          owner.addLeadingZero(date[1]) +
                          "-" +
                          owner.addLeadingZero(date[0])
                     : "";
               },

               getBlocks: function () {
                  return this.blocks;
               },

               getValidatedDate: function (value) {
                  var owner = this,
                     result = "";

                  value = value.replace(/[^\d]/g, "");

                  owner.blocks.forEach(function (length, index) {
                     if (value.length > 0) {
                        var sub = value.slice(0, length),
                           sub0 = sub.slice(0, 1),
                           rest = value.slice(length);

                        switch (owner.datePattern[index]) {
                           case "d":
                              if (sub === "00") {
                                 sub = "01";
                              } else if (parseInt(sub0, 10) > 3) {
                                 sub = "0" + sub0;
                              } else if (parseInt(sub, 10) > 31) {
                                 sub = "31";
                              }

                              break;

                           case "m":
                              if (sub === "00") {
                                 sub = "01";
                              } else if (parseInt(sub0, 10) > 1) {
                                 sub = "0" + sub0;
                              } else if (parseInt(sub, 10) > 12) {
                                 sub = "12";
                              }

                              break;
                        }

                        result += sub;

                        // update remaining string
                        value = rest;
                     }
                  });

                  return this.getFixedDateString(result);
               },

               getFixedDateString: function (value) {
                  var owner = this,
                     datePattern = owner.datePattern,
                     date = [],
                     dayIndex = 0,
                     monthIndex = 0,
                     yearIndex = 0,
                     dayStartIndex = 0,
                     monthStartIndex = 0,
                     yearStartIndex = 0,
                     day,
                     month,
                     year,
                     fullYearDone = false;

                  // mm-dd || dd-mm
                  if (
                     value.length === 4 &&
                     datePattern[0].toLowerCase() !== "y" &&
                     datePattern[1].toLowerCase() !== "y"
                  ) {
                     dayStartIndex = datePattern[0] === "d" ? 0 : 2;
                     monthStartIndex = 2 - dayStartIndex;
                     day = parseInt(
                        value.slice(dayStartIndex, dayStartIndex + 2),
                        10
                     );
                     month = parseInt(
                        value.slice(monthStartIndex, monthStartIndex + 2),
                        10
                     );

                     date = this.getFixedDate(day, month, 0);
                  }

                  // yyyy-mm-dd || yyyy-dd-mm || mm-dd-yyyy || dd-mm-yyyy || dd-yyyy-mm || mm-yyyy-dd
                  if (value.length === 8) {
                     datePattern.forEach(function (type, index) {
                        switch (type) {
                           case "d":
                              dayIndex = index;
                              break;
                           case "m":
                              monthIndex = index;
                              break;
                           default:
                              yearIndex = index;
                              break;
                        }
                     });

                     yearStartIndex = yearIndex * 2;
                     dayStartIndex =
                        dayIndex <= yearIndex ? dayIndex * 2 : dayIndex * 2 + 2;
                     monthStartIndex =
                        monthIndex <= yearIndex
                           ? monthIndex * 2
                           : monthIndex * 2 + 2;

                     day = parseInt(
                        value.slice(dayStartIndex, dayStartIndex + 2),
                        10
                     );
                     month = parseInt(
                        value.slice(monthStartIndex, monthStartIndex + 2),
                        10
                     );
                     year = parseInt(
                        value.slice(yearStartIndex, yearStartIndex + 4),
                        10
                     );

                     fullYearDone =
                        value.slice(yearStartIndex, yearStartIndex + 4)
                           .length === 4;

                     date = this.getFixedDate(day, month, year);
                  }

                  owner.date = date;

                  return date.length === 0
                     ? value
                     : datePattern.reduce(function (previous, current) {
                          switch (current) {
                             case "d":
                                return previous + owner.addLeadingZero(date[0]);
                             case "m":
                                return previous + owner.addLeadingZero(date[1]);
                             default:
                                return (
                                   previous +
                                   (fullYearDone
                                      ? owner.addLeadingZeroForYear(date[2])
                                      : "")
                                );
                          }
                       }, "");
               },

               getFixedDate: function (day, month, year) {
                  day = Math.min(day, 31);
                  month = Math.min(month, 12);
                  year = parseInt(year || 0, 10);

                  if (
                     (month < 7 && month % 2 === 0) ||
                     (month > 8 && month % 2 === 1)
                  ) {
                     day = Math.min(
                        day,
                        month === 2 ? (this.isLeapYear(year) ? 29 : 28) : 30
                     );
                  }

                  return [day, month, year];
               },

               isLeapYear: function (year) {
                  return (
                     (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0
                  );
               },

               addLeadingZero: function (number) {
                  return (number < 10 ? "0" : "") + number;
               },

               addLeadingZeroForYear: function (number) {
                  return (
                     (number < 10
                        ? "000"
                        : number < 100
                        ? "00"
                        : number < 1000
                        ? "0"
                        : "") + number
                  );
               },
            };

            module.exports = DateFormatter;

            /***/
         },
         /* 3 */
         /***/ function (module, exports) {
            "use strict";

            var TimeFormatter = function (timePattern, timeFormat) {
               var owner = this;

               owner.time = [];
               owner.blocks = [];
               owner.timePattern = timePattern;
               owner.timeFormat = timeFormat;
               owner.initBlocks();
            };

            TimeFormatter.prototype = {
               initBlocks: function () {
                  var owner = this;
                  owner.timePattern.forEach(function () {
                     owner.blocks.push(2);
                  });
               },

               getISOFormatTime: function () {
                  var owner = this,
                     time = owner.time;

                  return time[2]
                     ? owner.addLeadingZero(time[0]) +
                          ":" +
                          owner.addLeadingZero(time[1]) +
                          ":" +
                          owner.addLeadingZero(time[2])
                     : "";
               },

               getBlocks: function () {
                  return this.blocks;
               },

               getTimeFormatOptions: function () {
                  var owner = this;
                  if (String(owner.timeFormat) === "12") {
                     return {
                        maxHourFirstDigit: 1,
                        maxHours: 12,
                        maxMinutesFirstDigit: 5,
                        maxMinutes: 60,
                     };
                  }

                  return {
                     maxHourFirstDigit: 2,
                     maxHours: 23,
                     maxMinutesFirstDigit: 5,
                     maxMinutes: 60,
                  };
               },

               getValidatedTime: function (value) {
                  var owner = this,
                     result = "";

                  value = value.replace(/[^\d]/g, "");

                  var timeFormatOptions = owner.getTimeFormatOptions();

                  owner.blocks.forEach(function (length, index) {
                     if (value.length > 0) {
                        var sub = value.slice(0, length),
                           sub0 = sub.slice(0, 1),
                           rest = value.slice(length);

                        switch (owner.timePattern[index]) {
                           case "h":
                              if (
                                 parseInt(sub0, 10) >
                                 timeFormatOptions.maxHourFirstDigit
                              ) {
                                 sub = "0" + sub0;
                              } else if (
                                 parseInt(sub, 10) > timeFormatOptions.maxHours
                              ) {
                                 sub = timeFormatOptions.maxHours + "";
                              }

                              break;

                           case "m":
                           case "s":
                              if (
                                 parseInt(sub0, 10) >
                                 timeFormatOptions.maxMinutesFirstDigit
                              ) {
                                 sub = "0" + sub0;
                              } else if (
                                 parseInt(sub, 10) >
                                 timeFormatOptions.maxMinutes
                              ) {
                                 sub = timeFormatOptions.maxMinutes + "";
                              }
                              break;
                        }

                        result += sub;

                        // update remaining string
                        value = rest;
                     }
                  });

                  return this.getFixedTimeString(result);
               },

               getFixedTimeString: function (value) {
                  var owner = this,
                     timePattern = owner.timePattern,
                     time = [],
                     secondIndex = 0,
                     minuteIndex = 0,
                     hourIndex = 0,
                     secondStartIndex = 0,
                     minuteStartIndex = 0,
                     hourStartIndex = 0,
                     second,
                     minute,
                     hour;

                  if (value.length === 6) {
                     timePattern.forEach(function (type, index) {
                        switch (type) {
                           case "s":
                              secondIndex = index * 2;
                              break;
                           case "m":
                              minuteIndex = index * 2;
                              break;
                           case "h":
                              hourIndex = index * 2;
                              break;
                        }
                     });

                     hourStartIndex = hourIndex;
                     minuteStartIndex = minuteIndex;
                     secondStartIndex = secondIndex;

                     second = parseInt(
                        value.slice(secondStartIndex, secondStartIndex + 2),
                        10
                     );
                     minute = parseInt(
                        value.slice(minuteStartIndex, minuteStartIndex + 2),
                        10
                     );
                     hour = parseInt(
                        value.slice(hourStartIndex, hourStartIndex + 2),
                        10
                     );

                     time = this.getFixedTime(hour, minute, second);
                  }

                  if (
                     value.length === 4 &&
                     owner.timePattern.indexOf("s") < 0
                  ) {
                     timePattern.forEach(function (type, index) {
                        switch (type) {
                           case "m":
                              minuteIndex = index * 2;
                              break;
                           case "h":
                              hourIndex = index * 2;
                              break;
                        }
                     });

                     hourStartIndex = hourIndex;
                     minuteStartIndex = minuteIndex;

                     second = 0;
                     minute = parseInt(
                        value.slice(minuteStartIndex, minuteStartIndex + 2),
                        10
                     );
                     hour = parseInt(
                        value.slice(hourStartIndex, hourStartIndex + 2),
                        10
                     );

                     time = this.getFixedTime(hour, minute, second);
                  }

                  owner.time = time;

                  return time.length === 0
                     ? value
                     : timePattern.reduce(function (previous, current) {
                          switch (current) {
                             case "s":
                                return previous + owner.addLeadingZero(time[2]);
                             case "m":
                                return previous + owner.addLeadingZero(time[1]);
                             case "h":
                                return previous + owner.addLeadingZero(time[0]);
                          }
                       }, "");
               },

               getFixedTime: function (hour, minute, second) {
                  second = Math.min(parseInt(second || 0, 10), 60);
                  minute = Math.min(minute, 60);
                  hour = Math.min(hour, 60);

                  return [hour, minute, second];
               },

               addLeadingZero: function (number) {
                  return (number < 10 ? "0" : "") + number;
               },
            };

            module.exports = TimeFormatter;

            /***/
         },
         /* 4 */
         /***/ function (module, exports) {
            "use strict";

            var PhoneFormatter = function (formatter, delimiter) {
               var owner = this;

               owner.delimiter =
                  delimiter || delimiter === "" ? delimiter : " ";
               owner.delimiterRE = delimiter
                  ? new RegExp("\\" + delimiter, "g")
                  : "";

               owner.formatter = formatter;
            };

            PhoneFormatter.prototype = {
               setFormatter: function (formatter) {
                  this.formatter = formatter;
               },

               format: function (phoneNumber) {
                  var owner = this;

                  owner.formatter.clear();

                  // only keep number and +
                  phoneNumber = phoneNumber.replace(/[^\d+]/g, "");

                  // strip non-leading +
                  phoneNumber = phoneNumber
                     .replace(/^\+/, "B")
                     .replace(/\+/g, "")
                     .replace("B", "+");

                  // strip delimiter
                  phoneNumber = phoneNumber.replace(owner.delimiterRE, "");

                  var result = "",
                     current,
                     validated = false;

                  for (var i = 0, iMax = phoneNumber.length; i < iMax; i++) {
                     current = owner.formatter.inputDigit(
                        phoneNumber.charAt(i)
                     );

                     // has ()- or space inside
                     if (/[\s()-]/g.test(current)) {
                        result = current;

                        validated = true;
                     } else {
                        if (!validated) {
                           result = current;
                        }
                        // else: over length input
                        // it turns to invalid number again
                     }
                  }

                  // strip ()
                  // e.g. US: 7161234567 returns (716) 123-4567
                  result = result.replace(/[()]/g, "");
                  // replace library delimiter with user customized delimiter
                  result = result.replace(/[\s-]/g, owner.delimiter);

                  return result;
               },
            };

            module.exports = PhoneFormatter;

            /***/
         },
         /* 5 */
         /***/ function (module, exports) {
            "use strict";

            var CreditCardDetector = {
               blocks: {
                  uatp: [4, 5, 6],
                  amex: [4, 6, 5],
                  diners: [4, 6, 4],
                  discover: [4, 4, 4, 4],
                  mastercard: [4, 4, 4, 4],
                  dankort: [4, 4, 4, 4],
                  instapayment: [4, 4, 4, 4],
                  jcb15: [4, 6, 5],
                  jcb: [4, 4, 4, 4],
                  maestro: [4, 4, 4, 4],
                  visa: [4, 4, 4, 4],
                  mir: [4, 4, 4, 4],
                  unionPay: [4, 4, 4, 4],
                  general: [4, 4, 4, 4],
                  generalStrict: [4, 4, 4, 7],
               },

               re: {
                  // starts with 1; 15 digits, not starts with 1800 (jcb card)
                  uatp: /^(?!1800)1\d{0,14}/,

                  // starts with 34/37; 15 digits
                  amex: /^3[47]\d{0,13}/,

                  // starts with 6011/65/644-649; 16 digits
                  discover: /^(?:6011|65\d{0,2}|64[4-9]\d?)\d{0,12}/,

                  // starts with 300-305/309 or 36/38/39; 14 digits
                  diners: /^3(?:0([0-5]|9)|[689]\d?)\d{0,11}/,

                  // starts with 51-55/2221–2720; 16 digits
                  mastercard: /^(5[1-5]\d{0,2}|22[2-9]\d{0,1}|2[3-7]\d{0,2})\d{0,12}/,

                  // starts with 5019/4175/4571; 16 digits
                  dankort: /^(5019|4175|4571)\d{0,12}/,

                  // starts with 637-639; 16 digits
                  instapayment: /^63[7-9]\d{0,13}/,

                  // starts with 2131/1800; 15 digits
                  jcb15: /^(?:2131|1800)\d{0,11}/,

                  // starts with 2131/1800/35; 16 digits
                  jcb: /^(?:35\d{0,2})\d{0,12}/,

                  // starts with 50/56-58/6304/67; 16 digits
                  maestro: /^(?:5[0678]\d{0,2}|6304|67\d{0,2})\d{0,12}/,

                  // starts with 22; 16 digits
                  mir: /^220[0-4]\d{0,12}/,

                  // starts with 4; 16 digits
                  visa: /^4\d{0,15}/,

                  // starts with 62; 16 digits
                  unionPay: /^62\d{0,14}/,
               },

               getInfo: function (value, strictMode) {
                  var blocks = CreditCardDetector.blocks,
                     re = CreditCardDetector.re;

                  // Some credit card can have up to 19 digits number.
                  // Set strictMode to true will remove the 16 max-length restrain,
                  // however, I never found any website validate card number like
                  // this, hence probably you don't want to enable this option.
                  strictMode = !!strictMode;

                  for (var key in re) {
                     if (re[key].test(value)) {
                        var block;

                        if (strictMode) {
                           block = blocks.generalStrict;
                        } else {
                           block = blocks[key];
                        }

                        return {
                           type: key,
                           blocks: block,
                        };
                     }
                  }

                  return {
                     type: "unknown",
                     blocks: strictMode ? blocks.generalStrict : blocks.general,
                  };
               },
            };

            module.exports = CreditCardDetector;

            /***/
         },
         /* 6 */
         /***/ function (module, exports) {
            "use strict";

            var Util = {
               noop: function () {},

               strip: function (value, re) {
                  return value.replace(re, "");
               },

               getPostDelimiter: function (value, delimiter, delimiters) {
                  // single delimiter
                  if (delimiters.length === 0) {
                     return value.slice(-delimiter.length) === delimiter
                        ? delimiter
                        : "";
                  }

                  // multiple delimiters
                  var matchedDelimiter = "";
                  delimiters.forEach(function (current) {
                     if (value.slice(-current.length) === current) {
                        matchedDelimiter = current;
                     }
                  });

                  return matchedDelimiter;
               },

               getDelimiterREByDelimiter: function (delimiter) {
                  return new RegExp(
                     delimiter.replace(/([.?*+^$[\]\\(){}|-])/g, "\\$1"),
                     "g"
                  );
               },

               getNextCursorPosition: function (
                  prevPos,
                  oldValue,
                  newValue,
                  delimiter,
                  delimiters
               ) {
                  // If cursor was at the end of value, just place it back.
                  // Because new value could contain additional chars.
                  if (oldValue.length === prevPos) {
                     return newValue.length;
                  }

                  return (
                     prevPos +
                     this.getPositionOffset(
                        prevPos,
                        oldValue,
                        newValue,
                        delimiter,
                        delimiters
                     )
                  );
               },

               getPositionOffset: function (
                  prevPos,
                  oldValue,
                  newValue,
                  delimiter,
                  delimiters
               ) {
                  var oldRawValue, newRawValue, lengthOffset;

                  oldRawValue = this.stripDelimiters(
                     oldValue.slice(0, prevPos),
                     delimiter,
                     delimiters
                  );
                  newRawValue = this.stripDelimiters(
                     newValue.slice(0, prevPos),
                     delimiter,
                     delimiters
                  );
                  lengthOffset = oldRawValue.length - newRawValue.length;

                  return lengthOffset !== 0
                     ? lengthOffset / Math.abs(lengthOffset)
                     : 0;
               },

               stripDelimiters: function (value, delimiter, delimiters) {
                  var owner = this;

                  // single delimiter
                  if (delimiters.length === 0) {
                     var delimiterRE = delimiter
                        ? owner.getDelimiterREByDelimiter(delimiter)
                        : "";

                     return value.replace(delimiterRE, "");
                  }

                  // multiple delimiters
                  delimiters.forEach(function (current) {
                     current.split("").forEach(function (letter) {
                        value = value.replace(
                           owner.getDelimiterREByDelimiter(letter),
                           ""
                        );
                     });
                  });

                  return value;
               },

               headStr: function (str, length) {
                  return str.slice(0, length);
               },

               getMaxLength: function (blocks) {
                  return blocks.reduce(function (previous, current) {
                     return previous + current;
                  }, 0);
               },

               // strip prefix
               // Before type  |   After type    |     Return value
               // PEFIX-...    |   PEFIX-...     |     ''
               // PREFIX-123   |   PEFIX-123     |     123
               // PREFIX-123   |   PREFIX-23     |     23
               // PREFIX-123   |   PREFIX-1234   |     1234
               getPrefixStrippedValue: function (
                  value,
                  prefix,
                  prefixLength,
                  prevResult,
                  delimiter,
                  delimiters
               ) {
                  // No prefix
                  if (prefixLength === 0) {
                     return value;
                  }

                  // Pre result has issue
                  // Revert to raw prefix
                  if (prevResult.slice(0, prefixLength) !== prefix) {
                     return "";
                  }

                  var prevValue = this.stripDelimiters(
                     prevResult,
                     delimiter,
                     delimiters
                  );

                  // New value has issue, someone typed in between prefix letters
                  // Revert to pre value
                  if (value.slice(0, prefixLength) !== prefix) {
                     return prevValue.slice(prefixLength);
                  }

                  // No issue, strip prefix for new value
                  return value.slice(prefixLength);
               },

               getFirstDiffIndex: function (prev, current) {
                  var index = 0;

                  while (prev.charAt(index) === current.charAt(index)) {
                     if (prev.charAt(index++) === "") {
                        return -1;
                     }
                  }

                  return index;
               },

               getFormattedValue: function (
                  value,
                  blocks,
                  blocksLength,
                  delimiter,
                  delimiters,
                  delimiterLazyShow
               ) {
                  var result = "",
                     multipleDelimiters = delimiters.length > 0,
                     currentDelimiter;

                  // no options, normal input
                  if (blocksLength === 0) {
                     return value;
                  }

                  blocks.forEach(function (length, index) {
                     if (value.length > 0) {
                        var sub = value.slice(0, length),
                           rest = value.slice(length);

                        if (multipleDelimiters) {
                           currentDelimiter =
                              delimiters[
                                 delimiterLazyShow ? index - 1 : index
                              ] || currentDelimiter;
                        } else {
                           currentDelimiter = delimiter;
                        }

                        if (delimiterLazyShow) {
                           if (index > 0) {
                              result += currentDelimiter;
                           }

                           result += sub;
                        } else {
                           result += sub;

                           if (
                              sub.length === length &&
                              index < blocksLength - 1
                           ) {
                              result += currentDelimiter;
                           }
                        }

                        // update remaining string
                        value = rest;
                     }
                  });

                  return result;
               },

               // move cursor to the end
               // the first time user focuses on an input with prefix
               fixPrefixCursor: function (el, prefix, delimiter, delimiters) {
                  if (!el) {
                     return;
                  }

                  var val = el.value,
                     appendix = delimiter || delimiters[0] || " ";

                  if (
                     !el.setSelectionRange ||
                     !prefix ||
                     prefix.length + appendix.length < val.length
                  ) {
                     return;
                  }

                  var len = val.length * 2;

                  // set timeout to avoid blink
                  setTimeout(function () {
                     el.setSelectionRange(len, len);
                  }, 1);
               },

               setSelection: function (element, position, doc) {
                  if (element !== this.getActiveElement(doc)) {
                     return;
                  }

                  // cursor is already in the end
                  if (element && element.value.length <= position) {
                     return;
                  }

                  if (element.createTextRange) {
                     var range = element.createTextRange();

                     range.move("character", position);
                     range.select();
                  } else {
                     try {
                        element.setSelectionRange(position, position);
                     } catch (e) {
                        // eslint-disable-next-line
                        console.warn(
                           "The input element type does not support selection"
                        );
                     }
                  }
               },

               getActiveElement: function (parent) {
                  var activeElement = parent.activeElement;
                  if (activeElement && activeElement.shadowRoot) {
                     return this.getActiveElement(activeElement.shadowRoot);
                  }
                  return activeElement;
               },

               isAndroid: function () {
                  return navigator && /android/i.test(navigator.userAgent);
               },

               // On Android chrome, the keyup and keydown events
               // always return key code 229 as a composition that
               // buffers the user’s keystrokes
               // see https://github.com/nosir/cleave.js/issues/147
               isAndroidBackspaceKeydown: function (
                  lastInputValue,
                  currentInputValue
               ) {
                  if (
                     !this.isAndroid() ||
                     !lastInputValue ||
                     !currentInputValue
                  ) {
                     return false;
                  }

                  return currentInputValue === lastInputValue.slice(0, -1);
               },
            };

            module.exports = Util;

            /***/
         },
         /* 7 */
         /***/ function (module, exports) {
            /* WEBPACK VAR INJECTION */ (function (global) {
               "use strict";

               /**
                * Props Assignment
                *
                * Separate this, so react module can share the usage
                */
               var DefaultProperties = {
                  // Maybe change to object-assign
                  // for now just keep it as simple
                  assign: function (target, opts) {
                     target = target || {};
                     opts = opts || {};

                     // credit card
                     target.creditCard = !!opts.creditCard;
                     target.creditCardStrictMode = !!opts.creditCardStrictMode;
                     target.creditCardType = "";
                     target.onCreditCardTypeChanged =
                        opts.onCreditCardTypeChanged || function () {};

                     // phone
                     target.phone = !!opts.phone;
                     target.phoneRegionCode = opts.phoneRegionCode || "AU";
                     target.phoneFormatter = {};

                     // time
                     target.time = !!opts.time;
                     target.timePattern = opts.timePattern || ["h", "m", "s"];
                     target.timeFormat = opts.timeFormat || "24";
                     target.timeFormatter = {};

                     // date
                     target.date = !!opts.date;
                     target.datePattern = opts.datePattern || ["d", "m", "Y"];
                     target.dateFormatter = {};

                     // numeral
                     target.numeral = !!opts.numeral;
                     target.numeralIntegerScale =
                        opts.numeralIntegerScale > 0
                           ? opts.numeralIntegerScale
                           : 0;
                     target.numeralDecimalScale =
                        opts.numeralDecimalScale >= 0
                           ? opts.numeralDecimalScale
                           : 2;
                     target.numeralDecimalMark = opts.numeralDecimalMark || ".";
                     target.numeralThousandsGroupStyle =
                        opts.numeralThousandsGroupStyle || "thousand";
                     target.numeralPositiveOnly = !!opts.numeralPositiveOnly;
                     target.stripLeadingZeroes =
                        opts.stripLeadingZeroes !== false;

                     // others
                     target.numericOnly =
                        target.creditCard || target.date || !!opts.numericOnly;

                     target.uppercase = !!opts.uppercase;
                     target.lowercase = !!opts.lowercase;

                     target.prefix =
                        target.creditCard || target.date
                           ? ""
                           : opts.prefix || "";
                     target.noImmediatePrefix = !!opts.noImmediatePrefix;
                     target.prefixLength = target.prefix.length;
                     target.rawValueTrimPrefix = !!opts.rawValueTrimPrefix;
                     target.copyDelimiter = !!opts.copyDelimiter;

                     target.initValue =
                        opts.initValue !== undefined && opts.initValue !== null
                           ? opts.initValue.toString()
                           : "";

                     target.delimiter =
                        opts.delimiter || opts.delimiter === ""
                           ? opts.delimiter
                           : opts.date
                           ? "/"
                           : opts.time
                           ? ":"
                           : opts.numeral
                           ? ","
                           : opts.phone
                           ? " "
                           : " ";
                     target.delimiterLength = target.delimiter.length;
                     target.delimiterLazyShow = !!opts.delimiterLazyShow;
                     target.delimiters = opts.delimiters || [];

                     target.blocks = opts.blocks || [];
                     target.blocksLength = target.blocks.length;

                     target.root =
                        typeof global === "object" && global ? global : window;
                     target.document = opts.document || target.root.document;

                     target.maxLength = 0;

                     target.backspace = false;
                     target.result = "";

                     target.onValueChanged =
                        opts.onValueChanged || function () {};

                     return target;
                  },
               };

               module.exports = DefaultProperties;

               /* WEBPACK VAR INJECTION */
            }.call(
               exports,
               (function () {
                  return this;
               })()
            ));

            /***/
         },
         /******/
      ]
   );
});