Update charted to 0.4.8 and roll

packages/path/lib/path.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.
 
 /// A comprehensive, cross-platform path manipulation library.
 ///
 /// ## Installing ##
 ///
 /// Use [pub][] to install this package. Add the following to your
 /// `pubspec.yaml` file.
@@ skipping 26 matching lines @@
 ///
 /// If you want to work with paths for a specific platform regardless of the
 /// underlying platform that the program is running on, you can create a
 /// [Context] and give it an explicit [Style]:
 ///
 ///     var context = new path.Context(style: Style.windows);
 ///     context.join("directory", "file.txt");
 ///
 /// This will join "directory" and "file.txt" using the Windows path separator,
 /// even when the program is run on a POSIX machine.
-library path;
-
 import 'src/context.dart';
 import 'src/style.dart';
 
 export 'src/context.dart' hide createInternal;
 export 'src/path_exception.dart';
 export 'src/style.dart';
 
 /// A default context for manipulating POSIX paths.
 final Context posix = new Context(style: Style.posix);
 
 /// A default context for manipulating Windows paths.
 final Context windows = new Context(style: Style.windows);
 
 /// A default context for manipulating URLs.
+///
+/// URL path equality is undefined for paths that differ only in their
+/// percent-encoding or only in the case of their host segment.
 final Context url = new Context(style: Style.url);
 
 /// The system path context.
 ///
 /// This differs from a context created with [new Context] in that its
 /// [Context.current] is always the current working directory, rather than being
 /// set once when the context is created.
 final Context context = createInternal();
 
 /// Returns the [Style] of the current context.
@@ skipping 203 matching lines @@
 ///     path.split('/path/to/foo'); // -> ['/', 'path', 'to', 'foo']
 ///
 ///     // Windows
 ///     path.split(r'C:\path\to\foo'); // -> [r'C:\', 'path', 'to', 'foo']
 ///
 ///     // Browser
 ///     path.split('http://dartlang.org/path/to/foo');
 ///       // -> ['http://dartlang.org', 'path', 'to', 'foo']
 List<String> split(String path) => context.split(path);
 
+/// Canonicalizes [path].
+///
+/// This is guaranteed to return the same path for two different input paths
+/// if and only if both input paths point to the same location. Unlike
+/// [normalize], it returns absolute paths when possible and canonicalizes
+/// ASCII case on Windows.
+///
+/// Note that this does not resolve symlinks.
+///
+/// If you want a map that uses path keys, it's probably more efficient to
+/// pass [equals] and [hash] to [new HashMap] than it is to canonicalize every
+/// key.
+String canonicalize(String path) => context.canonicalize(path);
+
 /// Normalizes [path], simplifying it by handling `..`, and `.`, and
 /// removing redundant path separators whenever possible.
 ///
+/// Note that this is *not* guaranteed to return the same result for two
+/// equivalent input paths. For that, see [canonicalize]. Or, if you're using
+/// paths as map keys, pass [equals] and [hash] to [new HashMap].
+///
 ///     path.normalize('path/./to/..//file.text'); // -> 'path/file.txt'
 String normalize(String path) => context.normalize(path);
 
 /// Attempts to convert [path] to an equivalent relative path from the current
 /// directory.
 ///
 ///     // Given current directory is /root/path:
 ///     path.relative('/root/path/a/b.dart'); // -> 'a/b.dart'
 ///     path.relative('/root/other.dart'); // -> '../other.dart'
 ///
@@ skipping 20 matching lines @@
 String relative(String path, {String from}) =>
     context.relative(path, from: from);
 
 /// Returns `true` if [child] is a path beneath `parent`, and `false` otherwise.
 ///
 ///     path.isWithin('/root/path', '/root/path/a'); // -> true
 ///     path.isWithin('/root/path', '/root/other'); // -> false
 ///     path.isWithin('/root/path', '/root/path') // -> false
 bool isWithin(String parent, String child) => context.isWithin(parent, child);
 
+/// Returns `true` if [path1] points to the same location as [path2], and
+/// `false` otherwise.
+///
+/// The [hash] function returns a hash code that matches these equality
+/// semantics.
+bool equals(String path1, String path2) => context.equals(path1, path2);
+
+/// Returns a hash code for [path] such that, if [equals] returns `true` for two
+/// paths, their hash codes are the same.
+///
+/// Note that the same path may have different hash codes on different platforms
+/// or with different [current] directories.
+int hash(String path) => context.hash(path);
+
 /// Removes a trailing extension from the last part of [path].
 ///
 ///     withoutExtension('path/to/foo.dart'); // -> 'path/to/foo'
 String withoutExtension(String path) => context.withoutExtension(path);
 
 /// Returns the path represented by [uri], which may be a [String] or a [Uri].
 ///
 /// For POSIX and Windows styles, [uri] must be a `file:` URI. For the URL
 /// style, this will just convert [uri] to a string.
 ///
@@ skipping 52 matching lines @@
 ///
 ///     // Windows at "C:\root\path"
 ///     path.prettyUri('file:///C:/root/path/a/b.dart'); // -> r'a\b.dart'
 ///     path.prettyUri('http://dartlang.org/'); // -> 'http://dartlang.org'
 ///
 ///     // URL at "http://dartlang.org/root/path"
 ///     path.prettyUri('http://dartlang.org/root/path/a/b.dart');
 ///         // -> r'a/b.dart'
 ///     path.prettyUri('file:///root/path'); // -> 'file:///root/path'
 String prettyUri(uri) => context.prettyUri(uri);