Tweak corelib files so dartfmt can do a better job. Use // comments to force line wrapping for long…

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;
@@ skipping 100 matching lines @@
    * use an empty map for `queryParameters`.
    *
    * If both `query` and `queryParameters` are omitted or `null`,
    * the URI has no query part.
    *
    * The fragment component is set through [fragment].
    * It should be a valid URI fragment, but invalid characters other than
    * general delimiters, are escaped if necessary.
    * If `fragment` is omitted or `null`, the URI has no fragment part.
    */
-  factory Uri({String scheme,
-               String userInfo,
-               String host,
-               int port,
-               String path,
-               Iterable<String> pathSegments,
-               String query,
-               Map<String, dynamic/*String|Iterable<String>*/> queryParameters,
-               String fragment}) = _Uri;
+  factory Uri(
+      {String scheme,
+      String userInfo,
+      String host,
+      int port,
+      String path,
+      Iterable<String> pathSegments,
+      String query,
+      Map<String, dynamic /*String|Iterable<String>*/ > queryParameters,
+      String fragment}) = _Uri;
 
   /**
    * Creates a new `http` URI from authority, path and query.
    *
    * Examples:
    *
    * ```
    * // http://example.org/path?q=dart.
    * new Uri.http("example.org", "/path", { "q" : "dart" });
    *
@@ skipping 14 matching lines @@
    * the created `Uri` has no authority, and isn't directly usable
    * as an HTTP URL, which must have a non-empty host.
    *
    * The `path` component is set from the [unencodedPath]
    * argument. The path passed must not be encoded as this constructor
    * encodes the path.
    *
    * The `query` component is set from the optional [queryParameters]
    * argument.
    */
-  factory Uri.http(String authority,
-                   String unencodedPath,
-                   [Map<String, String> queryParameters]) = _Uri.http;
+  factory Uri.http(String authority, String unencodedPath,
+      [Map<String, String> queryParameters]) = _Uri.http;
 
   /**
    * Creates a new `https` URI from authority, path and query.
    *
    * This constructor is the same as [Uri.http] except for the scheme
    * which is set to `https`.
    */
-  factory Uri.https(String authority,
-                    String unencodedPath,
-                    [Map<String, String> queryParameters]) = _Uri.https;
+  factory Uri.https(String authority, String unencodedPath,
+      [Map<String, String> queryParameters]) = _Uri.https;
 
   /**
    * Creates a new file URI from an absolute or relative file path.
    *
    * The file path is passed in [path].
    *
    * This path is interpreted using either Windows or non-Windows
    * semantics.
    *
    * With non-Windows semantics the slash (`/`) is used to separate
@@ skipping 104 matching lines @@
    * If [mimeType] and/or [parameters] are supplied, they are added to the
    * created URI. If any of these contain characters that are not allowed
    * in the data URI, the character is percent-escaped. If the character is
    * non-ASCII, it is first UTF-8 encoded and then the bytes are percent
    * encoded. An omitted [mimeType] in a data URI means `text/plain`, just
    * as an omitted `charset` parameter defaults to meaning `US-ASCII`.
    *
    * To read the content back, use [UriData.contentAsString].
    */
   factory Uri.dataFromString(String content,
-                             {String mimeType,
-                              Encoding encoding,
-                              Map<String, String> parameters,
-                              bool base64: false}) {
-    UriData data =  new UriData.fromString(content,
-                                           mimeType: mimeType,
-                                           encoding: encoding,
-                                           parameters: parameters,
-                                           base64: base64);
+      {String mimeType,
+      Encoding encoding,
+      Map<String, String> parameters,
+      bool base64: false}) {
+    UriData data = new UriData.fromString(content,
+        mimeType: mimeType,
+        encoding: encoding,
+        parameters: parameters,
+        base64: base64);
     return data.uri;
   }
 
   /**
    * Creates a `data:` URI containing an encoding of [bytes].
    *
    * Defaults to Base64 encoding the bytes, but if [percentEncoded]
    * is `true`, the bytes will instead be percent encoded (any non-ASCII
    * or non-valid-ASCII-character byte is replaced by a percent encoding).
    *
    * To read the bytes back, use [UriData.contentAsBytes].
    *
    * It defaults to having the mime-type `application/octet-stream`.
    * The [mimeType] and [parameters] are added to the created URI.
    * If any of these contain characters that are not allowed
    * in the data URI, the character is percent-escaped. If the character is
    * non-ASCII, it is first UTF-8 encoded and then the bytes are percent
    * encoded.
    */
   factory Uri.dataFromBytes(List<int> bytes,
-                            {mimeType: "application/octet-stream",
-                             Map<String, String> parameters,
-                             percentEncoded: false}) {
+      {mimeType: "application/octet-stream",
+      Map<String, String> parameters,
+      percentEncoded: false}) {
     UriData data = new UriData.fromBytes(bytes,
-                                         mimeType: mimeType,
-                                         parameters: parameters,
-                                         percentEncoded: percentEncoded);
+        mimeType: mimeType,
+        parameters: parameters,
+        percentEncoded: percentEncoded);
     return data.uri;
   }
 
   /**
    * The scheme component of the URI.
    *
    * Returns the empty string if there is no scheme component.
    *
    * A URI scheme is case insensitive.
    * The returned scheme is canonicalized to lowercase letters.
@@ skipping 260 matching lines @@
    * of a `data:` URI.
    */
   UriData get data;
 
   /// Returns a hash code computed as `toString().hashCode`.
   ///
   /// This guarantees that URIs with the same normalized
   int get hashCode;
 
   /// A URI is equal to another URI with the same normalized representation.
-  bool operator==(Object other);
+  bool operator ==(Object other);
 
   /// Returns the normalized string representation of the URI.
   String toString();
 
   /**
    * Returns a new `Uri` based on this one, but with some parts replaced.
    *
    * This method takes the same parameters as the [new Uri] constructor,
    * and they have the same meaning.
    *
@@ skipping 24 matching lines @@
    *         path: "D/E/E",
    *         query: uri1.query,
    *         fragment: "G");
    *     print(uri3);  // prints "a://b@c:4/D/E/E?f#G"
    *     print(uri2 == uri3);  // prints true.
    *
    * Using this method can be seen as a shorthand for the `Uri` constructor
    * call above, but may also be slightly faster because the parts taken
    * from this `Uri` need not be checked for validity again.
    */
-  Uri replace({String scheme,
-               String userInfo,
-               String host,
-               int port,
-               String path,
-               Iterable<String> pathSegments,
-               String query,
-               Map<String, dynamic/*String|Iterable<String>*/> queryParameters,
-               String fragment});
+  Uri replace(
+      {String scheme,
+      String userInfo,
+      String host,
+      int port,
+      String path,
+      Iterable<String> pathSegments,
+      String query,
+      Map<String, dynamic /*String|Iterable<String>*/ > queryParameters,
+      String fragment});
 
   /**
    * Returns a `Uri` that differs from this only in not having a fragment.
    *
    * If this `Uri` does not have a fragment, it is itself returned.
    */
   Uri removeFragment();
 
   /**
    * Resolve [reference] as an URI relative to `this`.
@@ skipping 115 matching lines @@
         return UriData._parse(uri, 5, null).uri;
       } else if (dataDelta == 0x20) {
         return UriData._parse(uri.substring(start + 5, end), 0, null).uri;
       }
       // Otherwise the URI doesn't start with "data:" or any case variant of it.
     }
 
     // The following index-normalization belongs with the scanning, but is
     // easier to do here because we already have extracted variables from the
     // indices list.
-    var indices = new List<int>(8);//new List<int>.filled(8, start - 1);
+    var indices = new List<int>(8);
 
     // Set default values for each position.
     // The value will either be correct in some cases where it isn't set
     // by the scanner, or it is clearly recognizable as an unset value.
     indices
       ..[0] = 0
       ..[_schemeEndIndex] = start - 1
       ..[_hostStartIndex] = start - 1
       ..[_notSimpleIndex] = start - 1
       ..[_portStartIndex] = start
@@ skipping 15 matching lines @@
         indices[_notSimpleIndex] = schemeEnd;
       }
     }
     // The returned positions are limited by the scanners ability to write only
     // one position per character, and only the current position.
     // Scanning from left to right, we only know whether something is a scheme
     // or a path when we see a `:` or `/`, and likewise we only know if the first
     // `/` is part of the path or is leading an authority component when we see
     // the next character.
 
-    int hostStart     = indices[_hostStartIndex] + 1;
-    int portStart     = indices[_portStartIndex];
-    int pathStart     = indices[_pathStartIndex];
-    int queryStart    = indices[_queryStartIndex];
+    int hostStart = indices[_hostStartIndex] + 1;
+    int portStart = indices[_portStartIndex];
+    int pathStart = indices[_pathStartIndex];
+    int queryStart = indices[_queryStartIndex];
     int fragmentStart = indices[_fragmentStartIndex];
 
     // We may discover scheme while handling special cases.
     String scheme;
 
     // Derive some positions that weren't set to normalize the indices.
     // If pathStart isn't set (it's before scheme end or host start), then
     // the path is empty.
     if (fragmentStart < queryStart) queryStart = fragmentStart;
     if (pathStart < hostStart || pathStart <= schemeEnd) {
@@ skipping 21 matching lines @@
       if (hostStart > schemeEnd + 3) {
         // Always be non-simple if URI contains user-info.
         // The scanner doesn't set the not-simple position in this case because
         // it's setting the host-start position instead.
         isSimple = false;
       } else if (portStart > start && portStart + 1 == pathStart) {
         // If the port is empty, it should be omitted.
         // Pathological case, don't bother correcting it.
         isSimple = false;
       } else if (queryStart < end &&
-                 (queryStart == pathStart + 2 &&
+              (queryStart == pathStart + 2 &&
                   uri.startsWith("..", pathStart)) ||
-                 (queryStart > pathStart + 2 &&
-                  uri.startsWith("/..", queryStart - 3))) {
+          (queryStart > pathStart + 2 &&
+              uri.startsWith("/..", queryStart - 3))) {
         // The path ends in a ".." segment. This should be normalized to "../".
         // We didn't detect this while scanning because a query or fragment was
         // detected at the same time (which is why we only need to check this
         // if there is something after the path).
         isSimple = false;
       } else {
         // There are a few scheme-based normalizations that
         // the scanner couldn't check.
         // That means that the input is very close to simple, so just do
         // the normalizations.
@@ skipping 21 matching lines @@
               end = uri.length;
             } else if (pathStart == queryStart) {
               // Uri has authority and empty path. Add "/" as path.
               if (start == 0 && end == uri.length) {
                 uri = uri.replaceRange(pathStart, queryStart, "/");
                 queryStart += 1;
                 fragmentStart += 1;
                 end += 1;
               } else {
                 uri = "${uri.substring(start, pathStart)}/"
-                      "${uri.substring(queryStart, end)}";
+                    "${uri.substring(queryStart, end)}";
                 schemeEnd -= start;
                 hostStart -= start;
                 portStart -= start;
                 pathStart -= start;
                 queryStart += 1 - start;
                 fragmentStart += 1 - start;
                 start = 0;
                 end = uri.length;
               }
             }
           } else if (uri.startsWith("http", start)) {
             scheme = "http";
             // HTTP URIs should not have an explicit port of 80.
-            if (portStart > start && portStart + 3 == pathStart &&
+            if (portStart > start &&
+                portStart + 3 == pathStart &&
                 uri.startsWith("80", portStart + 1)) {
               if (start == 0 && end == uri.length) {
                 uri = uri.replaceRange(portStart, pathStart, "");
                 pathStart -= 3;
                 queryStart -= 3;
                 fragmentStart -= 3;
                 end -= 3;
               } else {
                 uri = uri.substring(start, portStart) +
-                      uri.substring(pathStart, end);
+                    uri.substring(pathStart, end);
                 schemeEnd -= start;
                 hostStart -= start;
                 portStart -= start;
                 pathStart -= 3 + start;
                 queryStart -= 3 + start;
                 fragmentStart -= 3 + start;
                 start = 0;
                 end = uri.length;
               }
             }
           }
         } else if (schemeEnd == start + 5 && uri.startsWith("https", start)) {
           scheme = "https";
           // HTTPS URIs should not have an explicit port of 443.
-          if (portStart > start && portStart + 4 == pathStart &&
+          if (portStart > start &&
+              portStart + 4 == pathStart &&
               uri.startsWith("443", portStart + 1)) {
             if (start == 0 && end == uri.length) {
               uri = uri.replaceRange(portStart, pathStart, "");
               pathStart -= 4;
               queryStart -= 4;
               fragmentStart -= 4;
               end -= 3;
             } else {
               uri = uri.substring(start, portStart) +
-                    uri.substring(pathStart, end);
+                  uri.substring(pathStart, end);
               schemeEnd -= start;
               hostStart -= start;
               portStart -= start;
               pathStart -= 4 + start;
               queryStart -= 4 + start;
               fragmentStart -= 4 + start;
               start = 0;
               end = uri.length;
             }
           }
         }
       }
     }
 
     if (isSimple) {
       if (start > 0 || end < uri.length) {
         uri = uri.substring(start, end);
         schemeEnd -= start;
         hostStart -= start;
         portStart -= start;
         pathStart -= start;
         queryStart -= start;
         fragmentStart -= start;
       }
       return new _SimpleUri(uri, schemeEnd, hostStart, portStart, pathStart,
-                            queryStart, fragmentStart, scheme);
-
+          queryStart, fragmentStart, scheme);
     }
 
     return new _Uri.notSimple(uri, start, end, schemeEnd, hostStart, portStart,
-                              pathStart, queryStart, fragmentStart, scheme);
+        pathStart, queryStart, fragmentStart, scheme);
   }
 
   /**
    * Encode the string [component] using percent-encoding to make it
    * safe for literal use as a URI component.
    *
    * All characters except uppercase and lowercase letters, digits and
    * the characters `-_.!~*'()` are percent-encoded. This is the
    * set of characters specified in RFC 2396 and the which is
    * specified for the encodeUriComponent in ECMA-262 version 5.1.
@@ skipping 40 matching lines @@
    * part separately before building the query string.
    *
    * To avoid the need for explicitly encoding the query use the
    * [queryParameters] optional named arguments when constructing a
    * [Uri].
    *
    * See http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.2 for more
    * details.
    */
   static String encodeQueryComponent(String component,
-                                     {Encoding encoding: UTF8}) {
+      {Encoding encoding: UTF8}) {
     return _Uri._uriEncode(_Uri._unreservedTable, component, encoding, true);
   }
 
   /**
    * Decodes the percent-encoding in [encodedComponent].
    *
    * Note that decoding a URI component might change its meaning as
    * some of the decoded characters could be characters with are
    * delimiters for a given URI component type. Always split a URI
    * component using the delimiters for the component before decoding
    * the individual parts.
    *
    * For handling the [path] and [query] components consider using
    * [pathSegments] and [queryParameters] to get the separated and
    * decoded component.
    */
   static String decodeComponent(String encodedComponent) {
-    return _Uri._uriDecode(encodedComponent, 0, encodedComponent.length,
-                           UTF8, false);
+    return _Uri._uriDecode(
+        encodedComponent, 0, encodedComponent.length, UTF8, false);
   }
 
   /**
    * Decodes the percent-encoding in [encodedComponent], converting
    * pluses to spaces.
    *
    * It will create a byte-list of the decoded characters, and then use
    * [encoding] to decode the byte-list to a String. The default encoding is
    * UTF-8.
    */
