text: (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;
  
  	    if (typeof element === 'string') {
  	        owner.element = document.querySelector(element);
  	    } else {
  	        owner.element = ((typeof element.length !== 'undefined') && element.length > 0) ? element[0] : element;
  	    }
  
  	    if (!owner.element) {
  	        throw new Error('[cleave.js] Please check the element');
  	    }
  
  	    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.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.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('cut', owner.onCutListener);
  	        owner.element.addEventListener('copy', owner.onCopyListener);
  
  
  	        owner.initDateFormatter();
  
  	        // 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);
  	        }
  	    },
  
  
  	    initDateFormatter: function () {
  	        var owner = this, pps = owner.properties;
  
  	        if (!pps.date) {
  	            return;
  	        }
  
  	        pps.dateFormatter = new Cleave.DateFormatter(pps);
  	        pps.blocks = pps.dateFormatter.getBlocks();
  	        pps.blocksLength = pps.blocks.length;
  	        pps.maxLength = Cleave.Util.getMaxLength(pps.blocks);
  	    },
  	    onKeyDown: function (event) {
  	        var owner = this, pps = owner.properties,
  	            charCode = event.which || event.keyCode,
  	            Util = Cleave.Util,
  	            currentValue = owner.element.value;
  
  	        if (charCode === 229
  	            && Util.isAndroidBackspaceKeydown(owner.lastInputValue, currentValue)
  	        ) {
  	            charCode = 8;
  	        }
  
  	        owner.lastInputValue = currentValue;
  
  	        // hit backspace when last character is delimiter
  	        if (charCode === 8 && Util.isDelimiter(currentValue.slice(-pps.delimiterLength), pps.delimiter, pps.delimiters)) {
  	            pps.backspace = true;
  
  	            return;
  	        }
  
  	        pps.backspace = false;
  	    },
  
  	    onChange: function () {
  	        this.onInput(this.element.value);
  	    },
  
  	    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
  	        if (!pps.numeral && pps.backspace && !Util.isDelimiter(value.slice(-pps.delimiterLength), pps.delimiter, pps.delimiters)) {
  	            value = Util.headStr(value, value.length - pps.delimiterLength);
  	        }
  
  
  	        // date
  	        if (pps.date) {
  	            value = pps.dateFormatter.getValidatedDate(value);
  	        }
  
  
  	        // strip delimiters
  	        value = Util.stripDelimiters(value, pps.delimiter, pps.delimiters);
  
  	        // strip prefix
  	        value = Util.getPrefixStrippedValue(value, pps.prefix, pps.prefixLength, pps.result);
  
  	        // 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;
  	            }
  	        }
  
  	        // 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();
  	    },
  
  	    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()
  	            }
  	        });
  	    },
  
  	    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.backspace = 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);
  	        }
  
  	        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() : '';
  	    },
  
  	    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('cut', owner.onCutListener);
  	        owner.element.removeEventListener('copy', owner.onCopyListener);
  	    },
  
  	    toString: function () {
  	        return '[Cleave Object]';
  	    }
  	};
  
  	Cleave.DateFormatter = __webpack_require__(1);
  	Cleave.Util = __webpack_require__(2);
  	Cleave.DefaultProperties = __webpack_require__(3);
  
  	// 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 DateFormatter = function (pps) {
  	    var owner = this;
  
  	    owner.date = [];
  	    owner.blocks = [];
  	    owner.datePattern = pps.datePattern;
  	    owner.pps = pps;
  	    owner.initBlocks();
  	};
  
  	DateFormatter.prototype = {
  	    initBlocks: function () {
  	        var owner = this;
  	        owner.datePattern.forEach(function (value) {
  	            if (value === 'Y' && owner.pps.yearLength === 4) {
  	                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);
  	        }
  
  	        // yy-mm-dd || yy-dd-mm || mm-dd-yy || dd-mm-yy || dd-yy-mm || mm-yy-dd
  	        if ((owner.pps.yearLength === 4 && value.length === 8) || (owner.pps.yearLength === 2 && value.length === 6)) {
  	            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);
  	            if(owner.pps.yearLength === 4){
  	                fullYearDone = value.slice(yearStartIndex, yearStartIndex + 4).length === 4;
  	                year = parseInt(value.slice(yearStartIndex, yearStartIndex + 4), 10);
  	            } else {
  	                year = parseInt(value.slice(yearStartIndex, yearStartIndex + 2), 10);
  	            }
  	           
  
  	            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 + owner.addLeadingZero(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;
  	    }
  	};
  
  	module.exports = DateFormatter;
  
  
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	var Util = {
  	    noop: function () {
  	    },
  
  	    strip: function (value, re) {
  	        return value.replace(re, '');
  	    },
  
  	    isDelimiter: function (letter, delimiter, delimiters) {
  	        // single delimiter
  	        if (delimiters.length === 0) {
  	            return letter === delimiter;
  	        }
  
  	        // multiple delimiters
  	        return delimiters.some(function (current) {
  	            if (letter === current) {
  	                return true;
  	            }
  	        });
  	    },
  
  	    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) {
  	            value = value.replace(owner.getDelimiterREByDelimiter(current), '');
  	        });
  
  	        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 value by prefix length
  	    // for prefix: PRE
  	    // (PRE123, 3) -> 123
  	    // (PR123, 3) -> 23 this happens when user hits backspace in front of "PRE"
  	    getPrefixStrippedValue: function (value, prefix, prefixLength, prevValue) {
  	        if (value.slice(0, prefixLength) !== prefix) {
  
  	            // Check whether if it is a deletion
  	            if (value.length < prevValue.length) {
  	                value = value.length > prefixLength ? prevValue : prefix;
  	            } else {
  	                var diffIndex = this.getFirstDiffIndex(prefix, value.slice(0, prefixLength));
  	                value = prefix + value.slice(diffIndex, diffIndex + 1) + value.slice(prefixLength + 1);
  	            }
  	        }
  
  	        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;
  	    },
  
  
  	    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;
  
  
  /***/ }),
  /* 3 */
  /***/ (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 || {};
  
  
  	        // date
  	        target.date = !!opts.date;
  	        target.datePattern = opts.datePattern || ['d', 'm', 'Y'];
  	        target.dateFormatter = {};
  	        target.yearLength = opts.yearLength || 4;
  
  
  	        // others
  	        target.numericOnly = target.date;
  
  	        target.uppercase = !!opts.uppercase;
  	        target.lowercase = !!opts.lowercase;
  
  	        target.prefix = 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 ? '/' : ' ');
  	        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; }())))
  
  /***/ })
  /******/ ])
  });
  ;