Normalize UriData.parse result.

sdk/lib/core/uri.dart

 // Copyright (c) 2012, 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 dart.core;
 
 // Frequently used character codes.
 const int _SPACE = 0x20;
 const int _PERCENT = 0x25;
+const int _AMPERSAND = 0x26;
 const int _PLUS = 0x2B;
 const int _DOT = 0x2E;
 const int _SLASH = 0x2F;
 const int _COLON = 0x3A;
+const int _EQUALS = 0x3d;
 const int _UPPER_CASE_A = 0x41;
 const int _UPPER_CASE_Z = 0x5A;
 const int _LEFT_BRACKET = 0x5B;
 const int _BACKSLASH = 0x5C;
 const int _RIGHT_BRACKET = 0x5D;
 const int _LOWER_CASE_A = 0x61;
 const int _LOWER_CASE_F = 0x66;
 const int _LOWER_CASE_Z = 0x7A;
 
 const String _hexDigits = "0123456789ABCDEF";
@@ skipping 1338 matching lines @@
    * The port. Set to null if there is no port. Normalized to null if
    * the port is the default port for the scheme.
    */
   int _port;
 
   /**
    * The path of the URI.
    *
    * Always non-null.
    */
-  String _path;
+  final String path;
 
   // The query content, or null if there is no query.
   final String _query;
 
   // The fragment content, or null if there is no fragment.
   final String _fragment;
 
   /**
    * Cache the computed return value of [pathSegments].
    */
@@ skipping 11 matching lines @@
    */
   int _hashCodeCache;
 
   /**
    * Cache the computed return value of [queryParameters].
    */
   Map<String, String> _queryParameters;
   Map<String, List<String>> _queryParameterLists;
 
   /// Internal non-verifying constructor. Only call with validated arguments.
+  ///
+  /// The components must be properly normalized.
+  ///
+  /// Use `null` for [_host] if there is no authority. In that case, always
+  /// pass `null` for [_port] and [_userInfo] as well.
+  ///
+  /// Use `null` for [_port], [_userInfo], [_query] and [_fragment] if there is
+  /// component of that type.
+  ///
+  /// The [path] and [scheme] are never empty.
   _Uri._internal(this.scheme,
                  this._userInfo,
                  this._host,
                  this._port,
-                 this._path,
+                 this.path,
                  this._query,
                  this._fragment);
 
   /// Create a [_Uri] from parts of [uri].
   ///
   /// The parameters specify the start/end of particular components of the URI.
   /// The [scheme] may contain a string representing a normalized scheme
   /// component if one has already been discovered.
   factory _Uri.notSimple(String uri, int start, int end, int schemeEnd,
                         int hostStart, int portStart, int pathStart,
@@ skipping 117 matching lines @@
     return _port;
   }
 
   // The default port for the scheme of this Uri.
   static int _defaultPort(String scheme) {
     if (scheme == "http") return 80;
     if (scheme == "https") return 443;
     return 0;
   }
 
-  String get path => _path;
-
   String get query => _query ?? "";
 
   String get fragment => _fragment ?? "";
 
   bool isScheme(String scheme) {
     String thisScheme = this.scheme;
     if (scheme == null) return thisScheme.isEmpty;
     if (scheme.length != thisScheme.length) return false;
     return _compareScheme(scheme, thisScheme);
   }
