description

# normalize method

String normalize(

1. String source, [
2. int start = 0,
3. int? end

])

Validates and normalizes the base64 encoded data in `source`.

Only acts on the substring from `start` to `end`, with `end` defaulting to the end of the string.

Normalization will:

- Unescape any `%`-escapes.
- Only allow valid characters (`A`-`Z`, `a`-`z`, `0`-`9`, `/` and `+`).
- Normalize a `_` or `-` character to `/` or `+`.
- Validate that existing padding (trailing `=` characters) is correct.
- If no padding exists, add correct padding if necessary and possible.
- Validate that the length is correct (a multiple of four).

## Implementation

    String normalize(String source, [int start = 0, int? end]) {
      end = RangeError.checkValidRange(start, end, source.length);
      const percent = 0x25;
      const equals = 0x3d;
      StringBuffer? buffer;
      var sliceStart = start;
      var alphabet = _Base64Encoder._base64Alphabet;
      var inverseAlphabet = _Base64Decoder._inverseAlphabet;
      var firstPadding = -1;
      var firstPaddingSourceIndex = -1;
      var paddingCount = 0;
      for (var i = start; i < end;) {
        var sliceEnd = i;
        var char = source.codeUnitAt(i++);
        var originalChar = char;
        // Normalize char, keep originalChar to see if it matches the source.
        if (char == percent) {
          if (i + 2 <= end) {
            char = parseHexByte(source, i); // May be negative.
            i += 2;
            // We know that %25 isn't valid, but our table considers it
            // a potential padding start, so skip the checks.
            if (char == percent) char = -1;
          } else {
            // An invalid HEX escape (too short).
            // Just skip past the handling and reach the throw below.
            char = -1;
          }
        }
        // If char is negative here, hex-decoding failed in some way.
        if (0 <= char && char <= 127) {
          var value = inverseAlphabet[char];
          if (value >= 0) {
            char = alphabet.codeUnitAt(value);
            if (char == originalChar) continue;
          } else if (value == _Base64Decoder._padding) {
            // We have ruled out percent, so char is '='.
            if (firstPadding < 0) {
              // Mark position in normalized output where padding occurs.
              firstPadding = (buffer?.length ?? 0) + (sliceEnd - sliceStart);
              firstPaddingSourceIndex = sliceEnd;
            }
            paddingCount++;
            // It could have been an escaped equals (%3D).
            if (originalChar == equals) continue;
          }
          if (value != _Base64Decoder._invalid) {
            (buffer ??= StringBuffer())
              ..write(source.substring(sliceStart, sliceEnd))
              ..writeCharCode(char);
            sliceStart = i;
            continue;
          }
        }
        throw FormatException("Invalid base64 data", source, sliceEnd);
      }
      if (buffer != null) {
        buffer.write(source.substring(sliceStart, end));
        if (firstPadding >= 0) {
          // There was padding in the source. Check that it is valid:
          // * result length a multiple of four
          // * one or two padding characters at the end.
          _checkPadding(
            source,
            firstPaddingSourceIndex,
            end,
            firstPadding,
            paddingCount,
            buffer.length,
          );
        } else {
          // Length of last chunk (1-4 chars) in the encoding.
          var endLength = ((buffer.length - 1) % 4) + 1;
          if (endLength == 1) {
            // The data must have length 0, 2 or 3 modulo 4.
            throw FormatException("Invalid base64 encoding length ", source, end);
          }
          while (endLength < 4) {
            buffer.write("=");
            endLength++;
          }
        }
        return source.replaceRange(start, end, buffer.toString());
      }
      // Original was already normalized, only check padding.
      var length = end - start;
      if (firstPadding >= 0) {
        _checkPadding(
          source,
          firstPaddingSourceIndex,
          end,
          firstPadding,
          paddingCount,
          length,
        );
      } else {
        // No padding given, so add some if needed it.
        var endLength = length % 4;
        if (endLength == 1) {
          // The data must have length 0, 2 or 3 modulo 4.
          throw FormatException("Invalid base64 encoding length ", source, end);
        }
        if (endLength > 1) {
          // There is no "insertAt" on String, but this works as well.
          source = source.replaceRange(end, end, (endLength == 2) ? "==" : "=");
        }
      }
      return source;
    }