Update charted to 0.4.8 and roll

packages/utf/lib/src/utf16.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 utf;
+library utf.utf16;
 
-// TODO(jmesserly): would be nice to have this on String (dartbug.com/6501).
-/**
- * Provide a list of Unicode codepoints for a given string.
- */
-List<int> stringToCodepoints(String str) {
-  // Note: str.codeUnits gives us 16-bit code units on all Dart implementations.
-  // So we need to convert.
-  return utf16CodeUnitsToCodepoints(str.codeUnits);
-}
+import "dart:collection";
+
+import 'constants.dart';
+import 'list_range.dart';
+import 'utf_16_code_unit_decoder.dart';
+import 'util.dart';
 
 /**
  * Generate a string from the provided Unicode codepoints.
  *
  * *Deprecated* Use [String.fromCharCodes] instead.
  */
 @deprecated
 String codepointsToString(List<int> codepoints) {
   return new String.fromCharCodes(codepoints);
 }
+
 /**
  * Decodes the UTF-16 bytes as an iterable. Thus, the consumer can only convert
  * as much of the input as needed. Determines the byte order from the BOM,
  * or uses big-endian as a default. This method always strips a leading BOM.
  * Set the [replacementCodepoint] to null to throw an ArgumentError
  * rather than replace the bad value. The default value for
  * [replacementCodepoint] is U+FFFD.
  */