@@ skipping 282 matching lines @@
       host = this._host;
     } else if (userInfo.isNotEmpty || port != null || isFile) {
       host = "";
     }
 
     bool hasAuthority = host != null;
     if (path != null || pathSegments != null) {
       path = _makePath(path, 0, _stringOrNullLength(path), pathSegments,
                        scheme, hasAuthority);
     } else {
-      path = this._path;
+      path = this.path;
       if ((isFile || (hasAuthority && !path.isEmpty)) &&
           !path.startsWith('/')) {
         path = "/" + path;
       }
     }
 
     if (query != null || queryParameters != null) {
       query = _makeQuery(query, 0, _stringOrNullLength(query), queryParameters);
     } else {
       query = this._query;
     }
 
     if (fragment != null) {
       fragment = _makeFragment(fragment, 0, fragment.length);
     } else {
       fragment = this._fragment;
     }
 
     return new _Uri._internal(
         scheme, userInfo, host, port, path, query, fragment);
   }
 
   Uri removeFragment() {
     if (!this.hasFragment) return this;
     return new _Uri._internal(scheme, _userInfo, _host, _port,
-                             _path, _query, null);
+                             path, _query, null);
   }
 
   List<String> get pathSegments {
     var result = _pathSegments;
     if (result != null) return result;
 
     var pathToSplit = path;
     if (pathToSplit.isNotEmpty && pathToSplit.codeUnitAt(0) == _SLASH) {
       pathToSplit = pathToSplit.substring(1);
     }
@@ skipping 20 matching lines @@
         queryParameterLists[key] =
             new List<String>.unmodifiable(queryParameterLists[key]);
       }
       _queryParameterLists =
           new Map<String, List<String>>.unmodifiable(queryParameterLists);
     }
     return _queryParameterLists;
   }
 
   Uri normalizePath() {
-    String path = _normalizePath(_path, scheme, hasAuthority);
-    if (identical(path, _path)) return this;
+    String path = _normalizePath(this.path, scheme, hasAuthority);
+    if (identical(path, this.path)) return this;
     return this.replace(path: path);
   }
 
   static int _makePort(int port, String scheme) {
     // Perform scheme specific normalization.
     if (port != null && port == _defaultPort(scheme)) return null;
     return port;
   }
 
   /**
@@ skipping 146 matching lines @@
   static String _canonicalizeScheme(String scheme) {
     if (scheme == "http") return "http";
     if (scheme == "file") return "file";
     if (scheme == "https") return "https";
     if (scheme == "package") return "package";
     return scheme;
   }
 
   static String _makeUserInfo(String userInfo, int start, int end) {
     if (userInfo == null) return "";
-    return _normalize(userInfo, start, end, _userinfoTable);
+    return _normalizeOrSubstring(userInfo, start, end, _userinfoTable);
   }
 
   static String _makePath(String path, int start, int end,
                           Iterable<String> pathSegments,
                           String scheme,
                           bool hasAuthority) {
     bool isFile = (scheme == "file");
     bool ensureLeadingSlash = isFile || hasAuthority;
     if (path == null && pathSegments == null) return isFile ? "/" : "";
     if (path != null && pathSegments != null) {
       throw new ArgumentError('Both path and pathSegments specified');
     }
     var result;
     if (path != null) {
-      result = _normalize(path, start, end, _pathCharOrSlashTable);
+      result = _normalizeOrSubstring(path, start, end, _pathCharOrSlashTable);
     } else {
       result = pathSegments.map((s) =>
           _uriEncode(_pathCharTable, s, UTF8, false)).join("/");
     }
     if (result.isEmpty) {
       if (isFile) return "/";
     } else if (ensureLeadingSlash && !result.startsWith('/')) {
       result = "/" + result;
     }
     result = _normalizePath(result, scheme, hasAuthority);
@@ skipping 12 matching lines @@
     return _removeDotSegments(path);
   }
 
   static String _makeQuery(
       String query, int start, int end,
       Map<String, dynamic/*String|Iterable<String>*/> queryParameters) {
     if (query != null) {
       if (queryParameters != null) {
         throw new ArgumentError('Both query and queryParameters specified');
       }
-      return _normalize(query, start, end, _queryCharTable);
+      return _normalizeOrSubstring(query, start, end, _queryCharTable);
     }
     if (queryParameters == null) return null;
 
     var result = new StringBuffer();
     var separator = "";
 
     void writeParameter(String key, String value) {
       result.write(separator);
       separator = "&";
       result.write(Uri.encodeQueryComponent(key));
@@ skipping 11 matching lines @@
         for (String value in values) {
           writeParameter(key, value);
         }
       }
     });
     return result.toString();
   }
 
   static String _makeFragment(String fragment, int start, int end) {
     if (fragment == null) return null;
-    return _normalize(fragment, start, end, _queryCharTable);
+    return _normalizeOrSubstring(fragment, start, end, _queryCharTable);
   }
 
   /**
    * Performs RFC 3986 Percent-Encoding Normalization.
    *
    * Returns a replacement string that should be replace the original escape.
    * Returns null if no replacement is necessary because the escape is
    * not for an unreserved character and is already non-lower-case.
    *
    * Returns "%" if the escape is invalid (not two valid hex digits following
    * the percent sign). The calling code should replace the percent
    * sign with "%25", but leave the following two characters unmodified.
    *
    * If [lowerCase] is true, a single character returned is always lower case,
    */
   static String _normalizeEscape(String source, int index, bool lowerCase) {
     assert(source.codeUnitAt(index) == _PERCENT);
     if (index + 2 >= source.length) {
       return "%";  // Marks the escape as invalid.
     }
     int firstDigit = source.codeUnitAt(index + 1);
     int secondDigit = source.codeUnitAt(index + 2);
-    int firstDigitValue = _parseHexDigit(firstDigit);
-    int secondDigitValue = _parseHexDigit(secondDigit);
+    int firstDigitValue = hexDigitValue(firstDigit);
+    int secondDigitValue = hexDigitValue(secondDigit);
     if (firstDigitValue < 0 || secondDigitValue < 0) {
       return "%";  // Marks the escape as invalid.
     }
     int value = firstDigitValue * 16 + secondDigitValue;
     if (_isUnreservedChar(value)) {
       if (lowerCase && _UPPER_CASE_A <= value && _UPPER_CASE_Z >= value) {
         value |= 0x20;
       }
       return new String.fromCharCode(value);
     }
     if (firstDigit >= _LOWER_CASE_A || secondDigit >= _LOWER_CASE_A) {
       // Either digit is lower case.
       return source.substring(index, index + 3).toUpperCase();
     }
     // Escape is retained, and is already non-lower case, so return null to
     // represent "no replacement necessary".
     return null;
   }
 