-  static String decodeQueryComponent(
-      String encodedComponent,
+  static String decodeQueryComponent(String encodedComponent,
       {Encoding encoding: UTF8}) {
-    return _Uri._uriDecode(encodedComponent, 0, encodedComponent.length,
-                           encoding, true);
+    return _Uri._uriDecode(
+        encodedComponent, 0, encodedComponent.length, encoding, true);
   }
 
   /**
    * Encode the string [uri] using percent-encoding to make it
    * safe for literal use as a full URI.
    *
    * All characters except uppercase and lowercase letters, digits and
    * the characters `!#$&'()*+,-./:;=?@_~` are percent-encoded. This
    * is the set of characters specified in in ECMA-262 version 5.1 for
    * the encodeURI function .
@@ skipping 21 matching lines @@
    * Each key and value in the returned map has been decoded. If the [query]
    * is the empty string an empty map is returned.
    *
    * Keys in the query string that have no value are mapped to the
    * empty string.
    *
    * Each query component will be decoded using [encoding]. The default encoding
    * is UTF-8.
    */
   static Map<String, String> splitQueryString(String query,
-                                              {Encoding encoding: UTF8}) {
+      {Encoding encoding: UTF8}) {
     return query.split("&").fold({}, (map, element) {
       int index = element.indexOf("=");
       if (index == -1) {
         if (element != "") {
           map[decodeQueryComponent(element, encoding: encoding)] = "";
         }
       } else if (index != 0) {
         var key = element.substring(0, index);
         var value = element.substring(index + 1);
         map[decodeQueryComponent(key, encoding: encoding)] =
             decodeQueryComponent(value, encoding: encoding);
       }
       return map;
     });
   }
 
-
   /**
    * Parse the [host] as an IP version 4 (IPv4) address, returning the address
    * as a list of 4 bytes in network byte order (big endian).
    *
    * Throws a [FormatException] if [host] is not a valid IPv4 address
    * representation.
    */
   static List<int> parseIPv4Address(String host) =>
-       _parseIPv4Address(host, 0, host.length);
+      _parseIPv4Address(host, 0, host.length);
 
   /// Implementation of [parseIPv4Address] that can work on a substring.
   static List<int> _parseIPv4Address(String host, int start, int end) {
     void error(String msg, int position) {
       throw new FormatException('Illegal IPv4 address, $msg', host, position);
     }
 
     var result = new Uint8List(4);
     int partIndex = 0;
     int partStart = start;
@@ skipping 220 matching lines @@
   ///
   /// 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._query,
-                 this._fragment);
+  _Uri._internal(this.scheme, this._userInfo, this._host, this._port, 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,
-                        int queryStart, int fragmentStart, String scheme) {
+  factory _Uri.notSimple(
+      String uri,
+      int start,
+      int end,
+      int schemeEnd,
+      int hostStart,
+      int portStart,
+      int pathStart,
+      int queryStart,
+      int fragmentStart,
+      String scheme) {
     if (scheme == null) {
       scheme = "";
       if (schemeEnd > start) {
         scheme = _makeScheme(uri, start, schemeEnd);
       } else if (schemeEnd == start) {
         _fail(uri, start, "Invalid empty scheme");
       }
     }
     String userInfo = "";
     String host;
     int port;
     if (hostStart > start) {
       int userInfoStart = schemeEnd + 3;
       if (userInfoStart < hostStart) {
         userInfo = _makeUserInfo(uri, userInfoStart, hostStart - 1);
       }
       host = _makeHost(uri, hostStart, portStart, false);
       if (portStart + 1 < pathStart) {
         // Should throw because invalid.
         port = int.parse(uri.substring(portStart + 1, pathStart), onError: (_) {
           throw new FormatException("Invalid port", uri, portStart + 1);
         });
         port = _makePort(port, scheme);
       }
     }
-    String path = _makePath(uri, pathStart, queryStart, null,
-                            scheme, host != null);
+    String path =
+        _makePath(uri, pathStart, queryStart, null, scheme, host != null);
     String query;
     if (queryStart < fragmentStart) {
       query = _makeQuery(uri, queryStart + 1, fragmentStart, null);
     }
     String fragment;
     if (fragmentStart < end) {
       fragment = _makeFragment(uri, fragmentStart + 1, end);
     }
-    return new _Uri._internal(scheme,
-                              userInfo,
-                              host,
-                              port,
-                              path,
-                              query,
-                              fragment);
+    return new _Uri._internal(
+        scheme, userInfo, host, port, path, query, fragment);
   }
 
   /// Implementation of [Uri.Uri].
-  factory _Uri({String scheme,
-                String userInfo,
-                String host,
-                int port,
-                String path,
-                Iterable<String> pathSegments,
-                String query,
-                Map<String, dynamic/*String|Iterable<String>*/> queryParameters,
-                String fragment}) {
+  factory _Uri(
+      {String scheme,
+      String userInfo,
+      String host,
+      int port,
+      String path,
+      Iterable<String> pathSegments,
+      String query,
+      Map<String, dynamic /*String|Iterable<String>*/ > queryParameters,
+      String fragment}) {
     scheme = _makeScheme(scheme, 0, _stringOrNullLength(scheme));
     userInfo = _makeUserInfo(userInfo, 0, _stringOrNullLength(userInfo));
     host = _makeHost(host, 0, _stringOrNullLength(host), false);
     // Special case this constructor for backwards compatibility.
     if (query == "") query = null;
     query = _makeQuery(query, 0, _stringOrNullLength(query), queryParameters);
     fragment = _makeFragment(fragment, 0, _stringOrNullLength(fragment));
     port = _makePort(port, scheme);
     bool isFile = (scheme == "file");
-    if (host == null &&
-        (userInfo.isNotEmpty || port != null || isFile)) {
+    if (host == null && (userInfo.isNotEmpty || port != null || isFile)) {
       host = "";
     }
     bool hasAuthority = (host != null);
-    path = _makePath(path, 0, _stringOrNullLength(path), pathSegments,
-                     scheme, hasAuthority);
+    path = _makePath(
+        path, 0, _stringOrNullLength(path), pathSegments, scheme, hasAuthority);
     if (scheme.isEmpty && host == null && !path.startsWith('/')) {
       bool allowScheme = scheme.isNotEmpty || host != null;
       path = _normalizeRelativePath(path, allowScheme);
     } else {
       path = _removeDotSegments(path);
     }
     if (host == null && path.startsWith("//")) {
       host = "";
     }
-    return new _Uri._internal(scheme, userInfo, host, port,
-                              path, query, fragment);
+    return new _Uri._internal(
+        scheme, userInfo, host, port, path, query, fragment);
   }
 
   /// Implementation of [Uri.http].
-  factory _Uri.http(String authority,
-                    String unencodedPath,
-                    [Map<String, String> queryParameters]) {
+  factory _Uri.http(String authority, String unencodedPath,
+      [Map<String, String> queryParameters]) {
     return _makeHttpUri("http", authority, unencodedPath, queryParameters);
   }
 
   /// Implementation of [Uri.https].
-  factory _Uri.https(String authority,
-                     String unencodedPath,
-                     [Map<String, String> queryParameters]) {
+  factory _Uri.https(String authority, String unencodedPath,
+      [Map<String, String> queryParameters]) {
     return _makeHttpUri("https", authority, unencodedPath, queryParameters);
   }
 
   String get authority {
     if (!hasAuthority) return "";
     var sb = new StringBuffer();
     _writeAuthority(sb);
     return sb.toString();
   }
 
@@ skipping 59 matching lines @@
       }
     }
     return true;
   }
 
   // Report a parse failure.
   static void _fail(String uri, int index, String message) {
     throw new FormatException(message, uri, index);
   }
 
-  static Uri _makeHttpUri(String scheme,
-                          String authority,
-                          String unencodedPath,
-                          Map<String, String> queryParameters) {
+  static Uri _makeHttpUri(String scheme, String authority, String unencodedPath,
+      Map<String, String> queryParameters) {
     var userInfo = "";
     var host = null;
     var port = null;
 
     if (authority != null && authority.isNotEmpty) {
       var hostStart = 0;
       // Split off the user info.
       bool hasUserInfo = false;
       for (int i = 0; i < authority.length; i++) {
         const int atSign = 0x40;
         if (authority.codeUnitAt(i) == atSign) {
           hasUserInfo = true;
           userInfo = authority.substring(0, i);
           hostStart = i + 1;
           break;
         }
       }
       var hostEnd = hostStart;
       if (hostStart < authority.length &&
           authority.codeUnitAt(hostStart) == _LEFT_BRACKET) {
         // IPv6 host.
         for (; hostEnd < authority.length; hostEnd++) {
           if (authority.codeUnitAt(hostEnd) == _RIGHT_BRACKET) break;
         }
         if (hostEnd == authority.length) {
-          throw new FormatException("Invalid IPv6 host entry.",
-                                    authority, hostStart);
+          throw new FormatException(
+              "Invalid IPv6 host entry.", authority, hostStart);
         }
         Uri.parseIPv6Address(authority, hostStart + 1, hostEnd);
-        hostEnd++;  // Skip the closing bracket.
+        hostEnd++; // Skip the closing bracket.
         if (hostEnd != authority.length &&
             authority.codeUnitAt(hostEnd) != _COLON) {
-          throw new FormatException("Invalid end of authority",
-                                    authority, hostEnd);
+          throw new FormatException(
+              "Invalid end of authority", authority, hostEnd);
         }
       }
       // Split host and port.
       bool hasPort = false;
       for (; hostEnd < authority.length; hostEnd++) {
         if (authority.codeUnitAt(hostEnd) == _COLON) {
           var portString = authority.substring(hostEnd + 1);
           // We allow the empty port - falling back to initial value.
           if (portString.isNotEmpty) port = int.parse(portString);
           break;
         }
       }
       host = authority.substring(hostStart, hostEnd);
     }
-    return new Uri(scheme: scheme,
-                   userInfo: userInfo,
-                   host: host,
-                   port: port,
-                   pathSegments: unencodedPath.split("/"),
-                   queryParameters: queryParameters);
+    return new Uri(
+        scheme: scheme,
+        userInfo: userInfo,
+        host: host,
+        port: port,
+        pathSegments: unencodedPath.split("/"),
+        queryParameters: queryParameters);
   }
 
   /// Implementation of [Uri.file].
   factory _Uri.file(String path, {bool windows}) {
     windows = (windows == null) ? _Uri._isWindows : windows;
-    return windows ? _makeWindowsFileUrl(path, false)
-                   : _makeFileUri(path, false);
+    return windows
+        ? _makeWindowsFileUrl(path, false)
+        : _makeFileUri(path, false);
   }
 
   /// Implementation of [Uri.directory].
   factory _Uri.directory(String path, {bool windows}) {
     windows = (windows == null) ? _Uri._isWindows : windows;
-    return windows ? _makeWindowsFileUrl(path, true)
-                   : _makeFileUri(path, true);
+    return windows ? _makeWindowsFileUrl(path, true) : _makeFileUri(path, true);
   }
 
-
   /// Used internally in path-related constructors.
   external static bool get _isWindows;
 
-  static _checkNonWindowsPathReservedCharacters(List<String> segments,
-                                                bool argumentError) {
+  static _checkNonWindowsPathReservedCharacters(
+      List<String> segments, bool argumentError) {
     segments.forEach((segment) {
       if (segment.contains("/")) {
         if (argumentError) {
           throw new ArgumentError("Illegal path character $segment");
         } else {
           throw new UnsupportedError("Illegal path character $segment");
         }
       }
     });
   }
 
-  static _checkWindowsPathReservedCharacters(List<String> segments,
-                                             bool argumentError,
-                                             [int firstSegment = 0]) {
+  static _checkWindowsPathReservedCharacters(
+      List<String> segments, bool argumentError,
+      [int firstSegment = 0]) {
     for (var segment in segments.skip(firstSegment)) {
       if (segment.contains(new RegExp(r'["*/:<>?\\|]'))) {
         if (argumentError) {
           throw new ArgumentError("Illegal character in path");
         } else {
           throw new UnsupportedError("Illegal character in path");
         }
       }
     }
   }
 
   static _checkWindowsDriveLetter(int charCode, bool argumentError) {
     if ((_UPPER_CASE_A <= charCode && charCode <= _UPPER_CASE_Z) ||
         (_LOWER_CASE_A <= charCode && charCode <= _LOWER_CASE_Z)) {
       return;
     }
     if (argumentError) {
-      throw new ArgumentError("Illegal drive letter " +
-                              new String.fromCharCode(charCode));
+      throw new ArgumentError(
+          "Illegal drive letter " + new String.fromCharCode(charCode));
     } else {
-      throw new UnsupportedError("Illegal drive letter " +
-                              new String.fromCharCode(charCode));
+      throw new UnsupportedError(
+          "Illegal drive letter " + new String.fromCharCode(charCode));
     }
   }
 
   static _makeFileUri(String path, bool slashTerminated) {
     const String sep = "/";
     var segments = path.split(sep);
-    if (slashTerminated &&
-        segments.isNotEmpty &&
-        segments.last.isNotEmpty) {
-      segments.add("");  // Extra separator at end.
+    if (slashTerminated && segments.isNotEmpty && segments.last.isNotEmpty) {
+      segments.add(""); // Extra separator at end.
     }
     if (path.startsWith(sep)) {
       // Absolute file:// URI.
       return new Uri(scheme: "file", pathSegments: segments);
     } else {
       // Relative URI.
       return new Uri(pathSegments: segments);
     }
   }
 
@@ skipping 15 matching lines @@
     }
     const String sep = r'\';
     if (path.length > 1 && path.codeUnitAt(1) == _COLON) {
       _checkWindowsDriveLetter(path.codeUnitAt(0), true);
       if (path.length == 2 || path.codeUnitAt(2) != _BACKSLASH) {
         throw new ArgumentError(
             "Windows paths with drive letter must be absolute");
       }
       // Absolute file://C:/ URI.
       var pathSegments = path.split(sep);
-      if (slashTerminated &&
-          pathSegments.last.isNotEmpty) {
-        pathSegments.add("");  // Extra separator at end.
+      if (slashTerminated && pathSegments.last.isNotEmpty) {
+        pathSegments.add(""); // Extra separator at end.
       }
       _checkWindowsPathReservedCharacters(pathSegments, true, 1);
       return new Uri(scheme: "file", pathSegments: pathSegments);
     }
 
     if (path.startsWith(sep)) {
       if (path.startsWith(sep, 1)) {
         // Absolute file:// URI with host.
         int pathStart = path.indexOf(r'\', 2);
         String hostPart =
             (pathStart < 0) ? path.substring(2) : path.substring(2, pathStart);
-        String pathPart =
-            (pathStart < 0) ? "" : path.substring(pathStart + 1);
+        String pathPart = (pathStart < 0) ? "" : path.substring(pathStart + 1);
         var pathSegments = pathPart.split(sep);
         _checkWindowsPathReservedCharacters(pathSegments, true);
-        if (slashTerminated &&
-            pathSegments.last.isNotEmpty) {
-          pathSegments.add("");  // Extra separator at end.
+        if (slashTerminated && pathSegments.last.isNotEmpty) {
+          pathSegments.add(""); // Extra separator at end.
         }
         return new Uri(
             scheme: "file", host: hostPart, pathSegments: pathSegments);
       } else {
         // Absolute file:// URI.
         var pathSegments = path.split(sep);
-        if (slashTerminated &&
-            pathSegments.last.isNotEmpty) {
-          pathSegments.add("");  // Extra separator at end.
+        if (slashTerminated && pathSegments.last.isNotEmpty) {
+          pathSegments.add(""); // Extra separator at end.
         }
         _checkWindowsPathReservedCharacters(pathSegments, true);
         return new Uri(scheme: "file", pathSegments: pathSegments);
       }
     } else {
       // Relative URI.
       var pathSegments = path.split(sep);
       _checkWindowsPathReservedCharacters(pathSegments, true);
       if (slashTerminated &&
           pathSegments.isNotEmpty &&
           pathSegments.last.isNotEmpty) {
-        pathSegments.add("");  // Extra separator at end.
+        pathSegments.add(""); // Extra separator at end.
       }
       return new Uri(pathSegments: pathSegments);
     }
   }
 
-  Uri replace({String scheme,
-               String userInfo,
-               String host,
-               int port,
-               String path,
-               Iterable<String> pathSegments,
-               String query,
-               Map<String, dynamic/*String|Iterable<String>*/> queryParameters,
-               String fragment}) {
+  Uri replace(
+      {String scheme,
+      String userInfo,
+      String host,
+      int port,
+      String path,
+      Iterable<String> pathSegments,
+      String query,
+      Map<String, dynamic /*String|Iterable<String>*/ > queryParameters,
+      String fragment}) {
     // Set to true if the scheme has (potentially) changed.
     // In that case, the default port may also have changed and we need
     // to check even the existing port.
     bool schemeChanged = false;
     if (scheme != null) {
       scheme = _makeScheme(scheme, 0, scheme.length);
       schemeChanged = (scheme != this.scheme);
     } else {
       scheme = this.scheme;
     }
@@ skipping 15 matching lines @@
     if (host != null) {
       host = _makeHost(host, 0, host.length, false);
     } else if (this.hasAuthority) {
       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);
+      path = _makePath(path, 0, _stringOrNullLength(path), pathSegments, scheme,
+          hasAuthority);
     } else {
       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);
+    return new _Uri._internal(
+        scheme, _userInfo, _host, _port, 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);
     }
     result = (pathToSplit == "")
-        ? const<String>[]
+        ? const <String>[]
         : new List<String>.unmodifiable(
-              pathToSplit.split("/").map(Uri.decodeComponent));
+            pathToSplit.split("/").map(Uri.decodeComponent));
     _pathSegments = result;
     return result;
   }
 
   Map<String, String> get queryParameters {
     if (_queryParameters == null) {
       _queryParameters =
           new UnmodifiableMapView<String, String>(Uri.splitQueryString(query));
     }
     return _queryParameters;
@@ skipping 178 matching lines @@
     if (scheme == "package") return "package";
     return scheme;
   }
 
   static String _makeUserInfo(String userInfo, int start, int end) {
     if (userInfo == null) return "";
     return _normalizeOrSubstring(userInfo, start, end, _userinfoTable);
   }
 
   static String _makePath(String path, int start, int end,
-                          Iterable<String> pathSegments,
-                          String scheme,
-                          bool hasAuthority) {
+      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 = _normalizeOrSubstring(path, start, end, _pathCharOrSlashTable);
     } else {
-      result = pathSegments.map((s) =>
-          _uriEncode(_pathCharTable, s, UTF8, false)).join("/");
+      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);
     return result;
   }
 
   /// Performs path normalization (remove dot segments) on a path.
   ///
   /// If the URI has neither scheme nor authority, it's considered a
   /// "pure path" and normalization won't remove leading ".." segments.
   /// Otherwise it follows the RFC 3986 "remove dot segments" algorithm.
   static String _normalizePath(String path, String scheme, bool hasAuthority) {
     if (scheme.isEmpty && !hasAuthority && !path.startsWith('/')) {
       return _normalizeRelativePath(path, scheme.isNotEmpty || hasAuthority);
     }
     return _removeDotSegments(path);
   }
 
-  static String _makeQuery(
-      String query, int start, int end,
-      Map<String, dynamic/*String|Iterable<String>*/> queryParameters) {
+  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 _normalizeOrSubstring(query, start, end, _queryCharTable);
     }
     if (queryParameters == null) return null;
 
     var result = new StringBuffer();
     var separator = "";
@@ skipping 35 matching lines @@
    *
    * 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.
+      return "%"; // Marks the escape as invalid.
     }
     int firstDigit = source.codeUnitAt(index + 1);
     int secondDigit = source.codeUnitAt(index + 2);
     int firstDigitValue = hexDigitValue(firstDigit);
     int secondDigitValue = hexDigitValue(secondDigit);
     if (firstDigitValue < 0 || secondDigitValue < 0) {
-      return "%";  // Marks the escape as invalid.
+      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;
   }
 
   static String _escapeChar(int char) {
-    assert(char <= 0x10ffff);  // It's a valid unicode code point.
+    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 {
       // Do UTF-8 encoding of character, then percent encode bytes.
-      int flag = 0xc0;  // The high-bit markers on the first byte of UTF-8.
+      int flag = 0xc0; // The high-bit markers on the first byte of UTF-8.
       int encodedBytes = 2;
       if (char > 0x7ff) {
         flag = 0xe0;
         encodedBytes = 3;
         if (char > 0xffff) {
           encodedBytes = 4;
           flag = 0xf0;
         }
       }
       codeUnits = new List(3 * encodedBytes);
       int index = 0;
       while (--encodedBytes >= 0) {
         int byte = ((char >> (6 * encodedBytes)) & 0x3f) | flag;
         codeUnits[index] = _PERCENT;
         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.
+        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) {
+  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,
-                           {bool escapeDelimiters = false}) {
+  static String _normalize(
+      String component, int start, int end, 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;
@@ skipping 81 matching lines @@
       // If we see a "." or ".." segment in base, stop here and let
       // _removeDotSegments handle it.
       if ((delta == 2 || delta == 3) &&
           base.codeUnitAt(newEnd + 1) == _DOT &&
           (delta == 2 || base.codeUnitAt(newEnd + 2) == _DOT)) {
         break;
       }
       baseEnd = newEnd;
       backCount--;
     }
-    return base.replaceRange(baseEnd + 1, null,
-                             reference.substring(refStart - 3 * backCount));
+    return base.replaceRange(
+        baseEnd + 1, null, reference.substring(refStart - 3 * backCount));
   }
 
   /// Make a guess at whether a path contains a `..` or `.` segment.
   ///
   /// This is a primitive test that can cause false positives.
   /// It's only used to avoid a more expensive operation in the case where
   /// it's not necessary.
   static bool _mayContainDotSegments(String path) {
     if (path.startsWith('.')) return true;
     int index = path.indexOf("/.");
     return index != -1;
   }
 
   /// Removes '.' and '..' segments from a path.
   ///
   /// Follows the RFC 2986 "remove dot segments" algorithm.
   /// This algorithm is only used on paths of URIs with a scheme,
   /// and it treats the path as if it is absolute (leading '..' are removed).
   static String _removeDotSegments(String path) {
     if (!_mayContainDotSegments(path)) return path;
-    assert(path.isNotEmpty);  // An empty path would not have dot segments.
+    assert(path.isNotEmpty); // An empty path would not have dot segments.
     List<String> output = [];
     bool appendSlash = false;
     for (String segment in path.split("/")) {
       appendSlash = false;
       if (segment == "..") {
         if (output.isNotEmpty) {
           output.removeLast();
           if (output.isEmpty) {
             output.add("");
           }
@@ skipping 14 matching lines @@
   /// If the path starts with something that looks like a scheme,
   /// and [allowScheme] is false, the colon is escaped.
   ///
   /// Removing the ".." from a "bar/foo/.." sequence results in "bar/"
   /// (trailing "/"). If the entire path is removed (because it contains as
   /// many ".." segments as real segments), the result is "./".
   /// This is different from an empty string, which represents "no path",
   /// when you resolve it against a base URI with a path with a non-empty
   /// final segment.
   static String _normalizeRelativePath(String path, bool allowScheme) {
-    assert(!path.startsWith('/'));  // Only get called for relative paths.
+    assert(!path.startsWith('/')); // Only get called for relative paths.
     if (!_mayContainDotSegments(path)) {
       if (!allowScheme) path = _escapeScheme(path);
       return path;
     }
-    assert(path.isNotEmpty);  // An empty path would not have dot segments.
+    assert(path.isNotEmpty); // An empty path would not have dot segments.
     List<String> output = [];
     bool appendSlash = false;
     for (String segment in path.split("/")) {
       appendSlash = false;
       if (".." == segment) {
         if (!output.isEmpty && output.last != "..") {
           output.removeLast();
           appendSlash = true;
         } else {
           output.add("..");
@@ skipping 50 matching lines @@
       }
       targetPath = _removeDotSegments(reference.path);
       if (reference.hasQuery) {
         targetQuery = reference.query;
       }
     } else {
       targetScheme = this.scheme;
       if (reference.hasAuthority) {
         targetUserInfo = reference.userInfo;
         targetHost = reference.host;
-        targetPort = _makePort(reference.hasPort ? reference.port : null,
-                               targetScheme);
+        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;
           if (reference.hasQuery) {
             targetQuery = reference.query;
@@ skipping 21 matching lines @@
               }
             } else {
               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);
+                targetPath = _normalizeRelativePath(
+                    mergedPath, this.hasScheme || this.hasAuthority);
               }
             }
           }
           if (reference.hasQuery) targetQuery = reference.query;
         }
       }
     }
     String fragment = reference.hasFragment ? reference.fragment : null;
-    return new _Uri._internal(targetScheme,
-                              targetUserInfo,
-                              targetHost,
-                              targetPort,
-                              targetPath,
-                              targetQuery,
-                              fragment);
+    return new _Uri._internal(targetScheme, targetUserInfo, targetHost,
+        targetPort, targetPath, targetQuery, fragment);
   }
 
   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 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");
+          "Origin is only applicable schemes http and https: $this");
     }
     if (_host == null || _host == "") {
       throw new StateError(
           "A $scheme: URI should have a non-empty host name: $this");
     }
     if (_port == null) return "$scheme://$_host";
     return "$scheme://$_host:$_port";
   }
 
   String toFilePath({bool windows}) {
@@ skipping 94 matching lines @@
       // The empty URI means "localhost".
       sb.write("//");
       _writeAuthority(sb);
     }
     sb.write(path);
     if (_query != null) sb..write("?")..write(_query);
     if (_fragment != null) sb..write("#")..write(_fragment);
     return sb.toString();
   }
 
-  bool operator==(other) {
+  bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is Uri) {
       Uri uri = other;
-      return scheme       == uri.scheme       &&
-             hasAuthority == uri.hasAuthority &&
-             userInfo     == uri.userInfo     &&
-             host         == uri.host         &&
-             port         == uri.port         &&
-             path         == uri.path         &&
-             hasQuery     == uri.hasQuery     &&
-             query        == uri.query        &&
-             hasFragment  == uri.hasFragment  &&
-             fragment     == uri.fragment;
+      return scheme == uri.scheme &&
+          hasAuthority == uri.hasAuthority &&
+          userInfo == uri.userInfo &&
+          host == uri.host &&
+          port == uri.port &&
+          path == uri.path &&
+          hasQuery == uri.hasQuery &&
+          query == uri.query &&
+          hasFragment == uri.hasFragment &&
+          fragment == uri.fragment;
     }
     return false;
   }
 
   int get hashCode {
     return _hashCodeCache ??= toString().hashCode;
   }
 
   static List _createList() => [];
 
-  static Map _splitQueryStringAll(
-      String query, {Encoding encoding: UTF8}) {
+  static Map _splitQueryStringAll(String query, {Encoding encoding: UTF8}) {
     Map result = {};
     int i = 0;
     int start = 0;
     int equalsIndex = -1;
 
     void parsePair(int start, int equalsIndex, int end) {
       String key;
       String value;
       if (start == end) return;
       if (equalsIndex < 0) {
-        key =  _uriDecode(query, start, end, encoding, true);
+        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);
     }
 
     while (i < query.length) {
       int char = query.codeUnitAt(i);
       if (char == _EQUALS) {
         if (equalsIndex < 0) equalsIndex = i;
       } else if (char == _AMPERSAND) {
         parsePair(start, equalsIndex, i);
         start = i + 1;
         equalsIndex = -1;
       }
       i++;
     }
     parsePair(start, equalsIndex, i);
     return result;
   }
 
-  external static String _uriEncode(List<int> canonicalTable,
-                                    String text,
-                                    Encoding encoding,
-                                    bool spaceToPlus);
+  external static String _uriEncode(List<int> canonicalTable, String text,
+      Encoding encoding, bool spaceToPlus);
 
   /**
    * Convert a byte (2 character hex sequence) in string [s] starting
    * at position [pos] to its ordinal value
    */
   static int _hexCharPairToByte(String s, int pos) {
     int byte = 0;
     for (int i = 0; i < 2; i++) {
       var charCode = s.codeUnitAt(pos + i);
       if (0x30 <= charCode && charCode <= 0x39) {
@@ skipping 16 matching lines @@
    *
    * It unescapes the string [text] and returns the unescaped string.
    *
    * This function is similar to the JavaScript-function `decodeURI`.
    *
    * If [plusToSpace] is `true`, plus characters will be converted to spaces.
    *
    * The decoder will create a byte-list of the percent-encoded parts, and then
    * decode the byte-list using [encoding]. The default encodings UTF-8.
    */
-  static String _uriDecode(String text,
-                           int start,
-                           int end,
-                           Encoding encoding,
-                           bool plusToSpace) {
+  static String _uriDecode(
+      String text, int start, int end, Encoding encoding, bool plusToSpace) {
     assert(0 <= start);
     assert(start <= end);
     assert(end <= text.length);
     assert(encoding != null);
     // First check whether there is any characters which need special handling.
     bool simple = true;
     for (int i = start; i < end; i++) {
       var codeUnit = text.codeUnitAt(i);
       if (codeUnit > 127 ||
           codeUnit == _PERCENT ||
@@ skipping 32 matching lines @@
     return encoding.decode(bytes);
   }
 
   static bool _isAlphabeticCharacter(int codeUnit) {
     var lowerCase = codeUnit | 0x20;
     return (_LOWER_CASE_A <= lowerCase && lowerCase <= _LOWER_CASE_Z);
   }
 
   static bool _isUnreservedChar(int char) {
     return char < 127 &&
-           ((_unreservedTable[char >> 4] & (1 << (char & 0x0f))) != 0);
+        ((_unreservedTable[char >> 4] & (1 << (char & 0x0f))) != 0);
   }
 
   // Tables of char-codes organized as a bit vector of 128 bits where
   // each bit indicate whether a character code on the 0-127 needs to
   // be escaped or not.
 
   // The unreserved characters of RFC 3986.
   static const _unreservedTable = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //                           -.
-      0x6000,   // 0x20 - 0x2f  0000000000000110
-                //              0123456789
-      0x03ff,   // 0x30 - 0x3f  1111111111000000
-                //               ABCDEFGHIJKLMNO
-      0xfffe,   // 0x40 - 0x4f  0111111111111111
-                //              PQRSTUVWXYZ    _
-      0x87ff,   // 0x50 - 0x5f  1111111111100001
-                //               abcdefghijklmno
-      0xfffe,   // 0x60 - 0x6f  0111111111111111
-                //              pqrstuvwxyz   ~
-      0x47ff];  // 0x70 - 0x7f  1111111111100010
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                                   -.
+    0x6000, // 0x20 - 0x2f  0000000000000110
+    //                      0123456789
+    0x03ff, // 0x30 - 0x3f  1111111111000000
+    //                       ABCDEFGHIJKLMNO
+    0xfffe, // 0x40 - 0x4f  0111111111111111
+    //                      PQRSTUVWXYZ    _
+    0x87ff, // 0x50 - 0x5f  1111111111100001
+    //                       abcdefghijklmno
+    0xfffe, // 0x60 - 0x6f  0111111111111111
+    //                      pqrstuvwxyz   ~
+    0x47ff, // 0x70 - 0x7f  1111111111100010
+  ];
 
   // The unreserved characters of RFC 2396.
   static const _unreserved2396Table = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //               !     '()*  -.
-      0x6782,   // 0x20 - 0x2f  0100000111100110
-                //              0123456789
-      0x03ff,   // 0x30 - 0x3f  1111111111000000
-                //               ABCDEFGHIJKLMNO
-      0xfffe,   // 0x40 - 0x4f  0111111111111111
-                //              PQRSTUVWXYZ    _
-      0x87ff,   // 0x50 - 0x5f  1111111111100001
-                //               abcdefghijklmno
-      0xfffe,   // 0x60 - 0x6f  0111111111111111
-                //              pqrstuvwxyz   ~
-      0x47ff];  // 0x70 - 0x7f  1111111111100010
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                       !     '()*  -.
+    0x6782, // 0x20 - 0x2f  0100000111100110
+    //                      0123456789
+    0x03ff, // 0x30 - 0x3f  1111111111000000
+    //                       ABCDEFGHIJKLMNO
+    0xfffe, // 0x40 - 0x4f  0111111111111111
+    //                      PQRSTUVWXYZ    _
+    0x87ff, // 0x50 - 0x5f  1111111111100001
+    //                       abcdefghijklmno
+    0xfffe, // 0x60 - 0x6f  0111111111111111
+    //                      pqrstuvwxyz   ~
+    0x47ff, // 0x70 - 0x7f  1111111111100010
+  ];
 
   // Table of reserved characters specified by ECMAScript 5.
   static const _encodeFullTable = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //               ! #$ &'()*+,-./
-      0xffda,   // 0x20 - 0x2f  0101101111111111
-                //              0123456789:; = ?
-      0xafff,   // 0x30 - 0x3f  1111111111110101
-                //              @ABCDEFGHIJKLMNO
-      0xffff,   // 0x40 - 0x4f  1111111111111111
-                //              PQRSTUVWXYZ    _
-      0x87ff,   // 0x50 - 0x5f  1111111111100001
-                //               abcdefghijklmno
-      0xfffe,   // 0x60 - 0x6f  0111111111111111
-                //              pqrstuvwxyz   ~
-      0x47ff];  // 0x70 - 0x7f  1111111111100010
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                       ! #$ &'()*+,-./
+    0xffda, // 0x20 - 0x2f  0101101111111111
+    //                      0123456789:; = ?
+    0xafff, // 0x30 - 0x3f  1111111111110101
+    //                      @ABCDEFGHIJKLMNO
+    0xffff, // 0x40 - 0x4f  1111111111111111
+    //                      PQRSTUVWXYZ    _
+    0x87ff, // 0x50 - 0x5f  1111111111100001
+    //                       abcdefghijklmno
+    0xfffe, // 0x60 - 0x6f  0111111111111111
+    //                      pqrstuvwxyz   ~
+    0x47ff, // 0x70 - 0x7f  1111111111100010
+  ];
 
   // Characters allowed in the scheme.
   static const _schemeTable = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //                         + -.
-      0x6800,   // 0x20 - 0x2f  0000000000010110
-                //              0123456789
-      0x03ff,   // 0x30 - 0x3f  1111111111000000
-                //               ABCDEFGHIJKLMNO
-      0xfffe,   // 0x40 - 0x4f  0111111111111111
-                //              PQRSTUVWXYZ
-      0x07ff,   // 0x50 - 0x5f  1111111111100001
-                //               abcdefghijklmno
-      0xfffe,   // 0x60 - 0x6f  0111111111111111
-                //              pqrstuvwxyz
-      0x07ff];  // 0x70 - 0x7f  1111111111100010
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                                 + -.
+    0x6800, // 0x20 - 0x2f  0000000000010110
+    //                      0123456789
+    0x03ff, // 0x30 - 0x3f  1111111111000000
+    //                       ABCDEFGHIJKLMNO
+    0xfffe, // 0x40 - 0x4f  0111111111111111
+    //                      PQRSTUVWXYZ
+    0x07ff, // 0x50 - 0x5f  1111111111100001
+    //                       abcdefghijklmno
+    0xfffe, // 0x60 - 0x6f  0111111111111111
+    //                      pqrstuvwxyz
+    0x07ff, // 0x70 - 0x7f  1111111111100010
+  ];
 
   // Characters allowed in scheme except for upper case letters.
   static const _schemeLowerTable = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //                         + -.
-      0x6800,   // 0x20 - 0x2f  0000000000010110
-                //              0123456789
-      0x03ff,   // 0x30 - 0x3f  1111111111000000
-                //
-      0x0000,   // 0x40 - 0x4f  0111111111111111
-                //
-      0x0000,   // 0x50 - 0x5f  1111111111100001
-                //               abcdefghijklmno
-      0xfffe,   // 0x60 - 0x6f  0111111111111111
-                //              pqrstuvwxyz
-      0x07ff];  // 0x70 - 0x7f  1111111111100010
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                                 + -.
+    0x6800, // 0x20 - 0x2f  0000000000010110
+    //                      0123456789
+    0x03ff, // 0x30 - 0x3f  1111111111000000
+    //
+    0x0000, // 0x40 - 0x4f  0111111111111111
+    //
+    0x0000, // 0x50 - 0x5f  1111111111100001
+    //                       abcdefghijklmno
+    0xfffe, // 0x60 - 0x6f  0111111111111111
+    //                      pqrstuvwxyz
+    0x07ff, // 0x70 - 0x7f  1111111111100010
+  ];
 
   // Sub delimiter characters combined with unreserved as of 3986.
   // sub-delims  = "!" / "$" / "&" / "'" / "(" / ")"
