Add a percent-encoding converter.

lib/src/hex/decoder.dart

 // Copyright (c) 2015, 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.
 
 library convert.hex.decoder;
 
 import 'dart:convert';
 import 'dart:typed_data';
 
-import 'package:charcode/ascii.dart';
+import '../utils.dart';
 
 /// The canonical instance of [HexDecoder].
 const hexDecoder = const HexDecoder._();
 
 /// A converter that decodes hexadecimal strings into byte arrays.
 ///
 /// Because two hexadecimal digits correspond to a single byte, this will throw
 /// a [FormatException] if given an odd-length string. It will also throw a
 /// [FormatException] if given a string containing non-hexadecimal code units.
 class HexDecoder extends Converter<String, List<int>> {
@@ skipping 38 matching lines @@
 
     var codeUnits = string.codeUnits;
     var bytes;
     var bytesStart;
     if (_lastDigit == null) {
       bytes = new Uint8List((end - start) ~/ 2);
       bytesStart = 0;
     } else {
       var hexPairs = (end - start - 1) ~/ 2;
       bytes = new Uint8List(1 + hexPairs);
-      bytes[0] = _lastDigit + _digitForCodeUnit(codeUnits, start);
+      bytes[0] = _lastDigit + digitForCodeUnit(codeUnits, start);
       start++;
       bytesStart = 1;
     }
 
     _lastDigit = _decode(codeUnits, start, end, bytes, bytesStart);
 
     _sink.add(bytes);
     if (isLast) close();
   }
 
@@ skipping 34 matching lines @@
     }
 
     var bytes;
     var bytesStart;
     if (_lastDigit == null) {
       bytes = new Uint8List((end - start) ~/ 2);
       bytesStart = 0;
     } else {
       var hexPairs = (end - start - 1) ~/ 2;
       bytes = new Uint8List(1 + hexPairs);
-      bytes[0] = _lastDigit + _digitForCodeUnit(chunk, start);
+      bytes[0] = _lastDigit + digitForCodeUnit(chunk, start);
       start++;
       bytesStart = 1;
     }
 
     _lastDigit = _decode(chunk, start, end, bytes, bytesStart);
 
     _sink.add(bytes);
     if (isLast) close();
   }
 
@@ skipping 10 matching lines @@
 ///
 /// This reads from [codeUnits] between [sourceStart] and [sourceEnd]. It writes
 /// the result into [destination] starting at [destinationStart].
 ///
 /// If there's a leftover digit at the end of the decoding, this returns that
 /// digit. Otherwise it returns `null`.
 int _decode(List<int> codeUnits, int sourceStart, int sourceEnd,
     List<int> destination, int destinationStart) {
   var destinationIndex = destinationStart;
   for (var i = sourceStart; i < sourceEnd - 1; i += 2) {
-    var firstDigit = _digitForCodeUnit(codeUnits, i);
-    var secondDigit = _digitForCodeUnit(codeUnits, i + 1);
+    var firstDigit = digitForCodeUnit(codeUnits, i);
+    var secondDigit = digitForCodeUnit(codeUnits, i + 1);
     destination[destinationIndex++] = 16 * firstDigit + secondDigit;
   }
 
   if ((sourceEnd - sourceStart).isEven) return null;
-  return 16 * _digitForCodeUnit(codeUnits, sourceEnd - 1);
+  return 16 * digitForCodeUnit(codeUnits, sourceEnd - 1);
 }
-
-/// Returns the digit (0 through 15) corresponding to the hexadecimal code unit
-/// at index [i] in [codeUnits].
-///
-/// If the given code unit isn't valid hexadecimal, throws a [FormatException].
-int _digitForCodeUnit(List<int> codeUnits, int index) {
-  // If the code unit is a numeral, get its value. XOR works because 0 in ASCII
-  // is `0b110000` and the other numerals come after it in ascending order and
-  // take up at most four bits.
-  //
-  // We check for digits first because it ensures there's only a single branch
-  // for 10 out of 16 of the expected cases. We don't count the `digit >= 0`
-  // check because branch prediction will always work on it for valid data.
-  var codeUnit = codeUnits[index];
-  var digit = $0 ^ codeUnit;
-  if (digit <= 9) {
-    if (digit >= 0) return digit;
-  } else {
-    // If the code unit is an uppercase letter, convert it to lowercase. This
-    // works because uppercase letters in ASCII are exactly `0b100000 = 0x20`
-    // less than lowercase letters, so if we ensure that that bit is 1 we ensure
-    // that the letter is lowercase.
-    var letter = 0x20 | codeUnit;
-    if ($a <= letter && letter <= $f) return letter - $a + 10;
-  }
-
-  throw new FormatException(
-      "Invalid hexadecimal code unit "
-          "U+${codeUnit.toRadixString(16).padLeft(4, '0')}.",
-      codeUnits, index);
-}