react-maskedinput/umd/react-maskedinput.js

/*!
 * react-maskedinput 3.2.1 - https://github.com/insin/react-maskedinput
 * MIT Licensed
 */
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("react"));
	else if(typeof define === 'function' && define.amd)
		define(["react"], factory);
	else if(typeof exports === 'object')
		exports["MaskedInput"] = factory(require("react"));
	else
		root["MaskedInput"] = factory(root["React"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_12__) {
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__) {

	'use strict';

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

	var React = __webpack_require__(12);

	var _require = __webpack_require__(9);

	var getSelection = _require.getSelection;
	var setSelection = _require.setSelection;

	var InputMask = __webpack_require__(7);

	var KEYCODE_Z = 90;
	var KEYCODE_Y = 89;

	function isUndo(e) {
	  return (e.ctrlKey || e.metaKey) && e.keyCode === (e.shiftKey ? KEYCODE_Y : KEYCODE_Z);
	}

	function isRedo(e) {
	  return (e.ctrlKey || e.metaKey) && e.keyCode === (e.shiftKey ? KEYCODE_Z : KEYCODE_Y);
	}

	var MaskedInput = React.createClass({
	  displayName: 'MaskedInput',

	  propTypes: {
	    mask: React.PropTypes.string.isRequired,

	    formatCharacters: React.PropTypes.object,
	    placeholderChar: React.PropTypes.string
	  },

	  getDefaultProps: function getDefaultProps() {
	    return {
	      value: ''
	    };
	  },

	  componentWillMount: function componentWillMount() {
	    var options = {
	      pattern: this.props.mask,
	      value: this.props.value,
	      formatCharacters: this.props.formatCharacters
	    };
	    if (this.props.placeholderChar) {
	      options.placeholderChar = this.props.placeholderChar;
	    }
	    this.mask = new InputMask(options);
	  },

	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	    if (this.props.value !== nextProps.value) {
	      this.mask.setValue(nextProps.value);
	    }
	    if (this.props.mask !== nextProps.mask) {
	      this.mask.setPattern(nextProps.mask, { value: this.mask.getRawValue() });
	    }
	  },

	  componentWillUpdate: function componentWillUpdate(nextProps, nextState) {
	    if (nextProps.mask !== this.props.mask) {
	      this._updatePattern(nextProps);
	    }
	  },

	  componentDidUpdate: function componentDidUpdate(prevProps) {
	    if (prevProps.mask !== this.props.mask && this.mask.selection.start) {
	      this._updateInputSelection();
	    }
	  },

	  _updatePattern: function _updatePattern(props) {
	    this.mask.setPattern(props.mask, {
	      value: this.mask.getRawValue(),
	      selection: getSelection(this.input)
	    });
	  },

	  _updateMaskSelection: function _updateMaskSelection() {
	    this.mask.selection = getSelection(this.input);
	  },

	  _updateInputSelection: function _updateInputSelection() {
	    setSelection(this.input, this.mask.selection);
	  },

	  _onChange: function _onChange(e) {
	    // console.log('onChange', JSON.stringify(getSelection(this.input)), e.target.value)

	    var maskValue = this.mask.getValue();
	    if (e.target.value !== maskValue) {
	      // Cut or delete operations will have shortened the value
	      if (e.target.value.length < maskValue.length) {
	        var sizeDiff = maskValue.length - e.target.value.length;
	        this._updateMaskSelection();
	        this.mask.selection.end = this.mask.selection.start + sizeDiff;
	        this.mask.backspace();
	      }
	      var value = this._getDisplayValue();
	      e.target.value = value;
	      if (value) {
	        this._updateInputSelection();
	      }
	    }
	    if (this.props.onChange) {
	      this.props.onChange(e);
	    }
	  },

	  _onKeyDown: function _onKeyDown(e) {
	    // console.log('onKeyDown', JSON.stringify(getSelection(this.input)), e.key, e.target.value)

	    if (isUndo(e)) {
	      e.preventDefault();
	      if (this.mask.undo()) {
	        e.target.value = this._getDisplayValue();
	        this._updateInputSelection();
	        if (this.props.onChange) {
	          this.props.onChange(e);
	        }
	      }
	      return;
	    } else if (isRedo(e)) {
	      e.preventDefault();
	      if (this.mask.redo()) {
	        e.target.value = this._getDisplayValue();
	        this._updateInputSelection();
	        if (this.props.onChange) {
	          this.props.onChange(e);
	        }
	      }
	      return;
	    }

	    if (e.key === 'Backspace') {
	      e.preventDefault();
	      this._updateMaskSelection();
	      if (this.mask.backspace()) {
	        var value = this._getDisplayValue();
	        e.target.value = value;
	        if (value) {
	          this._updateInputSelection();
	        }
	        if (this.props.onChange) {
	          this.props.onChange(e);
	        }
	      }
	    }
	  },

	  _onKeyPress: function _onKeyPress(e) {
	    // console.log('onKeyPress', JSON.stringify(getSelection(this.input)), e.key, e.target.value)

	    // Ignore modified key presses
	    // Ignore enter key to allow form submission
	    if (e.metaKey || e.altKey || e.ctrlKey || e.key === 'Enter') {
	      return;
	    }

	    e.preventDefault();
	    this._updateMaskSelection();
	    if (this.mask.input(e.key)) {
	      e.target.value = this.mask.getValue();
	      this._updateInputSelection();
	      if (this.props.onChange) {
	        this.props.onChange(e);
	      }
	    }
	  },

	  _onPaste: function _onPaste(e) {
	    // console.log('onPaste', JSON.stringify(getSelection(this.input)), e.clipboardData.getData('Text'), e.target.value)

	    e.preventDefault();
	    this._updateMaskSelection();
	    // getData value needed for IE also works in FF & Chrome
	    if (this.mask.paste(e.clipboardData.getData('Text'))) {
	      e.target.value = this.mask.getValue();
	      // Timeout needed for IE
	      setTimeout(this._updateInputSelection, 0);
	      if (this.props.onChange) {
	        this.props.onChange(e);
	      }
	    }
	  },

	  _getDisplayValue: function _getDisplayValue() {
	    var value = this.mask.getValue();
	    return value === this.mask.emptyValue ? '' : value;
	  },

	  focus: function focus() {
	    this.input.focus();
	  },

	  blur: function blur() {
	    this.input.blur();
	  },

	  render: function render() {
	    var _this = this;

	    var _props = this.props;
	    var mask = _props.mask;
	    var formatCharacters = _props.formatCharacters;
	    var size = _props.size;
	    var placeholder = _props.placeholder;
	    var placeholderChar = _props.placeholderChar;

	    var props = _objectWithoutProperties(_props, ['mask', 'formatCharacters', 'size', 'placeholder', 'placeholderChar']);

	    var patternLength = this.mask.pattern.length;
	    return React.createElement('input', _extends({}, props, {
	      ref: function (r) {
	        return _this.input = r;
	      },
	      maxLength: patternLength,
	      onChange: this._onChange,
	      onKeyDown: this._onKeyDown,
	      onKeyPress: this._onKeyPress,
	      onPaste: this._onPaste,
	      placeholder: placeholder || this.mask.emptyValue,
	      size: size || patternLength,
	      value: this._getDisplayValue()
	    }));
	  }
	});

	module.exports = MaskedInput;

/***/ },
/* 1 */
/***/ function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 */

	'use strict';

	var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);

	/**
	 * Simple, lightweight module assisting with the detection and context of
	 * Worker. Helps avoid circular dependencies and allows code to reason about
	 * whether or not they are in a Worker, even if they never include the main
	 * `ReactWorker` dependency.
	 */
	var ExecutionEnvironment = {

	  canUseDOM: canUseDOM,

	  canUseWorkers: typeof Worker !== 'undefined',

	  canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),

	  canUseViewport: canUseDOM && !!window.screen,

	  isInWorker: !canUseDOM // For now, this is true - might change in the future.

	};

	module.exports = ExecutionEnvironment;