-  //             / "*" / "+" / "," / ";" / "="
+  //         / "*" / "+" / "," / ";" / "="
   // RFC 3986 section 2.3.
   // unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
   static const _subDelimitersTable = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //               !  $ &'()*+,-.
-      0x7fd2,   // 0x20 - 0x2f  0100101111111110
-                //              0123456789 ; =
-      0x2bff,   // 0x30 - 0x3f  1111111111010100
-                //               ABCDEFGHIJKLMNO
-      0xfffe,   // 0x40 - 0x4f  0111111111111111
-                //              PQRSTUVWXYZ    _
-      0x87ff,   // 0x50 - 0x5f  1111111111100001
-                //               abcdefghijklmno
-      0xfffe,   // 0x60 - 0x6f  0111111111111111
-                //              pqrstuvwxyz   ~
-      0x47ff];  // 0x70 - 0x7f  1111111111100010
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                       !  $ &'()*+,-.
+    0x7fd2, // 0x20 - 0x2f  0100101111111110
+    //                      0123456789 ; =
+    0x2bff, // 0x30 - 0x3f  1111111111010100
+    //                       ABCDEFGHIJKLMNO
+    0xfffe, // 0x40 - 0x4f  0111111111111111
+    //                      PQRSTUVWXYZ    _
+    0x87ff, // 0x50 - 0x5f  1111111111100001
+    //                       abcdefghijklmno
+    0xfffe, // 0x60 - 0x6f  0111111111111111
+    //                      pqrstuvwxyz   ~
+    0x47ff, // 0x70 - 0x7f  1111111111100010
+  ];
 
   // General delimiter characters, RFC 3986 section 2.2.
   // gen-delims  = ":" / "/" / "?" / "#" / "[" / "]" / "@"
   //
   static const _genDelimitersTable = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //                 #           /
