lib/src/intl/compact_number_format.dart - intl - Git at Google

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 part of 'number_format.dart';

 // Suppress naming issues as changes would be breaking.
 // ignore_for_file: constant_identifier_names

 /// An abstract class for compact number styles.
 abstract class _CompactStyleBase {
   /// The _CompactStyle for the [number].
   _CompactStyle styleForNumber(dynamic number, _CompactNumberFormat format);

   /// What should we divide the number by in order to print. Normally it is
   /// either `10^normalizedExponent` or 1 if we shouldn't divide at all.
   int get divisor;

   /// The iterable of all possible styles which we represent.
   ///
   /// Normally this will be either a list with just ourself, or of two elements
   /// for our positive and negative styles.
   Iterable<_CompactStyle> get allStyles;
 }

 /// A compact format with separate styles for plural forms.
 class _CompactStyleWithPlurals extends _CompactStyleBase {
   int exponent;
   Map<String, _CompactStyleBase> styles;
   plural_rules.PluralCase Function()? _plural;
   late _CompactStyleBase _defaultStyle;

   _CompactStyleWithPlurals(this.styles, this.exponent, String? locale) {
     _plural = plural_rules.pluralRules[locale];
     _defaultStyle = styles['other']!;
   }

   @override
   Iterable<_CompactStyle> get allStyles =>
       styles.values.expand((x) => x.allStyles);

   @override
   int get divisor => _defaultStyle.divisor;

   @override
   _CompactStyle styleForNumber(dynamic number, _CompactNumberFormat format) {
     var value = number.abs();
     if (_plural == null) {
       return _defaultStyle.styleForNumber(number, format);
     }

     var displayed = value;
     var precision = format._minimumFractionDigits;

     if (format.significantDigitsInUse) {
       // Note: this is not 100% correct, but good enough for most cases.
       var integerPart = format._floor(value);
       var integerLength = NumberFormat.numberOfIntegerDigits(integerPart);
       if (format.minimumSignificantDigits != null) {
         precision = max(0, format.minimumSignificantDigits! - integerLength);
       }
     }

     // Round to the right precision.
     var factor = pow(10, precision);
     displayed = (displayed * factor).round() / factor;

     if (format.significantDigitsInUse &&
         !format.minimumSignificantDigitsStrict) {
       // Check for trailing 0.
       var fractionStr = format._floor(displayed * factor).toString();
       while (precision > 0 && fractionStr.endsWith('0')) {
         precision--;
         fractionStr = fractionStr.substring(0, fractionStr.length - 1);
       }
     }

     // Direct value? (French 1000 => "mille" has key "1".)
     if (number >= 0 && precision == 0) {
       var indexed = styles[format._floor(displayed).toString()];
       if (indexed != null) {
         return indexed.styleForNumber(number, format);
       }
     }

     plural_rules.startRuleEvaluation(displayed, precision);
     var pluralCase = _plural!();
     var style = _defaultStyle;
     switch (pluralCase) {
       case plural_rules.PluralCase.ZERO:
         style = styles['zero'] ?? _defaultStyle;
         break;
       case plural_rules.PluralCase.ONE:
         style = styles['one'] ?? _defaultStyle;
         break;
       case plural_rules.PluralCase.TWO:
         style = styles['two'] ?? styles['few'] ?? _defaultStyle;
         break;
       case plural_rules.PluralCase.FEW:
         style = styles['few'] ?? _defaultStyle;
         break;
       case plural_rules.PluralCase.MANY:
         style = styles['many'] ?? _defaultStyle;
         break;
       default:
       // Keep _defaultStyle;
     }
     return style.styleForNumber(number, format);
   }
 }

 /// A compact format with separate styles for positive and negative numbers.
 class _CompactStyleWithNegative extends _CompactStyleBase {
   _CompactStyleWithNegative(this.positiveStyle, this.negativeStyle);
   final _CompactStyle positiveStyle;
   final _CompactStyle negativeStyle;

   @override
   _CompactStyle styleForNumber(dynamic number, _CompactNumberFormat format) =>
       number < 0 ? negativeStyle : positiveStyle;

   @override
   int get divisor => positiveStyle.divisor;

   @override
   List<_CompactStyle> get allStyles => [positiveStyle, negativeStyle];
 }

 /// Represents a compact format for a particular base
 ///
 /// For example, 10K can be used to represent 10,000.  Corresponds to one of the
 /// patterns in COMPACT_DECIMAL_SHORT_FORMAT. So, for example, in en_US we have
 /// the pattern
 ///
 ///       4: '00K'
 /// which matches
 ///
 ///       _CompactStyle(pattern: '00K', divisor: 1000,
 ///           prefix: '', suffix: 'K');
 class _CompactStyle extends _CompactStyleBase {
   _CompactStyle(
       {this.pattern,
       this.divisor = 1,
       this.positivePrefix = '',
       this.negativePrefix = '',
       this.positiveSuffix = '',
       this.negativeSuffix = '',
       this.isDirectValue = false});

   /// The pattern on which this is based.
   ///
   /// We don't actually need this, but it makes debugging easier.
   String? pattern;

   /// What should we divide the number by in order to print. Normally is either
   /// 10^normalizedExponent or 1 if we shouldn't divide at all.
   @override
   int divisor;

   // Prefixes / suffixes.
   String positivePrefix;
   String negativePrefix;
   String positiveSuffix;
   String negativeSuffix;

   /// Whether this pattern omits numbers. Ex: "mille" for 1000 in fr.
   bool isDirectValue;

   /// Return true if this is the fallback compact pattern, printing the number
   /// un-compacted. e.g. 1200 might print as '1.2K', but 12 just prints as '12'.
   ///
   /// For currencies, with the fallback pattern we use the super implementation
   /// so that we will respect things like the default number of decimal digits
   /// for a particular currency (e.g. two for USD, zero for JPY)
   bool get isFallback => pattern == null || pattern == '0';

   @override
   _CompactStyle styleForNumber(dynamic number, _CompactNumberFormat format) =>
       this;

   @override
   List<_CompactStyle> get allStyles => [this];

   static final _regex = RegExp('([^0]*)(0+)(.*)');

   static final _justZeros = RegExp(r'^0*$');

   /// Does pattern have any additional characters or is it just zeros.
   static bool _hasNonZeroContent(String pattern) =>
       !_justZeros.hasMatch(pattern);

   /// Creates a [_CompactStyle] instance for pattern with [normalizedExponent].
   static _CompactStyle createStyle(
       NumberSymbols symbols, String pattern, int normalizedExponent,
       {bool isSigned = false, bool explicitSign = false}) {
     var prefix = '';
     var suffix = '';
     var divisor = 1;
     var isDirectValue = false;
     var match = _regex.firstMatch(pattern);
     if (match != null) {
       prefix = match.group(1)!;
       suffix = match.group(3)!;
       // If the pattern is just zeros, with no suffix, then we shouldn't divide
       // by the number of digits. e.g. for 'af', the pattern for 3 is '0', but
       // it doesn't mean that 4321 should print as 4. But if the pattern was
       // '0K', then it should print as '4K'. So we have to check if the pattern
       // has a suffix. This seems extremely hacky, but I don't know how else to
       // encode that. Check what other things are doing.
       if (_hasNonZeroContent(pattern)) {
         var integerDigits = match.group(2)!.length;
         divisor = pow(10, normalizedExponent - integerDigits + 1) as int;
       }
     } else {
       if (pattern.isNotEmpty && !pattern.contains('0')) {
         // "Direct" pattern: no numbers.
         divisor = pow(10, normalizedExponent) as int;
         isDirectValue = true;
       }
     }

     final positivePrefix =
         (explicitSign && !isSigned) ? '${symbols.PLUS_SIGN}$prefix' : prefix;
     final negativePrefix =
         (!isSigned) ? '${symbols.MINUS_SIGN}$prefix' : prefix;
     final positiveSuffix = suffix;
     final negativeSuffix = suffix;

     return _CompactStyle(
         pattern: pattern,
         positivePrefix: positivePrefix,
         negativePrefix: negativePrefix,
         positiveSuffix: positiveSuffix,
         negativeSuffix: negativeSuffix,
         divisor: divisor,
         isDirectValue: isDirectValue);
   }
 }

 /// Enumerates the different formats supported.
 enum _CompactFormatType {
   COMPACT_DECIMAL_SHORT_PATTERN,
   COMPACT_DECIMAL_LONG_PATTERN,
   COMPACT_DECIMAL_SHORT_CURRENCY_PATTERN
 }

 class _CompactNumberFormat extends NumberFormat {
   /// A default, using the decimal pattern, for the `getPattern` constructor parameter.
   static String _forDecimal(NumberSymbols symbols) => symbols.DECIMAL_PATTERN;

   // Map exponent => style.
   final Map<int, _CompactStyleBase> _styles;

   // Whether positive sign should be explicitly printed.
   final bool _explicitSign;

   factory _CompactNumberFormat(
       {String? locale,
       _CompactFormatType? formatType,
       String? name,
       String? currencySymbol,
       String? Function(NumberSymbols) getPattern = _forDecimal,
       int? decimalDigits,
       bool explicitSign = false,
       bool lookupSimpleCurrencySymbol = false,
       bool isForCurrency = false}) {
     // Initialization copied from `NumberFormat` constructor.
     // TODO(davidmorgan): deduplicate.
     locale = helpers.verifiedLocale(locale, NumberFormat.localeExists, null)!;
     var symbols = numberFormatSymbols[locale] as NumberSymbols;
     var localeZero = symbols.ZERO_DIGIT.codeUnitAt(0);
     var zeroOffset = localeZero - constants.asciiZeroCodeUnit;
     name ??= symbols.DEF_CURRENCY_CODE;
     if (currencySymbol == null && lookupSimpleCurrencySymbol) {
       currencySymbol = constants.simpleCurrencySymbols[name];
     }
     currencySymbol ??= name;
     var pattern = getPattern(symbols);

     // CompactNumberFormat initialization.

     /// Map from magnitude to formatting pattern for that magnitude.
     ///
     /// The magnitude is the exponent when using the normalized scientific
     /// notation (so numbers from 1000 to 9999 correspond to magnitude 3).
     ///
     /// These patterns are taken from the appropriate CompactNumberSymbols
     /// instance's COMPACT_DECIMAL_SHORT_PATTERN, COMPACT_DECIMAL_LONG_PATTERN,
     /// or COMPACT_DECIMAL_SHORT_CURRENCY_PATTERN members.
     Map<int, Map<String, String>> patterns;

     var compactSymbols = compactNumberSymbols[locale]!;

     var styles = <int, _CompactStyleBase>{};
     switch (formatType) {
       case _CompactFormatType.COMPACT_DECIMAL_SHORT_PATTERN:
         patterns = compactSymbols.COMPACT_DECIMAL_SHORT_PATTERN;
         break;
       case _CompactFormatType.COMPACT_DECIMAL_LONG_PATTERN:
         patterns = compactSymbols.COMPACT_DECIMAL_LONG_PATTERN ??
             compactSymbols.COMPACT_DECIMAL_SHORT_PATTERN;
         break;
       case _CompactFormatType.COMPACT_DECIMAL_SHORT_CURRENCY_PATTERN:
         patterns = compactSymbols.COMPACT_DECIMAL_SHORT_CURRENCY_PATTERN;
         break;
       default:
         throw ArgumentError.notNull('formatType');
     }

     patterns.forEach((int exponent, Map<String, String> patterns) {
       _CompactStyleBase style;
       if (patterns.keys.length == 1 && patterns.keys.single == 'other') {
         // No plural.
         var pattern = patterns.values.single;
         style = _styleFromPattern(pattern, exponent, explicitSign, symbols);
       } else {
         style = _CompactStyleWithPlurals(
             patterns.map((key, value) => MapEntry(key,
                 _styleFromPattern(value, exponent, explicitSign, symbols))),
             exponent,
             locale);
       }
       styles[exponent] = style;
     });

     return _CompactNumberFormat._(
         name,
         currencySymbol,
         isForCurrency,
         locale,
         localeZero,
         pattern,
         symbols,
         zeroOffset,
         NumberFormatParser.parse(symbols, pattern, isForCurrency,
             currencySymbol, name, decimalDigits),
         styles,
         explicitSign);
   }

   static _CompactStyleBase _styleFromPattern(
       String pattern, int exponent, bool explicitSign, NumberSymbols symbols) {
     if (pattern.contains(';')) {
       var patterns = pattern.split(';');
       var positivePattern = patterns.first;
       var negativePattern = patterns.last;
       if (explicitSign &&
           !positivePattern.contains(symbols.PLUS_SIGN) &&
           negativePattern.contains(symbols.MINUS_SIGN) &&
           positivePattern ==
               negativePattern.replaceAll(symbols.MINUS_SIGN, '')) {
         // Re-use the negative pattern, with plus sign.
         positivePattern =
             negativePattern.replaceAll(symbols.MINUS_SIGN, symbols.PLUS_SIGN);
       }
       return _CompactStyleWithNegative(
           _CompactStyle.createStyle(symbols, positivePattern, exponent,
               isSigned: positivePattern.contains(symbols.PLUS_SIGN)),
           _CompactStyle.createStyle(symbols, negativePattern, exponent,
               isSigned: true));
     } else {
       return _CompactStyle.createStyle(symbols, pattern, exponent,
           explicitSign: explicitSign);
     }
   }

   _CompactNumberFormat._(
       String currencyName,
       String currencySymbol,
       bool isForCurrency,
       String locale,
       int localeZero,
       String? pattern,
       NumberSymbols symbols,
       int zeroOffset,
       NumberFormatParseResult result,
       // Fields introduced in this class.
       this._styles,
       this._explicitSign)
       : super._(currencyName, currencySymbol, isForCurrency, locale, localeZero,
             pattern, symbols, zeroOffset, result) {
     significantDigits = 3;
     turnOffGrouping();
   }

   @override
   set significantDigits(int? x) {
     // Replicate ICU behavior: set only the minimumSignificantDigits and
     // do not force trailing 0 in fractional part.
     _explicitMinimumFractionDigits = false;
     minimumSignificantDigits = x;
     maximumSignificantDigits = null;
     minimumSignificantDigitsStrict = false;
   }

   @override
   int get minimumFractionDigits =>
       _style != null && !_style!.isFallback && !_explicitMinimumFractionDigits
           ? 0
           : super.minimumFractionDigits;

   /// The style in which we will format a particular number.
   ///
   /// This is a temporary variable that is only valid within a call to format
   /// and parse.
   _CompactStyle? _style;

   // We delegate prefixes to current _style.
   @override
   String get positivePrefix =>
       _style!.isFallback ? super.positivePrefix : _style!.positivePrefix;
   @override
   String get negativePrefix =>
       _style!.isFallback ? super.negativePrefix : _style!.negativePrefix;
   @override
   String get positiveSuffix =>
       _style!.isFallback ? super.positiveSuffix : _style!.positiveSuffix;
   @override
   String get negativeSuffix =>
       _style!.isFallback ? super.negativeSuffix : _style!.negativeSuffix;

   @override
   String format(dynamic number) {
     var style = _styleFor(number);
     _style = style;
     final divisor = style.isFallback ? 1 : style.divisor;
     final numberToFormat = _divide(number, divisor);
     var formatted = style.isDirectValue
         ? '${_signPrefix(number)}${style.pattern}${_signSuffix(number)}'
         : super.format(numberToFormat);
     if (_explicitSign &&
         style.isFallback &&
         number >= 0 &&
         !formatted.contains(symbols.PLUS_SIGN)) {
       formatted = '${symbols.PLUS_SIGN}$formatted';
     }
     if (_isForCurrency && !style.isFallback) {
       formatted = formatted.replaceFirst('\u00a4', currencySymbol);
     }
     _style = null;
     return formatted;
   }

   @override
   bool _useDefaultSignificantDigits() {
     // For non-currencies, or for currencies if the numbers are large enough to
     // compact, always use the number of significant digits and ignore
     // decimalDigits.
     return !_isForCurrency || !_style!.isFallback;
   }

   /// Divide numbers that may not have a division operator (e.g. Int64).
   ///
   /// Only used for powers of 10, so we require an integer denominator.
   static num _divide(numerator, int denominator) {
     if (numerator is num) {
       return numerator / denominator;
     }
     // If it doesn't fit in a JS int after division, we're not going to be able
     // to meaningfully print a compact representation for it.
     var divided = numerator ~/ denominator;
     var integerPart = divided.toInt();
     if (divided != integerPart) {
       throw FormatException(
           'Number too big to use with compact format', numerator);
     }
     var remainder = numerator.remainder(denominator).toInt();
     var originalFraction = numerator - (numerator ~/ 1);
     var fraction = originalFraction == 0 ? 0 : originalFraction / denominator;
     return integerPart + (remainder / denominator) + fraction;
   }

   _CompactStyle _styleFor(number) {
     if (number.abs() < 10) {
       // Cannot be compacted.
       return _defaultCompactStyle;
     }
     var rounded = number.toDouble(); // No rounding yet...
     var digitLength = NumberFormat.numberOfIntegerDigits(number);
     var divisor = 1; // Default.

     void updateRounding() {
       var fractionDigits = maximumFractionDigits;
       if (significantDigitsInUse) {
         var divisorLength = NumberFormat.numberOfIntegerDigits(divisor);
         // We have to round the number based on the number of significant
         // digits so that we pick the right style based on the rounded form
         // and format 999999 as 1M rather than 1000K.
         fractionDigits =
             (maximumSignificantDigits ?? minimumSignificantDigits ?? 0) -
                 digitLength +
                 divisorLength -
                 1;
         if (maximumSignificantDigits == null) {
           // Keep all digits of the integer part.
           fractionDigits = max(0, fractionDigits);
         }
       }
       var fractionMultiplier = pow(10, fractionDigits);
       rounded = (rounded * fractionMultiplier / divisor).round() *
           divisor /
           fractionMultiplier;
       digitLength = NumberFormat.numberOfIntegerDigits(rounded);
     }

     updateRounding();

     _CompactStyleBase? style;
     for (var entry in _styles.entries) {
       var exponent = entry.key + 1;
       if (exponent > digitLength) {
         break;
       }
       style = entry.value;
       // Recompute digits length based on new exponent.
       divisor = style.divisor;
       updateRounding();
     }
     return style?.styleForNumber(_divide(number, divisor), this) ??
         _defaultCompactStyle;
   }

   Iterable<_CompactStyle> get _stylesForSearching =>
       _styles.values.expand((x) => x.allStyles);

   String _normalize(String input) {
     return input
         .replaceAll('\u200e', '') // LEFT-TO-RIGHT MARK.
         .replaceAll('\u200f', '') // RIGHT-TO-LEFT MARK.
         .replaceAll('\u0020', '') // SPACE.
         .replaceAll('\u00a0', '') // NO-BREAK SPACE.
         .replaceAll('\u202f', '') // NARROW NO-BREAK SPACE.
         .replaceAll('\u2212', '-'); // MINUS SIGN.
   }

   @override
   num parse(final String inputText) {
     for (var style in [_defaultCompactStyle, ..._stylesForSearching]) {
       _style = style;
       var text = _normalize(inputText);
       var negative = false;
       var negativePrefix = _normalize(style.negativePrefix);
       var negativeSuffix = _normalize(style.negativeSuffix);
       var positivePrefix = _normalize(style.positivePrefix);
       var positiveSuffix = _normalize(style.positiveSuffix);
       if (!style.isFallback) {
         if (text.startsWith(negativePrefix) && text.endsWith(negativeSuffix)) {
           text = text.substring(
               negativePrefix.length, text.length - negativeSuffix.length);
           negative = true;
         } else if (text.startsWith(positivePrefix) &&
             text.endsWith(positiveSuffix)) {
           text = text.substring(
               positivePrefix.length, text.length - positiveSuffix.length);
         } else {
           continue;
         }
       }
       if (style.isDirectValue) {
         // "Direct formatting" pattern (1000 => "mille").
         if (text == style.pattern!) {
           _style = null;
           return style.divisor * (negative ? -1 : 1);
         } else {
           // Do not attempt parsing: no number.
           continue;
         }
       }
       var number = _tryParsing(text);
       if (number == null && _zeroOffset != 0) {
         // Locale has non-roman numerals.
         // Try simple number parse, in case input contains roman numerals.
         number = num.tryParse(text);
       }
       if (number != null) {
         _style = null;
         return number * style.divisor * (negative ? -1 : 1);
       }
     }
     _style = null;

     throw FormatException(
         "Cannot parse compact number in locale '$locale'", inputText);
   }

   /// Returns text parsed into a number if possible, else returns null.
   num? _tryParsing(String text) {
     try {
       return super.parse(text);
     } on FormatException {
       return null;
     }
   }
 }

 final _defaultCompactStyle = _CompactStyle();
	// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	part of 'number_format.dart';

	// Suppress naming issues as changes would be breaking.
	// ignore_for_file: constant_identifier_names

	/// An abstract class for compact number styles.
	abstract class _CompactStyleBase {
	/// The _CompactStyle for the [number].
	_CompactStyle styleForNumber(dynamic number, _CompactNumberFormat format);

	/// What should we divide the number by in order to print. Normally it is
	/// either `10^normalizedExponent` or 1 if we shouldn't divide at all.
	int get divisor;

	/// The iterable of all possible styles which we represent.
	///
	/// Normally this will be either a list with just ourself, or of two elements
	/// for our positive and negative styles.
	Iterable<_CompactStyle> get allStyles;
	}

	/// A compact format with separate styles for plural forms.
	class _CompactStyleWithPlurals extends _CompactStyleBase {
	int exponent;
	Map<String, _CompactStyleBase> styles;
	plural_rules.PluralCase Function()? _plural;
	late _CompactStyleBase _defaultStyle;

	_CompactStyleWithPlurals(this.styles, this.exponent, String? locale) {
	_plural = plural_rules.pluralRules[locale];
	_defaultStyle = styles['other']!;
	}

	@override
	Iterable<_CompactStyle> get allStyles =>
	styles.values.expand((x) => x.allStyles);

	@override
	int get divisor => _defaultStyle.divisor;

	@override
	_CompactStyle styleForNumber(dynamic number, _CompactNumberFormat format) {
	var value = number.abs();
	if (_plural == null) {
	return _defaultStyle.styleForNumber(number, format);
	}

	var displayed = value;
	var precision = format._minimumFractionDigits;

	if (format.significantDigitsInUse) {
	// Note: this is not 100% correct, but good enough for most cases.
	var integerPart = format._floor(value);
	var integerLength = NumberFormat.numberOfIntegerDigits(integerPart);
	if (format.minimumSignificantDigits != null) {
	precision = max(0, format.minimumSignificantDigits! - integerLength);
	}
	}

	// Round to the right precision.
	var factor = pow(10, precision);
	displayed = (displayed * factor).round() / factor;

	if (format.significantDigitsInUse &&
	!format.minimumSignificantDigitsStrict) {
	// Check for trailing 0.
	var fractionStr = format._floor(displayed * factor).toString();
	while (precision > 0 && fractionStr.endsWith('0')) {
	precision--;
	fractionStr = fractionStr.substring(0, fractionStr.length - 1);
	}
	}

	// Direct value? (French 1000 => "mille" has key "1".)
	if (number >= 0 && precision == 0) {
	var indexed = styles[format._floor(displayed).toString()];
	if (indexed != null) {
	return indexed.styleForNumber(number, format);
	}
	}

	plural_rules.startRuleEvaluation(displayed, precision);
	var pluralCase = _plural!();
	var style = _defaultStyle;
	switch (pluralCase) {
	case plural_rules.PluralCase.ZERO:
	style = styles['zero'] ?? _defaultStyle;
	break;
	case plural_rules.PluralCase.ONE:
	style = styles['one'] ?? _defaultStyle;
	break;
	case plural_rules.PluralCase.TWO:
	style = styles['two'] ?? styles['few'] ?? _defaultStyle;
	break;
	case plural_rules.PluralCase.FEW:
	style = styles['few'] ?? _defaultStyle;
	break;
	case plural_rules.PluralCase.MANY:
	style = styles['many'] ?? _defaultStyle;
	break;
	default:
	// Keep _defaultStyle;
	}
	return style.styleForNumber(number, format);
	}
	}

	/// A compact format with separate styles for positive and negative numbers.
	class _CompactStyleWithNegative extends _CompactStyleBase {
	_CompactStyleWithNegative(this.positiveStyle, this.negativeStyle);
	final _CompactStyle positiveStyle;
	final _CompactStyle negativeStyle;

	@override
	_CompactStyle styleForNumber(dynamic number, _CompactNumberFormat format) =>
	number < 0 ? negativeStyle : positiveStyle;

	@override
	int get divisor => positiveStyle.divisor;

	@override
	List<_CompactStyle> get allStyles => [positiveStyle, negativeStyle];
	}

	/// Represents a compact format for a particular base
	///
	/// For example, 10K can be used to represent 10,000. Corresponds to one of the
	/// patterns in COMPACT_DECIMAL_SHORT_FORMAT. So, for example, in en_US we have
	/// the pattern
	///
	/// 4: '00K'
	/// which matches
	///
	/// _CompactStyle(pattern: '00K', divisor: 1000,
	/// prefix: '', suffix: 'K');
	class _CompactStyle extends _CompactStyleBase {
	_CompactStyle(
	{this.pattern,
	this.divisor = 1,
	this.positivePrefix = '',
	this.negativePrefix = '',
	this.positiveSuffix = '',
	this.negativeSuffix = '',
	this.isDirectValue = false});

	/// The pattern on which this is based.
	///
	/// We don't actually need this, but it makes debugging easier.
	String? pattern;

	/// What should we divide the number by in order to print. Normally is either
	/// 10^normalizedExponent or 1 if we shouldn't divide at all.
	@override
	int divisor;

	// Prefixes / suffixes.
	String positivePrefix;
	String negativePrefix;
	String positiveSuffix;
	String negativeSuffix;

	/// Whether this pattern omits numbers. Ex: "mille" for 1000 in fr.
	bool isDirectValue;

	/// Return true if this is the fallback compact pattern, printing the number
	/// un-compacted. e.g. 1200 might print as '1.2K', but 12 just prints as '12'.
	///
	/// For currencies, with the fallback pattern we use the super implementation
	/// so that we will respect things like the default number of decimal digits
	/// for a particular currency (e.g. two for USD, zero for JPY)
	bool get isFallback => pattern == null \|\| pattern == '0';

	@override
	_CompactStyle styleForNumber(dynamic number, _CompactNumberFormat format) =>
	this;

	@override
	List<_CompactStyle> get allStyles => [this];

	static final _regex = RegExp('([^0])(0+)(.)');

	static final _justZeros = RegExp(r'^0*$');

	/// Does pattern have any additional characters or is it just zeros.
	static bool _hasNonZeroContent(String pattern) =>
	!_justZeros.hasMatch(pattern);

	/// Creates a [_CompactStyle] instance for pattern with [normalizedExponent].
	static _CompactStyle createStyle(
	NumberSymbols symbols, String pattern, int normalizedExponent,
	{bool isSigned = false, bool explicitSign = false}) {
	var prefix = '';
	var suffix = '';
	var divisor = 1;
	var isDirectValue = false;
	var match = _regex.firstMatch(pattern);
	if (match != null) {
	prefix = match.group(1)!;
	suffix = match.group(3)!;
	// If the pattern is just zeros, with no suffix, then we shouldn't divide
	// by the number of digits. e.g. for 'af', the pattern for 3 is '0', but
	// it doesn't mean that 4321 should print as 4. But if the pattern was
	// '0K', then it should print as '4K'. So we have to check if the pattern
	// has a suffix. This seems extremely hacky, but I don't know how else to
	// encode that. Check what other things are doing.
	if (_hasNonZeroContent(pattern)) {
	var integerDigits = match.group(2)!.length;
	divisor = pow(10, normalizedExponent - integerDigits + 1) as int;
	}
	} else {
	if (pattern.isNotEmpty && !pattern.contains('0')) {
	// "Direct" pattern: no numbers.
	divisor = pow(10, normalizedExponent) as int;
	isDirectValue = true;
	}
	}

	final positivePrefix =
	(explicitSign && !isSigned) ? '${symbols.PLUS_SIGN}$prefix' : prefix;
	final negativePrefix =
	(!isSigned) ? '${symbols.MINUS_SIGN}$prefix' : prefix;
	final positiveSuffix = suffix;
	final negativeSuffix = suffix;

	return _CompactStyle(
	pattern: pattern,
	positivePrefix: positivePrefix,
	negativePrefix: negativePrefix,
	positiveSuffix: positiveSuffix,
	negativeSuffix: negativeSuffix,
	divisor: divisor,
	isDirectValue: isDirectValue);
	}
	}

	/// Enumerates the different formats supported.
	enum _CompactFormatType {
	COMPACT_DECIMAL_SHORT_PATTERN,
	COMPACT_DECIMAL_LONG_PATTERN,
	COMPACT_DECIMAL_SHORT_CURRENCY_PATTERN
	}

	class _CompactNumberFormat extends NumberFormat {
	/// A default, using the decimal pattern, for the `getPattern` constructor parameter.
	static String _forDecimal(NumberSymbols symbols) => symbols.DECIMAL_PATTERN;

	// Map exponent => style.
	final Map<int, _CompactStyleBase> _styles;

	// Whether positive sign should be explicitly printed.
	final bool _explicitSign;

	factory _CompactNumberFormat(
	{String? locale,
	_CompactFormatType? formatType,
	String? name,
	String? currencySymbol,
	String? Function(NumberSymbols) getPattern = _forDecimal,
	int? decimalDigits,
	bool explicitSign = false,
	bool lookupSimpleCurrencySymbol = false,
	bool isForCurrency = false}) {
	// Initialization copied from `NumberFormat` constructor.
	// TODO(davidmorgan): deduplicate.
	locale = helpers.verifiedLocale(locale, NumberFormat.localeExists, null)!;
	var symbols = numberFormatSymbols[locale] as NumberSymbols;
	var localeZero = symbols.ZERO_DIGIT.codeUnitAt(0);
	var zeroOffset = localeZero - constants.asciiZeroCodeUnit;
	name ??= symbols.DEF_CURRENCY_CODE;
	if (currencySymbol == null && lookupSimpleCurrencySymbol) {
	currencySymbol = constants.simpleCurrencySymbols[name];
	}
	currencySymbol ??= name;
	var pattern = getPattern(symbols);

	// CompactNumberFormat initialization.

	/// Map from magnitude to formatting pattern for that magnitude.
	///
	/// The magnitude is the exponent when using the normalized scientific
	/// notation (so numbers from 1000 to 9999 correspond to magnitude 3).
	///
	/// These patterns are taken from the appropriate CompactNumberSymbols
	/// instance's COMPACT_DECIMAL_SHORT_PATTERN, COMPACT_DECIMAL_LONG_PATTERN,
	/// or COMPACT_DECIMAL_SHORT_CURRENCY_PATTERN members.
	Map<int, Map<String, String>> patterns;

	var compactSymbols = compactNumberSymbols[locale]!;

	var styles = <int, _CompactStyleBase>{};
	switch (formatType) {
	case _CompactFormatType.COMPACT_DECIMAL_SHORT_PATTERN:
	patterns = compactSymbols.COMPACT_DECIMAL_SHORT_PATTERN;
	break;
	case _CompactFormatType.COMPACT_DECIMAL_LONG_PATTERN:
	patterns = compactSymbols.COMPACT_DECIMAL_LONG_PATTERN ??
	compactSymbols.COMPACT_DECIMAL_SHORT_PATTERN;
	break;
	case _CompactFormatType.COMPACT_DECIMAL_SHORT_CURRENCY_PATTERN:
	patterns = compactSymbols.COMPACT_DECIMAL_SHORT_CURRENCY_PATTERN;
	break;
	default:
	throw ArgumentError.notNull('formatType');
	}

	patterns.forEach((int exponent, Map<String, String> patterns) {
	_CompactStyleBase style;
	if (patterns.keys.length == 1 && patterns.keys.single == 'other') {
	// No plural.
	var pattern = patterns.values.single;
	style = _styleFromPattern(pattern, exponent, explicitSign, symbols);
	} else {
	style = _CompactStyleWithPlurals(
	patterns.map((key, value) => MapEntry(key,
	_styleFromPattern(value, exponent, explicitSign, symbols))),
	exponent,
	locale);
	}
	styles[exponent] = style;
	});

	return _CompactNumberFormat._(
	name,
	currencySymbol,
	isForCurrency,
	locale,
	localeZero,
	pattern,
	symbols,
	zeroOffset,
	NumberFormatParser.parse(symbols, pattern, isForCurrency,
	currencySymbol, name, decimalDigits),
	styles,
	explicitSign);
	}

	static _CompactStyleBase _styleFromPattern(
	String pattern, int exponent, bool explicitSign, NumberSymbols symbols) {
	if (pattern.contains(';')) {
	var patterns = pattern.split(';');
	var positivePattern = patterns.first;
	var negativePattern = patterns.last;
	if (explicitSign &&
	!positivePattern.contains(symbols.PLUS_SIGN) &&
	negativePattern.contains(symbols.MINUS_SIGN) &&
	positivePattern ==
	negativePattern.replaceAll(symbols.MINUS_SIGN, '')) {
	// Re-use the negative pattern, with plus sign.
	positivePattern =
	negativePattern.replaceAll(symbols.MINUS_SIGN, symbols.PLUS_SIGN);
	}
	return _CompactStyleWithNegative(
	_CompactStyle.createStyle(symbols, positivePattern, exponent,
	isSigned: positivePattern.contains(symbols.PLUS_SIGN)),
	_CompactStyle.createStyle(symbols, negativePattern, exponent,
	isSigned: true));
	} else {
	return _CompactStyle.createStyle(symbols, pattern, exponent,
	explicitSign: explicitSign);
	}
	}

	_CompactNumberFormat._(
	String currencyName,
	String currencySymbol,
	bool isForCurrency,
	String locale,
	int localeZero,
	String? pattern,
	NumberSymbols symbols,
	int zeroOffset,
	NumberFormatParseResult result,
	// Fields introduced in this class.
	this._styles,
	this._explicitSign)
	: super._(currencyName, currencySymbol, isForCurrency, locale, localeZero,
	pattern, symbols, zeroOffset, result) {
	significantDigits = 3;
	turnOffGrouping();
	}

	@override
	set significantDigits(int? x) {
	// Replicate ICU behavior: set only the minimumSignificantDigits and
	// do not force trailing 0 in fractional part.
	_explicitMinimumFractionDigits = false;
	minimumSignificantDigits = x;
	maximumSignificantDigits = null;
	minimumSignificantDigitsStrict = false;
	}

	@override
	int get minimumFractionDigits =>
	_style != null && !_style!.isFallback && !_explicitMinimumFractionDigits
	? 0
	: super.minimumFractionDigits;

	/// The style in which we will format a particular number.
	///
	/// This is a temporary variable that is only valid within a call to format
	/// and parse.
	_CompactStyle? _style;

	// We delegate prefixes to current _style.
	@override
	String get positivePrefix =>
	_style!.isFallback ? super.positivePrefix : _style!.positivePrefix;
	@override
	String get negativePrefix =>
	_style!.isFallback ? super.negativePrefix : _style!.negativePrefix;
	@override
	String get positiveSuffix =>
	_style!.isFallback ? super.positiveSuffix : _style!.positiveSuffix;
	@override
	String get negativeSuffix =>
	_style!.isFallback ? super.negativeSuffix : _style!.negativeSuffix;

	@override
	String format(dynamic number) {
	var style = _styleFor(number);
	_style = style;
	final divisor = style.isFallback ? 1 : style.divisor;
	final numberToFormat = _divide(number, divisor);
	var formatted = style.isDirectValue
	? '${_signPrefix(number)}${style.pattern}${_signSuffix(number)}'
	: super.format(numberToFormat);
	if (_explicitSign &&
	style.isFallback &&
	number >= 0 &&
	!formatted.contains(symbols.PLUS_SIGN)) {
	formatted = '${symbols.PLUS_SIGN}$formatted';
	}
	if (_isForCurrency && !style.isFallback) {
	formatted = formatted.replaceFirst('\u00a4', currencySymbol);
	}
	_style = null;
	return formatted;
	}

	@override
	bool _useDefaultSignificantDigits() {
	// For non-currencies, or for currencies if the numbers are large enough to
	// compact, always use the number of significant digits and ignore
	// decimalDigits.
	return !_isForCurrency \|\| !_style!.isFallback;
	}

	/// Divide numbers that may not have a division operator (e.g. Int64).
	///
	/// Only used for powers of 10, so we require an integer denominator.
	static num _divide(numerator, int denominator) {
	if (numerator is num) {
	return numerator / denominator;
	}
	// If it doesn't fit in a JS int after division, we're not going to be able
	// to meaningfully print a compact representation for it.
	var divided = numerator ~/ denominator;
	var integerPart = divided.toInt();
	if (divided != integerPart) {
	throw FormatException(
	'Number too big to use with compact format', numerator);
	}
	var remainder = numerator.remainder(denominator).toInt();
	var originalFraction = numerator - (numerator ~/ 1);
	var fraction = originalFraction == 0 ? 0 : originalFraction / denominator;
	return integerPart + (remainder / denominator) + fraction;
	}

	_CompactStyle _styleFor(number) {
	if (number.abs() < 10) {
	// Cannot be compacted.
	return _defaultCompactStyle;
	}
	var rounded = number.toDouble(); // No rounding yet...
	var digitLength = NumberFormat.numberOfIntegerDigits(number);
	var divisor = 1; // Default.

	void updateRounding() {
	var fractionDigits = maximumFractionDigits;
	if (significantDigitsInUse) {
	var divisorLength = NumberFormat.numberOfIntegerDigits(divisor);
	// We have to round the number based on the number of significant
	// digits so that we pick the right style based on the rounded form
	// and format 999999 as 1M rather than 1000K.
	fractionDigits =
	(maximumSignificantDigits ?? minimumSignificantDigits ?? 0) -
	digitLength +
	divisorLength -
	1;
	if (maximumSignificantDigits == null) {
	// Keep all digits of the integer part.
	fractionDigits = max(0, fractionDigits);
	}
	}
	var fractionMultiplier = pow(10, fractionDigits);
	rounded = (rounded * fractionMultiplier / divisor).round() *
	divisor /
	fractionMultiplier;
	digitLength = NumberFormat.numberOfIntegerDigits(rounded);
	}

	updateRounding();

	_CompactStyleBase? style;
	for (var entry in _styles.entries) {
	var exponent = entry.key + 1;
	if (exponent > digitLength) {
	break;
	}
	style = entry.value;
	// Recompute digits length based on new exponent.
	divisor = style.divisor;
	updateRounding();
	}
	return style?.styleForNumber(_divide(number, divisor), this) ??
	_defaultCompactStyle;
	}

	Iterable<_CompactStyle> get _stylesForSearching =>
	_styles.values.expand((x) => x.allStyles);

	String _normalize(String input) {
	return input
	.replaceAll('\u200e', '') // LEFT-TO-RIGHT MARK.
	.replaceAll('\u200f', '') // RIGHT-TO-LEFT MARK.
	.replaceAll('\u0020', '') // SPACE.
	.replaceAll('\u00a0', '') // NO-BREAK SPACE.
	.replaceAll('\u202f', '') // NARROW NO-BREAK SPACE.
	.replaceAll('\u2212', '-'); // MINUS SIGN.
	}

	@override
	num parse(final String inputText) {
	for (var style in [_defaultCompactStyle, ..._stylesForSearching]) {
	_style = style;
	var text = _normalize(inputText);
	var negative = false;
	var negativePrefix = _normalize(style.negativePrefix);
	var negativeSuffix = _normalize(style.negativeSuffix);
	var positivePrefix = _normalize(style.positivePrefix);
	var positiveSuffix = _normalize(style.positiveSuffix);
	if (!style.isFallback) {
	if (text.startsWith(negativePrefix) && text.endsWith(negativeSuffix)) {
	text = text.substring(
	negativePrefix.length, text.length - negativeSuffix.length);
	negative = true;
	} else if (text.startsWith(positivePrefix) &&
	text.endsWith(positiveSuffix)) {
	text = text.substring(
	positivePrefix.length, text.length - positiveSuffix.length);
	} else {
	continue;
	}
	}
	if (style.isDirectValue) {
	// "Direct formatting" pattern (1000 => "mille").
	if (text == style.pattern!) {
	_style = null;
	return style.divisor * (negative ? -1 : 1);
	} else {
	// Do not attempt parsing: no number.
	continue;
	}
	}
	var number = _tryParsing(text);
	if (number == null && _zeroOffset != 0) {
	// Locale has non-roman numerals.
	// Try simple number parse, in case input contains roman numerals.
	number = num.tryParse(text);
	}
	if (number != null) {
	_style = null;
	return number * style.divisor * (negative ? -1 : 1);
	}
	}
	_style = null;

	throw FormatException(
	"Cannot parse compact number in locale '$locale'", inputText);
	}

	/// Returns text parsed into a number if possible, else returns null.
	num? _tryParsing(String text) {
	try {
	return super.parse(text);
	} on FormatException {
	return null;
	}
	}
	}

	final _defaultCompactStyle = _CompactStyle();