-  // Converts a UTF-16 code-unit to its value as a hex digit.
-  // Returns -1 for non-hex digits.
-  static int _parseHexDigit(int char) {
-    const int zeroDigit = 0x30;
-    int digit = char ^ zeroDigit;
-    if (digit <= 9) return digit;
-    int lowerCase = char | 0x20;
-    if (_LOWER_CASE_A <= lowerCase && lowerCase <= _LOWER_CASE_F) {
-      return lowerCase - (_LOWER_CASE_A - 10);
-    }
-    return -1;
-  }
-
   static String _escapeChar(int char) {
     assert(char <= 0x10ffff);  // It's a valid unicode code point.
     List<int> codeUnits;
     if (char < 0x80) {
       // ASCII, a single percent encoded sequence.
       codeUnits = new List(3);
       codeUnits[0] = _PERCENT;
       codeUnits[1] = _hexDigits.codeUnitAt(char >> 4);
       codeUnits[2] = _hexDigits.codeUnitAt(char & 0xf);
     } else {
@@ skipping 16 matching lines @@
         codeUnits[index + 1] = _hexDigits.codeUnitAt(byte >> 4);
         codeUnits[index + 2] = _hexDigits.codeUnitAt(byte & 0xf);
         index += 3;
         flag = 0x80;  // Following bytes have only high bit set.
       }
     }
     return new String.fromCharCodes(codeUnits);
   }
 
   /**
+   * Normalizes using [_normalize] or returns substring of original.
+   *
+   * If [_normalize] returns `null` (original content is already normalized),
+   * this methods returns the substring if [component] from [start] to [end].
+   */
+  static String _normalizeOrSubstring(String component, int start, int end,
+                                      List<int> charTable) {
+    return _normalize(component, start, end, charTable) ??
+        component.substring(start, end);
+  }
+
+  /**
    * Runs through component checking that each character is valid and
    * normalize percent escapes.
    *
    * Uses [charTable] to check if a non-`%` character is allowed.
    * Each `%` character must be followed by two hex digits.
    * If the hex-digits are lower case letters, they are converted to
    * upper case.
+   *
+   * Returns `null` if the original content was already normalized.
    */
   static String _normalize(String component, int start, int end,
-                           List<int> charTable) {
+                           List<int> charTable,
+                           {bool escapeDelimiters = false}) {
     StringBuffer buffer;
     int sectionStart = start;
     int index = start;
     // Loop while characters are valid and escapes correct and upper-case.
     while (index < end) {
       int char = component.codeUnitAt(index);
       if (char < 127 && (charTable[char >> 4] & (1 << (char & 0x0f))) != 0) {
         index++;
       } else {
         String replacement;
         int sourceLength;
         if (char == _PERCENT) {
           replacement = _normalizeEscape(component, index, false);
           // Returns null if we should keep the existing escape.
           if (replacement == null) {
             index += 3;
             continue;
           }
           // Returns "%" if we should escape the existing percent.
           if ("%" == replacement) {
             replacement = "%25";
             sourceLength = 1;
           } else {
             sourceLength = 3;
           }
-        } else if (_isGeneralDelimiter(char)) {
+        } else if (!escapeDelimiters && _isGeneralDelimiter(char)) {
           _fail(component, index, "Invalid character");
         } else {
           sourceLength = 1;
           if ((char & 0xFC00) == 0xD800) {
             // Possible lead surrogate.
             if (index + 1 < end) {
               int tail = component.codeUnitAt(index + 1);
               if ((tail & 0xFC00) == 0xDC00) {
                 // Tail surrogate.
                 sourceLength = 2;
                 char = 0x10000 | ((char & 0x3ff) << 10) | (tail & 0x3ff);
               }
             }
           }
           replacement = _escapeChar(char);
         }
         if (buffer == null) buffer = new StringBuffer();
         buffer.write(component.substring(sectionStart, index));
         buffer.write(replacement);
         index += sourceLength;
         sectionStart = index;
       }
     }
     if (buffer == null) {
-      // Makes no copy if start == 0 and end == component.length.
-      return component.substring(start, end);
+      return null;
     }
     if (sectionStart < end) {
       buffer.write(component.substring(sectionStart, end));
     }
     return buffer.toString();
   }
 
   static bool _isSchemeCharacter(int ch) {
     return ch < 128 && ((_schemeTable[ch >> 4] & (1 << (ch & 0x0f))) != 0);
   }