-      0x8008,   // 0x20 - 0x2f  0001000000000001
-                //                        :    ?
-      0x8400,   // 0x30 - 0x3f  0000000000100001
-                //              @
-      0x0001,   // 0x40 - 0x4f  1000000000000000
-                //                         [ ]
-      0x2800,   // 0x50 - 0x5f  0000000000010100
-                //
-      0x0000,   // 0x60 - 0x6f  0000000000000000
-                //
-      0x0000];  // 0x70 - 0x7f  0000000000000000
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                         #           /
+    0x8008, // 0x20 - 0x2f  0001000000000001
+    //                                :    ?
+    0x8400, // 0x30 - 0x3f  0000000000100001
+    //                      @
+    0x0001, // 0x40 - 0x4f  1000000000000000
+    //                                 [ ]
+    0x2800, // 0x50 - 0x5f  0000000000010100
+    //
+    0x0000, // 0x60 - 0x6f  0000000000000000
+    //
+    0x0000, // 0x70 - 0x7f  0000000000000000
+  ];
 
   // Characters allowed in the userinfo as of RFC 3986.
   // RFC 3986 Apendix A
   // userinfo = *( unreserved / pct-encoded / sub-delims / ':')
   static const _userinfoTable = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //               !  $ &'()*+,-.
-      0x7fd2,   // 0x20 - 0x2f  0100101111111110
-                //              0123456789:; =
-      0x2fff,   // 0x30 - 0x3f  1111111111110100
-                //               ABCDEFGHIJKLMNO
-      0xfffe,   // 0x40 - 0x4f  0111111111111111
-                //              PQRSTUVWXYZ    _
-      0x87ff,   // 0x50 - 0x5f  1111111111100001
-                //               abcdefghijklmno
-      0xfffe,   // 0x60 - 0x6f  0111111111111111
-                //              pqrstuvwxyz   ~
-      0x47ff];  // 0x70 - 0x7f  1111111111100010
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                       !  $ &'()*+,-.
+    0x7fd2, // 0x20 - 0x2f  0100101111111110
+    //                      0123456789:; =
+    0x2fff, // 0x30 - 0x3f  1111111111110100
+    //                       ABCDEFGHIJKLMNO
+    0xfffe, // 0x40 - 0x4f  0111111111111111
+    //                      PQRSTUVWXYZ    _
+    0x87ff, // 0x50 - 0x5f  1111111111100001
+    //                       abcdefghijklmno
+    0xfffe, // 0x60 - 0x6f  0111111111111111
+    //                      pqrstuvwxyz   ~
+    0x47ff, // 0x70 - 0x7f  1111111111100010
+  ];
 
   // Characters allowed in the reg-name as of RFC 3986.
   // RFC 3986 Apendix A
   // reg-name = *( unreserved / pct-encoded / sub-delims )
   static const _regNameTable = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //               !  $%&'()*+,-.
