globalize-rpk 1.7.0 → 1.7.1

package/globalize/number.js

@@ -0,0 +1,1727 @@
+/**
+ * Globalize v1.7.0
+ *
+ * https://github.com/globalizejs/globalize
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license
+ * https://jquery.org/license
+ *
+ * Date: 2021-08-02T11:53Z
+ */
+/*!
+ * Globalize v1.7.0 2021-08-02T11:53Z Released under the MIT license
+ * http://git.io/TrdQbw
+ */
+(function( root, factory ) {
+
+	// UMD returnExports
+	if ( typeof define === "function" && define.amd ) {
+
+		// AMD
+		define([
+			"cldr",
+			"../globalize",
+			"cldr/event",
+			"cldr/supplemental"
+		], factory );
+	} else if ( typeof exports === "object" ) {
+
+		// Node, CommonJS
+		module.exports = factory( require( "cldrjs" ), require( "../globalize" ) );
+	} else {
+
+		// Global
+		factory( root.Cldr, root.Globalize );
+	}
+}(this, function( Cldr, Globalize ) {
+
+var createError = Globalize._createError,
+	partsJoin = Globalize._partsJoin,
+	partsPush = Globalize._partsPush,
+	regexpEscape = Globalize._regexpEscape,
+	runtimeBind = Globalize._runtimeBind,
+	stringPad = Globalize._stringPad,
+	validateCldr = Globalize._validateCldr,
+	validateDefaultLocale = Globalize._validateDefaultLocale,
+	validateParameterPresence = Globalize._validateParameterPresence,
+	validateParameterRange = Globalize._validateParameterRange,
+	validateParameterType = Globalize._validateParameterType,
+	validateParameterTypePlainObject = Globalize._validateParameterTypePlainObject;
+
+
+var createErrorUnsupportedFeature = function( feature ) {
+	return createError( "E_UNSUPPORTED", "Unsupported {feature}.", {
+		feature: feature
+	});
+};
+
+
+
+
+var validateParameterTypeNumber = function( value, name ) {
+	validateParameterType(
+		value,
+		name,
+		value === undefined || typeof value === "number",
+		"Number"
+	);
+};
+
+
+
+
+var validateParameterTypeString = function( value, name ) {
+	validateParameterType(
+		value,
+		name,
+		value === undefined || typeof value === "string",
+		"a string"
+	);
+};
+
+
+
+
+var numberFormatterFn = function( numberToPartsFormatter ) {
+	return function numberFormatter( value ) {
+		return partsJoin( numberToPartsFormatter( value ));
+	};
+};
+
+
+
+
+/**
+ * NumberingSystem( cldr )
+ *
+ * - http://www.unicode.org/reports/tr35/tr35-numbers.html#otherNumberingSystems
+ * - http://cldr.unicode.org/index/bcp47-extension
+ * - http://www.unicode.org/reports/tr35/#u_Extension
+ */
+var numberNumberingSystem = function( cldr ) {
+	var nu = cldr.attributes[ "u-nu" ];
+
+	if ( nu ) {
+		if ( nu === "traditio" ) {
+			nu = "traditional";
+		}
+		if ( [ "native", "traditional", "finance" ].indexOf( nu ) !== -1 ) {
+
+			// Unicode locale extension `u-nu` is set using either (native, traditional or
+			// finance). So, lookup the respective locale's numberingSystem and return it.
+			return cldr.main([ "numbers/otherNumberingSystems", nu ]);
+		}
+
+		// Unicode locale extension `u-nu` is set with an explicit numberingSystem. Return it.
+		return nu;
+	}
+
+	// Return the default numberingSystem.
+	return cldr.main( "numbers/defaultNumberingSystem" );
+};
+
+
+
+
+/**
+ * Compact( name, cldr )
+ *
+ * @compactType [String] Compact mode, `short` or `long`.
+ *
+ * @cldr [Cldr instance].
+ *
+ * Return the localized compact map for the given compact mode.
+ */
+var numberCompact = function( compactType, cldr ) {
+	var maxExponent = 0;
+
+	var object = cldr.main([
+		"numbers/decimalFormats-numberSystem-" + numberNumberingSystem( cldr ),
+		compactType,
+		"decimalFormat"
+	]);
+
+	object = Object.keys( object ).reduce(function( newObject, compactKey ) {
+		var numberExponent = compactKey.split( "0" ).length - 1;
+		var pluralForm = compactKey.split( "-" )[ 2 ];
+		newObject[ numberExponent ] = newObject[ numberExponent ] || {};
+		newObject[ numberExponent ][ pluralForm ] = object[ compactKey ];
+		maxExponent = Math.max( numberExponent, maxExponent );
+		return newObject;
+	}, {});
+
+	object.maxExponent = maxExponent;
+
+	return object;
+};
+
+
+
+
+/**
+ * nuMap( cldr )
+ *
+ * @cldr [Cldr instance].
+ *
+ * Return digits map if numbering system is different than `latn`.
+ */
+var numberNumberingSystemDigitsMap = function( cldr ) {
+	var aux,
+		nu = numberNumberingSystem( cldr );
+
+	if ( nu === "latn" ) {
+		return;
+	}
+
+	aux = cldr.supplemental([ "numberingSystems", nu ]);
+
+	if ( aux._type !== "numeric" ) {
+		throw createErrorUnsupportedFeature( "`" + aux._type + "` numbering system" );
+	}
+
+	return aux._digits;
+};
+
+
+
+
+/**
+ * EBNF representation:
+ *
+ * number_pattern_re =        prefix?
+ *                            padding?
+ *                            (integer_fraction_pattern | significant_pattern)
+ *                            scientific_notation?
+ *                            suffix?
+ *
+ * prefix =                   non_number_stuff
+ *
+ * padding =                  "*" regexp(.)
+ *
+ * integer_fraction_pattern = integer_pattern
+ *                            fraction_pattern?
+ *
+ * integer_pattern =          regexp([#,]*[0,]*0+)
+ *
+ * fraction_pattern =         "." regexp(0*[0-9]*#*)
+ *
+ * significant_pattern =      regexp([#,]*@+#*)
+ *
+ * scientific_notation =      regexp(E\+?0+)
+ *
+ * suffix =                   non_number_stuff
+ *
+ * non_number_stuff =         regexp(('[^']+'|''|[^*#@0,.E])*)
+ *
+ *
+ * Regexp groups:
+ *
+ *  0: number_pattern_re
+ *  1: prefix
+ *  2: -
+ *  3: -
+ *  4: padding
+ *  5: (integer_fraction_pattern | significant_pattern)
+ *  6: integer_fraction_pattern
+ *  7: integer_pattern
+ *  8: fraction_pattern
+ *  9: significant_pattern
+ * 10: scientific_notation
+ * 11: suffix
+ * 12: -
+ */
+var numberPatternRe = ( /^(('([^']|'')*'|[^*#@0,.E])*)(\*.)?((([#,]*[0,]*0+)(\.0*[0-9]*#*)?)|([#,]*@+#*))(E\+?0+)?(('[^']+'|''|[^*#@0,.E])*)$/ );
+
+
+
+
+/**
+ * format( number, pattern )
+ *
+ * @number [Number].
+ *
+ * @pattern [String] raw pattern for numbers.
+ *
+ * Return the formatted number.
+ * ref: http://www.unicode.org/reports/tr35/tr35-numbers.html
+ */
+var numberPatternProperties = function( pattern ) {
+	var aux1, aux2, fractionPattern, integerFractionOrSignificantPattern, integerPattern,
+		maximumFractionDigits, maximumSignificantDigits, minimumFractionDigits,
+		minimumIntegerDigits, minimumSignificantDigits, padding, prefix, primaryGroupingSize,
+		roundIncrement, scientificNotation, secondaryGroupingSize, significantPattern, suffix;
+
+	pattern = pattern.match( numberPatternRe );
+	if ( !pattern ) {
+		throw new Error( "Invalid pattern: " + pattern );
+	}
+
+	prefix = pattern[ 1 ];
+	padding = pattern[ 4 ];
+	integerFractionOrSignificantPattern = pattern[ 5 ];
+	significantPattern = pattern[ 9 ];
+	scientificNotation = pattern[ 10 ];
+	suffix = pattern[ 11 ];
+
+	// Significant digit format
+	if ( significantPattern ) {
+		significantPattern.replace( /(@+)(#*)/, function( _match, minimumSignificantDigitsMatch, maximumSignificantDigitsMatch ) {
+			minimumSignificantDigits = minimumSignificantDigitsMatch.length;
+			maximumSignificantDigits = minimumSignificantDigits +
+				maximumSignificantDigitsMatch.length;
+		});
+
+	// Integer and fractional format
+	} else {
+		fractionPattern = pattern[ 8 ];
+		integerPattern = pattern[ 7 ];
+
+		if ( fractionPattern ) {
+
+			// Minimum fraction digits, and rounding.
+			fractionPattern.replace( /[0-9]+/, function( match ) {
+				minimumFractionDigits = match;
+			});
+			if ( minimumFractionDigits ) {
+				roundIncrement = +( "0." + minimumFractionDigits );
+				minimumFractionDigits = minimumFractionDigits.length;
+			} else {
+				minimumFractionDigits = 0;
+			}
+
+			// Maximum fraction digits
+			// 1: ignore decimal character
+			maximumFractionDigits = fractionPattern.length - 1; /* 1 */
+		} else {
+			minimumFractionDigits = 0;
+			maximumFractionDigits = 0;
+		}
+
+		// Minimum integer digits
+		integerPattern.replace( /0+$/, function( match ) {
+			minimumIntegerDigits = match.length;
+		});
+	}
+
+	// Scientific notation
+	if ( scientificNotation ) {
+		throw createErrorUnsupportedFeature({
+			feature: "scientific notation (not implemented)"
+		});
+	}
+
+	// Padding
+	if ( padding ) {
+		throw createErrorUnsupportedFeature({
+			feature: "padding (not implemented)"
+		});
+	}
+
+	// Grouping
+	if ( ( aux1 = integerFractionOrSignificantPattern.lastIndexOf( "," ) ) !== -1 ) {
+
+		// Primary grouping size is the interval between the last group separator and the end of
+		// the integer (or the end of the significant pattern).
+		aux2 = integerFractionOrSignificantPattern.split( "." )[ 0 ];
+		primaryGroupingSize = aux2.length - aux1 - 1;
+
+		// Secondary grouping size is the interval between the last two group separators.
+		if ( ( aux2 = integerFractionOrSignificantPattern.lastIndexOf( ",", aux1 - 1 ) ) !== -1 ) {
+			secondaryGroupingSize = aux1 - 1 - aux2;
+		}
+	}
+
+	// Return:
+	//  0: @prefix String
+	//  1: @padding Array [ <character>, <count> ] TODO
+	//  2: @minimumIntegerDigits non-negative integer Number value indicating the minimum integer
+	//        digits to be used. Numbers will be padded with leading zeroes if necessary.
+	//  3: @minimumFractionDigits and
+	//  4: @maximumFractionDigits are non-negative integer Number values indicating the minimum and
+	//        maximum fraction digits to be used. Numbers will be rounded or padded with trailing
+	//        zeroes if necessary.
+	//  5: @minimumSignificantDigits and
+	//  6: @maximumSignificantDigits are positive integer Number values indicating the minimum and
+	//        maximum fraction digits to be shown. Either none or both of these properties are
+	//        present; if they are, they override minimum and maximum integer and fraction digits
+	//        – the formatter uses however many integer and fraction digits are required to display
+	//        the specified number of significant digits.
+	//  7: @roundIncrement Decimal round increment or null
+	//  8: @primaryGroupingSize
+	//  9: @secondaryGroupingSize
+	// 10: @suffix String
+	return [
+		prefix,
+		padding,
+		minimumIntegerDigits,
+		minimumFractionDigits,
+		maximumFractionDigits,
+		minimumSignificantDigits,
+		maximumSignificantDigits,
+		roundIncrement,
+		primaryGroupingSize,
+		secondaryGroupingSize,
+		suffix
+	];
+};
+
+
+
+
+/**
+ * Symbol( name, cldr )
+ *
+ * @name [String] Symbol name.
+ *
+ * @cldr [Cldr instance].
+ *
+ * Return the localized symbol given its name.
+ */
+var numberSymbol = function( name, cldr ) {
+	return cldr.main([
+		"numbers/symbols-numberSystem-" + numberNumberingSystem( cldr ),
+		name
+	]);
+};
+
+
+
+
+var numberSymbolName = {
+	".": "decimal",
+	",": "group",
+	"%": "percentSign",
+	"+": "plusSign",
+	"-": "minusSign",
+	"E": "exponential",
+	"\u2030": "perMille"
+};
+
+
+
+
+/**
+ * symbolMap( cldr )
+ *
+ * @cldr [Cldr instance].
+ *
+ * Return the (localized symbol, pattern symbol) key value pair, eg. {
+ *   ".": "٫",
+ *   ",": "٬",
+ *   "%": "٪",
+ *   ...
+ * };
+ */
+var numberSymbolMap = function( cldr ) {
+	var symbol,
+		symbolMap = {};
+
+	for ( symbol in numberSymbolName ) {
+		symbolMap[ symbol ] = numberSymbol( numberSymbolName[ symbol ], cldr );
+	}
+
+	return symbolMap;
+};
+
+
+
+
+var numberTruncate = function( value ) {
+	if ( isNaN( value ) ) {
+		return NaN;
+	}
+	return Math[ value < 0 ? "ceil" : "floor" ]( value );
+};
+
+
+
+
+/**
+ * round( method )
+ *
+ * @method [String] with either "round", "ceil", "floor", or "truncate".
+ *
+ * Return function( value, incrementOrExp ):
+ *
+ *   @value [Number] eg. 123.45.
+ *
+ *   @incrementOrExp [Number] optional, eg. 0.1; or
+ *     [Object] Either { increment: <value> } or { exponent: <value> }
+ *
+ *   Return the rounded number, eg:
+ *   - round( "round" )( 123.45 ): 123;
+ *   - round( "ceil" )( 123.45 ): 124;
+ *   - round( "floor" )( 123.45 ): 123;
+ *   - round( "truncate" )( 123.45 ): 123;
+ *   - round( "round" )( 123.45, 0.1 ): 123.5;
+ *   - round( "round" )( 123.45, 10 ): 120;
+ *
+ *   Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round
+ *   Ref: #376
+ */
+var numberRound = function( method ) {
+	method = method || "round";
+	method = method === "truncate" ? numberTruncate : Math[ method ];
+
+	return function( value, incrementOrExp ) {
+		var exp, increment;
+
+		value = +value;
+
+		// If the value is not a number, return NaN.
+		if ( isNaN( value ) ) {
+			return NaN;
+		}
+
+		// Exponent given.
+		if ( typeof incrementOrExp === "object" && incrementOrExp.exponent ) {
+			exp = +incrementOrExp.exponent;
+			increment = 1;
+
+			if ( exp === 0 ) {
+				return method( value );
+			}
+
+			// If the exp is not an integer, return NaN.
+			if ( !( typeof exp === "number" && exp % 1 === 0 ) ) {
+				return NaN;
+			}
+
+		// Increment given.
+		} else {
+			increment = +incrementOrExp || 1;
+
+			if ( increment === 1 ) {
+				return method( value );
+			}
+
+			// If the increment is not a number, return NaN.
+			if ( isNaN( increment ) ) {
+				return NaN;
+			}
+
+			increment = increment.toExponential().split( "e" );
+			exp = +increment[ 1 ];
+			increment = +increment[ 0 ];
+		}
+
+		// Shift & Round
+		value = value.toString().split( "e" );
+		value[ 0 ] = +value[ 0 ] / increment;
+		value[ 1 ] = value[ 1 ] ? ( +value[ 1 ] - exp ) : -exp;
+		value = method( +( value[ 0 ] + "e" + value[ 1 ] ) );
+
+		// Shift back
+		value = value.toString().split( "e" );
+		value[ 0 ] = +value[ 0 ] * increment;
+		value[ 1 ] = value[ 1 ] ? ( +value[ 1 ] + exp ) : exp;
+		return +( value[ 0 ] + "e" + value[ 1 ] );
+	};
+};
+
+
+
+
+/**
+ * formatProperties( pattern, cldr [, options] )
+ *
+ * @pattern [String] raw pattern for numbers.
+ *
+ * @cldr [Cldr instance].
+ *
+ * @options [Object]:
+ * - minimumIntegerDigits [Number]
+ * - minimumFractionDigits, maximumFractionDigits [Number]
+ * - minimumSignificantDigits, maximumSignificantDigits [Number]
+ * - round [String] "ceil", "floor", "round" (default), or "truncate".
+ * - useGrouping [Boolean] default true.
+ *
+ * Return the processed properties that will be used in number/format.
+ * ref: http://www.unicode.org/reports/tr35/tr35-numbers.html
+ */
+var numberFormatProperties = function( pattern, cldr, options ) {
+	var negativePattern, negativePrefix, negativeProperties, negativeSuffix, positivePattern,
+		roundFn, properties;
+
+	function getOptions( attribute, propertyIndex ) {
+		if ( attribute in options ) {
+			properties[ propertyIndex ] = options[ attribute ];
+		}
+	}
+
+	options = options || {};
+	pattern = pattern.split( ";" );
+
+	positivePattern = pattern[ 0 ];
+
+	negativePattern = pattern[ 1 ] || "-" + positivePattern;
+	negativeProperties = numberPatternProperties( negativePattern );
+	negativePrefix = negativeProperties[ 0 ];
+	negativeSuffix = negativeProperties[ 10 ];
+
+	// Have runtime code to refer to numberRound() instead of including it explicitly.
+	roundFn = numberRound( options.round );
+	roundFn.generatorString = function() {
+		return "numberRound(" + ( options.round ? "\"" + options.round + "\"" : "" ) + ")";
+	};
+
+	properties = numberPatternProperties( positivePattern ).concat([
+		positivePattern,
+		negativePrefix + positivePattern + negativeSuffix,
+		negativePrefix,
+		negativeSuffix,
+		roundFn,
+		numberSymbol( "infinity", cldr ),
+		numberSymbol( "nan", cldr ),
+		numberSymbolMap( cldr ),
+		numberNumberingSystemDigitsMap( cldr )
+	]);
+
+	if ( options.compact ) {
+
+		// The compact digits number pattern is always `0+`, so override the following properties.
+		// Note: minimumIntegerDigits would actually range from `0` to `000` based on the scale of
+		// the value to be formatted, though we're always using 1 as a simplification, because the
+		// number won't be zero-padded since we chose the right format based on the scale, i.e.,
+		// we'd never see something like `003M` anyway.
+		properties[ 2 ] = 1; // minimumIntegerDigits
+		properties[ 3 ] = 0; // minimumFractionDigits
+		properties[ 4 ] = 0; // maximumFractionDigits
+		properties[ 5 ] = // minimumSignificantDigits &
+			properties[ 6 ] = undefined; // maximumSignificantDigits
+
+		properties[ 20 ] = numberCompact( options.compact, cldr );
+	}
+
+	getOptions( "minimumIntegerDigits", 2 );
+	getOptions( "minimumFractionDigits", 3 );
+	getOptions( "maximumFractionDigits", 4 );
+	getOptions( "minimumSignificantDigits", 5 );
+	getOptions( "maximumSignificantDigits", 6 );
+
+	// Grouping separators
+	if ( options.useGrouping === false ) {
+		properties[ 8 ] = null;
+	}
+
+	// Normalize number of digits if only one of either minimumFractionDigits or
+	// maximumFractionDigits is passed in as an option
+	if ( "minimumFractionDigits" in options && !( "maximumFractionDigits" in options ) ) {
+
+		// maximumFractionDigits = Math.max( minimumFractionDigits, maximumFractionDigits );
+		properties[ 4 ] = Math.max( properties[ 3 ], properties[ 4 ] );
+	} else if ( !( "minimumFractionDigits" in options ) &&
+			"maximumFractionDigits" in options ) {
+
+		// minimumFractionDigits = Math.min( minimumFractionDigits, maximumFractionDigits );
+		properties[ 3 ] = Math.min( properties[ 3 ], properties[ 4 ] );
+	}
+
+	// Return:
+	// 0-10: see number/pattern-properties.
+	// 11: @positivePattern [String] Positive pattern.
+	// 12: @negativePattern [String] Negative pattern.
+	// 13: @negativePrefix [String] Negative prefix.
+	// 14: @negativeSuffix [String] Negative suffix.
+	// 15: @round [Function] Round function.
+	// 16: @infinitySymbol [String] Infinity symbol.
+	// 17: @nanSymbol [String] NaN symbol.
+	// 18: @symbolMap [Object] A bunch of other symbols.
+	// 19: @nuDigitsMap [Array] Digits map if numbering system is different than `latn`.
+	// 20: @compactMap [Object] Map of per-digit-count format patterns for specified compact mode.
+	return properties;
+};
+
+
+
+
+/**
+ * Generated by:
+ *
+ * var regenerate = require( "regenerate" );
+ * var formatSymbols = require( "@unicode/unicode-13.0.0/General_Category/Format/symbols" );
+ * regenerate().add( formatSymbols ).toString();
+ *
+ * https://github.com/mathiasbynens/regenerate
+ * https://github.com/node-unicode/unicode-13.0.0
+ */
+var regexpCfG = /[\xAD\u0600-\u0605\u061C\u06DD\u070F\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB]|\uD804[\uDCBD\uDCCD]|\uD80D[\uDC30-\uDC38]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]/g;
+
+
+
+
+/**
+ * Generated by:
+ *
+ * var regenerate = require( "regenerate" );
+ * var dashSymbols = require( "https://github.com/node-unicode/unicode-13.0.0/General_Category/Dash_Punctuation/symbols" );
+ * regenerate().add( dashSymbols ).toString();
+ *
+ * https://github.com/mathiasbynens/regenerate
+ * https://github.com/node-unicode/unicode-13.0.0
+ *
+ * NOTE: In addition to [:dash:],  the below includes MINUS SIGN U+2212.
+ */
+var regexpDashG = /[\x2D\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D\u2212]|\uD803\uDEAD/g;
+
+
+
+
+/**
+ * Generated by:
+ *
+ * var regenerate = require( "regenerate" );
+ * var spaceSeparatorSymbols = require( "@unicode/unicode-13.0.0/General_Category/Space_Separator/symbols" );
+ * regenerate().add( spaceSeparatorSymbols ).toString();
+ *
+ * https://github.com/mathiasbynens/regenerate
+ * https://github.com/node-unicode/unicode-13.0.0
+ */
+var regexpZsG = /[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/g;
+
+
+
+
+/**
+ * Loose Matching:
+ * - Ignore all format characters, which includes RLM, LRM or ALM used to control BIDI
+ *   formatting.
+ * - Map all characters in [:Zs:] to U+0020 SPACE;
+ * - Map all characters in [:Dash:] to U+002D HYPHEN-MINUS;
+ */
+var looseMatching = function( value ) {
+	return value
+		.replace( regexpCfG, "" )
+		.replace( regexpDashG, "-" )
+		.replace( regexpZsG, " " );
+};
+
+
+
+
+/**
+ * parse( value, properties )
+ *
+ * @value [String].
+ *
+ * @properties [Object] Parser properties is a reduced pre-processed cldr
+ * data set returned by numberParserProperties().
+ *
+ * Return the parsed Number (including Infinity) or NaN when value is invalid.
+ * ref: http://www.unicode.org/reports/tr35/tr35-numbers.html
+ */
+var numberParse = function( value, properties ) {
+	var grammar, invertedNuDigitsMap, invertedSymbolMap, negative, number, prefix, prefixNSuffix,
+		suffix, tokenizer, valid;
+
+	// Grammar:
+	// - Value <=           NaN | PositiveNumber | NegativeNumber
+	// - PositiveNumber <=  PositivePrefix NumberOrInf PositiveSufix
+	// - NegativeNumber <=  NegativePrefix NumberOrInf
+	// - NumberOrInf <=     Number | Inf
+	grammar = [
+		[ "nan" ],
+		[ "prefix", "infinity", "suffix" ],
+		[ "prefix", "number", "suffix" ],
+		[ "negativePrefix", "infinity", "negativeSuffix" ],
+		[ "negativePrefix", "number", "negativeSuffix" ]
+	];
+
+	invertedSymbolMap = properties[ 0 ];
+	invertedNuDigitsMap = properties[ 1 ] || {};
+	tokenizer = properties[ 2 ];
+
+	value = looseMatching( value );
+
+	function parse( type ) {
+		return function( lexeme ) {
+
+			// Reverse localized symbols and numbering system.
+			lexeme = lexeme.split( "" ).map(function( character ) {
+				return invertedSymbolMap[ character ] ||
+					invertedNuDigitsMap[ character ] ||
+					character;
+			}).join( "" );
+
+			switch ( type ) {
+				case "infinity":
+					number = Infinity;
+					break;
+
+				case "nan":
+					number = NaN;
+					break;
+
+				case "number":
+
+					// Remove grouping separators.
+					lexeme = lexeme.replace( /,/g, "" );
+
+					number = +lexeme;
+					break;
+
+				case "prefix":
+				case "negativePrefix":
+					prefix = lexeme;
+					break;
+
+				case "suffix":
+					suffix = lexeme;
+					break;
+
+				case "negativeSuffix":
+					suffix = lexeme;
+					negative = true;
+					break;
+
+				// This should never be reached.
+				default:
+					throw new Error( "Internal error" );
+			}
+			return "";
+		};
+	}
+
+	function tokenizeNParse( _value, grammar ) {
+		return grammar.some(function( statement ) {
+			var value = _value;
+
+			// The whole grammar statement should be used (i.e., .every() return true) and value be
+			// entirely consumed (i.e., !value.length).
+			return statement.every(function( type ) {
+				if ( value.match( tokenizer[ type ] ) === null ) {
+					return false;
+				}
+
+				// Consume and parse it.
+				value = value.replace( tokenizer[ type ], parse( type ) );
+				return true;
+			}) && !value.length;
+		});
+	}
+
+	valid = tokenizeNParse( value, grammar );
+
+	// NaN
+	if ( !valid || isNaN( number ) ) {
+		return NaN;
+	}
+
+	prefixNSuffix = "" + prefix + suffix;
+
+	// Percent
+	if ( prefixNSuffix.indexOf( "%" ) !== -1 ) {
+		number /= 100;
+
+	// Per mille
+	} else if ( prefixNSuffix.indexOf( "\u2030" ) !== -1 ) {
+		number /= 1000;
+	}
+
+	// Negative number
+	if ( negative ) {
+		number *= -1;
+	}
+
+	return number;
+};
+
+
+
+
+var numberParserFn = function( properties ) {
+	return function numberParser( value ) {
+		validateParameterPresence( value, "value" );
+		validateParameterTypeString( value, "value" );
+
+		return numberParse( value, properties );
+	};
+
+};
+
+
+
+
+/**
+ * symbolMap( cldr )
+ *
+ * @cldr [Cldr instance].
+ *
+ * Return the (localized symbol, pattern symbol) key value pair, eg. {
+ *   "٫": ".",
+ *   "٬": ",",
+ *   "٪": "%",
+ *   ...
+ * };
+ */
+var numberSymbolInvertedMap = function( cldr ) {
+	var symbol,
+		symbolMap = {};
+
+	for ( symbol in numberSymbolName ) {
+		symbolMap[ numberSymbol( numberSymbolName[ symbol ], cldr ) ] = symbol;
+	}
+
+	return symbolMap;
+};
+
+
+
+
+/**
+ * objectMap( object, fn)
+ *
+ * - object
+ *
+ * - fn( pair ) => pair
+ */
+var objectMap = function( object, fn ) {
+	return Object.keys( object ).map(function( key ) {
+		return fn([ key, object[ key ] ]);
+	}).reduce(function( object, pair ) {
+		object[ pair[ 0 ] ] = pair[ 1 ];
+		return object;
+	}, {});
+};
+
+
+
+
+/**
+ * removeLiteralQuotes( string )
+ *
+ * Return:
+ * - `'` if input string is `''`.
+ * - `o'clock` if input string is `'o''clock'`.
+ * - `foo` if input string is `foo`, i.e., return the same value in case it isn't a single-quoted
+ *   string.
+ */
+var removeLiteralQuotes = function( string ) {
+	if ( string[ 0 ] + string[ string.length - 1 ] !== "''" ) {
+		return string;
+	}
+	if ( string === "''" ) {
+		return "'";
+	}
+	return string.replace( /''/g, "'" ).slice( 1, -1 );
+};
+
+
+
+
+/**
+ * parseProperties( pattern, cldr )
+ *
+ * @pattern [String] raw pattern for numbers.
+ *
+ * @cldr [Cldr instance].
+ *
+ * Return parser properties, used to feed parser function.
+ *
+ * TODO:
+ * - Scientific_notation;
+ * - Padding;
+ */
+var numberParseProperties = function( pattern, cldr, options ) {
+	var aux, decimalSymbolRe, digitsRe, groupingSeparatorRe, infinitySymbol, invertedNuDigitsMap,
+		invertedSymbolMap, maximumFractionDigits, maximumSignificantDigits,
+		minimumSignificantDigits, nanSymbol, negativePrefix, negativeSuffix, nuDigitsMap,
+		numberTokenizer, prefix, primaryGroupingSize, secondaryGroupingSize, suffix, symbolMap,
+		formatProperties = numberFormatProperties( pattern, cldr, options );
+
+	prefix = looseMatching( formatProperties[ 0 ] );
+	maximumFractionDigits = formatProperties[ 4 ];
+	minimumSignificantDigits = formatProperties[ 5 ];
+	maximumSignificantDigits = formatProperties[ 6 ];
+	primaryGroupingSize = formatProperties[ 8 ];
+	secondaryGroupingSize = formatProperties[ 9 ];
+	suffix = looseMatching( formatProperties[ 10 ] );
+	negativePrefix = looseMatching( formatProperties[ 13 ] );
+	negativeSuffix = looseMatching( formatProperties[ 14 ] );
+	infinitySymbol = looseMatching( formatProperties[ 16 ] );
+	nanSymbol = looseMatching( formatProperties[ 17 ] );
+	symbolMap = objectMap( formatProperties[ 18 ], function( pair ) {
+		return [ pair[ 0 ], looseMatching( pair[ 1 ] ) ];
+	});
+	nuDigitsMap = formatProperties[ 19 ];
+
+	invertedSymbolMap = objectMap( numberSymbolInvertedMap( cldr ), function( pair ) {
+		return [ looseMatching( pair[ 0 ] ), pair[ 1 ] ];
+	});
+
+	digitsRe = nuDigitsMap ? "[" + nuDigitsMap + "]" : "\\d";
+	groupingSeparatorRe = regexpEscape( symbolMap[ "," ] );
+	decimalSymbolRe = regexpEscape( symbolMap[ "." ] );
+
+	if ( nuDigitsMap ) {
+		invertedNuDigitsMap = nuDigitsMap.split( "" ).reduce(function( object, localizedDigit, i ) {
+			object[ localizedDigit ] = String( i );
+			return object;
+		}, {} );
+	}
+
+	aux = [ prefix, suffix, negativePrefix, negativeSuffix ].map(function( value ) {
+		return value.replace( /('([^']|'')+'|'')|./g, function( character, literal ) {
+
+			// Literals
+			if ( literal ) {
+				return removeLiteralQuotes( literal );
+			}
+
+			// Symbols
+			character = character.replace( /[\-+E%\u2030]/, function( symbol ) {
+				return symbolMap[ symbol ];
+			});
+
+			return character;
+		});
+	});
+
+	prefix = aux[ 0 ];
+	suffix = aux[ 1 ];
+	negativePrefix = aux[ 2 ];
+	negativeSuffix = aux[ 3 ];
+
+	// Number
+	//
+	// number_re =                       integer fraction?
+	//
+	// integer =                         digits | digits_using_grouping_separators
+	//
+	// fraction =                        regexp((.\d+)?)
+	//
+	// digits =                          regexp(\d+)
+	//
+	// digits_w_grouping_separators =    digits_w_1_grouping_separators |
+	//                                   digits_w_2_grouping_separators
+	//
+	// digits_w_1_grouping_separators =  regexp(\d{1,3}(,\d{3})+)
+	//
+	// digits_w_2_grouping_separators =  regexp(\d{1,2}((,\d{2})*(,\d{3})))
+
+	// Integer part
+	numberTokenizer = digitsRe + "+";
+
+	// Grouping separators
+	if ( primaryGroupingSize ) {
+		if ( secondaryGroupingSize ) {
+			aux = digitsRe + "{1," + secondaryGroupingSize + "}((" + groupingSeparatorRe +
+				digitsRe + "{" + secondaryGroupingSize + "})*(" + groupingSeparatorRe +
+				digitsRe + "{" + primaryGroupingSize + "}))";
+		} else {
+			aux = digitsRe + "{1," + primaryGroupingSize + "}(" + groupingSeparatorRe +
+				digitsRe + "{" + primaryGroupingSize + "})+";
+		}
+		numberTokenizer = "(" + aux + "|" + numberTokenizer + ")";
+	}
+
+	// Fraction part? Only included if 1 or 2.
+	// 1: Using significant digit format.
+	// 2: Using integer and fractional format && it has a maximumFractionDigits.
+	if ( !isNaN( minimumSignificantDigits * maximumSignificantDigits ) || /* 1 */
+				maximumFractionDigits /* 2 */ ) {
+
+		// 1: Handle trailing decimal separator, e.g., `"1." => `1``.
+		aux = decimalSymbolRe + digitsRe + "+";
+		numberTokenizer = numberTokenizer + "(" + aux + "|" + decimalSymbolRe /* 1 */ + ")?" +
+
+			// Handle non-padded decimals, e.g., `".12"` => `0.12` by making the integer part
+			// optional.
+			"|(" + numberTokenizer + ")?" + aux;
+
+		numberTokenizer = "(" + numberTokenizer + ")";
+	}
+
+	// 0: @invertedSymbolMap [Object] Inverted symbol map.
+	// 1: @invertedNuDigitsMap [Object] Inverted digits map if numbering system is different than
+	//    `latn`.
+	// 2: @tokenizer [Object] Tokenizer map, used by parser to consume input.
+	return [
+		invertedSymbolMap,
+		invertedNuDigitsMap,
+		{
+			infinity: new RegExp( "^" + regexpEscape( infinitySymbol ) ),
+			nan: new RegExp( "^" + regexpEscape( nanSymbol ) ),
+			negativePrefix: new RegExp( "^" + regexpEscape( negativePrefix ) ),
+			negativeSuffix: new RegExp( "^" + regexpEscape( negativeSuffix ) ),
+			number: new RegExp( "^" + numberTokenizer ),
+			prefix: new RegExp( "^" + regexpEscape( prefix ) ),
+			suffix: new RegExp( "^" + regexpEscape( suffix ) )
+		}
+	];
+
+};
+
+
+
+
+/**
+ * Pattern( style )
+ *
+ * @style [String] "decimal" (default) or "percent".
+ *
+ * @cldr [Cldr instance].
+ */
+var numberPattern = function( style, cldr ) {
+	if ( style !== "decimal" && style !== "percent" ) {
+		throw new Error( "Invalid style" );
+	}
+
+	return cldr.main([
+		"numbers",
+		style + "Formats-numberSystem-" + numberNumberingSystem( cldr ),
+		"standard"
+	]);
+};
+
+
+
+
+/**
+ * EBNF representation:
+ *
+ * compact_pattern_re =       prefix?
+ *                            number_pattern_re
+ *                            suffix?
+ *
+ * number_pattern_re =        0+
+ *
+ * Regexp groups:
+ *
+ *  0: compact_pattern_re
+ *  1: prefix
+ *  2: number_pattern_re (the number pattern to use in compact mode)
+ *  3: suffix
+ */
+var numberCompactPatternRe = ( /^([^0]*)(0+)([^0]*)$/ );
+
+
+
+
+/**
+ * goupingSeparator( number, primaryGroupingSize, secondaryGroupingSize )
+ *
+ * @number [Number].
+ *
+ * @primaryGroupingSize [Number]
+ *
+ * @secondaryGroupingSize [Number]
+ *
+ * Return the formatted number with group separator.
+ */
+var numberFormatGroupingSeparator = function( number, primaryGroupingSize, secondaryGroupingSize ) {
+	var index,
+		currentGroupingSize = primaryGroupingSize,
+		ret = "",
+		sep = ",",
+		switchToSecondary = secondaryGroupingSize ? true : false;
+
+	number = String( number ).split( "." );
+	index = number[ 0 ].length;
+
+	while ( index > currentGroupingSize ) {
+		ret = number[ 0 ].slice( index - currentGroupingSize, index ) +
+			( ret.length ? sep : "" ) + ret;
+		index -= currentGroupingSize;
+		if ( switchToSecondary ) {
+			currentGroupingSize = secondaryGroupingSize;
+			switchToSecondary = false;
+		}
+	}
+
+	number[ 0 ] = number[ 0 ].slice( 0, index ) + ( ret.length ? sep : "" ) + ret;
+	return number.join( "." );
+};
+
+
+
+
+/**
+ * integerFractionDigits( number, minimumIntegerDigits, minimumFractionDigits,
+ * maximumFractionDigits, round, roundIncrement )
+ *
+ * @number [Number]
+ *
+ * @minimumIntegerDigits [Number]
+ *
+ * @minimumFractionDigits [Number]
+ *
+ * @maximumFractionDigits [Number]
+ *
+ * @round [Function]
+ *
+ * @roundIncrement [Function]
+ *
+ * Return the formatted integer and fraction digits.
+ */
+var numberFormatIntegerFractionDigits = function( number, minimumIntegerDigits, minimumFractionDigits, maximumFractionDigits, round,
+	roundIncrement ) {
+
+	// Fraction
+	if ( maximumFractionDigits ) {
+
+		// Rounding
+		if ( roundIncrement ) {
+			number = round( number, roundIncrement );
+
+		// Maximum fraction digits
+		} else {
+			number = round( number, { exponent: -maximumFractionDigits } );
+		}
+
+	} else {
+		number = round( number );
+	}
+
+	number = String( number );
+
+	// Maximum integer digits (post string phase)
+	if ( maximumFractionDigits && /e-/.test( number ) ) {
+
+		// Use toFixed( maximumFractionDigits ) to make sure small numbers like 1e-7 are
+		// displayed using plain digits instead of scientific notation.
+		// 1: Remove leading decimal zeros.
+		// 2: Remove leading decimal separator.
+		// Note: String() is still preferred so it doesn't mess up with a number precision
+		// unnecessarily, e.g., (123456789.123).toFixed(10) === "123456789.1229999959",
+		// String(123456789.123) === "123456789.123".
+		number = ( +number ).toFixed( maximumFractionDigits )
+			.replace( /0+$/, "" ) /* 1 */
+			.replace( /\.$/, "" ); /* 2 */
+	}
+
+	// Minimum fraction digits (post string phase)
+	if ( minimumFractionDigits ) {
+		number = number.split( "." );
+		number[ 1 ] = stringPad( number[ 1 ] || "", minimumFractionDigits, true );
+		number = number.join( "." );
+	}
+
+	// Minimum integer digits
+	if ( minimumIntegerDigits ) {
+		number = number.split( "." );
+		number[ 0 ] = stringPad( number[ 0 ], minimumIntegerDigits );
+		number = number.join( "." );
+	}
+
+	return number;
+};
+
+
+
+
+/**
+ * toPrecision( number, precision, round )
+ *
+ * @number (Number)
+ *
+ * @precision (Number) significant figures precision (not decimal precision).
+ *
+ * @round (Function)
+ *
+ * Return number.toPrecision( precision ) using the given round function.
+ */
+var numberToPrecision = function( number, precision, round ) {
+	var roundOrder;
+
+	if ( number === 0 ) {  // Fix #706
+		return number;
+	}
+
+	roundOrder = Math.ceil( Math.log( Math.abs( number ) ) / Math.log( 10 ) );
+	roundOrder -= precision;
+
+	return round( number, { exponent: roundOrder } );
+};
+
+
+
+
+/**
+ * toPrecision( number, minimumSignificantDigits, maximumSignificantDigits, round )
+ *
+ * @number [Number]
+ *
+ * @minimumSignificantDigits [Number]
+ *
+ * @maximumSignificantDigits [Number]
+ *
+ * @round [Function]
+ *
+ * Return the formatted significant digits number.
+ */
+var numberFormatSignificantDigits = function( number, minimumSignificantDigits, maximumSignificantDigits, round ) {
+	var atMinimum, atMaximum;
+
+	// Sanity check.
+	if ( minimumSignificantDigits > maximumSignificantDigits ) {
+		maximumSignificantDigits = minimumSignificantDigits;
+	}
+
+	atMinimum = numberToPrecision( number, minimumSignificantDigits, round );
+	atMaximum = numberToPrecision( number, maximumSignificantDigits, round );
+
+	// Use atMaximum only if it has more significant digits than atMinimum.
+	number = +atMinimum === +atMaximum ? atMinimum : atMaximum;
+
+	// Expand integer numbers, eg. 123e5 to 12300.
+	number = ( +number ).toString( 10 );
+
+	if ( ( /e/ ).test( number ) ) {
+		throw createErrorUnsupportedFeature({
+			feature: "integers out of (1e21, 1e-7)"
+		});
+	}
+
+	// Add trailing zeros if necessary.
+	if ( minimumSignificantDigits - number.replace( /^0+|\./g, "" ).length > 0 ) {
+		number = number.split( "." );
+		number[ 1 ] = stringPad( number[ 1 ] || "", minimumSignificantDigits - number[ 0 ].replace( /^0+/, "" ).length, true );
+		number = number.join( "." );
+	}
+
+	return number;
+};
+
+
+
+
+/**
+ * format( number, properties )
+ *
+ * @number [Number].
+ *
+ * @properties [Object] Output of number/format-properties.
+ *
+ * Return the formatted number.
+ * ref: http://www.unicode.org/reports/tr35/tr35-numbers.html
+ */
+var numberFormat = function( number, properties, pluralGenerator ) {
+	var aux, compactMap, infinitySymbol, maximumFractionDigits, maximumSignificantDigits,
+		minimumFractionDigits, minimumIntegerDigits, minimumSignificantDigits, nanSymbol,
+		nuDigitsMap, prefix, primaryGroupingSize, pattern, round, roundIncrement,
+		secondaryGroupingSize, stringToParts, suffix, symbolMap;
+
+	minimumIntegerDigits = properties[ 2 ];
+	minimumFractionDigits = properties[ 3 ];
+	maximumFractionDigits = properties[ 4 ];
+	minimumSignificantDigits = properties[ 5 ];
+	maximumSignificantDigits = properties[ 6 ];
+	roundIncrement = properties[ 7 ];
+	primaryGroupingSize = properties[ 8 ];
+	secondaryGroupingSize = properties[ 9 ];
+	round = properties[ 15 ];
+	infinitySymbol = properties[ 16 ];
+	nanSymbol = properties[ 17 ];
+	symbolMap = properties[ 18 ];
+	nuDigitsMap = properties[ 19 ];
+	compactMap = properties[ 20 ];
+
+	// NaN
+	if ( isNaN( number ) ) {
+		return [ { type: "nan", value: nanSymbol } ];
+	}
+
+	if ( number < 0 ) {
+		pattern = properties[ 12 ];
+		prefix = properties[ 13 ];
+		suffix = properties[ 14 ];
+	} else {
+		pattern = properties[ 11 ];
+		prefix = properties[ 0 ];
+		suffix = properties[ 10 ];
+	}
+
+	// For prefix, suffix, and number parts.
+	stringToParts = function( string ) {
+		var numberType = "integer",
+			parts = [];
+
+		// TODO Move the tokenization of all parts that don't depend on number into
+		// format-properties.
+		string.replace( /('([^']|'')+'|'')|./g, function( character, literal ) {
+
+			// Literals
+			if ( literal ) {
+				partsPush( parts, "literal", removeLiteralQuotes( literal ) );
+				return;
+			}
+
+			// Currency symbol
+			if ( character === "\u00A4" ) {
+				partsPush( parts, "currency", character );
+				return;
+			}
+
+			// Symbols
+			character = character.replace( /[.,\-+E%\u2030]/, function( symbol ) {
+				if ( symbol === "." ) {
+					numberType = "fraction";
+				}
+				partsPush( parts, numberSymbolName[ symbol ], symbolMap[ symbol ] );
+
+				// "Erase" handled character.
+				return "";
+			});
+
+			// Number
+			character = character.replace( /[0-9]/, function( digit ) {
+
+				// Numbering system
+				if ( nuDigitsMap ) {
+					digit = nuDigitsMap[ +digit ];
+				}
+				partsPush( parts, numberType, digit );
+
+				// "Erase" handled character.
+				return "";
+			});
+
+			// Etc
+			character.replace( /./, function( etc ) {
+				partsPush( parts, "literal", etc );
+			});
+		});
+		return parts;
+	};
+
+	prefix = stringToParts( prefix );
+	suffix = stringToParts( suffix );
+
+	// Infinity
+	if ( !isFinite( number ) ) {
+		return prefix.concat(
+			{ type: "infinity", value: infinitySymbol },
+			suffix
+		);
+	}
+
+	// Percent
+	if ( pattern.indexOf( "%" ) !== -1 ) {
+		number *= 100;
+
+	// Per mille
+	} else if ( pattern.indexOf( "\u2030" ) !== -1 ) {
+		number *= 1000;
+	}
+
+	var compactPattern, compactDigits, compactProperties, divisor, numberExponent, pluralForm;
+
+	// Compact mode: initial number digit processing
+	if ( compactMap ) {
+		numberExponent = Math.abs( Math.floor( number ) ).toString().length - 1;
+		numberExponent = Math.min( numberExponent, compactMap.maxExponent );
+
+		// Use default plural form to perform initial decimal shift
+		if ( numberExponent >= 3 ) {
+			compactPattern = compactMap[ numberExponent ] && compactMap[ numberExponent ].other;
+		}
+
+		if ( compactPattern === "0" ) {
+			compactPattern = null;
+		} else if ( compactPattern ) {
+			compactDigits = compactPattern.split( "0" ).length - 1;
+			divisor = numberExponent - ( compactDigits - 1 );
+			number = number / Math.pow( 10, divisor );
+		}
+	}
+
+	// Significant digit format
+	if ( !isNaN( minimumSignificantDigits * maximumSignificantDigits ) ) {
+		number = numberFormatSignificantDigits( number, minimumSignificantDigits,
+			maximumSignificantDigits, round );
+
+	// Integer and fractional format
+	} else {
+		number = numberFormatIntegerFractionDigits( number, minimumIntegerDigits,
+			minimumFractionDigits, maximumFractionDigits, round, roundIncrement );
+	}
+
+	// Compact mode: apply formatting
+	if ( compactMap && compactPattern ) {
+
+		// Get plural form after possible roundings
+		pluralForm = pluralGenerator ? pluralGenerator( +number ) : "other";
+
+		compactPattern = compactMap[ numberExponent ][ pluralForm ] || compactPattern;
+		compactProperties = compactPattern.match( numberCompactPatternRe );
+
+		// TODO Move the tokenization of all parts that don't depend on number into
+		// format-properties.
+		aux = function( string ) {
+			var parts = [];
+			string.replace( /(\s+)|([^\s0]+)/g, function( _garbage, space, compact ) {
+
+				// Literals
+				if ( space ) {
+					partsPush( parts, "literal", space );
+					return;
+				}
+
+				// Compact value
+				if ( compact ) {
+					partsPush( parts, "compact", compact );
+					return;
+				}
+			});
+			return parts;
+		};
+
+		// update prefix/suffix with compact prefix/suffix
+		prefix = prefix.concat( aux( compactProperties[ 1 ] ) );
+		suffix = aux( compactProperties[ 3 ] ).concat( suffix );
+	}
+
+	// Remove the possible number minus sign
+	number = number.replace( /^-/, "" );
+
+	// Grouping separators
+	if ( primaryGroupingSize ) {
+		number = numberFormatGroupingSeparator( number, primaryGroupingSize,
+			secondaryGroupingSize );
+	}
+
+	// Scientific notation
+	// TODO implement here
+
+	// Padding/'([^']|'')+'|''|[.,\-+E%\u2030]/g
+	// TODO implement here
+
+	return prefix.concat(
+		stringToParts( number ),
+		suffix
+	);
+};
+
+
+
+
+var numberToPartsFormatterFn = function( properties, pluralGenerator ) {
+	return function numberToPartsFormatter( value ) {
+		validateParameterPresence( value, "value" );
+		validateParameterTypeNumber( value, "value" );
+
+		return numberFormat( value, properties, pluralGenerator );
+	};
+};
+
+
+
+
+function validateDigits( properties ) {
+	var minimumIntegerDigits = properties[ 2 ],
+		minimumFractionDigits = properties[ 3 ],
+		maximumFractionDigits = properties[ 4 ],
+		minimumSignificantDigits = properties[ 5 ],
+		maximumSignificantDigits = properties[ 6 ];
+
+	// Validate significant digit format properties
+	if ( !isNaN( minimumSignificantDigits * maximumSignificantDigits ) ) {
+		validateParameterRange( minimumSignificantDigits, "minimumSignificantDigits", 1, 21 );
+		validateParameterRange( maximumSignificantDigits, "maximumSignificantDigits",
+			minimumSignificantDigits, 21 );
+
+	} else if ( !isNaN( minimumSignificantDigits ) || !isNaN( maximumSignificantDigits ) ) {
+		throw new Error( "Neither or both the minimum and maximum significant digits must be " +
+			"present" );
+
+	// Validate integer and fractional format
+	} else {
+		validateParameterRange( minimumIntegerDigits, "minimumIntegerDigits", 1, 21 );
+		validateParameterRange( minimumFractionDigits, "minimumFractionDigits", 0, 20 );
+		validateParameterRange( maximumFractionDigits, "maximumFractionDigits",
+			minimumFractionDigits, 20 );
+	}
+}
+
+/**
+ * .numberFormatter( [options] )
+ *
+ * @options [Object]:
+ * - style: [String] "decimal" (default) or "percent".
+ * - see also number/format options.
+ *
+ * Return a function that formats a number according to the given options and default/instance
+ * locale.
+ */
+Globalize.numberFormatter =
+Globalize.prototype.numberFormatter = function( options ) {
+	var args, numberToPartsFormatter, returnFn;
+
+	validateParameterTypePlainObject( options, "options" );
+
+	options = options || {};
+	args = [ options ];
+
+	numberToPartsFormatter = this.numberToPartsFormatter( options );
+	returnFn = numberFormatterFn( numberToPartsFormatter );
+	runtimeBind( args, this.cldr, returnFn, [ numberToPartsFormatter ] );
+
+	return returnFn;
+};
+
+/**
+ * .numberToPartsFormatter( [options] )
+ *
+ * @options [Object]:
+ * - style: [String] "symbol" (default), "accounting", "code" or "name".
+ * - see also number/format options.
+ *
+ * Return a function that formats a number to parts according to the given options and
+ * default/instance locale.
+ */
+Globalize.numberToPartsFormatter =
+Globalize.prototype.numberToPartsFormatter = function( options ) {
+	var args, cldr, fnArgs, pattern, properties, returnFn;
+
+	validateParameterTypePlainObject( options, "options" );
+
+	options = options || {};
+	cldr = this.cldr;
+
+	args = [ options ];
+
+	validateDefaultLocale( cldr );
+
+	cldr.on( "get", validateCldr );
+	try {
+		if ( options.raw ) {
+			pattern = options.raw;
+		} else {
+			pattern = numberPattern( options.style || "decimal", cldr );
+		}
+
+		properties = numberFormatProperties( pattern, cldr, options );
+		fnArgs = [ properties ];
+	} finally {
+		cldr.off( "get", validateCldr );
+	}
+
+	validateDigits( properties );
+
+	if ( options.compact ) {
+		fnArgs.push( this.pluralGenerator() );
+	}
+	returnFn = numberToPartsFormatterFn.apply( null, fnArgs );
+	runtimeBind( args, cldr, returnFn, fnArgs );
+
+	return returnFn;
+};
+
+/**
+ * .numberParser( [options] )
+ *
+ * @options [Object]:
+ * - style: [String] "decimal" (default) or "percent".
+ *
+ * Return the number parser according to the default/instance locale.
+ */
+Globalize.numberParser =
+Globalize.prototype.numberParser = function( options ) {
+	var args, cldr, pattern, properties, returnFn;
+
+	validateParameterTypePlainObject( options, "options" );
+
+	options = options || {};
+	cldr = this.cldr;
+
+	args = [ options ];
+
+	validateDefaultLocale( cldr );
+	if ( options.compact ) {
+		throw createErrorUnsupportedFeature({
+			feature: "compact number parsing (not implemented)"
+		});
+	}
+
+	cldr.on( "get", validateCldr );
+
+	if ( options.raw ) {
+		pattern = options.raw;
+	} else {
+		pattern = numberPattern( options.style || "decimal", cldr );
+	}
+
+	properties = numberParseProperties( pattern, cldr, options );
+
+	cldr.off( "get", validateCldr );
+
+	returnFn = numberParserFn( properties );
+
+	runtimeBind( args, cldr, returnFn, [ properties ] );
+
+	return returnFn;
+};
+
+/**
+ * .formatNumber( value [, options] )
+ *
+ * @value [Number] number to be formatted.
+ *
+ * @options [Object]: see number/format-properties.
+ *
+ * Format a number according to the given options and default/instance locale.
+ */
+Globalize.formatNumber =
+Globalize.prototype.formatNumber = function( value, options ) {
+	validateParameterPresence( value, "value" );
+	validateParameterTypeNumber( value, "value" );
+
+	return this.numberFormatter( options )( value );
+};
+
+/**
+ * .formatNumberToParts( value [, options] )
+ *
+ * @value [Number] number to be formatted.
+ *
+ * @options [Object]: see number/format-properties.
+ *
+ * Format a number to pars according to the given options and default/instance locale.
+ */
+Globalize.formatNumberToParts =
+Globalize.prototype.formatNumberToParts = function( value, options ) {
+	validateParameterPresence( value, "value" );
+	validateParameterTypeNumber( value, "value" );
+
+	return this.numberToPartsFormatter( options )( value );
+};
+
+/**
+ * .parseNumber( value [, options] )
+ *
+ * @value [String]
+ *
+ * @options [Object]: See numberParser().
+ *
+ * Return the parsed Number (including Infinity) or NaN when value is invalid.
+ */
+Globalize.parseNumber =
+Globalize.prototype.parseNumber = function( value, options ) {
+	validateParameterPresence( value, "value" );
+	validateParameterTypeString( value, "value" );
+
+	return this.numberParser( options )( value );
+};
+
+/**
+ * Optimization to avoid duplicating some internal functions across modules.
+ */
+Globalize._createErrorUnsupportedFeature = createErrorUnsupportedFeature;
+Globalize._numberNumberingSystem = numberNumberingSystem;
+Globalize._numberNumberingSystemDigitsMap = numberNumberingSystemDigitsMap;
+Globalize._numberPattern = numberPattern;
+Globalize._numberSymbol = numberSymbol;
+Globalize._looseMatching = looseMatching;
+Globalize._removeLiteralQuotes = removeLiteralQuotes;
+Globalize._stringPad = stringPad;
+Globalize._validateParameterTypeNumber = validateParameterTypeNumber;
+Globalize._validateParameterTypeString = validateParameterTypeString;
+
+return Globalize;
+
+
+
+
+}));