-IterableUtf16Decoder decodeUtf16AsIterable(List<int> bytes, [int offset = 0,
-    int length, int replacementCodepoint =
-    UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
+IterableUtf16Decoder decodeUtf16AsIterable(List<int> bytes,
+    [int offset = 0,
+    int length,
+    int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
   return new IterableUtf16Decoder._(
-      () => new Utf16BytesToCodeUnitsDecoder(bytes, offset, length,
-      replacementCodepoint), replacementCodepoint);
+      () => new Utf16BytesToCodeUnitsDecoder(
+          bytes, offset, length, replacementCodepoint),
+      replacementCodepoint);
 }
 
 /**
  * Decodes the UTF-16BE bytes as an iterable. Thus, the consumer can only
  * convert as much of the input as needed. This method strips a leading BOM by
  * default, but can be overridden by setting the optional parameter [stripBom]
  * to false. Set the [replacementCodepoint] to null to throw an
  * ArgumentError rather than replace the bad value. The default
  * value for the [replacementCodepoint] is U+FFFD.
  */
-IterableUtf16Decoder decodeUtf16beAsIterable(List<int> bytes, [int offset = 0,
-    int length, bool stripBom = true, int replacementCodepoint =
-    UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
+IterableUtf16Decoder decodeUtf16beAsIterable(List<int> bytes,
+    [int offset = 0,
+    int length,
+    bool stripBom = true,
+    int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
   return new IterableUtf16Decoder._(
-      () => new Utf16beBytesToCodeUnitsDecoder(bytes, offset, length, stripBom,
-      replacementCodepoint), replacementCodepoint);
+      () => new Utf16beBytesToCodeUnitsDecoder(
+          bytes, offset, length, stripBom, replacementCodepoint),
+      replacementCodepoint);
 }
 
 /**
  * Decodes the UTF-16LE bytes as an iterable. Thus, the consumer can only
  * convert as much of the input as needed. This method strips a leading BOM by
  * default, but can be overridden by setting the optional parameter [stripBom]
  * to false. Set the [replacementCodepoint] to null to throw an
  * ArgumentError rather than replace the bad value. The default
  * value for the [replacementCodepoint] is U+FFFD.
  */
-IterableUtf16Decoder decodeUtf16leAsIterable(List<int> bytes, [int offset = 0,
-    int length, bool stripBom = true, int replacementCodepoint =
-    UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
+IterableUtf16Decoder decodeUtf16leAsIterable(List<int> bytes,
+    [int offset = 0,
+    int length,
+    bool stripBom = true,
+    int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
   return new IterableUtf16Decoder._(
-      () => new Utf16leBytesToCodeUnitsDecoder(bytes, offset, length, stripBom,
-      replacementCodepoint), replacementCodepoint);
+      () => new Utf16leBytesToCodeUnitsDecoder(
+          bytes, offset, length, stripBom, replacementCodepoint),
+      replacementCodepoint);
 }
 
 /**
  * Produce a String from a sequence of UTF-16 encoded bytes. This method always
  * strips a leading BOM. Set the [replacementCodepoint] to null to throw  an
  * ArgumentError rather than replace the bad value. The default
  * value for the [replacementCodepoint] is U+FFFD.
  */
-String decodeUtf16(List<int> bytes, [int offset = 0, int length,
+String decodeUtf16(List<int> bytes,
+    [int offset = 0,
+    int length,
     int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
-  Utf16BytesToCodeUnitsDecoder decoder = new Utf16BytesToCodeUnitsDecoder(bytes,
-      offset, length, replacementCodepoint);
+  Utf16BytesToCodeUnitsDecoder decoder = new Utf16BytesToCodeUnitsDecoder(
+      bytes, offset, length, replacementCodepoint);
   List<int> codeunits = decoder.decodeRest();
   return new String.fromCharCodes(
       utf16CodeUnitsToCodepoints(codeunits, 0, null, replacementCodepoint));
 }
 
 /**
  * Produce a String from a sequence of UTF-16BE encoded bytes. This method
  * strips a leading BOM by default, but can be overridden by setting the
  * optional parameter [stripBom] to false. Set the [replacementCodepoint] to
  * null to throw an ArgumentError rather than replace the bad value.
  * The default value for the [replacementCodepoint] is U+FFFD.
  */
-String decodeUtf16be(List<int> bytes, [int offset = 0, int length,
+String decodeUtf16be(List<int> bytes,
+    [int offset = 0,
+    int length,
     bool stripBom = true,
     int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
-  List<int> codeunits = (new Utf16beBytesToCodeUnitsDecoder(bytes, offset,
-      length, stripBom, replacementCodepoint)).decodeRest();
+  List<int> codeunits = (new Utf16beBytesToCodeUnitsDecoder(
+          bytes, offset, length, stripBom, replacementCodepoint))
+      .decodeRest();
   return new String.fromCharCodes(
       utf16CodeUnitsToCodepoints(codeunits, 0, null, replacementCodepoint));
 }
 
 /**
  * Produce a String from a sequence of UTF-16LE encoded bytes. This method
  * strips a leading BOM by default, but can be overridden by setting the
  * optional parameter [stripBom] to false. Set the [replacementCodepoint] to
  * null to throw an ArgumentError rather than replace the bad value.
  * The default value for the [replacementCodepoint] is U+FFFD.
  */
-String decodeUtf16le(List<int> bytes, [int offset = 0, int length,
+String decodeUtf16le(List<int> bytes,
+    [int offset = 0,
+    int length,
     bool stripBom = true,
     int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
-  List<int> codeunits = (new Utf16leBytesToCodeUnitsDecoder(bytes, offset,
-      length, stripBom, replacementCodepoint)).decodeRest();
+  List<int> codeunits = (new Utf16leBytesToCodeUnitsDecoder(
+          bytes, offset, length, stripBom, replacementCodepoint))
+      .decodeRest();
   return new String.fromCharCodes(
       utf16CodeUnitsToCodepoints(codeunits, 0, null, replacementCodepoint));
 }
 
 /**
  * Produce a list of UTF-16 encoded bytes. This method prefixes the resulting
  * bytes with a big-endian byte-order-marker.
  */
-List<int> encodeUtf16(String str) =>
-    encodeUtf16be(str, true);
+List<int> encodeUtf16(String str) => encodeUtf16be(str, true);
 
 /**
  * Produce a list of UTF-16BE encoded bytes. By default, this method produces
  * UTF-16BE bytes with no BOM.
  */
 List<int> encodeUtf16be(String str, [bool writeBOM = false]) {
   List<int> utf16CodeUnits = _stringToUtf16CodeUnits(str);
   List<int> encoding =
       new List<int>(2 * utf16CodeUnits.length + (writeBOM ? 2 : 0));
   int i = 0;
@@ skipping 72 matching lines @@
  */
 // TODO(floitsch): Consider removing the extend and switch to implements since
 // that's cheaper to allocate.
 class IterableUtf16Decoder extends IterableBase<int> {
   final _CodeUnitsProvider codeunitsProvider;
   final int replacementCodepoint;
 
   IterableUtf16Decoder._(this.codeunitsProvider, this.replacementCodepoint);
 
   Utf16CodeUnitDecoder get iterator =>
-      new Utf16CodeUnitDecoder.fromListRangeIterator(codeunitsProvider(),
-          replacementCodepoint);
+      new Utf16CodeUnitDecoder.fromListRangeIterator(
+          codeunitsProvider(), replacementCodepoint);
 }
 
 /**
  * Convert UTF-16 encoded bytes to UTF-16 code units by grouping 1-2 bytes
  * to produce the code unit (0-(2^16)-1). Relies on BOM to determine
  * endian-ness, and defaults to BE.
  */
 abstract class Utf16BytesToCodeUnitsDecoder implements ListRangeIterator {
   // TODO(kevmoo): should this field be private?
   final ListRangeIterator utf16EncodedBytesIterator;
   final int replacementCodepoint;
   int _current = null;
 
   Utf16BytesToCodeUnitsDecoder._fromListRangeIterator(
       this.utf16EncodedBytesIterator, this.replacementCodepoint);
 
-  factory Utf16BytesToCodeUnitsDecoder(List<int> utf16EncodedBytes, [
-      int offset = 0, int length,
+  factory Utf16BytesToCodeUnitsDecoder(List<int> utf16EncodedBytes,
+      [int offset = 0,
+      int length,
       int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
     if (length == null) {
       length = utf16EncodedBytes.length - offset;
     }
     if (hasUtf16beBom(utf16EncodedBytes, offset, length)) {
       return new Utf16beBytesToCodeUnitsDecoder(utf16EncodedBytes, offset + 2,
           length - 2, false, replacementCodepoint);
     } else if (hasUtf16leBom(utf16EncodedBytes, offset, length)) {
       return new Utf16leBytesToCodeUnitsDecoder(utf16EncodedBytes, offset + 2,
           length - 2, false, replacementCodepoint);
     } else {
-      return new Utf16beBytesToCodeUnitsDecoder(utf16EncodedBytes, offset,
-          length, false, replacementCodepoint);
+      return new Utf16beBytesToCodeUnitsDecoder(
+          utf16EncodedBytes, offset, length, false, replacementCodepoint);
     }
   }
 
   /**
    * Provides a fast way to decode the rest of the source bytes in a single
    * call. This method trades memory for improved speed in that it potentially
    * over-allocates the List containing results.
    */
   List<int> decodeRest() {
     List<int> codeunits = new List<int>(remaining);
@@ skipping 46 matching lines @@
   }
 
   int decode();
 }
 
 /**
  * Convert UTF-16BE encoded bytes to utf16 code units by grouping 1-2 bytes
  * to produce the code unit (0-(2^16)-1).
  */
 class Utf16beBytesToCodeUnitsDecoder extends Utf16BytesToCodeUnitsDecoder {
-  Utf16beBytesToCodeUnitsDecoder(List<int> utf16EncodedBytes, [
-      int offset = 0, int length, bool stripBom = true,
-      int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) :
-      super._fromListRangeIterator(
-          (new ListRange(utf16EncodedBytes, offset, length)).iterator,
-          replacementCodepoint) {
+  Utf16beBytesToCodeUnitsDecoder(List<int> utf16EncodedBytes,
+      [int offset = 0,
+      int length,
+      bool stripBom = true,
+      int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT])
+      : super._fromListRangeIterator(
+            (new ListRange(utf16EncodedBytes, offset, length)).iterator,
+            replacementCodepoint) {
     if (stripBom && hasUtf16beBom(utf16EncodedBytes, offset, length)) {
       skip();
     }
   }
 
   int decode() {
     utf16EncodedBytesIterator.moveNext();
     int hi = utf16EncodedBytesIterator.current;
     utf16EncodedBytesIterator.moveNext();
     int lo = utf16EncodedBytesIterator.current;
     return (hi << 8) + lo;
   }
 }
 
 /**
  * Convert UTF-16LE encoded bytes to utf16 code units by grouping 1-2 bytes
  * to produce the code unit (0-(2^16)-1).
  */
 class Utf16leBytesToCodeUnitsDecoder extends Utf16BytesToCodeUnitsDecoder {
-  Utf16leBytesToCodeUnitsDecoder(List<int> utf16EncodedBytes, [
-      int offset = 0, int length, bool stripBom = true,
-      int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) :
-      super._fromListRangeIterator(
-          (new ListRange(utf16EncodedBytes, offset, length)).iterator,
-          replacementCodepoint) {
+  Utf16leBytesToCodeUnitsDecoder(List<int> utf16EncodedBytes,
+      [int offset = 0,
+      int length,
+      bool stripBom = true,
+      int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT])
+      : super._fromListRangeIterator(
+            (new ListRange(utf16EncodedBytes, offset, length)).iterator,
+            replacementCodepoint) {
     if (stripBom && hasUtf16leBom(utf16EncodedBytes, offset, length)) {
       skip();
     }
   }
 
   int decode() {
     utf16EncodedBytesIterator.moveNext();
     int lo = utf16EncodedBytesIterator.current;
     utf16EncodedBytesIterator.moveNext();
     int hi = utf16EncodedBytesIterator.current;
     return (hi << 8) + lo;
   }
 }