-      0x7ff2,   // 0x20 - 0x2f  0100111111111110
-                //              0123456789 ; =
-      0x2bff,   // 0x30 - 0x3f  1111111111010100
-                //               ABCDEFGHIJKLMNO
-      0xfffe,   // 0x40 - 0x4f  0111111111111111
-                //              PQRSTUVWXYZ    _
-      0x87ff,   // 0x50 - 0x5f  1111111111100001
-                //               abcdefghijklmno
-      0xfffe,   // 0x60 - 0x6f  0111111111111111
-                //              pqrstuvwxyz   ~
-      0x47ff];  // 0x70 - 0x7f  1111111111100010
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                       !  $%&'()*+,-.
+    0x7ff2, // 0x20 - 0x2f  0100111111111110
+    //                      0123456789 ; =
+    0x2bff, // 0x30 - 0x3f  1111111111010100
+    //                       ABCDEFGHIJKLMNO
+    0xfffe, // 0x40 - 0x4f  0111111111111111
+    //                      PQRSTUVWXYZ    _
+    0x87ff, // 0x50 - 0x5f  1111111111100001
+    //                       abcdefghijklmno
+    0xfffe, // 0x60 - 0x6f  0111111111111111
+    //                      pqrstuvwxyz   ~
+    0x47ff, // 0x70 - 0x7f  1111111111100010
+  ];
 
   // Characters allowed in the path as of RFC 3986.
   // RFC 3986 section 3.3.
   // pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
   static const _pathCharTable = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //               !  $ &'()*+,-.
-      0x7fd2,   // 0x20 - 0x2f  0100101111111110
-                //              0123456789:; =
-      0x2fff,   // 0x30 - 0x3f  1111111111110100
-                //              @ABCDEFGHIJKLMNO
-      0xffff,   // 0x40 - 0x4f  1111111111111111
-                //              PQRSTUVWXYZ    _
-      0x87ff,   // 0x50 - 0x5f  1111111111100001
-                //               abcdefghijklmno
-      0xfffe,   // 0x60 - 0x6f  0111111111111111
-                //              pqrstuvwxyz   ~
-      0x47ff];  // 0x70 - 0x7f  1111111111100010
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                       !  $ &'()*+,-.
+    0x7fd2, // 0x20 - 0x2f  0100101111111110
+    //                      0123456789:; =
+    0x2fff, // 0x30 - 0x3f  1111111111110100
+    //                      @ABCDEFGHIJKLMNO
+    0xffff, // 0x40 - 0x4f  1111111111111111
+    //                      PQRSTUVWXYZ    _
+    0x87ff, // 0x50 - 0x5f  1111111111100001
+    //                       abcdefghijklmno
+    0xfffe, // 0x60 - 0x6f  0111111111111111
+    //                      pqrstuvwxyz   ~
+    0x47ff, // 0x70 - 0x7f  1111111111100010
+  ];
 
   // Characters allowed in the path as of RFC 3986.
   // RFC 3986 section 3.3 *and* slash.
   static const _pathCharOrSlashTable = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //               !  $ &'()*+,-./
