Update charted to 0.4.8 and roll

packages/charted/lib/core/scales/ordinal_scale.dart

 //
 // Copyright 2014 Google Inc. All rights reserved.
 //
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file or at
 // https://developers.google.com/open-source/licenses/bsd
 //
 part of charted.core.scales;
 
 class _OrdinalScale implements OrdinalScale {
   final _index = new Map<dynamic, int>();
 
   List _domain = [];
   List _range = [];
   num _rangeBand = 0;
   Extent _rangeExtent;
   Function _reset;
 
   _OrdinalScale();
 
   _OrdinalScale._clone(_OrdinalScale source)
-      : _domain = source._domain,
-        _range = source._range,
+      : _domain = new List.from(source._domain),
+        _range = new List.from(source._range),
         _reset = source._reset,
         _rangeExtent = source._rangeExtent,
         _rangeBand = source._rangeBand {
     _index.addAll(source._index);
   }
 
   @override
   scale(dynamic value) {
     if (!_index.containsKey(value)) {
       _index[value] = domain.length;
@@ skipping 79 matching lines @@
       s._rangeExtent = null;
     };
     scale._reset(scale);
   }
 
   static void _setRangePoints(
       _OrdinalScale scale, Iterable range, double padding) {
     scale._reset = (_OrdinalScale s) {
       var start = range.first,
           stop = range.last,
-          step = (stop - start) / (s.domain.length - 1 + padding);
+          step = s.domain.length > 1
+              ? (stop - start - 2 * padding) / (s.domain.length - 1)
+              : 0;
 
       s._range = s._steps(
-          s.domain.length < 2 ? (start + stop) / 2 : start + step * padding / 2,
-          step);
+          s.domain.length < 2 ? (start + stop) / 2 : start + padding, step);
       s._rangeBand = 0;
       s._rangeExtent = new Extent(start, stop);
     };
     if (scale.domain.isNotEmpty) {
       scale._reset(scale);
     }
   }
 
   static void _setRangeBands(_OrdinalScale scale, Iterable range,
       double padding, double outerPadding) {
     scale._reset = (_OrdinalScale s) {
       var start = range.first,
           stop = range.last,
-          step = (stop - start) / s.domain.length - padding + 2 * outerPadding;
+          step = (stop - start - 2 * outerPadding) /
+              (s.domain.length > 1
+                  ? (s.domain.length - padding)
+                  : 1);
 
       s._range = s._steps(start + step * outerPadding, step);
       s._rangeBand = step * (1 - padding);
       s._rangeExtent = new Extent(start, stop);
     };
     if (scale.domain.isNotEmpty) {
       scale._reset(scale);
     }
   }
 
   static void _setRangeRoundBands(_OrdinalScale scale, Iterable range,
       double padding, double outerPadding) {
     scale._reset = (_OrdinalScale s) {
       var start = range.first,
           stop = range.last,
           step =
-          ((stop - start) / (s.domain.length - padding + 2 * outerPadding))
-              .floor(),
-          error = stop - start - (s.domain.length - padding) * step;
+          ((stop - start - 2 * outerPadding) /
+              (s.domain.length > 1
+                  ? (s.domain.length - padding)
+                  : 1)).floor();
 
-      s._range = s._steps(start + (error / 2).round(), step);
+      s._range = s._steps(start + outerPadding, step);
       s._rangeBand = (step * (1 - padding)).round();
       s._rangeExtent = new Extent(start, stop);
     };
     if (scale.domain.isNotEmpty) {
       scale._reset(scale);
     }
   }
 
   //
   // Properties that are valid only on quantitative scales.
   //
-
   bool clamp;
   bool nice;
   bool rounded;
   int ticksCount;
+  int forcedTicksCount;
 }