/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * 
	 */

	var isTextNode = __webpack_require__(6);

	/*eslint-disable no-bitwise */

	/**
	 * Checks if a given DOM node contains or is another DOM node.
	 */
	function containsNode(outerNode, innerNode) {
	  if (!outerNode || !innerNode) {
	    return false;
	  } else if (outerNode === innerNode) {
	    return true;
	  } else if (isTextNode(outerNode)) {
	    return false;
	  } else if (isTextNode(innerNode)) {
	    return containsNode(outerNode, innerNode.parentNode);
	  } else if ('contains' in outerNode) {
	    return outerNode.contains(innerNode);
	  } else if (outerNode.compareDocumentPosition) {
	    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
	  } else {
	    return false;
	  }
	}

	module.exports = containsNode;

/***/ },
/* 3 */
/***/ function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 */

	'use strict';

	/**
	 * @param {DOMElement} node input/textarea to focus
	 */

	function focusNode(node) {
	  // IE8 can throw "Can't move focus to the control because it is invisible,
	  // not enabled, or of a type that does not accept the focus." for all kinds of
	  // reasons that are too expensive and fragile to test.
	  try {
	    node.focus();
	  } catch (e) {}
	}

	module.exports = focusNode;

/***/ },
/* 4 */
/***/ function(module, exports) {

	'use strict';

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @typechecks
	 */

	/* eslint-disable fb-www/typeof-undefined */

	/**
	 * Same as document.activeElement but wraps in a try-catch block. In IE it is
	 * not safe to call document.activeElement if there is nothing focused.
	 *
	 * The activeElement will be null only if the document or document body is not
	 * yet defined.
	 */
	function getActiveElement() /*?DOMElement*/{
	  if (typeof document === 'undefined') {
	    return null;
	  }
	  try {
	    return document.activeElement || document.body;
	  } catch (e) {
	    return document.body;
	  }
	}

	module.exports = getActiveElement;

/***/ },
/* 5 */
/***/ function(module, exports) {

	'use strict';

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @typechecks
	 */

	/**
	 * @param {*} object The object to check.
	 * @return {boolean} Whether or not the object is a DOM node.
	 */
	function isNode(object) {
	  return !!(object && (typeof Node === 'function' ? object instanceof Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));
	}

	module.exports = isNode;

/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @typechecks
	 */

	var isNode = __webpack_require__(5);

	/**
	 * @param {*} object The object to check.
	 * @return {boolean} Whether or not the object is a DOM text node.
	 */
	function isTextNode(object) {
	  return isNode(object) && object.nodeType == 3;
	}

	module.exports = isTextNode;

/***/ },
/* 7 */
/***/ function(module, exports) {

	'use strict'

	function extend(dest, src) {
	  if (src) {
	    var props = Object.keys(src)
	    for (var i = 0, l = props.length; i < l ; i++) {
	      dest[props[i]] = src[props[i]]
	    }
	  }
	  return dest
	}

	function copy(obj) {
	  return extend({}, obj)
	}

	/**
	 * Merge an object defining format characters into the defaults.
	 * Passing null/undefined for en existing format character removes it.
	 * Passing a definition for an existing format character overrides it.
	 * @param {?Object} formatCharacters.
	 */
	function mergeFormatCharacters(formatCharacters) {
	  var merged = copy(DEFAULT_FORMAT_CHARACTERS)
	  if (formatCharacters) {
	    var chars = Object.keys(formatCharacters)
	    for (var i = 0, l = chars.length; i < l ; i++) {
	      var char = chars[i]
	      if (formatCharacters[char] == null) {
	        delete merged[char]
	      }
	      else {
	        merged[char] = formatCharacters[char]
	      }
	    }
	  }
	  return merged
	}

	var ESCAPE_CHAR = '\\'

	var DIGIT_RE = /^\d$/
	var LETTER_RE = /^[A-Za-z]$/
	var ALPHANNUMERIC_RE = /^[\dA-Za-z]$/

	var DEFAULT_PLACEHOLDER_CHAR = '_'
	var DEFAULT_FORMAT_CHARACTERS = {
	  '*': {
	    validate: function(char) { return ALPHANNUMERIC_RE.test(char) }
	  },
	  '1': {
	    validate: function(char) { return DIGIT_RE.test(char) }
	  },
	  'a': {
	    validate: function(char) { return LETTER_RE.test(char) }
	  },
	  'A': {
	    validate: function(char) { return LETTER_RE.test(char) },
	    transform: function(char) { return char.toUpperCase() }
	  },
	  '#': {
	    validate: function(char) { return ALPHANNUMERIC_RE.test(char) },
	    transform: function(char) { return char.toUpperCase() }
	  }
	}

	/**
	 * @param {string} source
	 * @patam {?Object} formatCharacters
	 */
	function Pattern(source, formatCharacters, placeholderChar) {
	  if (!(this instanceof Pattern)) {
	    return new Pattern(source, formatCharacters, placeholderChar)
	  }

	  /** Placeholder character */
	  this.placeholderChar = placeholderChar || DEFAULT_PLACEHOLDER_CHAR
	  /** Format character definitions. */
	  this.formatCharacters = formatCharacters || DEFAULT_FORMAT_CHARACTERS
	  /** Pattern definition string with escape characters. */
	  this.source = source
	  /** Pattern characters after escape characters have been processed. */
	  this.pattern = []
	  /** Length of the pattern after escape characters have been processed. */
	  this.length = 0
	  /** Index of the first editable character. */
	  this.firstEditableIndex = null
	  /** Index of the last editable character. */
	  this.lastEditableIndex = null

	  /** Lookup for indices of editable characters in the pattern. */
	  this._editableIndices = {}

	  this._parse()
	}

	Pattern.prototype._parse = function parse() {
	  var sourceChars = this.source.split('')
	  var patternIndex = 0
	  var pattern = []

	  for (var i = 0, l = sourceChars.length; i < l; i++) {
	    var char = sourceChars[i]
	    if (char === ESCAPE_CHAR) {
	      if (i === l - 1) {
	        throw new Error('InputMask: pattern ends with a raw ' + ESCAPE_CHAR)
	      }
	      char = sourceChars[++i]
	    }
	    else if (char in this.formatCharacters) {
	      if (this.firstEditableIndex === null) {
	        this.firstEditableIndex = patternIndex
	      }
	      this.lastEditableIndex = patternIndex
	      this._editableIndices[patternIndex] = true
	    }

	    pattern.push(char)
	    patternIndex++
	  }

	  if (this.firstEditableIndex === null) {
	    throw new Error(
	      'InputMask: pattern "' + this.source + '" does not contain any editable characters.'
	    )
	  }

	  this.pattern = pattern
	  this.length = pattern.length
	}

	/**
	 * @param {Array<string>} value
	 * @return {Array<string>}
	 */
	Pattern.prototype.formatValue = function format(value) {
	  var valueBuffer = new Array(this.length)
	  var valueIndex = 0

	  for (var i = 0, l = this.length; i < l ; i++) {
	    if (this.isEditableIndex(i)) {
	      valueBuffer[i] = (value.length > valueIndex && this.isValidAtIndex(value[valueIndex], i)
	                        ? this.transform(value[valueIndex], i)
	                        : this.placeholderChar)
	      valueIndex++
	    }
	    else {
	      valueBuffer[i] = this.pattern[i]
	      // Also allow the value to contain static values from the pattern by
	      // advancing its index.
	      if (value.length > valueIndex && value[valueIndex] === this.pattern[i]) {
	        valueIndex++
	      }
	    }
	  }

	  return valueBuffer
	}

	/**
	 * @param {number} index
	 * @return {boolean}
	 */
	Pattern.prototype.isEditableIndex = function isEditableIndex(index) {
	  return !!this._editableIndices[index]
	}

	/**
	 * @param {string} char
	 * @param {number} index
	 * @return {boolean}
	 */
	Pattern.prototype.isValidAtIndex = function isValidAtIndex(char, index) {
	  return this.formatCharacters[this.pattern[index]].validate(char)
	}

	Pattern.prototype.transform = function transform(char, index) {
	  var format = this.formatCharacters[this.pattern[index]]
	  return typeof format.transform == 'function' ? format.transform(char) : char
	}

	function InputMask(options) {
	  if (!(this instanceof InputMask)) { return new InputMask(options) }

	  options = extend({
	    formatCharacters: null,
	    pattern: null,
	    placeholderChar: DEFAULT_PLACEHOLDER_CHAR,
	    selection: {start: 0, end: 0},
	    value: ''
	  }, options)

	  if (options.pattern == null) {
	    throw new Error('InputMask: you must provide a pattern.')
	  }

	  if (options.placeholderChar.length !== 1) {
	    throw new Error('InputMask: placeholderChar should be a single character.')
	  }

	  this.placeholderChar = options.placeholderChar
	  this.formatCharacters = mergeFormatCharacters(options.formatCharacters)
	  this.setPattern(options.pattern, {
	    value: options.value,
	    selection: options.selection
	  })
	}

	// Editing

	/**
	 * Applies a single character of input based on the current selection.
	 * @param {string} char
	 * @return {boolean} true if a change has been made to value or selection as a
	 *   result of the input, false otherwise.
	 */
	InputMask.prototype.input = function input(char) {
	  // Ignore additional input if the cursor's at the end of the pattern
	  if (this.selection.start === this.selection.end &&
	      this.selection.start === this.pattern.length) {
	    return false
	  }

	  var selectionBefore = copy(this.selection)
	  var valueBefore = this.getValue()

	  var inputIndex = this.selection.start

	  // If the cursor or selection is prior to the first editable character, make
	  // sure any input given is applied to it.
	  if (inputIndex < this.pattern.firstEditableIndex) {
	    inputIndex = this.pattern.firstEditableIndex
	  }

	  // Bail out or add the character to input
	  if (this.pattern.isEditableIndex(inputIndex)) {
	    if (!this.pattern.isValidAtIndex(char, inputIndex)) {
	      return false
	    }
	    this.value[inputIndex] = this.pattern.transform(char, inputIndex)
	  }

	  // If multiple characters were selected, blank the remainder out based on the
	  // pattern.
	  var end = this.selection.end - 1
	  while (end > inputIndex) {
	    if (this.pattern.isEditableIndex(end)) {
	      this.value[end] = this.placeholderChar
	    }
	    end--
	  }

	  // Advance the cursor to the next character
	  this.selection.start = this.selection.end = inputIndex + 1

	  // Skip over any subsequent static characters
	  while (this.pattern.length > this.selection.start &&
	         !this.pattern.isEditableIndex(this.selection.start)) {
	    this.selection.start++
	    this.selection.end++
	  }

	  // History
	  if (this._historyIndex != null) {
	    // Took more input after undoing, so blow any subsequent history away
	    console.log('splice(', this._historyIndex, this._history.length - this._historyIndex, ')')
	    this._history.splice(this._historyIndex, this._history.length - this._historyIndex)
	    this._historyIndex = null
	  }
	  if (this._lastOp !== 'input' ||
	      selectionBefore.start !== selectionBefore.end ||
	      this._lastSelection !== null && selectionBefore.start !== this._lastSelection.start) {
	    this._history.push({value: valueBefore, selection: selectionBefore, lastOp: this._lastOp})
	  }
	  this._lastOp = 'input'
	  this._lastSelection = copy(this.selection)

	  return true
	}

	/**
	 * Attempts to delete from the value based on the current cursor position or
	 * selection.
	 * @return {boolean} true if the value or selection changed as the result of
	 *   backspacing, false otherwise.
	 */
	InputMask.prototype.backspace = function backspace() {
	  // If the cursor is at the start there's nothing to do
	  if (this.selection.start === 0 && this.selection.end === 0) {
	    return false
	  }

	  var selectionBefore = copy(this.selection)
	  var valueBefore = this.getValue()

	  // No range selected - work on the character preceding the cursor
	  if (this.selection.start === this.selection.end) {
	    if (this.pattern.isEditableIndex(this.selection.start - 1)) {
	      this.value[this.selection.start - 1] = this.placeholderChar
	    }
	    this.selection.start--
	    this.selection.end--
	  }
	  // Range selected - delete characters and leave the cursor at the start of the selection
	  else {
	    var end = this.selection.end - 1
	    while (end >= this.selection.start) {
	      if (this.pattern.isEditableIndex(end)) {
	        this.value[end] = this.placeholderChar
	      }
	      end--
	    }
	    this.selection.end = this.selection.start
	  }

	  // History
	  if (this._historyIndex != null) {
	    // Took more input after undoing, so blow any subsequent history away
	    this._history.splice(this._historyIndex, this._history.length - this._historyIndex)
	  }
	  if (this._lastOp !== 'backspace' ||
	      selectionBefore.start !== selectionBefore.end ||
	      this._lastSelection !== null && selectionBefore.start !== this._lastSelection.start) {
	    this._history.push({value: valueBefore, selection: selectionBefore, lastOp: this._lastOp})
	  }
	  this._lastOp = 'backspace'
	  this._lastSelection = copy(this.selection)

	  return true
	}

	/**
	 * Attempts to paste a string of input at the current cursor position or over
	 * the top of the current selection.
	 * Invalid content at any position will cause the paste to be rejected, and it
	 * may contain static parts of the mask's pattern.
	 * @param {string} input
	 * @return {boolean} true if the paste was successful, false otherwise.
	 */
	InputMask.prototype.paste = function paste(input) {
	  // This is necessary because we're just calling input() with each character
	  // and rolling back if any were invalid, rather than checking up-front.
	  var initialState = {
	    value: this.value.slice(),
	    selection: copy(this.selection),
	    _lastOp: this._lastOp,
	    _history: this._history.slice(),
	    _historyIndex: this._historyIndex,
	    _lastSelection: copy(this._lastSelection)
	  }

	  // If there are static characters at the start of the pattern and the cursor
	  // or selection is within them, the static characters must match for a valid
	  // paste.
	  if (this.selection.start < this.pattern.firstEditableIndex) {
	    for (var i = 0, l = this.pattern.firstEditableIndex - this.selection.start; i < l; i++) {
	      if (input.charAt(i) !== this.pattern.pattern[i]) {
	        return false
	      }
	    }

	    // Continue as if the selection and input started from the editable part of
	    // the pattern.
	    input = input.substring(this.pattern.firstEditableIndex - this.selection.start)
	    this.selection.start = this.pattern.firstEditableIndex
	  }

	  for (i = 0, l = input.length;
	       i < l && this.selection.start <= this.pattern.lastEditableIndex;
	       i++) {
	    var valid = this.input(input.charAt(i))
	    // Allow static parts of the pattern to appear in pasted input - they will
	    // already have been stepped over by input(), so verify that the value
	    // deemed invalid by input() was the expected static character.
	    if (!valid) {
	      if (this.selection.start > 0) {
	        // XXX This only allows for one static character to be skipped
	        var patternIndex = this.selection.start - 1
	        if (!this.pattern.isEditableIndex(patternIndex) &&
	            input.charAt(i) === this.pattern.pattern[patternIndex]) {
	          continue
	        }
	      }
	      extend(this, initialState)
	      return false
	    }
	  }

	  return true
	}

	// History

	InputMask.prototype.undo = function undo() {
	  // If there is no history, or nothing more on the history stack, we can't undo
	  if (this._history.length === 0 || this._historyIndex === 0) {
	    return false
	  }

	  var historyItem
	  if (this._historyIndex == null) {
	    // Not currently undoing, set up the initial history index
	    this._historyIndex = this._history.length - 1
	    historyItem = this._history[this._historyIndex]
	    // Add a new history entry if anything has changed since the last one, so we
	    // can redo back to the initial state we started undoing from.
	    var value = this.getValue()
	    if (historyItem.value !== value ||
	        historyItem.selection.start !== this.selection.start ||
	        historyItem.selection.end !== this.selection.end) {
	      this._history.push({value: value, selection: copy(this.selection), lastOp: this._lastOp, startUndo: true})
	    }
	  }
	  else {
	    historyItem = this._history[--this._historyIndex]
	  }

	  this.value = historyItem.value.split('')
	  this.selection = historyItem.selection
	  this._lastOp = historyItem.lastOp
	  return true
	}

	InputMask.prototype.redo = function redo() {
	  if (this._history.length === 0 || this._historyIndex == null) {
	    return false
	  }
	  var historyItem = this._history[++this._historyIndex]
	  // If this is the last history item, we're done redoing
	  if (this._historyIndex === this._history.length - 1) {
	    this._historyIndex = null
	    // If the last history item was only added to start undoing, remove it
	    if (historyItem.startUndo) {
	      this._history.pop()
	    }
	  }
	  this.value = historyItem.value.split('')
	  this.selection = historyItem.selection
	  this._lastOp = historyItem.lastOp
	  return true
	}

	// Getters & setters

	InputMask.prototype.setPattern = function setPattern(pattern, options) {
	  options = extend({
	    selection: {start: 0, end: 0},
	    value: ''
	  }, options)
	  this.pattern = new Pattern(pattern, this.formatCharacters, this.placeholderChar)
	  this.setValue(options.value)
	  this.emptyValue = this.pattern.formatValue([]).join('')
	  this.selection = options.selection
	  this._resetHistory()
	}

	InputMask.prototype.setSelection = function setSelection(selection) {
	  this.selection = copy(selection)
	  if (this.selection.start === this.selection.end) {
	    if (this.selection.start < this.pattern.firstEditableIndex) {
	      this.selection.start = this.selection.end = this.pattern.firstEditableIndex
	      return true
	    }
	    if (this.selection.end > this.pattern.lastEditableIndex + 1) {
	      this.selection.start = this.selection.end = this.pattern.lastEditableIndex + 1
	      return true
	    }
	  }
	  return false
	}

	InputMask.prototype.setValue = function setValue(value) {
	  if (value == null) {
	    value = ''
	  }
	  this.value = this.pattern.formatValue(value.split(''))
	}

	InputMask.prototype.getValue = function getValue() {
	  return this.value.join('')
	}

	InputMask.prototype.getRawValue = function getRawValue() {
	  var rawValue = []
	  for (var i = 0; i < this.value.length; i++) {
	    if (this.pattern._editableIndices[i] === true) {
	      rawValue.push(this.value[i])
	    }
	  }
	  return rawValue.join('')
	}

	InputMask.prototype._resetHistory = function _resetHistory() {
	  this._history = []
	  this._historyIndex = null
	  this._lastOp = null
	  this._lastSelection = copy(this.selection)
	}

	InputMask.Pattern = Pattern

	module.exports = InputMask


/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule ReactDOMSelection
	 */

	'use strict';

	var ExecutionEnvironment = __webpack_require__(1);

	var getNodeForCharacterOffset = __webpack_require__(10);
	var getTextContentAccessor = __webpack_require__(11);

	/**
	 * While `isCollapsed` is available on the Selection object and `collapsed`
	 * is available on the Range object, IE11 sometimes gets them wrong.
	 * If the anchor/focus nodes and offsets are the same, the range is collapsed.
	 */
	function isCollapsed(anchorNode, anchorOffset, focusNode, focusOffset) {
	  return anchorNode === focusNode && anchorOffset === focusOffset;
	}

	/**
	 * Get the appropriate anchor and focus node/offset pairs for IE.
	 *
	 * The catch here is that IE's selection API doesn't provide information
	 * about whether the selection is forward or backward, so we have to
	 * behave as though it's always forward.
	 *
	 * IE text differs from modern selection in that it behaves as though
	 * block elements end with a new line. This means character offsets will
	 * differ between the two APIs.
	 *
	 * @param {DOMElement} node
	 * @return {object}
	 */
	function getIEOffsets(node) {
	  var selection = document.selection;
	  var selectedRange = selection.createRange();
	  var selectedLength = selectedRange.text.length;

	  // Duplicate selection so we can move range without breaking user selection.
	  var fromStart = selectedRange.duplicate();
	  fromStart.moveToElementText(node);
	  fromStart.setEndPoint('EndToStart', selectedRange);

	  var startOffset = fromStart.text.length;
	  var endOffset = startOffset + selectedLength;

	  return {
	    start: startOffset,
	    end: endOffset
	  };
	}

	/**
	 * @param {DOMElement} node
	 * @return {?object}
	 */
	function getModernOffsets(node) {
	  var selection = window.getSelection && window.getSelection();

	  if (!selection || selection.rangeCount === 0) {
	    return null;
	  }

	  var anchorNode = selection.anchorNode;
	  var anchorOffset = selection.anchorOffset;
	  var focusNode = selection.focusNode;
	  var focusOffset = selection.focusOffset;

	  var currentRange = selection.getRangeAt(0);

	  // In Firefox, range.startContainer and range.endContainer can be "anonymous
	  // divs", e.g. the up/down buttons on an <input type="number">. Anonymous
	  // divs do not seem to expose properties, triggering a "Permission denied
	  // error" if any of its properties are accessed. The only seemingly possible
	  // way to avoid erroring is to access a property that typically works for
	  // non-anonymous divs and catch any error that may otherwise arise. See
	  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
	  try {
	    /* eslint-disable no-unused-expressions */
	    currentRange.startContainer.nodeType;
	    currentRange.endContainer.nodeType;
	    /* eslint-enable no-unused-expressions */
	  } catch (e) {
	    return null;
	  }

	  // If the node and offset values are the same, the selection is collapsed.
	  // `Selection.isCollapsed` is available natively, but IE sometimes gets
	  // this value wrong.
	  var isSelectionCollapsed = isCollapsed(selection.anchorNode, selection.anchorOffset, selection.focusNode, selection.focusOffset);

	  var rangeLength = isSelectionCollapsed ? 0 : currentRange.toString().length;

	  var tempRange = currentRange.cloneRange();
	  tempRange.selectNodeContents(node);
	  tempRange.setEnd(currentRange.startContainer, currentRange.startOffset);

	  var isTempRangeCollapsed = isCollapsed(tempRange.startContainer, tempRange.startOffset, tempRange.endContainer, tempRange.endOffset);

	  var start = isTempRangeCollapsed ? 0 : tempRange.toString().length;
	  var end = start + rangeLength;

	  // Detect whether the selection is backward.
	  var detectionRange = document.createRange();
	  detectionRange.setStart(anchorNode, anchorOffset);
	  detectionRange.setEnd(focusNode, focusOffset);
	  var isBackward = detectionRange.collapsed;

	  return {
	    start: isBackward ? end : start,
	    end: isBackward ? start : end
	  };
	}

	/**
	 * @param {DOMElement|DOMTextNode} node
	 * @param {object} offsets
	 */
	function setIEOffsets(node, offsets) {
	  var range = document.selection.createRange().duplicate();
	  var start, end;

	  if (offsets.end === undefined) {
	    start = offsets.start;
	    end = start;
	  } else if (offsets.start > offsets.end) {
	    start = offsets.end;
	    end = offsets.start;
	  } else {
	    start = offsets.start;
	    end = offsets.end;
	  }

	  range.moveToElementText(node);
	  range.moveStart('character', start);
	  range.setEndPoint('EndToStart', range);
	  range.moveEnd('character', end - start);
	  range.select();
	}

	/**
	 * In modern non-IE browsers, we can support both forward and backward
	 * selections.
	 *
	 * Note: IE10+ supports the Selection object, but it does not support
	 * the `extend` method, which means that even in modern IE, it's not possible
	 * to programmatically create a backward selection. Thus, for all IE
	 * versions, we use the old IE API to create our selections.
	 *
	 * @param {DOMElement|DOMTextNode} node
	 * @param {object} offsets
	 */
	function setModernOffsets(node, offsets) {
	  if (!window.getSelection) {
	    return;
	  }

	  var selection = window.getSelection();
	  var length = node[getTextContentAccessor()].length;
	  var start = Math.min(offsets.start, length);
	  var end = offsets.end === undefined ? start : Math.min(offsets.end, length);

	  // IE 11 uses modern selection, but doesn't support the extend method.
	  // Flip backward selections, so we can set with a single range.
	  if (!selection.extend && start > end) {
	    var temp = end;
	    end = start;
	    start = temp;
	  }

	  var startMarker = getNodeForCharacterOffset(node, start);
	  var endMarker = getNodeForCharacterOffset(node, end);

	  if (startMarker && endMarker) {
	    var range = document.createRange();
	    range.setStart(startMarker.node, startMarker.offset);
	    selection.removeAllRanges();

	    if (start > end) {
	      selection.addRange(range);
	      selection.extend(endMarker.node, endMarker.offset);
	    } else {
	      range.setEnd(endMarker.node, endMarker.offset);
	      selection.addRange(range);
	    }
	  }
	}

	var useIEOffsets = ExecutionEnvironment.canUseDOM && 'selection' in document && !('getSelection' in window);

	var ReactDOMSelection = {
	  /**
	   * @param {DOMElement} node
	   */
	  getOffsets: useIEOffsets ? getIEOffsets : getModernOffsets,

	  /**
	   * @param {DOMElement|DOMTextNode} node
	   * @param {object} offsets
	   */
	  setOffsets: useIEOffsets ? setIEOffsets : setModernOffsets
	};

	module.exports = ReactDOMSelection;

/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule ReactInputSelection
	 */

	'use strict';

	var ReactDOMSelection = __webpack_require__(8);

	var containsNode = __webpack_require__(2);
	var focusNode = __webpack_require__(3);
	var getActiveElement = __webpack_require__(4);

	function isInDocument(node) {
	  return containsNode(document.documentElement, node);
	}

	/**
	 * @ReactInputSelection: React input selection module. Based on Selection.js,
	 * but modified to be suitable for react and has a couple of bug fixes (doesn't
	 * assume buttons have range selections allowed).
	 * Input selection module for React.
	 */
	var ReactInputSelection = {

	  hasSelectionCapabilities: function (elem) {
	    var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
	    return nodeName && (nodeName === 'input' && elem.type === 'text' || nodeName === 'textarea' || elem.contentEditable === 'true');
	  },

	  getSelectionInformation: function () {
	    var focusedElem = getActiveElement();
	    return {
	      focusedElem: focusedElem,
	      selectionRange: ReactInputSelection.hasSelectionCapabilities(focusedElem) ? ReactInputSelection.getSelection(focusedElem) : null
	    };
	  },

	  /**
	   * @restoreSelection: If any selection information was potentially lost,
	   * restore it. This is useful when performing operations that could remove dom
	   * nodes and place them back in, resulting in focus being lost.
	   */
	  restoreSelection: function (priorSelectionInformation) {
	    var curFocusedElem = getActiveElement();
	    var priorFocusedElem = priorSelectionInformation.focusedElem;
	    var priorSelectionRange = priorSelectionInformation.selectionRange;
	    if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
	      if (ReactInputSelection.hasSelectionCapabilities(priorFocusedElem)) {
	        ReactInputSelection.setSelection(priorFocusedElem, priorSelectionRange);
	      }
	      focusNode(priorFocusedElem);
	    }
	  },

	  /**
	   * @getSelection: Gets the selection bounds of a focused textarea, input or
	   * contentEditable node.
	   * -@input: Look up selection bounds of this input
	   * -@return {start: selectionStart, end: selectionEnd}
	   */
	  getSelection: function (input) {
	    var selection;

	    if ('selectionStart' in input) {
	      // Modern browser with input or textarea.
	      selection = {
	        start: input.selectionStart,
	        end: input.selectionEnd
	      };
	    } else if (document.selection && input.nodeName && input.nodeName.toLowerCase() === 'input') {
	      // IE8 input.
	      var range = document.selection.createRange();
	      // There can only be one selection per document in IE, so it must
	      // be in our element.
	      if (range.parentElement() === input) {
	        selection = {
	          start: -range.moveStart('character', -input.value.length),
	          end: -range.moveEnd('character', -input.value.length)
	        };
	      }
	    } else {
	      // Content editable or old IE textarea.
	      selection = ReactDOMSelection.getOffsets(input);
	    }

	    return selection || { start: 0, end: 0 };
	  },

	  /**
	   * @setSelection: Sets the selection bounds of a textarea or input and focuses
	   * the input.
	   * -@input     Set selection bounds of this input or textarea
	   * -@offsets   Object of same form that is returned from get*
	   */
	  setSelection: function (input, offsets) {
	    var start = offsets.start;
	    var end = offsets.end;
	    if (end === undefined) {
	      end = start;
	    }

	    if ('selectionStart' in input) {
	      input.selectionStart = start;
	      input.selectionEnd = Math.min(end, input.value.length);
	    } else if (document.selection && input.nodeName && input.nodeName.toLowerCase() === 'input') {
	      var range = input.createTextRange();
	      range.collapse(true);
	      range.moveStart('character', start);
	      range.moveEnd('character', end - start);
	      range.select();
	    } else {
	      ReactDOMSelection.setOffsets(input, offsets);
	    }
	  }
	};

	module.exports = ReactInputSelection;

