function requireIsCurrency () {
	if (hasRequiredIsCurrency) return isCurrencyExports;
	hasRequiredIsCurrency = 1;
	(function (module, exports) {

		Object.defineProperty(exports, "__esModule", {
		  value: true
		});
		exports.default = isCurrency;

		var _merge = _interopRequireDefault(requireMerge());

		var _assertString = _interopRequireDefault(requireAssertString());

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function currencyRegex(options) {
		  var decimal_digits = "\\d{".concat(options.digits_after_decimal[0], "}");
		  options.digits_after_decimal.forEach(function (digit, index) {
		    if (index !== 0) decimal_digits = "".concat(decimal_digits, "|\\d{").concat(digit, "}");
		  });
		  var symbol = "(".concat(options.symbol.replace(/\W/, function (m) {
		    return "\\".concat(m);
		  }), ")").concat(options.require_symbol ? '' : '?'),
		      negative = '-?',
		      whole_dollar_amount_without_sep = '[1-9]\\d*',
		      whole_dollar_amount_with_sep = "[1-9]\\d{0,2}(\\".concat(options.thousands_separator, "\\d{3})*"),
		      valid_whole_dollar_amounts = ['0', whole_dollar_amount_without_sep, whole_dollar_amount_with_sep],
		      whole_dollar_amount = "(".concat(valid_whole_dollar_amounts.join('|'), ")?"),
		      decimal_amount = "(\\".concat(options.decimal_separator, "(").concat(decimal_digits, "))").concat(options.require_decimal ? '' : '?');
		  var pattern = whole_dollar_amount + (options.allow_decimal || options.require_decimal ? decimal_amount : ''); // default is negative sign before symbol, but there are two other options (besides parens)

		  if (options.allow_negatives && !options.parens_for_negatives) {
		    if (options.negative_sign_after_digits) {
		      pattern += negative;
		    } else if (options.negative_sign_before_digits) {
		      pattern = negative + pattern;
		    }
		  } // South African Rand, for example, uses R 123 (space) and R-123 (no space)


		  if (options.allow_negative_sign_placeholder) {
		    pattern = "( (?!\\-))?".concat(pattern);
		  } else if (options.allow_space_after_symbol) {
		    pattern = " ?".concat(pattern);
		  } else if (options.allow_space_after_digits) {
		    pattern += '( (?!$))?';
		  }

		  if (options.symbol_after_digits) {
		    pattern += symbol;
		  } else {
		    pattern = symbol + pattern;
		  }

		  if (options.allow_negatives) {
		    if (options.parens_for_negatives) {
		      pattern = "(\\(".concat(pattern, "\\)|").concat(pattern, ")");
		    } else if (!(options.negative_sign_before_digits || options.negative_sign_after_digits)) {
		      pattern = negative + pattern;
		    }
		  } // ensure there's a dollar and/or decimal amount, and that
		  // it doesn't start with a space or a negative sign followed by a space


		  return new RegExp("^(?!-? )(?=.*\\d)".concat(pattern, "$"));
		}

		var default_currency_options = {
		  symbol: '$',
		  require_symbol: false,
		  allow_space_after_symbol: false,
		  symbol_after_digits: false,
		  allow_negatives: true,
		  parens_for_negatives: false,
		  negative_sign_before_digits: false,
		  negative_sign_after_digits: false,
		  allow_negative_sign_placeholder: false,
		  thousands_separator: ',',
		  decimal_separator: '.',
		  allow_decimal: true,
		  require_decimal: false,
		  digits_after_decimal: [2],
		  allow_space_after_digits: false
		};

		function isCurrency(str, options) {
		  (0, _assertString.default)(str);
		  options = (0, _merge.default)(options, default_currency_options);
		  return currencyRegex(options).test(str);
		}

		module.exports = exports.default;
		module.exports.default = exports.default;
} (isCurrency, isCurrencyExports));
	return isCurrencyExports;
}
Creates initial state object
for iteration over list

@param   {array|object} list - list to iterate over
@param   {function|null} sortMethod - function to use for keys sort,
                                    or `null` to keep them as is
@returns {object} - initial state object