-      0xffd2,   // 0x20 - 0x2f  0100101111111111
-                //              0123456789:; =
-      0x2fff,   // 0x30 - 0x3f  1111111111110100
-                //              @ABCDEFGHIJKLMNO
-      0xffff,   // 0x40 - 0x4f  1111111111111111
-
-                //              PQRSTUVWXYZ    _
-      0x87ff,   // 0x50 - 0x5f  1111111111100001
-                //               abcdefghijklmno
-      0xfffe,   // 0x60 - 0x6f  0111111111111111
-                //              pqrstuvwxyz   ~
-      0x47ff];  // 0x70 - 0x7f  1111111111100010
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                       !  $ &'()*+,-./
+    0xffd2, // 0x20 - 0x2f  0100101111111111
+    //                      0123456789:; =
+    0x2fff, // 0x30 - 0x3f  1111111111110100
+    //                      @ABCDEFGHIJKLMNO
+    0xffff, // 0x40 - 0x4f  1111111111111111
+
+    //                      PQRSTUVWXYZ    _
+    0x87ff, // 0x50 - 0x5f  1111111111100001
+    //                       abcdefghijklmno
+    0xfffe, // 0x60 - 0x6f  0111111111111111
+    //                      pqrstuvwxyz   ~
+    0x47ff, // 0x70 - 0x7f  1111111111100010
+  ];
 
   // Characters allowed in the query as of RFC 3986.
   // RFC 3986 section 3.4.
   // query = *( pchar / "/" / "?" )
   static const _queryCharTable = const [
-                //             LSB            MSB
-                //              |              |
-      0x0000,   // 0x00 - 0x0f  0000000000000000
-      0x0000,   // 0x10 - 0x1f  0000000000000000
-                //               !  $ &'()*+,-./
-      0xffd2,   // 0x20 - 0x2f  0100101111111111
-                //              0123456789:; = ?
-      0xafff,   // 0x30 - 0x3f  1111111111110101
-                //              @ABCDEFGHIJKLMNO
-      0xffff,   // 0x40 - 0x4f  1111111111111111
-                //              PQRSTUVWXYZ    _
-      0x87ff,   // 0x50 - 0x5f  1111111111100001
-                //               abcdefghijklmno
-      0xfffe,   // 0x60 - 0x6f  0111111111111111
-                //              pqrstuvwxyz   ~
-      0x47ff];  // 0x70 - 0x7f  1111111111100010
-
+    //                     LSB            MSB
+    //                      |              |
+    0x0000, // 0x00 - 0x0f  0000000000000000
+    0x0000, // 0x10 - 0x1f  0000000000000000
+    //                       !  $ &'()*+,-./
+    0xffd2, // 0x20 - 0x2f  0100101111111111
+    //                      0123456789:; = ?
+    0xafff, // 0x30 - 0x3f  1111111111110101
+    //                      @ABCDEFGHIJKLMNO
+    0xffff, // 0x40 - 0x4f  1111111111111111
+    //                      PQRSTUVWXYZ    _
+    0x87ff, // 0x50 - 0x5f  1111111111100001
+    //                       abcdefghijklmno
+    0xfffe, // 0x60 - 0x6f  0111111111111111
+    //                      pqrstuvwxyz   ~
+    0x47ff, // 0x70 - 0x7f  1111111111100010
+  ];
 }
 
 // --------------------------------------------------------------------
 // Data URI
 // --------------------------------------------------------------------
 
 /**
  * A way to access the structure of a `data:` URI.
  *
  * Data URIs are non-hierarchical URIs that can contain any binary data.
@@ skipping 43 matching lines @@
 
   UriData._(this._text, this._separatorIndices, this._uriCache);
 
   /**
    * Creates a `data:` URI containing the [content] string.
    *
    * Equivalent to `new Uri.dataFromString(...).data`, but may
    * be more efficient if the [uri] itself isn't used.
    */
   factory UriData.fromString(String content,
-                             {String mimeType,
-                              Encoding encoding,
-                              Map<String, String> parameters,
-                              bool base64: false}) {
+      {String mimeType,
+      Encoding encoding,
+      Map<String, String> parameters,
+      bool base64: false}) {
     StringBuffer buffer = new StringBuffer();
     List<int> indices = [_noScheme];
     String charsetName;
     String encodingName;
     if (parameters != null) charsetName = parameters["charset"];
     if (encoding == null) {
       if (charsetName != null) {
         encoding = Encoding.getByName(charsetName);
       }
     } else if (charsetName == null) {
@@ skipping 14 matching lines @@
     return new UriData._(buffer.toString(), indices, null);
   }
 
   /**
    * Creates a `data:` URI containing an encoding of [bytes].
    *
    * Equivalent to `new Uri.dataFromBytes(...).data`, but may
    * be more efficient if the [uri] itself isn't used.
    */
   factory UriData.fromBytes(List<int> bytes,
-                            {mimeType: "application/octet-stream",
-                             Map<String, String> parameters,
-                             percentEncoded: false}) {
+      {mimeType: "application/octet-stream",
+      Map<String, String> parameters,
+      percentEncoded: false}) {
     StringBuffer buffer = new StringBuffer();
     List<int> indices = [_noScheme];
     _writeUri(mimeType, null, parameters, buffer, indices);
     indices.add(buffer.length);
     if (percentEncoded) {
       buffer.write(',');
       _uriEncodeBytes(_uricTable, bytes, buffer);
     } else {
       buffer.write(';base64,');
       indices.add(buffer.length - 1);
       BASE64.encoder
-            .startChunkedConversion(
-                new StringConversionSink.fromStringSink(buffer))
-            .addSlice(bytes, 0, bytes.length, true);
+          .startChunkedConversion(
+              new StringConversionSink.fromStringSink(buffer))
+          .addSlice(bytes, 0, bytes.length, true);
     }
 
     return new UriData._(buffer.toString(), indices, null);
   }
 
   /**
    * Creates a `DataUri` from a [Uri] which must have `data` as [Uri.scheme].
    *
    * The [uri] must have scheme `data` and no authority or fragment,
    * and the path (concatenated with the query, if there is one) must be valid
    * as data URI content with the same rules as [parse].
    */
   factory UriData.fromUri(Uri uri) {
     if (uri.scheme != "data") {
-      throw new ArgumentError.value(uri, "uri",
-                                    "Scheme must be 'data'");
+      throw new ArgumentError.value(uri, "uri", "Scheme must be 'data'");
     }
     if (uri.hasAuthority) {
-      throw new ArgumentError.value(uri, "uri",
-                                    "Data uri must not have authority");
+      throw new ArgumentError.value(
+          uri, "uri", "Data uri must not have authority");
     }
     if (uri.hasFragment) {
-      throw new ArgumentError.value(uri, "uri",
-                                    "Data uri must not have a fragment part");
+      throw new ArgumentError.value(
+          uri, "uri", "Data uri must not have a fragment part");
     }
     if (!uri.hasQuery) {
       return _parse(uri.path, 0, uri);
     }
     // Includes path and query (and leading "data:").
     return _parse("$uri", 5, uri);
   }
 
   /**
    * Writes the initial part of a `data:` uri, from after the "data:"
    * until just before the ',' before the data, or before a `;base64,`
    * marker.
    *
    * Of an [indices] list is passed, separator indices are stored in that
    * list.
    */
-  static void _writeUri(String mimeType,
-                        String charsetName,
-                        Map<String, String> parameters,
-                        StringBuffer buffer, List indices) {
+  static void _writeUri(String mimeType, String charsetName,
+      Map<String, String> parameters, StringBuffer buffer, List indices) {
     if (mimeType == null || mimeType == "text/plain") {
       mimeType = "";
     }
     if (mimeType.isEmpty || identical(mimeType, "application/octet-stream")) {
-      buffer.write(mimeType);  // Common cases need no escaping.
+      buffer.write(mimeType); // Common cases need no escaping.
     } else {
       int slashIndex = _validateMimeType(mimeType);
       if (slashIndex < 0) {
-        throw new ArgumentError.value(mimeType, "mimeType",
-                                      "Invalid MIME type");
+        throw new ArgumentError.value(
+            mimeType, "mimeType", "Invalid MIME type");
       }
-      buffer.write(_Uri._uriEncode(_tokenCharTable,
-                                   mimeType.substring(0, slashIndex),
-                                   UTF8, false));
+      buffer.write(_Uri._uriEncode(
+          _tokenCharTable, mimeType.substring(0, slashIndex), UTF8, false));
       buffer.write("/");
-      buffer.write(_Uri._uriEncode(_tokenCharTable,
-                                   mimeType.substring(slashIndex + 1),
-                                   UTF8, false));
+      buffer.write(_Uri._uriEncode(
+          _tokenCharTable, mimeType.substring(slashIndex + 1), UTF8, false));
     }
     if (charsetName != null) {
       if (indices != null) {
-        indices..add(buffer.length)
-               ..add(buffer.length + 8);
+        indices..add(buffer.length)..add(buffer.length + 8);
       }
       buffer.write(";charset=");
       buffer.write(_Uri._uriEncode(_tokenCharTable, charsetName, UTF8, false));
     }
     parameters?.forEach((var key, var value) {
       if (key.isEmpty) {
         throw new ArgumentError.value("", "Parameter names must not be empty");
       }
       if (value.isEmpty) {
-        throw new ArgumentError.value("", "Parameter values must not be empty",
-                                      'parameters["$key"]');
+        throw new ArgumentError.value(
+            "", "Parameter values must not be empty", 'parameters["$key"]');
       }
       if (indices != null) indices.add(buffer.length);
       buffer.write(';');
       // Encode any non-RFC2045-token character and both '%' and '#'.
       buffer.write(_Uri._uriEncode(_tokenCharTable, key, UTF8, false));
       if (indices != null) indices.add(buffer.length);
       buffer.write('=');
       buffer.write(_Uri._uriEncode(_tokenCharTable, value, UTF8, false));
     });
   }
@@ skipping 70 matching lines @@
    * 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 = _text.length;
     if (queryIndex >= 0) {
-      query = _Uri._normalizeOrSubstring(_text, queryIndex + 1, end, _Uri._queryCharTable);
+      query = _Uri._normalizeOrSubstring(
+          _text, queryIndex + 1, end, _Uri._queryCharTable);
       end = queryIndex;
     }
-    path = _Uri._normalizeOrSubstring(_text, colonIndex + 1, end,
-        _Uri._pathCharOrSlashTable);
+    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.
@@ skipping 24 matching lines @@
    * 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.
+    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;
       var keyEnd = _separatorIndices[i + 1];
       if (keyEnd == keyStart + 7 && _text.startsWith("charset", keyStart)) {
-        return _Uri._uriDecode(_text, keyEnd + 1, _separatorIndices[i + 2],
-                               UTF8, false);
+        return _Uri._uriDecode(
+            _text, keyEnd + 1, _separatorIndices[i + 2], UTF8, false);
       }
     }
     return "US-ASCII";
   }
 
   /**
    * Whether the data is Base64 encoded or not.
    */
   bool get isBase64 => _separatorIndices.length.isOdd;
 