@@ skipping 172 matching lines @@
         targetHost = reference.host;
         targetPort = _makePort(reference.hasPort ? reference.port : null,
                                targetScheme);
         targetPath = _removeDotSegments(reference.path);
         if (reference.hasQuery) targetQuery = reference.query;
       } else {
         targetUserInfo = this._userInfo;
         targetHost = this._host;
         targetPort = this._port;
         if (reference.path == "") {
-          targetPath = this._path;
+          targetPath = this.path;
           if (reference.hasQuery) {
             targetQuery = reference.query;
           } else {
             targetQuery = this._query;
           }
         } else {
           if (reference.hasAbsolutePath) {
             targetPath = _removeDotSegments(reference.path);
           } else {
             // This is the RFC 3986 behavior for merging.
             if (this.hasEmptyPath) {
               if (!this.hasAuthority) {
                 if (!this.hasScheme) {
                   // Keep the path relative if no scheme or authority.
                   targetPath = reference.path;
                 } else {
                   // Remove leading dot-segments if the path is put
                   // beneath a scheme.
                   targetPath = _removeDotSegments(reference.path);
                 }
               } else {
                 // RFC algorithm for base with authority and empty path.
                 targetPath = _removeDotSegments("/" + reference.path);
               }
             } else {
-              var mergedPath = _mergePaths(this._path, reference.path);
+              var mergedPath = _mergePaths(this.path, reference.path);
               if (this.hasScheme || this.hasAuthority || this.hasAbsolutePath) {
                 targetPath = _removeDotSegments(mergedPath);
               } else {
                 // Non-RFC 3986 behavior.
                 // If both base and reference are relative paths,
                 // allow the merged path to start with "..".
                 // The RFC only specifies the case where the base has a scheme.
                 targetPath = _normalizeRelativePath(mergedPath,
                   this.hasScheme || this.hasAuthority);
               }
@@ skipping 16 matching lines @@
   bool get hasScheme => scheme.isNotEmpty;
 
   bool get hasAuthority => _host != null;
 
   bool get hasPort => _port != null;
 
   bool get hasQuery => _query != null;
 
   bool get hasFragment => _fragment != null;
 
-  bool get hasEmptyPath => _path.isEmpty;
+  bool get hasEmptyPath => path.isEmpty;
 
-  bool get hasAbsolutePath => _path.startsWith('/');
+  bool get hasAbsolutePath => path.startsWith('/');
 
   String get origin {
     if (scheme == "") {
       throw new StateError("Cannot use origin without a scheme: $this");
     }
     if (scheme != "http" && scheme != "https") {
       throw new StateError(
         "Origin is only applicable schemes http and https: $this");
     }
     if (_host == null || _host == "") {
@@ skipping 57 matching lines @@
         result.write(host);
         result.write(r"\");
       }
     }
     result.writeAll(segments, r"\");
     if (hasDriveLetter && segments.length == 1) result.write(r"\");
     return result.toString();
   }
 
   bool get _isPathAbsolute {
-    return _path != null && _path.startsWith('/');
+    return path != null && path.startsWith('/');
   }
 
   void _writeAuthority(StringSink ss) {
     if (_userInfo.isNotEmpty) {
       ss.write(_userInfo);
       ss.write("@");
     }
     if (_host != null) ss.write(_host);
     if (_port != null) {
       ss.write(":");
@@ skipping 69 matching lines @@
       if (equalsIndex < 0) {
         key =  _uriDecode(query, start, end, encoding, true);
         value = "";
       } else {
         key = _uriDecode(query, start, equalsIndex, encoding, true);
         value = _uriDecode(query, equalsIndex + 1, end, encoding, true);
       }
       result.putIfAbsent(key, _createList).add(value);
     }
 
-    const int _equals = 0x3d;
-    const int _ampersand = 0x26;
     while (i < query.length) {
       int char = query.codeUnitAt(i);
-      if (char == _equals) {
+      if (char == _EQUALS) {
         if (equalsIndex < 0) equalsIndex = i;
-      } else if (char == _ampersand) {
+      } else if (char == _AMPERSAND) {
         parsePair(start, equalsIndex, i);
         start = i + 1;
         equalsIndex = -1;
       }
       i++;
     }
     parsePair(start, equalsIndex, i);
     return result;
   }
 
@@ skipping 380 matching lines @@
    * `data:` scheme or not.
    *
    * The first speparator ends the mime type. We don't bother with finding
    * the '/' inside the mime type.
    *
    * Each two separators after that marks a parameter key and value.
    *
    * If there is a single separator left, it ends the "base64" marker.
    *
    * So the following separators are found for a text:
-   *
-   *     data:text/plain;foo=bar;base64,ARGLEBARGLE=
-   *         ^          ^   ^   ^      ^
-   *
+   * ```
+   * data:text/plain;foo=bar;base64,ARGLEBARGLE=
+   *     ^          ^   ^   ^      ^
+   * ```
    */
   final List<int> _separatorIndices;
 
   /**
    * Cache of the result returned by [uri].
    */
   Uri _uriCache;
 
   UriData._(this._text, this._separatorIndices, this._uriCache);
 
@@ skipping 180 matching lines @@
    * 'data:' (type '/' subtype)? (';' attribute '=' value)* (';base64')? ',' data
    * ````
    *
    * where `type`, `subtype`, `attribute` and `value` are specified in RFC-2045,
    * and `data` is a sequence of URI-characters (RFC-2396 `uric`).
    *
    * This means that all the characters must be ASCII, but the URI may contain
    * percent-escapes for non-ASCII byte values that need an interpretation
    * to be converted to the corresponding string.
    *
-   * Parsing doesn't check the validity of any part, it just checks that the
-   * input has the correct structure with the correct sequence of `/`, `;`, `=`
-   * and `,` delimiters.
+   * Parsing checks that Base64 encoded data is valid, and it normalizes it
+   * to use the default Base64 alphabet and to use padding.
+   * Non-Base64 data is escaped using percent-escapes as necessary to make
+   * it valid, and existing escapes are case normalized.
    *
    * Accessing the individual parts may fail later if they turn out to have
-   * content that can't be decoded successfully as a string.
+   * content that can't be decoded successfully as a string, for example if
+   * existing percent escapes represent bytes that cannot be decoded
+   * by the chosen [Encoding] (see [contentAsString]).
    */
   static UriData parse(String uri) {
     if (uri.length >= 5) {
       int dataDelta = _startsWithData(uri, 0);
       if (dataDelta == 0) {
         // Exact match on "data:".
         return _parse(uri, 5, null);
       }
       if (dataDelta == 0x20) {
         // Starts with a non-normalized "data" scheme containing upper-case
         // letters. Parse anyway, but throw away the scheme.
         return _parse(uri.substring(5), 0, null);
       }
     }
     throw new FormatException("Does not start with 'data:'", uri, 0);
   }
 
   /**
    * The [Uri] that this `UriData` is giving access to.
    *
    * Returns a `Uri` with scheme `data` and the remainder of the data URI
    * as path.
    */
   Uri get uri {
     if (_uriCache != null) return _uriCache;
     String path = _text;
     String query = null;
     int colonIndex = _separatorIndices[0];
     int queryIndex = _text.indexOf('?', colonIndex + 1);
-    int end = null;
+    int end = _text.length;
     if (queryIndex >= 0) {
-      query = _text.substring(queryIndex + 1);
+      query = _Uri._normalizeOrSubstring(_text, queryIndex + 1, end, _Uri._queryCharTable);
       end = queryIndex;
     }
-    path = _text.substring(colonIndex + 1, end);
-    // TODO(lrn): This can generate a URI that isn't path normalized.
-    // That's perfectly reasonable - data URIs are not hierarchical,
-    // but it may make some consumers stumble.
-    // Should we at least do escape normalization?
-    _uriCache = new _Uri._internal("data", "", null, null, path, query, null);
+    path = _Uri._normalizeOrSubstring(_text, colonIndex + 1, end,
+        _Uri._pathCharOrSlashTable);
+    _uriCache = new _DataUri(this, path, query);
     return _uriCache;
   }
 
   /**
    * The MIME type of the data URI.
    *
    * A data URI consists of a "media type" followed by data.
    * The media type starts with a MIME type and can be followed by
    * extra parameters.
+   * If the MIME type representation in the URI text contains URI escapes,
+   * they are unescaped in the returned string.
+   * If the value contain non-ASCII percent escapes, they are decoded as UTF-8.
    *
    * Example:
    *
    *     data:text/plain;charset=utf-8,Hello%20World!
    *
    * This data URI has the media type `text/plain;charset=utf-8`, which is the
    * MIME type `text/plain` with the parameter `charset` with value `utf-8`.
    * See [RFC 2045](https://tools.ietf.org/html/rfc2045) for more detail.
    *
    * If the first part of the data URI is empty, it defaults to `text/plain`.
    */
   String get mimeType {
     int start = _separatorIndices[0] + 1;
     int end = _separatorIndices[1];
     if (start == end) return "text/plain";
     return _Uri._uriDecode(_text, start, end, UTF8, false);
   }
 
   /**
    * The charset parameter of the media type.
    *
    * If the parameters of the media type contains a `charset` parameter
    * then this returns its value, otherwise it returns `US-ASCII`,
    * which is the default charset for data URIs.
+   * If the value contain non-ASCII percent escapes, they are decoded as UTF-8.
+   *
+   * If the MIME type representation in the URI text contains URI escapes,
+   * they are unescaped in the returned string.
    */
   String get charset {
     int parameterStart = 1;
     int parameterEnd = _separatorIndices.length - 1;  // The ',' before data.
     if (isBase64) {
       // There is a ";base64" separator, so subtract one for that as well.
       parameterEnd -= 1;
     }
     for (int i = parameterStart; i < parameterEnd; i += 2) {
       var keyStart = _separatorIndices[i] + 1;
@@ skipping 51 matching lines @@
       result.setRange(0, length, text.codeUnits, start);
       return result;
     }
     int index = 0;
     for (int i = start; i < text.length; i++) {
       var codeUnit = text.codeUnitAt(i);
       if (codeUnit != percent) {
         result[index++] = codeUnit;
       } else {
         if (i + 2 < text.length) {
-          var digit1 = _Uri._parseHexDigit(text.codeUnitAt(i + 1));
-          var digit2 = _Uri._parseHexDigit(text.codeUnitAt(i + 2));
-          if (digit1 >= 0 && digit2 >= 0) {
-            int byte = digit1 * 16 + digit2;
+          int byte = parseHexByte(text, i + 1);
+          if (byte >= 0) {
             result[index++] = byte;
             i += 2;
             continue;
           }
         }
         throw new FormatException("Invalid percent escape", text, i);
       }
     }
     assert(index == result.length);
     return result;
@@ skipping 34 matching lines @@
    * A map representing the parameters of the media type.
    *
    * A data URI may contain parameters between the MIME type and the
    * data. This converts these parameters to a map from parameter name
    * to parameter value.
    * The map only contains parameters that actually occur in the URI.
    * The `charset` parameter has a default value even if it doesn't occur
    * in the URI, which is reflected by the [charset] getter. This means that
    * [charset] may return a value even if `parameters["charset"]` is `null`.
    *
-   * If the values contain non-ASCII values or percent escapes, they default
-   * to being decoded as UTF-8.
+   * If the values contain non-ASCII values or percent escapes,
+   * they are decoded as UTF-8.
    */
   Map<String, String> get parameters {
     var result = <String, String>{};
     for (int i = 3; i < _separatorIndices.length; i += 2) {
       var start = _separatorIndices[i - 2] + 1;
       var equals = _separatorIndices[i - 1];
       var end = _separatorIndices[i];
       String key = _Uri._uriDecode(_text, start, equals, UTF8, false);
       String value = _Uri._uriDecode(_text,equals + 1, end, UTF8, false);
       result[key] = value;
@@ skipping 50 matching lines @@
         var lastSeparator = indices.last;
         if (char != comma ||
             i != lastSeparator + 7 /* "base64,".length */ ||
             !text.startsWith("base64", lastSeparator + 1)) {
           throw new FormatException("Expecting '='", text, i);
         }
         break;
       }
     }
     indices.add(i);
+    bool isBase64 = indices.length.isOdd;
+    if (isBase64) {
+      text = BASE64.normalize(text, i + 1, text.length);
+    } else {
+      // Validate "data" part, must only contain RFC 2396 'uric' characters
+      // (reserved, unreserved, or escape sequences).
+      // Normalize to this (throws on a fragment separator).
+      var data = _Uri._normalize(text, i + 1, text.length, _uricTable,
+                                 escapeDelimiters: true);
+      if (data != null) {
+        text = text.replaceRange(i + 1, text.length, data);
+      }
+    }
     return new UriData._(text, indices, sourceUri);
   }
 
   /**
    * Like [Uri._uriEncode] but takes the input as bytes, not a string.
    *
    * Encodes into [buffer] instead of creating its own buffer.
    */
   static void _uriEncodeBytes(List<int> canonicalTable,
                               List<int> bytes,
@@ skipping 53 matching lines @@
 
   // All non-escape RFC-2396 uric characters.
   //
   //  uric        =  reserved | unreserved | escaped
   //  reserved    =  ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ","
   //  unreserved  =  alphanum | mark
   //  mark        =  "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
   //
   // This is the same characters as in a URI query (which is URI pchar plus '?')
   static const _uricTable = _Uri._queryCharTable;
+
+  // Characters allowed in base-64 encoding (alphanumeric, '/', '+' and '=').
+  static const _base64Table = const [
+                //             LSB             MSB
+                //              |               |
+      0x0000,   // 0x00 - 0x0f  00000000 00000000
+      0x0000,   // 0x10 - 0x1f  00000000 00000000
+                //                          +   /
+      0x8800,   // 0x20 - 0x2f  00000000 00010001
+                //              01234567 89
+      0x03ff,   // 0x30 - 0x3f  11111111 11000000
+                //               ABCDEFG HIJKLMNO
+      0xfffe,   // 0x40 - 0x4f  01111111 11111111
+                //              PQRSTUVW XYZ
+      0x07ff,   // 0x50 - 0x5f  11111111 11100000
+                //               abcdefg hijklmno
+      0xfffe,   // 0x60 - 0x6f  01111111 11111111
+                //              pqrstuvw xyz
+      0x07ff,   // 0x70 - 0x7f  11111111 11100000
+  ];
 }
 
 // --------------------------------------------------------------------
 // Constants used to read the scanner result.
 // The indices points into the table filled by [_scan] which contains
 // recognized positions in the scanned URI.
 // The `0` index is only used internally.
 
 /// Index of the position of that `:` after a scheme.
 const int _schemeEndIndex     = 1;
@@ skipping 829 matching lines @@
       this.hasPort ? this.port : null,
       this.path,
       this.hasQuery ? this.query : null,
       this.hasFragment ? this.fragment : null
     );
   }
 
   String toString() => _uri;
 }
 
+/// Special [_Uri] created from an existing [UriData].
+class _DataUri extends _Uri {
+  final UriData _data;
+
+  _DataUri(this._data, String path, String query)
+      : super._internal("data", null, null, null, path, query, null);
+
+  UriData get data => _data;
+}
+
 /// Checks whether [text] starts with "data:" at position [start].
 ///
 /// The text must be long enough to allow reading five characters
 /// from the [start] position.
 ///
 /// Returns an integer value which is zero if text starts with all-lowercase
 /// "data:" and 0x20 if the text starts with "data:" that isn't all lower-case.
 /// All other values means the text starts with some other character.
 int _startsWithData(String text, int start) {
   // Multiply by 3 to avoid a non-colon character making delta be 0x20.
   int delta = (text.codeUnitAt(start + 4) ^ _COLON) * 3;
   delta |= text.codeUnitAt(start)     ^ 0x64 /*d*/;
   delta |= text.codeUnitAt(start + 1) ^ 0x61 /*a*/;
   delta |= text.codeUnitAt(start + 2) ^ 0x74 /*t*/;
   delta |= text.codeUnitAt(start + 3) ^ 0x61 /*a*/;
   return delta;
 }
 
 /// Helper function returning the length of a string, or `0` for `null`.
 int _stringOrNullLength(String s) => (s == null) ? 0 : s.length;