/***/ },
/* 10 */
/***/ function(module, exports) {

	/**
	 * Copyright 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getNodeForCharacterOffset
	 */

	'use strict';

	/**
	 * Given any node return the first leaf node without children.
	 *
	 * @param {DOMElement|DOMTextNode} node
	 * @return {DOMElement|DOMTextNode}
	 */

	function getLeafNode(node) {
	  while (node && node.firstChild) {
	    node = node.firstChild;
	  }
	  return node;
	}

	/**
	 * Get the next sibling within a container. This will walk up the
	 * DOM if a node's siblings have been exhausted.
	 *
	 * @param {DOMElement|DOMTextNode} node
	 * @return {?DOMElement|DOMTextNode}
	 */
	function getSiblingNode(node) {
	  while (node) {
	    if (node.nextSibling) {
	      return node.nextSibling;
	    }
	    node = node.parentNode;
	  }
	}

	/**
	 * Get object describing the nodes which contain characters at offset.
	 *
	 * @param {DOMElement|DOMTextNode} root
	 * @param {number} offset
	 * @return {?object}
	 */
	function getNodeForCharacterOffset(root, offset) {
	  var node = getLeafNode(root);
	  var nodeStart = 0;
	  var nodeEnd = 0;

	  while (node) {
	    if (node.nodeType === 3) {
	      nodeEnd = nodeStart + node.textContent.length;

	      if (nodeStart <= offset && nodeEnd >= offset) {
	        return {
	          node: node,
	          offset: offset - nodeStart
	        };
	      }

	      nodeStart = nodeEnd;
	    }

	    node = getLeafNode(getSiblingNode(node));
	  }
	}

	module.exports = getNodeForCharacterOffset;

/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getTextContentAccessor
	 */

	'use strict';

	var ExecutionEnvironment = __webpack_require__(1);

	var contentKey = null;

	/**
	 * Gets the key used to access text content on a DOM node.
	 *
	 * @return {?string} Key used to access text content.
	 * @internal
	 */
	function getTextContentAccessor() {
	  if (!contentKey && ExecutionEnvironment.canUseDOM) {
	    // Prefer textContent to innerText because many browsers support both but
	    // SVG <text> elements don't support innerText even when <div> does.
	    contentKey = 'textContent' in document.documentElement ? 'textContent' : 'innerText';
	  }
	  return contentKey;
	}

	module.exports = getTextContentAccessor;

/***/ },
/* 12 */
/***/ function(module, exports) {

	module.exports = __WEBPACK_EXTERNAL_MODULE_12__;

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