@@ skipping 67 matching lines @@
    * if it is recognized by [Encoding.getByName], otherwise it defaults to
    * the [ASCII] encoding, which is the default encoding for data URIs
    * that do not specify an encoding.
    *
    * If the content is not Base64 encoded, it will first have percent-escapes
    * converted to bytes and then the character codes and byte values are
    * decoded using [encoding].
    */
   String contentAsString({Encoding encoding}) {
     if (encoding == null) {
-      var charset = this.charset;  // Returns "US-ASCII" if not present.
+      var charset = this.charset; // Returns "US-ASCII" if not present.
       encoding = Encoding.getByName(charset);
       if (encoding == null) {
         throw new UnsupportedError("Unknown charset: $charset");
       }
     }
     String text = _text;
     int start = _separatorIndices.last + 1;
     if (isBase64) {
       var converter = BASE64.decoder.fuse(encoding.decoder);
       return converter.convert(text.substring(start));
@@ skipping 15 matching lines @@
    * 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);
+      String value = _Uri._uriDecode(_text, equals + 1, end, UTF8, false);
       result[key] = value;
     }
     return result;
   }
 
   static UriData _parse(String text, int start, Uri sourceUri) {
     assert(start == 0 || start == 5);
     assert((start == 5) == text.startsWith("data:"));
 
     /// Character codes.
-    const int comma     = 0x2c;
-    const int slash     = 0x2f;
+    const int comma = 0x2c;
+    const int slash = 0x2f;
     const int semicolon = 0x3b;
-    const int equals    = 0x3d;
+    const int equals = 0x3d;
     List<int> indices = [start - 1];
     int slashIndex = -1;
     var char;
     int i = start;
     for (; i < text.length; i++) {
       char = text.codeUnitAt(i);
       if (char == comma || char == semicolon) break;
       if (char == slash) {
         if (slashIndex < 0) {
           slashIndex = i;
@@ skipping 35 matching lines @@
     }
     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);
+          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,
-                              StringSink buffer) {
+  static void _uriEncodeBytes(
+      List<int> canonicalTable, List<int> bytes, StringSink buffer) {
     // Encode the string into bytes then generate an ASCII only string
     // by percent encoding selected bytes.
     int byteOr = 0;
     for (int i = 0; i < bytes.length; i++) {
       int byte = bytes[i];
       byteOr |= byte;
       if (byte < 128 &&
           ((canonicalTable[byte >> 4] & (1 << (byte & 0x0f))) != 0)) {
         buffer.writeCharCode(byte);
       } else {
@@ skipping 16 matching lines @@
       (_separatorIndices[0] == _noScheme) ? "data:$_text" : _text;
 
   // Table of the `token` characters of RFC 2045 in a URI.
   //
   // A token is any US-ASCII character except SPACE, control characters and
   // `tspecial` characters. The `tspecial` category is:
   // '(', ')', '<', '>', '@', ',', ';', ':', '\', '"', '/', '[, ']', '?', '='.
   //
   // In a data URI, we also need to escape '%' and '#' characters.
   static const _tokenCharTable = const [
-                //             LSB             MSB
-                //              |               |
-      0x0000,   // 0x00 - 0x0f  00000000 00000000
-      0x0000,   // 0x10 - 0x1f  00000000 00000000
-                //               !  $ &'   *+ -.
-      0x6cd2,   // 0x20 - 0x2f  01001011 00110110
-                //              01234567 89
-      0x03ff,   // 0x30 - 0x3f  11111111 11000000
-                //               ABCDEFG HIJKLMNO
-      0xfffe,   // 0x40 - 0x4f  01111111 11111111
-                //              PQRSTUVW XYZ   ^_
-      0xc7ff,   // 0x50 - 0x5f  11111111 11100011
-                //              `abcdefg hijklmno
-      0xffff,   // 0x60 - 0x6f  11111111 11111111
-                //              pqrstuvw xyz{|}~
-      0x7fff];  // 0x70 - 0x7f  11111111 11111110
+    //                     LSB             MSB
+    //                      |               |
+    0x0000, // 0x00 - 0x0f  00000000 00000000
+    0x0000, // 0x10 - 0x1f  00000000 00000000
+    //                       !  $ &'   *+ -.
+    0x6cd2, // 0x20 - 0x2f  01001011 00110110
+    //                      01234567 89
+    0x03ff, // 0x30 - 0x3f  11111111 11000000
+    //                       ABCDEFG HIJKLMNO
+    0xfffe, // 0x40 - 0x4f  01111111 11111111
+    //                      PQRSTUVW XYZ   ^_
+    0xc7ff, // 0x50 - 0x5f  11111111 11100011
+    //                      `abcdefg hijklmno
+    0xffff, // 0x60 - 0x6f  11111111 11111111
+    //                      pqrstuvw xyz{|}~
+    0x7fff, // 0x70 - 0x7f  11111111 11111110
+  ];
 
   // 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
+    //                     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;
+const int _schemeEndIndex = 1;
+
 /// Index of the position of the character just before the host name.
-const int _hostStartIndex     = 2;
+const int _hostStartIndex = 2;
+
 /// Index of the position of the `:` before a port value.
-const int _portStartIndex     = 3;
+const int _portStartIndex = 3;
+
 /// Index of the position of the first character of a path.
-const int _pathStartIndex     = 4;
+const int _pathStartIndex = 4;
+
 /// Index of the position of the `?` before a query.
-const int _queryStartIndex    = 5;
+const int _queryStartIndex = 5;
+
 /// Index of the position of the `#` before a fragment.
 const int _fragmentStartIndex = 6;
+
 /// Index of a position where the URI was determined to be "non-simple".
-const int _notSimpleIndex     = 7;
+const int _notSimpleIndex = 7;
 
 // Initial state for scanner.
-const int _uriStart           = 00;
+const int _uriStart = 00;
 
 // If scanning of a URI terminates in this state or above,
 // consider the URI non-simple
 const int _nonSimpleEndStates = 14;
 
 // Initial state for scheme validation.
-const int _schemeStart        = 20;
+const int _schemeStart = 20;
 
 /// Transition tables used to scan a URI to determine its structure.
 ///
 /// The tables represent a state machine with output.
 ///
 /// To scan the URI, start in the [_uriStart] state, then read each character
 /// of the URI in order, from start to end, and for each character perform a
 /// transition to a new state while writing the current position into the output
 /// buffer at a designated index.
 ///
@@ skipping 78 matching lines @@
 /// The transition tables cannot detect a trailing ".." in the path,
 /// followed by a query or fragment, because the segment is not known to be
 /// complete until we are past it, and we then need to store the query/fragment
 /// start instead. This cast is checked manually post-scanning (such a path
 /// needs to be normalized to end in "../", so the URI shouldn't be considered
 /// simple).
 List<Uint8List> _createTables() {
   // TODO(lrn): Use a precomputed table.
 
   // Total number of states for the scanner.
-  const int stateCount         = 22;
+  const int stateCount = 22;
 
   // States used to scan a URI from scratch.
-  const int schemeOrPath       = 01;
-  const int authOrPath         = 02;
-  const int authOrPathSlash    = 03;
-  const int uinfoOrHost0       = 04;
-  const int uinfoOrHost        = 05;
-  const int uinfoOrPort0       = 06;
-  const int uinfoOrPort        = 07;
-  const int ipv6Host           = 08;
-  const int relPathSeg         = 09;
-  const int pathSeg            = 10;
-  const int path               = 11;
-  const int query              = 12;
-  const int fragment           = 13;
-  const int schemeOrPathDot    = 14;
-  const int schemeOrPathDot2   = 15;
-  const int relPathSegDot      = 16;
-  const int relPathSegDot2     = 17;
-  const int pathSegDot         = 18;
-  const int pathSegDot2        = 19;
+  const int schemeOrPath = 01;
+  const int authOrPath = 02;
+  const int authOrPathSlash = 03;
+  const int uinfoOrHost0 = 04;
+  const int uinfoOrHost = 05;
+  const int uinfoOrPort0 = 06;
+  const int uinfoOrPort = 07;
+  const int ipv6Host = 08;
+  const int relPathSeg = 09;
+  const int pathSeg = 10;
+  const int path = 11;
+  const int query = 12;
+  const int fragment = 13;
+  const int schemeOrPathDot = 14;
+  const int schemeOrPathDot2 = 15;
+  const int relPathSegDot = 16;
+  const int relPathSegDot2 = 17;
+  const int pathSegDot = 18;
+  const int pathSegDot2 = 19;
 
   // States used to validate a scheme after its end position has been found.
-  const int scheme0            = _schemeStart;
-  const int scheme             = 21;
+  const int scheme0 = _schemeStart;
+  const int scheme = 21;
 
   // Constants encoding the write-index for the state transition into the top 5
   // bits of a byte.
-  const int schemeEnd          = _schemeEndIndex     << 5;
-  const int hostStart          = _hostStartIndex     << 5;
-  const int portStart          = _portStartIndex     << 5;
-  const int pathStart          = _pathStartIndex     << 5;
-  const int queryStart         = _queryStartIndex    << 5;
-  const int fragmentStart      = _fragmentStartIndex << 5;
-  const int notSimple          = _notSimpleIndex     << 5;
+  const int schemeEnd = _schemeEndIndex << 5;
+  const int hostStart = _hostStartIndex << 5;
+  const int portStart = _portStartIndex << 5;
+  const int pathStart = _pathStartIndex << 5;
+  const int queryStart = _queryStartIndex << 5;
+  const int fragmentStart = _fragmentStartIndex << 5;
+  const int notSimple = _notSimpleIndex << 5;
 
   /// The `unreserved` characters of RFC 3986.
   const unreserved =
-      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~"  ;
+      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~";
+
   /// The `sub-delim` characters of RFC 3986.
   const subDelims = r"!$&'()*+,;=";
   // The `pchar` characters of RFC 3986: characters that may occur in a path,
   // excluding escapes.
   const pchar = "$unreserved$subDelims";
 
-  var tables = new List<Uint8List>.generate(stateCount,
-      (_) => new Uint8List(96));
+  var tables =
+      new List<Uint8List>.generate(stateCount, (_) => new Uint8List(96));
 
   // Helper function which initialize the table for [state] with a default
   // transition and returns the table.
   Uint8List build(state, defaultTransition) =>
       tables[state]..fillRange(0, 96, defaultTransition);
 
   // Helper function which sets the transition for each character in [chars]
   // to [transition] in the [target] table.
   // The [chars] string must contain only characters in the U+0020 .. U+007E
   // range.
@@ skipping 16 matching lines @@
     }
   }
 
   // Create the transitions for each state.
   var b;
 
   // Validate as path, if it is a scheme, we handle it later.
   b = build(_uriStart, schemeOrPath | notSimple);
   setChars(b, pchar, schemeOrPath);
   setChars(b, ".", schemeOrPathDot);
-  setChars(b, ":", authOrPath | schemeEnd);  // Handle later.
+  setChars(b, ":", authOrPath | schemeEnd); // Handle later.
   setChars(b, "/", authOrPathSlash);
   setChars(b, "?", query | queryStart);
   setChars(b, "#", fragment | fragmentStart);
 
   b = build(schemeOrPathDot, schemeOrPath | notSimple);
   setChars(b, pchar, schemeOrPath);
   setChars(b, ".", schemeOrPathDot2);
   setChars(b, ':', authOrPath | schemeEnd);
   setChars(b, "/", pathSeg | notSimple);
   setChars(b, "?", query | queryStart);
@@ skipping 74 matching lines @@
   b = build(relPathSegDot, path | notSimple);
   setChars(b, pchar, path);
   setChars(b, ".", relPathSegDot2);
   setChars(b, "/", pathSeg | notSimple);
   setChars(b, "?", query | queryStart);
   setChars(b, "#", fragment | fragmentStart);
 
   b = build(relPathSegDot2, path | notSimple);
   setChars(b, pchar, path);
   setChars(b, "/", relPathSeg);
-  setChars(b, "?", query | queryStart);  // This should be non-simple.
-  setChars(b, "#", fragment | fragmentStart);  // This should be non-simple.
+  setChars(b, "?", query | queryStart); // This should be non-simple.
+  setChars(b, "#", fragment | fragmentStart); // This should be non-simple.
 
   b = build(pathSeg, path | notSimple);
   setChars(b, pchar, path);
   setChars(b, ".", pathSegDot);
   setChars(b, "/", pathSeg | notSimple);
   setChars(b, "?", query | queryStart);
   setChars(b, "#", fragment | fragmentStart);
 
   b = build(pathSegDot, path | notSimple);
   setChars(b, pchar, path);
@@ skipping 62 matching lines @@
 }
 
 class _SimpleUri implements Uri {
   final String _uri;
   final int _schemeEnd;
   final int _hostStart;
   final int _portStart;
   final int _pathStart;
   final int _queryStart;
   final int _fragmentStart;
+
   /// The scheme is often used to distinguish URIs.
   /// To make comparisons more efficient, we cache the value, and
   /// canonicalize a few known types.
   String _schemeCache;
   int _hashCodeCache;
 
   _SimpleUri(
       this._uri,
       this._schemeEnd,
       this._hostStart,
       this._portStart,
       this._pathStart,
       this._queryStart,
       this._fragmentStart,
       this._schemeCache);
 
   bool get hasScheme => _schemeEnd > 0;
   bool get hasAuthority => _hostStart > 0;
   bool get hasUserInfo => _hostStart > _schemeEnd + 4;
   bool get hasPort => _hostStart > 0 && _portStart + 1 < _pathStart;
   bool get hasQuery => _queryStart < _fragmentStart;
   bool get hasFragment => _fragmentStart < _uri.length;
 
   bool get _isFile => _schemeEnd == 4 && _uri.startsWith("file");
   bool get _isHttp => _schemeEnd == 4 && _uri.startsWith("http");
   bool get _isHttps => _schemeEnd == 5 && _uri.startsWith("https");
   bool get _isPackage => _schemeEnd == 7 && _uri.startsWith("package");
+
   /// Like [isScheme] but expects argument to be case normalized.
   bool _isScheme(String scheme) =>
-    _schemeEnd == scheme.length && _uri.startsWith(scheme);
+      _schemeEnd == scheme.length && _uri.startsWith(scheme);
 
   bool get hasAbsolutePath => _uri.startsWith("/", _pathStart);
   bool get hasEmptyPath => _pathStart == _queryStart;
 
   bool get isAbsolute => hasScheme && !hasFragment;
 
   bool isScheme(String scheme) {
     if (scheme == null || scheme.isEmpty) return _schemeEnd < 0;
     if (scheme.length != _schemeEnd) return false;
     return _Uri._compareScheme(scheme, _uri);
   }
 
   String get scheme {
     if (_schemeEnd <= 0) return "";
     if (_schemeCache != null) return _schemeCache;
     if (_isHttp) {
       _schemeCache = "http";
     } else if (_isHttps) {
       _schemeCache = "https";
     } else if (_isFile) {
       _schemeCache = "file";
     } else if (_isPackage) {
       _schemeCache = "package";
     } else {
       _schemeCache = _uri.substring(0, _schemeEnd);
     }
     return _schemeCache;
   }
-  String get authority => _hostStart > 0 ?
-      _uri.substring(_schemeEnd + 3, _pathStart) : "";
-  String get userInfo => (_hostStart > _schemeEnd + 3) ?
-      _uri.substring(_schemeEnd + 3, _hostStart - 1) : "";
+
+  String get authority =>
+      _hostStart > 0 ? _uri.substring(_schemeEnd + 3, _pathStart) : "";
+  String get userInfo => (_hostStart > _schemeEnd + 3)
+      ? _uri.substring(_schemeEnd + 3, _hostStart - 1)
+      : "";
   String get host =>
       _hostStart > 0 ? _uri.substring(_hostStart, _portStart) : "";
   int get port {
     if (hasPort) return int.parse(_uri.substring(_portStart + 1, _pathStart));
     if (_isHttp) return 80;
     if (_isHttps) return 443;
     return 0;
   }
-  String get path =>_uri.substring(_pathStart, _queryStart);
-  String get query => (_queryStart < _fragmentStart) ?
-     _uri.substring(_queryStart + 1, _fragmentStart) : "";
-  String get fragment => (_fragmentStart < _uri.length) ?
-     _uri.substring(_fragmentStart + 1) : "";
+
+  String get path => _uri.substring(_pathStart, _queryStart);
+  String get query => (_queryStart < _fragmentStart)
+      ? _uri.substring(_queryStart + 1, _fragmentStart)
+      : "";
+  String get fragment =>
+      (_fragmentStart < _uri.length) ? _uri.substring(_fragmentStart + 1) : "";
 
   String get origin {
     // Check original behavior - W3C spec is wonky!
     bool isHttp = _isHttp;
     if (_schemeEnd < 0) {
       throw new StateError("Cannot use origin without a scheme: $this");
     }
     if (!isHttp && !_isHttps) {
       throw new StateError(
-        "Origin is only applicable schemes http and https: $this");
+          "Origin is only applicable to schemes http and https: $this");
     }
     if (_hostStart == _portStart) {
       throw new StateError(
           "A $scheme: URI should have a non-empty host name: $this");
     }
     if (_hostStart == _schemeEnd + 3) {
       return _uri.substring(0, _pathStart);
     }
     // Need to drop anon-empty userInfo.
     return _uri.substring(0, _schemeEnd + 3) +
-           _uri.substring(_hostStart, _pathStart);
+        _uri.substring(_hostStart, _pathStart);
   }
 
   List<String> get pathSegments {
     int start = _pathStart;
     int end = _queryStart;
     if (_uri.startsWith("/", start)) start++;
     if (start == end) return const <String>[];
     List<String> parts = [];
     for (int i = start; i < end; i++) {
       var char = _uri.codeUnitAt(i);
       if (char == _SLASH) {
         parts.add(_uri.substring(start, i));
         start = i + 1;
       }
     }
     parts.add(_uri.substring(start, end));
     return new List<String>.unmodifiable(parts);
   }
 
   Map<String, String> get queryParameters {
     if (!hasQuery) return const <String, String>{};
-    return new UnmodifiableMapView<String, String>(
-        Uri.splitQueryString(query));
+    return new UnmodifiableMapView<String, String>(Uri.splitQueryString(query));
   }
 
   Map<String, List<String>> get queryParametersAll {
     if (!hasQuery) return const <String, List<String>>{};
     Map queryParameterLists = _Uri._splitQueryStringAll(query);
     for (var key in queryParameterLists.keys) {
       queryParameterLists[key] =
           new List<String>.unmodifiable(queryParameterLists[key]);
     }
     return new Map<String, List<String>>.unmodifiable(queryParameterLists);
   }
 
   bool _isPort(String port) {
     int portDigitStart = _portStart + 1;
     return portDigitStart + port.length == _pathStart &&
-           _uri.startsWith(port, portDigitStart);
+        _uri.startsWith(port, portDigitStart);
   }
 
   Uri normalizePath() => this;
 
   Uri removeFragment() {
     if (!hasFragment) return this;
     return new _SimpleUri(
-      _uri.substring(0, _fragmentStart),
-      _schemeEnd, _hostStart, _portStart,
-      _pathStart, _queryStart, _fragmentStart, _schemeCache);
+        _uri.substring(0, _fragmentStart),
+        _schemeEnd,
+        _hostStart,
+        _portStart,
+        _pathStart,
+        _queryStart,
+        _fragmentStart,
+        _schemeCache);
   }
 
-  Uri replace({String scheme,
-               String userInfo,
-               String host,
-               int port,
-               String path,
-               Iterable<String> pathSegments,
-               String query,
-               Map<String, dynamic/*String|Iterable<String>*/> queryParameters,
-               String fragment}) {
+  Uri replace(
+      {String scheme,
+      String userInfo,
+      String host,
+      int port,
+      String path,
+      Iterable<String> pathSegments,
+      String query,
+      Map<String, dynamic /*String|Iterable<String>*/ > queryParameters,
+      String fragment}) {
     bool schemeChanged = false;
     if (scheme != null) {
       scheme = _Uri._makeScheme(scheme, 0, scheme.length);
       schemeChanged = !_isScheme(scheme);
     } else {
       scheme = this.scheme;
     }
     bool isFile = (scheme == "file");
     if (userInfo != null) {
       userInfo = _Uri._makeUserInfo(userInfo, 0, userInfo.length);
@@ skipping 15 matching lines @@
       host = _Uri._makeHost(host, 0, host.length, false);
     } else if (_hostStart > 0) {
       host = _uri.substring(_hostStart, _portStart);
     } else if (userInfo.isNotEmpty || port != null || isFile) {
       host = "";
     }
 
     bool hasAuthority = host != null;
     if (path != null || pathSegments != null) {
       path = _Uri._makePath(path, 0, _stringOrNullLength(path), pathSegments,
-                           scheme, hasAuthority);
+          scheme, hasAuthority);
     } else {
       path = _uri.substring(_pathStart, _queryStart);
       if ((isFile || (hasAuthority && !path.isEmpty)) &&
           !path.startsWith('/')) {
         path = "/" + path;
       }
     }
 
     if (query != null || queryParameters != null) {
       query = _Uri._makeQuery(
@@ skipping 36 matching lines @@
       if (base._isFile) {
         isSimple = !ref.hasEmptyPath;
       } else if (base._isHttp) {
         isSimple = !ref._isPort("80");
       } else if (base._isHttps) {
         isSimple = !ref._isPort("443");
       }
       if (isSimple) {
         var delta = base._schemeEnd + 1;
         var newUri = base._uri.substring(0, base._schemeEnd + 1) +
-                     ref._uri.substring(ref._schemeEnd + 1);
-        return new _SimpleUri(newUri,
-           base._schemeEnd,
-           ref._hostStart + delta,
-           ref._portStart + delta,
-           ref._pathStart + delta,
-           ref._queryStart + delta,
-           ref._fragmentStart + delta,
-           base._schemeCache);
+            ref._uri.substring(ref._schemeEnd + 1);
+        return new _SimpleUri(
+            newUri,
+            base._schemeEnd,
+            ref._hostStart + delta,
+            ref._portStart + delta,
+            ref._pathStart + delta,
+            ref._queryStart + delta,
+            ref._fragmentStart + delta,
+            base._schemeCache);
       } else {
         // This will require normalization, so use the _Uri implementation.
         return _toNonSimple().resolveUri(ref);
       }
     }
     if (ref.hasEmptyPath) {
       if (ref.hasQuery) {
         int delta = base._queryStart - ref._queryStart;
         var newUri = base._uri.substring(0, base._queryStart) +
-                     ref._uri.substring(ref._queryStart);
-        return new _SimpleUri(newUri,
-           base._schemeEnd,
-           base._hostStart,
-           base._portStart,
-           base._pathStart,
-           ref._queryStart + delta,
-           ref._fragmentStart + delta,
-           base._schemeCache);
+            ref._uri.substring(ref._queryStart);
+        return new _SimpleUri(
+            newUri,
+            base._schemeEnd,
+            base._hostStart,
+            base._portStart,
+            base._pathStart,
+            ref._queryStart + delta,
+            ref._fragmentStart + delta,
+            base._schemeCache);
       }
       if (ref.hasFragment) {
         int delta = base._fragmentStart - ref._fragmentStart;
         var newUri = base._uri.substring(0, base._fragmentStart) +
-                     ref._uri.substring(ref._fragmentStart);
-        return new _SimpleUri(newUri,
-           base._schemeEnd,
-           base._hostStart,
-           base._portStart,
-           base._pathStart,
-           base._queryStart,
-           ref._fragmentStart + delta,
-           base._schemeCache);
+            ref._uri.substring(ref._fragmentStart);
+        return new _SimpleUri(
+            newUri,
+            base._schemeEnd,
+            base._hostStart,
+            base._portStart,
+            base._pathStart,
+            base._queryStart,
+            ref._fragmentStart + delta,
+            base._schemeCache);
       }
       return base.removeFragment();
     }
     if (ref.hasAbsolutePath) {
       var delta = base._pathStart - ref._pathStart;
       var newUri = base._uri.substring(0, base._pathStart) +
-                   ref._uri.substring(ref._pathStart);
-      return new _SimpleUri(newUri,
-        base._schemeEnd,
-        base._hostStart,
-        base._portStart,
-        base._pathStart,
-        ref._queryStart + delta,
-        ref._fragmentStart + delta,
-        base._schemeCache);
+          ref._uri.substring(ref._pathStart);
+      return new _SimpleUri(
+          newUri,
+          base._schemeEnd,
+          base._hostStart,
+          base._portStart,
+          base._pathStart,
+          ref._queryStart + delta,
+          ref._fragmentStart + delta,
+          base._schemeCache);
     }
     if (base.hasEmptyPath && base.hasAuthority) {
       // ref has relative non-empty path.
       // Add a "/" in front, then leading "/../" segments are folded to "/".
       int refStart = ref._pathStart;
       while (ref._uri.startsWith("../", refStart)) {
         refStart += 3;
       }
       var delta = base._pathStart - refStart + 1;
       var newUri = "${base._uri.substring(0, base._pathStart)}/"
-                   "${ref._uri.substring(refStart)}";
-      return new _SimpleUri(newUri,
-        base._schemeEnd,
-        base._hostStart,
-        base._portStart,
-        base._pathStart,
-        ref._queryStart + delta,
-        ref._fragmentStart + delta,
-        base._schemeCache);
+          "${ref._uri.substring(refStart)}";
+      return new _SimpleUri(
+          newUri,
+          base._schemeEnd,
+          base._hostStart,
+          base._portStart,
+          base._pathStart,
+          ref._queryStart + delta,
+          ref._fragmentStart + delta,
+          base._schemeCache);
     }
     // Merge paths.
 
     // The RFC 3986 algorithm merges the base path without its final segment
     // (anything after the final "/", or everything if the base path doesn't
     // contain any "/"), and the reference path.
     // Then it removes "." and ".." segments using the remove-dot-segment
     // algorithm.
     // This code combines the two steps. It is simplified by knowing that
     // the base path contains no "." or ".." segments, and the reference
     // path can only contain leading ".." segments.
 
     String baseUri = base._uri;
     String refUri = ref._uri;
     int baseStart = base._pathStart;
     int baseEnd = base._queryStart;
     while (baseUri.startsWith("../", baseStart)) baseStart += 3;
     int refStart = ref._pathStart;
     int refEnd = ref._queryStart;
 
     /// Count of leading ".." segments in reference path.
     /// The count is decremented when the segment is matched with a
     /// segment of the base path, and both are then omitted from the result.
     int backCount = 0;
+
     /// Count "../" segments and advance `refStart` to after the segments.
     while (refStart + 3 <= refEnd && refUri.startsWith("../", refStart)) {
       refStart += 3;
       backCount += 1;
     }
 
     // Extra slash inserted between base and reference path parts if
     // the base path contains any slashes, or empty string if none.
     // (We could use a slash from the base path in most cases, but not if
     // we remove the entire base path).
@@ skipping 23 matching lines @@
       // We reached the start of the base path, and want to stay relative,
       // so don't insert a slash.
       insert = "";
       // If we reached the start of the base path with more "../" left over
       // in the reference path, include those segments in the result.
       refStart -= backCount * 3;
     }
 
     var delta = baseEnd - refStart + insert.length;
     var newUri = "${base._uri.substring(0, baseEnd)}$insert"
-               "${ref._uri.substring(refStart)}";
+        "${ref._uri.substring(refStart)}";
 
-    return new _SimpleUri(newUri,
-      base._schemeEnd,
-      base._hostStart,
-      base._portStart,
-      base._pathStart,
-      ref._queryStart + delta,
-      ref._fragmentStart + delta,
-      base._schemeCache);
+    return new _SimpleUri(
+        newUri,
+        base._schemeEnd,
+        base._hostStart,
+        base._portStart,
+        base._pathStart,
+        ref._queryStart + delta,
+        ref._fragmentStart + delta,
+        base._schemeCache);
   }
 
   String toFilePath({bool windows}) {
     if (_schemeEnd >= 0 && !_isFile) {
       throw new UnsupportedError(
           "Cannot extract a file path from a $scheme URI");
     }
     if (_queryStart < _uri.length) {
       if (_queryStart < _fragmentStart) {
         throw new UnsupportedError(
             "Cannot extract a file path from a URI with a query component");
       }
       throw new UnsupportedError(
           "Cannot extract a file path from a URI with a fragment component");
     }
     if (windows == null) windows = _Uri._isWindows;
     return windows ? _Uri._toWindowsFilePath(this) : _toFilePath();
   }
 
   String _toFilePath() {
     if (_hostStart < _portStart) {
       // Has authority and non-empty host.
       throw new UnsupportedError(
-        "Cannot extract a non-Windows file path from a file URI "
-        "with an authority");
+          "Cannot extract a non-Windows file path from a file URI "
+          "with an authority");
     }
     return this.path;
   }
 
   UriData get data {
     assert(scheme != "data");
     return null;
   }
 
   int get hashCode => _hashCodeCache ??= _uri.hashCode;
 
-  bool operator==(Object other) {
+  bool operator ==(Object other) {
     if (identical(this, other)) return true;
     if (other is Uri) return _uri == other.toString();
     return false;
   }
 
   Uri _toNonSimple() {
     return new _Uri._internal(
-      this.scheme,
-      this.userInfo,
-      this.hasAuthority ? this.host: null,
-      this.hasPort ? this.port : null,
-      this.path,
-      this.hasQuery ? this.query : null,
-      this.hasFragment ? this.fragment : null
-    );
+        this.scheme,
+        this.userInfo,
+        this.hasAuthority ? this.host : null,
+        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) ^ 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;