function paritionNumberIntoParts(symbols, numberResult, notation, exponent, numberingSystem, useGrouping, 
  /**
   * This is the decimal number pattern without signs or symbols.
   * It is used to infer the group size when `useGrouping` is true.
   *
   * A typical value looks like "#,##0.00" (primary group size is 3).
   * Some locales like Hindi has secondary group size of 2 (e.g. "#,##,##0.00").
   */
  decimalNumberPattern) {
      var result = [];
      // eslint-disable-next-line prefer-const
      var n = numberResult.formattedString, x = numberResult.roundedNumber;
      if (isNaN(x)) {
          return [{ type: 'nan', value: n }];
      }
      else if (!isFinite(x)) {
          return [{ type: 'infinity', value: n }];
      }
      var digitReplacementTable = digitMapping$1[numberingSystem];
      if (digitReplacementTable) {
          n = n.replace(/\d/g, function (digit) { return digitReplacementTable[+digit] || digit; });
      }
      // TODO: Else use an implementation dependent algorithm to map n to the appropriate
      // representation of n in the given numbering system.
      var decimalSepIndex = n.indexOf('.');
      var integer;
      var fraction;
      if (decimalSepIndex > 0) {
          integer = n.slice(0, decimalSepIndex);
          fraction = n.slice(decimalSepIndex + 1);
      }
      else {
          integer = n;
      }
      // #region Grouping integer digits
      // The weird compact and x >= 10000 check is to ensure consistency with Node.js and Chrome.
      // Note that `de` does not have compact form for thousands, but Node.js does not insert grouping separator
      // unless the rounded number is greater than 10000:
      //   NumberFormat('de', {notation: 'compact', compactDisplay: 'short'}).format(1234) //=> "1234"
      //   NumberFormat('de').format(1234) //=> "1.234"
      if (useGrouping && (notation !== 'compact' || x >= 10000)) {
          var groupSepSymbol = symbols.group;
          var groups = [];
          // > There may be two different grouping sizes: The primary grouping size used for the least
          // > significant integer group, and the secondary grouping size used for more significant groups.
          // > If a pattern contains multiple grouping separators, the interval between the last one and the
          // > end of the integer defines the primary grouping size, and the interval between the last two
          // > defines the secondary grouping size. All others are ignored.
          var integerNumberPattern = decimalNumberPattern.split('.')[0];
          var patternGroups = integerNumberPattern.split(',');
          var primaryGroupingSize = 3;
          var secondaryGroupingSize = 3;
          if (patternGroups.length > 1) {
              primaryGroupingSize = patternGroups[patternGroups.length - 1].length;
          }
          if (patternGroups.length > 2) {
              secondaryGroupingSize = patternGroups[patternGroups.length - 2].length;
          }
          var i = integer.length - primaryGroupingSize;
          if (i > 0) {
              // Slice the least significant integer group
              groups.push(integer.slice(i, i + primaryGroupingSize));
              // Then iteratively push the more signicant groups
              // TODO: handle surrogate pairs in some numbering system digits
              for (i -= secondaryGroupingSize; i > 0; i -= secondaryGroupingSize) {
                  groups.push(integer.slice(i, i + secondaryGroupingSize));
              }
              groups.push(integer.slice(0, i + secondaryGroupingSize));
          }
          else {
              groups.push(integer);
          }
          while (groups.length > 0) {
              var integerGroup = groups.pop();
              result.push({ type: 'integer', value: integerGroup });
              if (groups.length > 0) {
                  result.push({ type: 'group', value: groupSepSymbol });
              }
          }
      }
      else {
          result.push({ type: 'integer', value: integer });
      }
      // #endregion
      if (fraction !== undefined) {
          result.push({ type: 'decimal', value: symbols.decimal }, { type: 'fraction', value: fraction });
      }
      if ((notation === 'scientific' || notation === 'engineering') &&
          isFinite(x)) {
          result.push({ type: 'exponentSeparator', value: symbols.exponential });
          if (exponent < 0) {
              result.push({ type: 'exponentMinusSign', value: symbols.minusSign });
              exponent = -exponent;
          }
          var exponentResult = ToRawFixed(exponent, 0, 0);
          result.push({
              type: 'exponentInteger',
              value: exponentResult.formattedString,
          });
      }
      return result;
  }
This is the decimal number pattern without signs or symbols.
It is used to infer the group size when `useGrouping` is true.

A typical value looks like "#,##0.00" (primary group size is 3).
Some locales like Hindi has secondary group size of 2 (e.g. "#,##,##0.00").