/**
                             * Parse number submodule.
                             *
                             * @module datatype-number
                             * @submodule datatype-number-parse
                             * @for Number
                             */
                            
                            var safe = Y.Escape.regex,
                                SPACES = '\\s*';
                            
                            Y.mix(Y.namespace("Number"), {
                                /**
                                 * Returns a parsing function for the given configuration.
                                 * It uses `Y.cached` so it expects the format spec separated into
                                 * individual values.
                                 * The method further uses closure to put together and save the
                                 * regular expresssion just once in the outer function.
                                 *
                                 * @method _buildParser
                                 * @param [prefix] {String} Prefix string to be stripped out.
                                 * @param [suffix] {String} Suffix string to be stripped out.
                                 * @param [separator] {String} Thousands separator to be stripped out.
                                 * @param [decimal] {String} Decimal separator to be replaced by a dot.
                                 * @return {Function} Parsing function.
                                 * @private
                                 */
                                _buildParser: Y.cached(function (prefix, suffix, separator, decimal) {
                                    var regexBits = [],
                                        regex;
                            
                                    if (prefix) {
                                        regexBits.push('^' + SPACES + safe(prefix) + SPACES);
                                    }
                                    if (suffix) {
                                        regexBits.push(SPACES + safe(suffix) + SPACES + '$');
                                    }
                                    if (separator) {
                                        regexBits.push(safe(separator) + '(?=\\d)');
                                    }
                            
                                    regex = new RegExp('(?:' + regexBits.join('|') + ')', 'g');
                            
                                    if (decimal === '.') {
                                        decimal = null;
                                    }
                                    return function (val) {
                                        val = val.replace(regex, '');
                            
                                        return decimal ? val.replace(decimal, '.') : val;
                                    };
                                }),
                                /**
                                 * Converts data to type Number.
                                 * If a `config` argument is used, it will strip the `data` of the prefix,
                                 * the suffix and the thousands separator, if any of them are found,
                                 * replace the decimal separator by a dot and parse the resulting string.
                                 * Extra whitespace around the prefix and suffix will be ignored.
                                 *
                                 * @method parse
                                 * @param data {String | Number | Boolean} Data to convert. The following
                                 * values return as null: null, undefined, NaN, "".
                                 * @param [config] {Object} Optional configuration values, same as for [Y.Date.format](#method_format).
                                 * @param [config.prefix] {String} String to be removed from the start, like a currency designator "$"
                                 * @param [config.decimalPlaces] {Number} Ignored, it is accepted only for compatibility with [Y.Date.format](#method_format).
                                 * @param [config.decimalSeparator] {String} Decimal separator.
                                 * @param [config.thousandsSeparator] {String} Thousands separator.
                                 * @param [config.suffix] {String} String to be removed from the end of the number, like " items".
                                 * @return {Number} A number, or null.
                                 */
                            
                                parse: function(data, config) {
                                    var parser;
                            
                                    if (config && typeof data === 'string') {
                                        parser = this._buildParser(config.prefix, config.suffix, config.thousandsSeparator, config.decimalSeparator);
                            
                                        data = parser(data);
                                    }
                            
                                    if (typeof data === 'string' && Y.Lang.trim(data) !== '') {
                                        data = +data;
                                    }
                            
                                    // catch NaN and ±Infinity
                                    if (typeof data !== 'number' || !isFinite(data)) {
                                        data = null;
                                    }
                            
                                    // on the same line to get stripped for raw/min.js by build system
                                    if (data === null) { Y.log("Could not parse data to type Number", "warn", "number"); }
                            
                                    return data;
                                }
                            });
                            
                            // Add Parsers shortcut
                            Y.namespace("Parsers").number = Y.Number.parse;
                            Y.namespace("DataType");
                            Y.DataType.Number = Y.Number;