fix spelling in core libraries

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 _PLUS = 0x2B;
@@ skipping 57 matching lines @@
    *
    * The port part of the authority component is set through
    * [port].
    * If [port] is omitted or `null`, it implies the default port for
    * the URI's scheme, and is equivalent to passing that port explicitly.
    * The recognized schemes, and their default ports, are "http" (80) and
    * "https" (443). All other schemes are considered as having zero as the
    * default port.
    *
    * If any of `userInfo`, `host` or `port` are provided,
-   * the URI has an autority according to [hasAuthority].
+   * the URI has an authority according to [hasAuthority].
    *
    * The path component is set through either [path] or
    * [pathSegments].
    * When [path] is used, it should be a valid URI path,
    * but invalid characters, except the general delimiters ':/@[]?#',
    * will be escaped if necessary.
    * When [pathSegments] is used, each of the provided segments
    * is first percent-encoded and then joined using the forward slash
    * separator.
    *
@@ skipping 517 matching lines @@
    * This method takes the same parameters as the [new Uri] constructor,
    * and they have the same meaning.
    *
    * At most one of [path] and [pathSegments] must be provided.
    * Likewise, at most one of [query] and [queryParameters] must be provided.
    *
    * Each part that is not provided will default to the corresponding
    * value from this `Uri` instead.
    *
    * This method is different from [Uri.resolve] which overrides in a
-   * hierarchial manner,
+   * hierarchical manner,
    * and can instead replace each part of a `Uri` individually.
    *
    * Example:
    *
    *     Uri uri1 = Uri.parse("a://b@c:4/d/e?f#g");
    *     Uri uri2 = uri1.replace(scheme: "A", path: "D/E/E", fragment: "G");
    *     print(uri2);  // prints "A://b@c:4/D/E/E/?f#G"
    *
    * This method acts similarly to using the `new Uri` constructor with
    * some of the arguments taken from this `Uri` . Example:
@@ skipping 426 matching lines @@
   static String encodeQueryComponent(String component,
                                      {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 componene type. Always split a URI
+   * 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);
@@ skipping 280 matching lines @@
    */
   String _path;
 
   // The query content, or null if there is no query.
   final String _query;
 
   // The fragment content, or null if there is no fragment.
   final String _fragment;
 
   /**
-   * Cache the computed return value of [pathSegements].
+   * Cache the computed return value of [pathSegments].
    */
   List<String> _pathSegments;
 
   /**
    * Cache of the full normalized text representation of the URI.
    */
   String _text;
 
   /**
    * Cache of the hashCode of [_text].
@@ skipping 1360 matching lines @@
   /**
    * Uri-decode a percent-encoded string.
    *
    * 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 encodingis UTF-8.
+   * decode the byte-list using [encoding]. The default encodings UTF-8.
    */
   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);
@@ skipping 1750 matching lines @@
   int delta = (text.codeUnitAt(start + 4) ^ _COLON) * 3;
   delta |= text.codeUnitAt(start)     ^ 0x64 /*d*/;
   delta |= text.codeUnitAt(start + 1) ^ 0x61 /*a*/;
   delta |= text.codeUnitAt(start + 2) ^ 0x74 /*t*/;
   delta |= text.codeUnitAt(start + 3) ^ 0x61 /*a*/;
   return delta;
 }
 
 /// Helper function returning the length of a string, or `0` for `null`.
 int _stringOrNullLength(String s) => (s == null) ? 0 : s.length;