var convert;
(function(exports) {
  'use strict';
  let ASCII = new AsciiCodec();
  let _ASCII_MASK = 127;
  let _allowInvalid = Symbol('_allowInvalid');
  let _nameToEncoding = Symbol('_nameToEncoding');
  let Codec$ = dart.generic(function(S, T) {
    class Codec extends core.Object {
      Codec() {
      }
      encode(input) {
        return this.encoder.convert(input);
      }
      decode(encoded) {
        return this.decoder.convert(encoded);
      }
      fuse(other) {
        return new (_FusedCodec$(S, T, dynamic))(this, other);
      }
      get inverted() {
        return new (_InvertedCodec$(T, S))(this);
      }
    }
    return Codec;
  });
  let Codec = Codec$();
  class Encoding extends Codec$(core.String, core.List$(core.int)) {
    Encoding() {
      super.Codec();
    }
    decodeStream(byteStream) {
      return dart.as(byteStream.transform(dart.as(this.decoder, async.StreamTransformer$(core.List$(core.int), dynamic))).fold(new core.StringBuffer(), (buffer, string) => dart.dinvoke(buffer, 'write', string), buffer).then((buffer) => dart.dinvoke(buffer, 'toString')), async.Future$(core.String));
    }
    static getByName(name) {
      if (name == null)
        return null;
      name = name.toLowerCase();
      return Encoding[_nameToEncoding].get(name);
    }
  }
  dart.defineLazyProperties(Encoding, {
    get _nameToEncoding() {
      return dart.map({"iso_8859-1:1987": LATIN1, "iso-ir-100": LATIN1, "iso_8859-1": LATIN1, "iso-8859-1": LATIN1, latin1: LATIN1, l1: LATIN1, ibm819: LATIN1, cp819: LATIN1, csisolatin1: LATIN1, "iso-ir-6": ASCII, "ansi_x3.4-1968": ASCII, "ansi_x3.4-1986": ASCII, "iso_646.irv:1991": ASCII, "iso646-us": ASCII, "us-ascii": ASCII, us: ASCII, ibm367: ASCII, cp367: ASCII, csascii: ASCII, ascii: ASCII, csutf8: UTF8, "utf-8": UTF8});
    },
    set _nameToEncoding(_) {}
  });
  class AsciiCodec extends Encoding {
    AsciiCodec(opts) {
      let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
      this[_allowInvalid] = allowInvalid;
      super.Encoding();
    }
    get name() {
      return "us-ascii";
    }
    decode(bytes, opts) {
      let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : null;
      if (allowInvalid == null)
        allowInvalid = this[_allowInvalid];
      if (allowInvalid) {
        return new AsciiDecoder({allowInvalid: true}).convert(bytes);
      } else {
        return new AsciiDecoder({allowInvalid: false}).convert(bytes);
      }
    }
    get encoder() {
      return new AsciiEncoder();
    }
    get decoder() {
      return this[_allowInvalid] ? new AsciiDecoder({allowInvalid: true}) : new AsciiDecoder({allowInvalid: false});
    }
  }
  let _subsetMask = Symbol('_subsetMask');
  let Converter$ = dart.generic(function(S, T) {
    class Converter extends core.Object {
      Converter() {
      }
      fuse(other) {
        return new (_FusedConverter$(S, T, dynamic))(this, other);
      }
      startChunkedConversion(sink) {
        throw new core.UnsupportedError(`This converter does not support chunked conversions: ${this}`);
      }
      bind(source) {
        return new async.Stream.eventTransformed(source, ((sink) => new _ConverterStreamEventSink(this, sink)).bind(this));
      }
    }
    Converter[dart.implements] = () => [async.StreamTransformer];
    return Converter;
  });
  let Converter = Converter$();
  class _UnicodeSubsetEncoder extends Converter$(core.String, core.List$(core.int)) {
    _UnicodeSubsetEncoder(subsetMask) {
      this[_subsetMask] = subsetMask;
      super.Converter();
    }
    convert(string, start, end) {
      if (start === void 0)
        start = 0;
      if (end === void 0)
        end = null;
      let stringLength = string.length;
      core.RangeError.checkValidRange(start, end, stringLength);
      if (end == null)
        end = stringLength;
      let length = dart.notNull(end) - dart.notNull(start);
      let result = new typed_data.Uint8List(length);
      for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
        let codeUnit = string.codeUnitAt(dart.notNull(start) + dart.notNull(i));
        if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) != 0) {
          throw new core.ArgumentError("String contains invalid characters.");
        }
        result[core.$set](i, codeUnit);
      }
      return dart.as(result, core.List$(core.int));
    }
    startChunkedConversion(sink) {
      if (!dart.is(sink, ByteConversionSink)) {
        sink = new ByteConversionSink.from(sink);
      }
      return new _UnicodeSubsetEncoderSink(this[_subsetMask], dart.as(sink, ByteConversionSink));
    }
    bind(stream) {
      return dart.as(super.bind(stream), async.Stream$(core.List$(core.int)));
    }
  }
  class AsciiEncoder extends _UnicodeSubsetEncoder {
    AsciiEncoder() {
      super._UnicodeSubsetEncoder(_ASCII_MASK);
    }
  }
  let _sink = Symbol('_sink');
  class StringConversionSinkMixin extends core.Object {
    add(str) {
      return this.addSlice(str, 0, str.length, false);
    }
    asUtf8Sink(allowMalformed) {
      return new _Utf8ConversionSink(this, allowMalformed);
    }
    asStringSink() {
      return new _StringConversionSinkAsStringSinkAdapter(this);
    }
  }
  StringConversionSinkMixin[dart.implements] = () => [StringConversionSink];
  class StringConversionSinkBase extends StringConversionSinkMixin {}
  class _UnicodeSubsetEncoderSink extends StringConversionSinkBase {
    _UnicodeSubsetEncoderSink(subsetMask, sink$) {
      this[_subsetMask] = subsetMask;
      this[_sink] = sink$;
      super.StringConversionSinkBase();
    }
    close() {
      this[_sink].close();
    }
    addSlice(source, start, end, isLast) {
      core.RangeError.checkValidRange(start, end, source.length);
      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
        let codeUnit = source.codeUnitAt(i);
        if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) != 0) {
          throw new core.ArgumentError(`Source contains invalid character with code point: ${codeUnit}.`);
        }
      }
      this[_sink].add(source.codeUnits[core.$sublist](start, end));
      if (isLast) {
        this.close();
      }
    }
  }
  let _convertInvalid = Symbol('_convertInvalid');
  class _UnicodeSubsetDecoder extends Converter$(core.List$(core.int), core.String) {
    _UnicodeSubsetDecoder(allowInvalid$, subsetMask) {
      this[_allowInvalid] = allowInvalid$;
      this[_subsetMask] = subsetMask;
      super.Converter();
    }
    convert(bytes, start, end) {
      if (start === void 0)
        start = 0;
      if (end === void 0)
        end = null;
      let byteCount = bytes[core.$length];
      core.RangeError.checkValidRange(start, end, byteCount);
      if (end == null)
        end = byteCount;
      let length = dart.notNull(end) - dart.notNull(start);
      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
        let byte = bytes[core.$get](i);
        if ((dart.notNull(byte) & ~dart.notNull(this[_subsetMask])) != 0) {
          if (!dart.notNull(this[_allowInvalid])) {
            throw new core.FormatException(`Invalid value in input: ${byte}`);
          }
          return this[_convertInvalid](bytes, start, end);
        }
      }
      return new core.String.fromCharCodes(bytes, start, end);
    }
    [_convertInvalid](bytes, start, end) {
      let buffer = new core.StringBuffer();
      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
        let value = bytes[core.$get](i);
        if ((dart.notNull(value) & ~dart.notNull(this[_subsetMask])) != 0)
          value = 65533;
        buffer.writeCharCode(value);
      }
      return buffer.toString();
    }
    bind(stream) {
      return dart.as(super.bind(stream), async.Stream$(core.String));
    }
  }
  class AsciiDecoder extends _UnicodeSubsetDecoder {
    AsciiDecoder(opts) {
      let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
      super._UnicodeSubsetDecoder(allowInvalid, _ASCII_MASK);
    }
    startChunkedConversion(sink) {
      let stringSink = null;
      if (dart.is(sink, StringConversionSink)) {
        stringSink = sink;
      } else {
        stringSink = new StringConversionSink.from(sink);
      }
      if (this[_allowInvalid]) {
        return new _ErrorHandlingAsciiDecoderSink(stringSink.asUtf8Sink(false));
      } else {
        return new _SimpleAsciiDecoderSink(stringSink);
      }
    }
  }
  let _utf8Sink = Symbol('_utf8Sink');
  let ChunkedConversionSink$ = dart.generic(function(T) {
    class ChunkedConversionSink extends core.Object {
      ChunkedConversionSink() {
      }
      withCallback(callback) {
        return new _SimpleCallbackSink(callback);
      }
    }
    ChunkedConversionSink[dart.implements] = () => [core.Sink$(T)];
    dart.defineNamedConstructor(ChunkedConversionSink, 'withCallback');
    return ChunkedConversionSink;
  });
  let ChunkedConversionSink = ChunkedConversionSink$();
  class ByteConversionSink extends ChunkedConversionSink$(core.List$(core.int)) {
    ByteConversionSink() {
      super.ChunkedConversionSink();
    }
    withCallback(callback) {
      return new _ByteCallbackSink(callback);
    }
    from(sink) {
      return new _ByteAdapterSink(sink);
    }
  }
  dart.defineNamedConstructor(ByteConversionSink, 'withCallback');
  dart.defineNamedConstructor(ByteConversionSink, 'from');
  class ByteConversionSinkBase extends ByteConversionSink {
    addSlice(chunk, start, end, isLast) {
      this.add(chunk[core.$sublist](start, end));
      if (isLast)
        this.close();
    }
  }
  class _ErrorHandlingAsciiDecoderSink extends ByteConversionSinkBase {
    _ErrorHandlingAsciiDecoderSink(utf8Sink) {
      this[_utf8Sink] = utf8Sink;
      super.ByteConversionSinkBase();
    }
    close() {
      this[_utf8Sink].close();
    }
    add(source) {
      this.addSlice(source, 0, source[core.$length], false);
    }
    addSlice(source, start, end, isLast) {
      core.RangeError.checkValidRange(start, end, source[core.$length]);
      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
        if ((dart.notNull(source[core.$get](i)) & ~dart.notNull(_ASCII_MASK)) != 0) {
          if (dart.notNull(i) > dart.notNull(start))
            this[_utf8Sink].addSlice(source, start, i, false);
          this[_utf8Sink].add(/* Unimplemented const */new core.List$(core.int).from([239, 191, 189]));
          start = dart.notNull(i) + 1;
        }
      }
      if (dart.notNull(start) < dart.notNull(end)) {
        this[_utf8Sink].addSlice(source, start, end, isLast);
      } else if (isLast) {
        this.close();
      }
    }
  }
  class _SimpleAsciiDecoderSink extends ByteConversionSinkBase {
    _SimpleAsciiDecoderSink(sink$) {
      this[_sink] = sink$;
      super.ByteConversionSinkBase();
    }
    close() {
      this[_sink].close();
    }
    add(source) {
      for (let i = 0; dart.notNull(i) < dart.notNull(source[core.$length]); i = dart.notNull(i) + 1) {
        if ((dart.notNull(source[core.$get](i)) & ~dart.notNull(_ASCII_MASK)) != 0) {
          throw new core.FormatException("Source contains non-ASCII bytes.");
        }
      }
      this[_sink].add(new core.String.fromCharCodes(source));
    }
    addSlice(source, start, end, isLast) {
      let length = source[core.$length];
      core.RangeError.checkValidRange(start, end, length);
      if (dart.notNull(start) < dart.notNull(end)) {
        if (start != 0 || end != length) {
          source = source[core.$sublist](start, end);
        }
        this.add(source);
      }
      if (isLast)
        this.close();
    }
  }
  class _ByteAdapterSink extends ByteConversionSinkBase {
    _ByteAdapterSink(sink$) {
      this[_sink] = sink$;
      super.ByteConversionSinkBase();
    }
    add(chunk) {
      return this[_sink].add(chunk);
    }
    close() {
      return this[_sink].close();
    }
  }
  let _buffer = Symbol('_buffer');
  let _INITIAL_BUFFER_SIZE = Symbol('_INITIAL_BUFFER_SIZE');
  let _callback = Symbol('_callback');
  let _bufferIndex = Symbol('_bufferIndex');
  let _roundToPowerOf2 = Symbol('_roundToPowerOf2');
  class _ByteCallbackSink extends ByteConversionSinkBase {
    _ByteCallbackSink(callback) {
      this[_buffer] = new typed_data.Uint8List(_ByteCallbackSink[_INITIAL_BUFFER_SIZE]);
      this[_callback] = callback;
      this[_bufferIndex] = 0;
      super.ByteConversionSinkBase();
    }
    add(chunk) {
      let freeCount = dart.notNull(this[_buffer][core.$length]) - dart.notNull(this[_bufferIndex]);
      if (dart.notNull(chunk[core.$length]) > dart.notNull(freeCount)) {
        let oldLength = this[_buffer][core.$length];
        let newLength = dart.notNull(_ByteCallbackSink[_roundToPowerOf2](dart.notNull(chunk[core.$length]) + dart.notNull(oldLength))) * 2;
        let grown = new typed_data.Uint8List(newLength);
        grown[core.$setRange](0, this[_buffer][core.$length], this[_buffer]);
        this[_buffer] = grown;
      }
      this[_buffer][core.$setRange](this[_bufferIndex], dart.notNull(this[_bufferIndex]) + dart.notNull(chunk[core.$length]), chunk);
      this[_bufferIndex] = chunk[core.$length];
    }
    static [_roundToPowerOf2](v) {
      dart.assert(dart.notNull(v) > 0);
      v = dart.notNull(v) - 1;
      v = dart.notNull(v) >> 1;
      v = dart.notNull(v) >> 2;
      v = dart.notNull(v) >> 4;
      v = dart.notNull(v) >> 8;
      v = dart.notNull(v) >> 16;
      v = dart.notNull(v) + 1;
      return v;
    }
    close() {
      this[_callback](this[_buffer][core.$sublist](0, this[_bufferIndex]));
    }
  }
  _ByteCallbackSink._INITIAL_BUFFER_SIZE = 1024;
  let _ChunkedConversionCallback$ = dart.generic(function(T) {
    class _ChunkedConversionCallback extends core.Function {}
    return _ChunkedConversionCallback;
  });
  let _ChunkedConversionCallback = _ChunkedConversionCallback$();
  let _accumulated = Symbol('_accumulated');
  let _SimpleCallbackSink$ = dart.generic(function(T) {
    class _SimpleCallbackSink extends ChunkedConversionSink$(T) {
      _SimpleCallbackSink(callback$) {
        this[_accumulated] = new core.List$(T).from([]);
        this[_callback] = callback$;
        super.ChunkedConversionSink();
      }
      add(chunk) {
        this[_accumulated][core.$add](chunk);
      }
      close() {
        this[_callback](this[_accumulated]);
      }
    }
    return _SimpleCallbackSink;
  });
  let _SimpleCallbackSink = _SimpleCallbackSink$();
  let _EventSinkAdapter$ = dart.generic(function(T) {
    class _EventSinkAdapter extends core.Object {
      _EventSinkAdapter(sink$) {
        this[_sink] = sink$;
      }
      add(data) {
        return this[_sink].add(data);
      }
      close() {
        return this[_sink].close();
      }
    }
    _EventSinkAdapter[dart.implements] = () => [ChunkedConversionSink$(T)];
    return _EventSinkAdapter;
  });
  let _EventSinkAdapter = _EventSinkAdapter$();
  let _eventSink = Symbol('_eventSink');
  let _chunkedSink = Symbol('_chunkedSink');
  let _ConverterStreamEventSink$ = dart.generic(function(S, T) {
    class _ConverterStreamEventSink extends core.Object {
      _ConverterStreamEventSink(converter, sink) {
        this[_eventSink] = sink;
        this[_chunkedSink] = converter.startChunkedConversion(sink);
      }
      add(o) {
        return this[_chunkedSink].add(o);
      }
      addError(error, stackTrace) {
        if (stackTrace === void 0)
          stackTrace = null;
        this[_eventSink].addError(error, stackTrace);
      }
      close() {
        return this[_chunkedSink].close();
      }
    }
    _ConverterStreamEventSink[dart.implements] = () => [async.EventSink$(S)];
    return _ConverterStreamEventSink;
  });
  let _ConverterStreamEventSink = _ConverterStreamEventSink$();
  let _first = Symbol('_first');
  let _second = Symbol('_second');
  let _FusedCodec$ = dart.generic(function(S, M, T) {
    class _FusedCodec extends Codec$(S, T) {
      get encoder() {
        return dart.as(this[_first].encoder.fuse(this[_second].encoder), Converter$(S, T));
      }
      get decoder() {
        return dart.as(this[_second].decoder.fuse(this[_first].decoder), Converter$(T, S));
      }
      _FusedCodec(first$, second) {
        this[_first] = first$;
        this[_second] = second;
        super.Codec();
      }
    }
    return _FusedCodec;
  });
  let _FusedCodec = _FusedCodec$();
  let _codec = Symbol('_codec');
  let _InvertedCodec$ = dart.generic(function(T, S) {
    class _InvertedCodec extends Codec$(T, S) {
      _InvertedCodec(codec) {
        this[_codec] = codec;
        super.Codec();
      }
      get encoder() {
        return this[_codec].decoder;
      }
      get decoder() {
        return this[_codec].encoder;
      }
      get inverted() {
        return this[_codec];
      }
    }
    return _InvertedCodec;
  });
  let _InvertedCodec = _InvertedCodec$();
  let _FusedConverter$ = dart.generic(function(S, M, T) {
    class _FusedConverter extends Converter$(S, T) {
      _FusedConverter(first$, second) {
        this[_first] = first$;
        this[_second] = second;
        super.Converter();
      }
      convert(input) {
        return dart.as(this[_second].convert(this[_first].convert(input)), T);
      }
      startChunkedConversion(sink) {
        return this[_first].startChunkedConversion(this[_second].startChunkedConversion(sink));
      }
    }
    return _FusedConverter;
  });
  let _FusedConverter = _FusedConverter$();
  let HTML_ESCAPE = new HtmlEscape();
  let _$ = Symbol('_');
  let _name = Symbol('_name');
  class HtmlEscapeMode extends core.Object {
    [_$](name$, escapeLtGt, escapeQuot, escapeApos, escapeSlash) {
      this[_name] = name$;
      this.escapeLtGt = escapeLtGt;
      this.escapeQuot = escapeQuot;
      this.escapeApos = escapeApos;
      this.escapeSlash = escapeSlash;
    }
    toString() {
      return this[_name];
    }
  }
  dart.defineNamedConstructor(HtmlEscapeMode, _$);
  HtmlEscapeMode.UNKNOWN = new HtmlEscapeMode[_$]('unknown', true, true, true, true);
  HtmlEscapeMode.ATTRIBUTE = new HtmlEscapeMode[_$]('attribute', false, true, false, false);
  HtmlEscapeMode.ELEMENT = new HtmlEscapeMode[_$]('element', true, false, false, true);
  let _convert = Symbol('_convert');
  class HtmlEscape extends Converter$(core.String, core.String) {
    HtmlEscape(mode) {
      if (mode === void 0)
        mode = HtmlEscapeMode.UNKNOWN;
      this.mode = mode;
      super.Converter();
    }
    convert(text) {
      let val = this[_convert](text, 0, text.length);
      return val == null ? text : val;
    }
    [_convert](text, start, end) {
      let result = null;
      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
        let ch = text.get(i);
        let replace = null;
        switch (ch) {
          case '&':
          {
            replace = '&amp;';
            break;
          }
          case ' ':
          {
            replace = '&nbsp;';
            break;
          }
          case '"':
          {
            if (this.mode.escapeQuot)
              replace = '&quot;';
            break;
          }
          case "'":
          {
            if (this.mode.escapeApos)
              replace = '&#x27;';
            break;
          }
          case '<':
          {
            if (this.mode.escapeLtGt)
              replace = '&lt;';
            break;
          }
          case '>':
          {
            if (this.mode.escapeLtGt)
              replace = '&gt;';
            break;
          }
          case '/':
          {
            if (this.mode.escapeSlash)
              replace = '&#x2F;';
            break;
          }
        }
        if (replace != null) {
          if (result == null)
            result = new core.StringBuffer(text.substring(start, i));
          result.write(replace);
        } else if (result != null) {
          result.write(ch);
        }
      }
      return result != null ? result.toString() : null;
    }
    startChunkedConversion(sink) {
      if (!dart.is(sink, StringConversionSink)) {
        sink = new StringConversionSink.from(sink);
      }
      return new _HtmlEscapeSink(this, dart.as(sink, StringConversionSink));
    }
  }
  let _escape = Symbol('_escape');
  class _HtmlEscapeSink extends StringConversionSinkBase {
    _HtmlEscapeSink(escape, sink$) {
      this[_escape] = escape;
      this[_sink] = sink$;
      super.StringConversionSinkBase();
    }
    addSlice(chunk, start, end, isLast) {
      let val = this[_escape][_convert](chunk, start, end);
      if (val == null) {
        this[_sink].addSlice(chunk, start, end, isLast);
      } else {
        this[_sink].add(val);
        if (isLast)
          this[_sink].close();
      }
    }
    close() {
      return this[_sink].close();
    }
  }
  class JsonUnsupportedObjectError extends core.Error {
    JsonUnsupportedObjectError(unsupportedObject, opts) {
      let cause = opts && 'cause' in opts ? opts.cause : null;
      this.unsupportedObject = unsupportedObject;
      this.cause = cause;
      super.Error();
    }
    toString() {
      if (this.cause != null) {
        return "Converting object to an encodable object failed.";
      } else {
        return "Converting object did not return an encodable object.";
      }
    }
  }
  class JsonCyclicError extends JsonUnsupportedObjectError {
    JsonCyclicError(object) {
      super.JsonUnsupportedObjectError(object);
    }
    toString() {
      return "Cyclic error in JSON stringify";
    }
  }
  let JSON = new JsonCodec();
  class _Reviver extends core.Function {}
  class _ToEncodable extends core.Function {}
  let _reviver = Symbol('_reviver');
  let _toEncodable$ = Symbol('_toEncodable');
  class JsonCodec extends Codec$(core.Object, core.String) {
    JsonCodec(opts) {
      let reviver = opts && 'reviver' in opts ? opts.reviver : null;
      let toEncodable = opts && 'toEncodable' in opts ? opts.toEncodable : null;
      this[_reviver] = reviver;
      this[_toEncodable$] = toEncodable;
      super.Codec();
    }
    withReviver(reviver) {
      this.JsonCodec({reviver: reviver});
    }
    decode(source, opts) {
      let reviver = opts && 'reviver' in opts ? opts.reviver : null;
      if (reviver == null)
        reviver = this[_reviver];
      if (reviver == null)
        return this.decoder.convert(source);
      return new JsonDecoder(reviver).convert(source);
    }
    encode(value, opts) {
      let toEncodable = opts && 'toEncodable' in opts ? opts.toEncodable : null;
      if (toEncodable == null)
        toEncodable = this[_toEncodable$];
      if (toEncodable == null)
        return this.encoder.convert(value);
      return new JsonEncoder(dart.as(toEncodable, dart.throw_("Unimplemented type (Object) → Object"))).convert(value);
    }
    get encoder() {
      if (this[_toEncodable$] == null)
        return new JsonEncoder();
      return new JsonEncoder(dart.as(this[_toEncodable$], dart.throw_("Unimplemented type (Object) → Object")));
    }
    get decoder() {
      if (this[_reviver] == null)
        return new JsonDecoder();
      return new JsonDecoder(this[_reviver]);
    }
  }
  dart.defineNamedConstructor(JsonCodec, 'withReviver');
  let _utf8Encode = Symbol('_utf8Encode');
  class JsonEncoder extends Converter$(core.Object, core.String) {
    JsonEncoder(toEncodable) {
      if (toEncodable === void 0)
        toEncodable = null;
      this.indent = null;
      this[_toEncodable$] = toEncodable;
      super.Converter();
    }
    withIndent(indent, toEncodable) {
      if (toEncodable === void 0)
        toEncodable = null;
      this.indent = indent;
      this[_toEncodable$] = toEncodable;
      super.Converter();
    }
    convert(object) {
      return _JsonStringStringifier.stringify(object, dart.as(this[_toEncodable$], dart.throw_("Unimplemented type (dynamic) → dynamic")), this.indent);
    }
    startChunkedConversion(sink) {
      if (!dart.is(sink, StringConversionSink)) {
        sink = new StringConversionSink.from(sink);
      } else if (dart.is(sink, _Utf8EncoderSink)) {
        return new _JsonUtf8EncoderSink(sink[_sink], this[_toEncodable$], JsonUtf8Encoder[_utf8Encode](this.indent), JsonUtf8Encoder.DEFAULT_BUFFER_SIZE);
      }
      return new _JsonEncoderSink(dart.as(sink, StringConversionSink), this[_toEncodable$], this.indent);
    }
    bind(stream) {
      return dart.as(super.bind(stream), async.Stream$(core.String));
    }
    fuse(other) {
      if (dart.is(other, Utf8Encoder)) {
        return new JsonUtf8Encoder(this.indent, dart.as(this[_toEncodable$], dart.throw_("Unimplemented type (Object) → dynamic")));
      }
      return super.fuse(other);
    }
  }
  dart.defineNamedConstructor(JsonEncoder, 'withIndent');
  let _indent = Symbol('_indent');
  let _bufferSize = Symbol('_bufferSize');
  class JsonUtf8Encoder extends Converter$(core.Object, core.List$(core.int)) {
    JsonUtf8Encoder(indent, toEncodable, bufferSize) {
      if (indent === void 0)
        indent = null;
      if (toEncodable === void 0)
        toEncodable = null;
      if (bufferSize === void 0)
        bufferSize = JsonUtf8Encoder.DEFAULT_BUFFER_SIZE;
      this[_indent] = JsonUtf8Encoder[_utf8Encode](indent);
      this[_toEncodable$] = toEncodable;
      this[_bufferSize] = bufferSize;
      super.Converter();
    }
    static [_utf8Encode](string) {
      if (string == null)
        return null;
      if (string.isEmpty)
        return new typed_data.Uint8List(0);
      checkAscii: {
        for (let i = 0; dart.notNull(i) < dart.notNull(string.length); i = dart.notNull(i) + 1) {
          if (dart.notNull(string.codeUnitAt(i)) >= 128)
            break checkAscii;
        }
        return string.codeUnits;
      }
      return UTF8.encode(string);
    }
    convert(object) {
      let bytes = dart.as(new core.List.from([]), core.List$(core.List$(core.int)));
      // Function addChunk: (Uint8List, int, int) → void
      function addChunk(chunk, start, end) {
        if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(chunk[core.$length])) {
          let length = dart.notNull(end) - dart.notNull(start);
          chunk = new typed_data.Uint8List.view(chunk.buffer, dart.notNull(chunk.offsetInBytes) + dart.notNull(start), length);
        }
        bytes[core.$add](chunk);
      }
      _JsonUtf8Stringifier.stringify(object, this[_indent], dart.as(this[_toEncodable$], dart.throw_("Unimplemented type (Object) → dynamic")), this[_bufferSize], addChunk);
      if (bytes[core.$length] == 1)
        return bytes[core.$get](0);
      let length = 0;
      for (let i = 0; dart.notNull(i) < dart.notNull(bytes[core.$length]); i = dart.notNull(i) + 1) {
        length = bytes[core.$get](i)[core.$length];
      }
      let result = new typed_data.Uint8List(length);
      for (let i = 0, offset = 0; dart.notNull(i) < dart.notNull(bytes[core.$length]); i = dart.notNull(i) + 1) {
        let byteList = bytes[core.$get](i);
        let end = dart.notNull(offset) + dart.notNull(byteList[core.$length]);
        result[core.$setRange](offset, end, byteList);
        offset = end;
      }
      return result;
    }
    startChunkedConversion(sink) {
      let byteSink = null;
      if (dart.is(sink, ByteConversionSink)) {
        byteSink = sink;
      } else {
        byteSink = new ByteConversionSink.from(sink);
      }
      return new _JsonUtf8EncoderSink(byteSink, this[_toEncodable$], this[_indent], this[_bufferSize]);
    }
    bind(stream) {
      return dart.as(super.bind(stream), async.Stream$(core.List$(core.int)));
    }
    fuse(other) {
      return super.fuse(other);
    }
  }
  JsonUtf8Encoder.DEFAULT_BUFFER_SIZE = 256;
  let _isDone = Symbol('_isDone');
  class _JsonEncoderSink extends ChunkedConversionSink$(core.Object) {
    _JsonEncoderSink(sink$, toEncodable$, indent$) {
      this[_sink] = sink$;
      this[_toEncodable$] = toEncodable$;
      this[_indent] = indent$;
      this[_isDone] = false;
      super.ChunkedConversionSink();
    }
    add(o) {
      if (this[_isDone]) {
        throw new core.StateError("Only one call to add allowed");
      }
      this[_isDone] = true;
      let stringSink = this[_sink].asStringSink();
      _JsonStringStringifier.printOn(o, stringSink, dart.as(this[_toEncodable$], dart.throw_("Unimplemented type (dynamic) → dynamic")), this[_indent]);
      stringSink.close();
    }
    close() {}
  }
  let _addChunk = Symbol('_addChunk');
  class _JsonUtf8EncoderSink extends ChunkedConversionSink$(core.Object) {
    _JsonUtf8EncoderSink(sink$, toEncodable$, indent$, bufferSize$) {
      this[_sink] = sink$;
      this[_toEncodable$] = toEncodable$;
      this[_indent] = indent$;
      this[_bufferSize] = bufferSize$;
      this[_isDone] = false;
      super.ChunkedConversionSink();
    }
    [_addChunk](chunk, start, end) {
      this[_sink].addSlice(chunk, start, end, false);
    }
    add(object) {
      if (this[_isDone]) {
        throw new core.StateError("Only one call to add allowed");
      }
      this[_isDone] = true;
      _JsonUtf8Stringifier.stringify(object, this[_indent], dart.as(this[_toEncodable$], dart.throw_("Unimplemented type (Object) → dynamic")), this[_bufferSize], this[_addChunk]);
      this[_sink].close();
    }
    close() {
      if (!dart.notNull(this[_isDone])) {
        this[_isDone] = true;
        this[_sink].close();
      }
    }
  }
  class JsonDecoder extends Converter$(core.String, core.Object) {
    JsonDecoder(reviver) {
      if (reviver === void 0)
        reviver = null;
      this[_reviver] = reviver;
      super.Converter();
    }
    convert(input) {
      return _parseJson(input, this[_reviver]);
    }
    startChunkedConversion(sink) {
      return new _JsonDecoderSink(this[_reviver], sink);
    }
    bind(stream) {
      return super.bind(stream);
    }
  }
  // Function _parseJson: (String, (dynamic, dynamic) → dynamic) → dynamic
  function _parseJson(source, reviver) {
    if (!(typeof source == 'string'))
      throw new core.ArgumentError(source);
    let parsed = null;
    try {
      parsed = JSON.parse(source);
    } catch (e) {
      throw new core.FormatException(String(e));
    }

    if (reviver == null) {
      return _convertJsonToDartLazy(parsed);
    } else {
      return _convertJsonToDart(parsed, reviver);
    }
  }
  // Function _defaultToEncodable: (dynamic) → Object
  function _defaultToEncodable(object) {
    return dart.dinvoke(object, 'toJson');
  }
  let _seen = Symbol('_seen');
  let _checkCycle = Symbol('_checkCycle');
  let _removeSeen = Symbol('_removeSeen');
  class _JsonStringifier extends core.Object {
    _JsonStringifier(_toEncodable) {
      this[_seen] = new core.List();
      this[_toEncodable$] = dart.as(_toEncodable != null ? _toEncodable : _defaultToEncodable, core.Function);
    }
    static hexDigit(x) {
      return dart.notNull(x) < 10 ? 48 + dart.notNull(x) : 87 + dart.notNull(x);
    }
    writeStringContent(s) {
      let offset = 0;
      let length = s.length;
      for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
        let charCode = s.codeUnitAt(i);
        if (dart.notNull(charCode) > dart.notNull(_JsonStringifier.BACKSLASH))
          continue;
        if (dart.notNull(charCode) < 32) {
          if (dart.notNull(i) > dart.notNull(offset))
            this.writeStringSlice(s, offset, i);
          offset = dart.notNull(i) + 1;
          this.writeCharCode(_JsonStringifier.BACKSLASH);
          switch (charCode) {
            case _JsonStringifier.BACKSPACE:
            {
              this.writeCharCode(_JsonStringifier.CHAR_b);
              break;
            }
            case _JsonStringifier.TAB:
            {
              this.writeCharCode(_JsonStringifier.CHAR_t);
              break;
            }
            case _JsonStringifier.NEWLINE:
            {
              this.writeCharCode(_JsonStringifier.CHAR_n);
              break;
            }
            case _JsonStringifier.FORM_FEED:
            {
              this.writeCharCode(_JsonStringifier.CHAR_f);
              break;
            }
            case _JsonStringifier.CARRIAGE_RETURN:
            {
              this.writeCharCode(_JsonStringifier.CHAR_r);
              break;
            }
            default:
            {
              this.writeCharCode(_JsonStringifier.CHAR_u);
              this.writeCharCode(_JsonStringifier.CHAR_0);
              this.writeCharCode(_JsonStringifier.CHAR_0);
              this.writeCharCode(_JsonStringifier.hexDigit(dart.notNull(charCode) >> 4 & 15));
              this.writeCharCode(_JsonStringifier.hexDigit(dart.notNull(charCode) & 15));
              break;
            }
          }
        } else if (charCode == _JsonStringifier.QUOTE || charCode == _JsonStringifier.BACKSLASH) {
          if (dart.notNull(i) > dart.notNull(offset))
            this.writeStringSlice(s, offset, i);
          offset = dart.notNull(i) + 1;
          this.writeCharCode(_JsonStringifier.BACKSLASH);
          this.writeCharCode(charCode);
        }
      }
      if (offset == 0) {
        this.writeString(s);
      } else if (dart.notNull(offset) < dart.notNull(length)) {
        this.writeStringSlice(s, offset, length);
      }
    }
    [_checkCycle](object) {
      for (let i = 0; dart.notNull(i) < dart.notNull(this[_seen][core.$length]); i = dart.notNull(i) + 1) {
        if (core.identical(object, this[_seen][core.$get](i))) {
          throw new JsonCyclicError(object);
        }
      }
      this[_seen][core.$add](object);
    }
    [_removeSeen](object) {
      dart.assert(!dart.notNull(this[_seen][core.$isEmpty]));
      dart.assert(core.identical(this[_seen][core.$last], object));
      this[_seen][core.$removeLast]();
    }
    writeObject(object) {
      if (this.writeJsonValue(object))
        return;
      this[_checkCycle](object);
      try {
        let customJson = dart.dinvokef(this[_toEncodable$], object);
        if (!dart.notNull(this.writeJsonValue(customJson))) {
          throw new JsonUnsupportedObjectError(object);
        }
        this[_removeSeen](object);
      } catch (e) {
        throw new JsonUnsupportedObjectError(object, {cause: e});
      }

    }
    writeJsonValue(object) {
      if (dart.is(object, core.num)) {
        if (dart.dunary('!', dart.dload(object, 'isFinite')))
          return false;
        this.writeNumber(dart.as(object, core.num));
        return true;
      } else if (core.identical(object, true)) {
        this.writeString('true');
        return true;
      } else if (core.identical(object, false)) {
        this.writeString('false');
        return true;
      } else if (object == null) {
        this.writeString('null');
        return true;
      } else if (typeof object == 'string') {
        this.writeString('"');
        this.writeStringContent(dart.as(object, core.String));
        this.writeString('"');
        return true;
      } else if (dart.is(object, core.List)) {
        this[_checkCycle](object);
        this.writeList(dart.as(object, core.List));
        this[_removeSeen](object);
        return true;
      } else if (dart.is(object, core.Map)) {
        this[_checkCycle](object);
        this.writeMap(dart.as(object, core.Map$(core.String, core.Object)));
        this[_removeSeen](object);
        return true;
      } else {
        return false;
      }
    }
    writeList(list) {
      this.writeString('[');
      if (dart.notNull(list[core.$length]) > 0) {
        this.writeObject(list[core.$get](0));
        for (let i = 1; dart.notNull(i) < dart.notNull(list[core.$length]); i = dart.notNull(i) + 1) {
          this.writeString(',');
          this.writeObject(list[core.$get](i));
        }
      }
      this.writeString(']');
    }
    writeMap(map) {
      this.writeString('{');
      let separator = '"';
      map.forEach(dart.as(((key, value) => {
        this.writeString(separator);
        separator = ',"';
        this.writeStringContent(key);
        this.writeString('":');
        this.writeObject(value);
      }).bind(this), dart.throw_("Unimplemented type (String, Object) → void")));
      this.writeString('}');
    }
  }
  _JsonStringifier.BACKSPACE = 8;
  _JsonStringifier.TAB = 9;
  _JsonStringifier.NEWLINE = 10;
  _JsonStringifier.CARRIAGE_RETURN = 13;
  _JsonStringifier.FORM_FEED = 12;
  _JsonStringifier.QUOTE = 34;
  _JsonStringifier.CHAR_0 = 48;
  _JsonStringifier.BACKSLASH = 92;
  _JsonStringifier.CHAR_b = 98;
  _JsonStringifier.CHAR_f = 102;
  _JsonStringifier.CHAR_n = 110;
  _JsonStringifier.CHAR_r = 114;
  _JsonStringifier.CHAR_t = 116;
  _JsonStringifier.CHAR_u = 117;
  let _indentLevel = Symbol('_indentLevel');
  class _JsonPrettyPrintMixin extends core.Object {
    _JsonPrettyPrintMixin() {
      this[_indentLevel] = 0;
    }
    writeList(list) {
      if (list[core.$isEmpty]) {
        this.writeString('[]');
      } else {
        this.writeString('[\n');
        this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
        this.writeIndentation(this[_indentLevel]);
        this.writeObject(list[core.$get](0));
        for (let i = 1; dart.notNull(i) < dart.notNull(list[core.$length]); i = dart.notNull(i) + 1) {
          this.writeString(',\n');
          this.writeIndentation(this[_indentLevel]);
          this.writeObject(list[core.$get](i));
        }
        this.writeString('\n');
        this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
        this.writeIndentation(this[_indentLevel]);
        this.writeString(']');
      }
    }
    writeMap(map) {
      if (map.isEmpty) {
        this.writeString('{}');
      } else {
        this.writeString('{\n');
        this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
        let first = true;
        map.forEach(((key, value) => {
          if (!dart.notNull(first)) {
            this.writeString(",\n");
          }
          this.writeIndentation(this[_indentLevel]);
          this.writeString('"');
          this.writeStringContent(key);
          this.writeString('": ');
          this.writeObject(value);
          first = false;
        }).bind(this));
        this.writeString('\n');
        this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
        this.writeIndentation(this[_indentLevel]);
        this.writeString('}');
      }
    }
  }
  _JsonPrettyPrintMixin[dart.implements] = () => [_JsonStringifier];
  class _JsonStringStringifier extends _JsonStringifier {
    _JsonStringStringifier(sink$, _toEncodable) {
      this[_sink] = sink$;
      super._JsonStringifier(dart.as(_toEncodable, dart.throw_("Unimplemented type (Object) → Object")));
    }
    static stringify(object, toEncodable, indent) {
      let output = new core.StringBuffer();
      _JsonStringStringifier.printOn(object, output, toEncodable, indent);
      return output.toString();
    }
    static printOn(object, output, toEncodable, indent) {
      let stringifier = null;
      if (indent == null) {
        stringifier = new _JsonStringStringifier(output, toEncodable);
      } else {
        stringifier = new _JsonStringStringifierPretty(output, toEncodable, indent);
      }
      dart.dinvoke(stringifier, 'writeObject', object);
    }
    writeNumber(number) {
      this[_sink].write(number.toString());
    }
    writeString(string) {
      this[_sink].write(string);
    }
    writeStringSlice(string, start, end) {
      this[_sink].write(string.substring(start, end));
    }
    writeCharCode(charCode) {
      this[_sink].writeCharCode(charCode);
    }
  }
  class _JsonStringStringifierPretty extends dart.mixin(_JsonStringStringifier, _JsonPrettyPrintMixin) {
    _JsonStringStringifierPretty(sink, toEncodable, indent$) {
      this[_indent] = indent$;
      super._JsonStringStringifier(sink, toEncodable);
    }
    writeIndentation(count) {
      for (let i = 0; dart.notNull(i) < dart.notNull(count); i = dart.notNull(i) + 1)
        this.writeString(this[_indent]);
    }
  }
  class _JsonUtf8Stringifier extends _JsonStringifier {
    _JsonUtf8Stringifier(toEncodable, bufferSize, addChunk) {
      this.addChunk = addChunk;
      this.bufferSize = bufferSize;
      this.buffer = new typed_data.Uint8List(bufferSize);
      this.index = 0;
      super._JsonStringifier(dart.as(toEncodable, dart.throw_("Unimplemented type (Object) → Object")));
    }
    static stringify(object, indent, toEncodableFunction, bufferSize, addChunk) {
      let stringifier = null;
      if (indent != null) {
        stringifier = new _JsonUtf8StringifierPretty(toEncodableFunction, indent, bufferSize, addChunk);
      } else {
        stringifier = new _JsonUtf8Stringifier(toEncodableFunction, bufferSize, addChunk);
      }
      stringifier.writeObject(object);
      stringifier.flush();
    }
    flush() {
      if (dart.notNull(this.index) > 0) {
        dart.dinvokef(this.addChunk, this.buffer, 0, this.index);
      }
      this.buffer = null;
      this.index = 0;
    }
    writeNumber(number) {
      this.writeAsciiString(number.toString());
    }
    writeAsciiString(string) {
      for (let i = 0; dart.notNull(i) < dart.notNull(string.length); i = dart.notNull(i) + 1) {
        let char = string.codeUnitAt(i);
        dart.assert(dart.notNull(char) <= 127);
        this.writeByte(char);
      }
    }
    writeString(string) {
      this.writeStringSlice(string, 0, string.length);
    }
    writeStringSlice(string, start, end) {
      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
        let char = string.codeUnitAt(i);
        if (dart.notNull(char) <= 127) {
          this.writeByte(char);
        } else {
          if ((dart.notNull(char) & 64512) == 55296 && dart.notNull(i) + 1 < dart.notNull(end)) {
            let nextChar = string.codeUnitAt(dart.notNull(i) + 1);
            if ((dart.notNull(nextChar) & 64512) == 56320) {
              char = 65536 + ((dart.notNull(char) & 1023) << 10) + (dart.notNull(nextChar) & 1023);
              this.writeFourByteCharCode(char);
              i = dart.notNull(i) + 1;
              continue;
            }
          }
          this.writeMultiByteCharCode(char);
        }
      }
    }
    writeCharCode(charCode) {
      if (dart.notNull(charCode) <= 127) {
        this.writeByte(charCode);
        return;
      }
      this.writeMultiByteCharCode(charCode);
    }
    writeMultiByteCharCode(charCode) {
      if (dart.notNull(charCode) <= 2047) {
        this.writeByte(192 | dart.notNull(charCode) >> 6);
        this.writeByte(128 | dart.notNull(charCode) & 63);
        return;
      }
      if (dart.notNull(charCode) <= 65535) {
        this.writeByte(224 | dart.notNull(charCode) >> 12);
        this.writeByte(128 | dart.notNull(charCode) >> 6 & 63);
        this.writeByte(128 | dart.notNull(charCode) & 63);
        return;
      }
      this.writeFourByteCharCode(charCode);
    }
    writeFourByteCharCode(charCode) {
      dart.assert(dart.notNull(charCode) <= 1114111);
      this.writeByte(240 | dart.notNull(charCode) >> 18);
      this.writeByte(128 | dart.notNull(charCode) >> 12 & 63);
      this.writeByte(128 | dart.notNull(charCode) >> 6 & 63);
      this.writeByte(128 | dart.notNull(charCode) & 63);
    }
    writeByte(byte) {
      dart.assert(dart.notNull(byte) <= 255);
      if (this.index == this.buffer[core.$length]) {
        dart.dinvokef(this.addChunk, this.buffer, 0, this.index);
        this.buffer = new typed_data.Uint8List(this.bufferSize);
        this.index = 0;
      }
      this.buffer[core.$set](((x$) => this.index = dart.notNull(x$) + 1, x$).bind(this)(this.index), byte);
    }
  }
  class _JsonUtf8StringifierPretty extends dart.mixin(_JsonUtf8Stringifier, _JsonPrettyPrintMixin) {
    _JsonUtf8StringifierPretty(toEncodableFunction, indent, bufferSize, addChunk) {
      this.indent = indent;
      super._JsonUtf8Stringifier(toEncodableFunction, dart.as(bufferSize, core.int), dart.as(addChunk, core.Function));
    }
    writeIndentation(count) {
      let indent = this.indent;
      let indentLength = indent[core.$length];
      if (indentLength == 1) {
        let char = indent[core.$get](0);
        while (dart.notNull(count) > 0) {
          this.writeByte(char);
          count = 1;
        }
        return;
      }
      while (dart.notNull(count) > 0) {
        count = dart.notNull(count) - 1;
        let end = dart.notNull(this.index) + dart.notNull(indentLength);
        if (dart.notNull(end) <= dart.notNull(this.buffer[core.$length])) {
          this.buffer[core.$setRange](this.index, end, indent);
          this.index = end;
        } else {
          for (let i = 0; dart.notNull(i) < dart.notNull(indentLength); i = dart.notNull(i) + 1) {
            this.writeByte(indent[core.$get](i));
          }
        }
      }
    }
  }
  let LATIN1 = new Latin1Codec();
  let _LATIN1_MASK = 255;
  class Latin1Codec extends Encoding {
    Latin1Codec(opts) {
      let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
      this[_allowInvalid] = allowInvalid;
      super.Encoding();
    }
    get name() {
      return "iso-8859-1";
    }
    decode(bytes, opts) {
      let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : null;
      if (allowInvalid == null)
        allowInvalid = this[_allowInvalid];
      if (allowInvalid) {
        return new Latin1Decoder({allowInvalid: true}).convert(bytes);
      } else {
        return new Latin1Decoder({allowInvalid: false}).convert(bytes);
      }
    }
    get encoder() {
      return new Latin1Encoder();
    }
    get decoder() {
      return this[_allowInvalid] ? new Latin1Decoder({allowInvalid: true}) : new Latin1Decoder({allowInvalid: false});
    }
  }
  class Latin1Encoder extends _UnicodeSubsetEncoder {
    Latin1Encoder() {
      super._UnicodeSubsetEncoder(_LATIN1_MASK);
    }
  }
  class Latin1Decoder extends _UnicodeSubsetDecoder {
    Latin1Decoder(opts) {
      let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
      super._UnicodeSubsetDecoder(allowInvalid, _LATIN1_MASK);
    }
    startChunkedConversion(sink) {
      let stringSink = null;
      if (dart.is(sink, StringConversionSink)) {
        stringSink = sink;
      } else {
        stringSink = new StringConversionSink.from(sink);
      }
      if (!dart.notNull(this[_allowInvalid]))
        return new _Latin1DecoderSink(stringSink);
      return new _Latin1AllowInvalidDecoderSink(stringSink);
    }
  }
  let _addSliceToSink = Symbol('_addSliceToSink');
  class _Latin1DecoderSink extends ByteConversionSinkBase {
    _Latin1DecoderSink(sink$) {
      this[_sink] = sink$;
      super.ByteConversionSinkBase();
    }
    close() {
      this[_sink].close();
    }
    add(source) {
      this.addSlice(source, 0, source[core.$length], false);
    }
    [_addSliceToSink](source, start, end, isLast) {
      this[_sink].add(new core.String.fromCharCodes(source, start, end));
      if (isLast)
        this.close();
    }
    addSlice(source, start, end, isLast) {
      core.RangeError.checkValidRange(start, end, source[core.$length]);
      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
        let char = source[core.$get](i);
        if (dart.notNull(char) > dart.notNull(_LATIN1_MASK) || dart.notNull(char) < 0) {
          throw new core.FormatException("Source contains non-Latin-1 characters.");
        }
      }
      if (dart.notNull(start) < dart.notNull(end)) {
        this[_addSliceToSink](source, start, end, isLast);
      }
      if (isLast) {
        this.close();
      }
    }
  }
  class _Latin1AllowInvalidDecoderSink extends _Latin1DecoderSink {
    _Latin1AllowInvalidDecoderSink(sink) {
      super._Latin1DecoderSink(sink);
    }
    addSlice(source, start, end, isLast) {
      core.RangeError.checkValidRange(start, end, source[core.$length]);
      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
        let char = source[core.$get](i);
        if (dart.notNull(char) > dart.notNull(_LATIN1_MASK) || dart.notNull(char) < 0) {
          if (dart.notNull(i) > dart.notNull(start))
            this[_addSliceToSink](source, start, i, false);
          this[_addSliceToSink](dart.as(/* Unimplemented const */new core.List.from([65533]), core.List$(core.int)), 0, 1, false);
          start = dart.notNull(i) + 1;
        }
      }
      if (dart.notNull(start) < dart.notNull(end)) {
        this[_addSliceToSink](source, start, end, isLast);
      }
      if (isLast) {
        this.close();
      }
    }
  }
  let _addSlice = Symbol('_addSlice');
  class LineSplitter extends Converter$(core.String, core.List$(core.String)) {
    LineSplitter() {
      super.Converter();
    }
    convert(data) {
      let lines = new (core.List$(core.String))();
      _LineSplitterSink[_addSlice](data, 0, data.length, true, lines[core.$add]);
      return lines;
    }
    startChunkedConversion(sink) {
      if (!dart.is(sink, StringConversionSink)) {
        sink = new StringConversionSink.from(sink);
      }
      return new _LineSplitterSink(dart.as(sink, StringConversionSink));
    }
  }
  let _carry = Symbol('_carry');
  let _LF = Symbol('_LF');
  let _CR = Symbol('_CR');
  class _LineSplitterSink extends StringConversionSinkBase {
    _LineSplitterSink(sink$) {
      this[_sink] = sink$;
      this[_carry] = null;
      super.StringConversionSinkBase();
    }
    addSlice(chunk, start, end, isLast) {
      if (this[_carry] != null) {
        chunk = core.String['+'](this[_carry], chunk.substring(start, end));
        start = 0;
        end = chunk.length;
        this[_carry] = null;
      }
      this[_carry] = _LineSplitterSink[_addSlice](chunk, start, end, isLast, this[_sink].add);
      if (isLast)
        this[_sink].close();
    }
    close() {
      this.addSlice('', 0, 0, true);
    }
    static [_addSlice](chunk, start, end, isLast, adder) {
      let pos = start;
      while (dart.notNull(pos) < dart.notNull(end)) {
        let skip = 0;
        let char = chunk.codeUnitAt(pos);
        if (char == _LineSplitterSink[_LF]) {
          skip = 1;
        } else if (char == _LineSplitterSink[_CR]) {
          skip = 1;
          if (dart.notNull(pos) + 1 < dart.notNull(end)) {
            if (chunk.codeUnitAt(dart.notNull(pos) + 1) == _LineSplitterSink[_LF]) {
              skip = 2;
            }
          } else if (!dart.notNull(isLast)) {
            return chunk.substring(start, end);
          }
        }
        if (dart.notNull(skip) > 0) {
          adder(chunk.substring(start, pos));
          start = pos = dart.notNull(pos) + dart.notNull(skip);
        } else {
          pos = dart.notNull(pos) + 1;
        }
      }
      if (pos != start) {
        let carry = chunk.substring(start, pos);
        if (isLast) {
          adder(carry);
        } else {
          return carry;
        }
      }
      return null;
    }
  }
  _LineSplitterSink._LF = 10;
  _LineSplitterSink._CR = 13;
  class StringConversionSink extends ChunkedConversionSink$(core.String) {
    StringConversionSink() {
      super.ChunkedConversionSink();
    }
    withCallback(callback) {
      return new _StringCallbackSink(callback);
    }
    from(sink) {
      return new _StringAdapterSink(sink);
    }
    fromStringSink(sink) {
      return new _StringSinkConversionSink(sink);
    }
  }
  dart.defineNamedConstructor(StringConversionSink, 'withCallback');
  dart.defineNamedConstructor(StringConversionSink, 'from');
  dart.defineNamedConstructor(StringConversionSink, 'fromStringSink');
  class ClosableStringSink extends core.StringSink {
    fromStringSink(sink, onClose) {
      return new _ClosableStringSink(sink, onClose);
    }
  }
  dart.defineNamedConstructor(ClosableStringSink, 'fromStringSink');
  class _StringSinkCloseCallback extends core.Function {}
  class _ClosableStringSink extends core.Object {
    _ClosableStringSink(sink$, callback$) {
      this[_sink] = sink$;
      this[_callback] = callback$;
    }
    close() {
      return this[_callback]();
    }
    writeCharCode(charCode) {
      return this[_sink].writeCharCode(charCode);
    }
    write(o) {
      return this[_sink].write(o);
    }
    writeln(o) {
      if (o === void 0)
        o = "";
      return this[_sink].writeln(o);
    }
    writeAll(objects, separator) {
      if (separator === void 0)
        separator = "";
      return this[_sink].writeAll(objects, separator);
    }
  }
  _ClosableStringSink[dart.implements] = () => [ClosableStringSink];
  let _flush = Symbol('_flush');
  let _MIN_STRING_SIZE = Symbol('_MIN_STRING_SIZE');
  class _StringConversionSinkAsStringSinkAdapter extends core.Object {
    _StringConversionSinkAsStringSinkAdapter(chunkedSink) {
      this[_chunkedSink] = chunkedSink;
      this[_buffer] = new core.StringBuffer();
    }
    close() {
      if (this[_buffer].isNotEmpty)
        this[_flush]();
      this[_chunkedSink].close();
    }
    writeCharCode(charCode) {
      this[_buffer].writeCharCode(charCode);
      if (dart.notNull(this[_buffer].length) > dart.notNull(_StringConversionSinkAsStringSinkAdapter[_MIN_STRING_SIZE]))
        this[_flush]();
    }
    write(o) {
      if (this[_buffer].isNotEmpty)
        this[_flush]();
      let str = o.toString();
      this[_chunkedSink].add(o.toString());
    }
    writeln(o) {
      if (o === void 0)
        o = "";
      this[_buffer].writeln(o);
      if (dart.notNull(this[_buffer].length) > dart.notNull(_StringConversionSinkAsStringSinkAdapter[_MIN_STRING_SIZE]))
        this[_flush]();
    }
    writeAll(objects, separator) {
      if (separator === void 0)
        separator = "";
      if (this[_buffer].isNotEmpty)
        this[_flush]();
      let iterator = objects[core.$iterator];
      if (!dart.notNull(iterator.moveNext()))
        return;
      if (separator.isEmpty) {
        do {
          this[_chunkedSink].add(dart.as(dart.dinvoke(iterator.current, 'toString'), core.String));
        } while (iterator.moveNext());
      } else {
        this[_chunkedSink].add(dart.as(dart.dinvoke(iterator.current, 'toString'), core.String));
        while (iterator.moveNext()) {
          this.write(separator);
          this[_chunkedSink].add(dart.as(dart.dinvoke(iterator.current, 'toString'), core.String));
        }
      }
    }
    [_flush]() {
      let accumulated = this[_buffer].toString();
      this[_buffer].clear();
      this[_chunkedSink].add(accumulated);
    }
  }
  _StringConversionSinkAsStringSinkAdapter[dart.implements] = () => [ClosableStringSink];
  _StringConversionSinkAsStringSinkAdapter._MIN_STRING_SIZE = 16;
  let _stringSink = Symbol('_stringSink');
  class _StringSinkConversionSink extends StringConversionSinkBase {
    _StringSinkConversionSink(stringSink$) {
      this[_stringSink] = stringSink$;
      super.StringConversionSinkBase();
    }
    close() {}
    addSlice(str, start, end, isLast) {
      if (start != 0 || end != str.length) {
        for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
          this[_stringSink].writeCharCode(str.codeUnitAt(i));
        }
      } else {
        this[_stringSink].write(str);
      }
      if (isLast)
        this.close();
    }
    add(str) {
      return this[_stringSink].write(str);
    }
    asUtf8Sink(allowMalformed) {
      return new _Utf8StringSinkAdapter(this, this[_stringSink], allowMalformed);
    }
    asStringSink() {
      return new ClosableStringSink.fromStringSink(this[_stringSink], this.close);
    }
  }
  class _StringCallbackSink extends _StringSinkConversionSink {
    _StringCallbackSink(callback$) {
      this[_callback] = callback$;
      super._StringSinkConversionSink(new core.StringBuffer());
    }
    close() {
      let buffer = dart.as(this[_stringSink], core.StringBuffer);
      let accumulated = buffer.toString();
      buffer.clear();
      this[_callback](accumulated);
    }
    asUtf8Sink(allowMalformed) {
      return new _Utf8StringSinkAdapter(this, this[_stringSink], allowMalformed);
    }
  }
  class _StringAdapterSink extends StringConversionSinkBase {
    _StringAdapterSink(sink$) {
      this[_sink] = sink$;
      super.StringConversionSinkBase();
    }
    add(str) {
      return this[_sink].add(str);
    }
    addSlice(str, start, end, isLast) {
      if (start == 0 && end == str.length) {
        this.add(str);
      } else {
        this.add(str.substring(start, end));
      }
      if (isLast)
        this.close();
    }
    close() {
      return this[_sink].close();
    }
  }
  let _decoder = Symbol('_decoder');
  class _Utf8StringSinkAdapter extends ByteConversionSink {
    _Utf8StringSinkAdapter(sink$, stringSink, allowMalformed) {
      this[_sink] = sink$;
      this[_decoder] = new _Utf8Decoder(stringSink, allowMalformed);
      super.ByteConversionSink();
    }
    close() {
      this[_decoder].close();
      if (this[_sink] != null)
        this[_sink].close();
    }
    add(chunk) {
      this.addSlice(chunk, 0, chunk[core.$length], false);
    }
    addSlice(codeUnits, startIndex, endIndex, isLast) {
      this[_decoder].convert(codeUnits, startIndex, endIndex);
      if (isLast)
        this.close();
    }
  }
  class _Utf8ConversionSink extends ByteConversionSink {
    _Utf8ConversionSink(sink, allowMalformed) {
      this[_$](sink, new core.StringBuffer(), allowMalformed);
    }
    [_$](chunkedSink, stringBuffer, allowMalformed) {
      this[_chunkedSink] = chunkedSink;
      this[_decoder] = new _Utf8Decoder(stringBuffer, allowMalformed);
      this[_buffer] = stringBuffer;
      super.ByteConversionSink();
    }
    close() {
      this[_decoder].close();
      if (this[_buffer].isNotEmpty) {
        let accumulated = this[_buffer].toString();
        this[_buffer].clear();
        this[_chunkedSink].addSlice(accumulated, 0, accumulated.length, true);
      } else {
        this[_chunkedSink].close();
      }
    }
    add(chunk) {
      this.addSlice(chunk, 0, chunk[core.$length], false);
    }
    addSlice(chunk, startIndex, endIndex, isLast) {
      this[_decoder].convert(chunk, startIndex, endIndex);
      if (this[_buffer].isNotEmpty) {
        let accumulated = this[_buffer].toString();
        this[_chunkedSink].addSlice(accumulated, 0, accumulated.length, isLast);
        this[_buffer].clear();
        return;
      }
      if (isLast)
        this.close();
    }
  }
  dart.defineNamedConstructor(_Utf8ConversionSink, _$);
  let UNICODE_REPLACEMENT_CHARACTER_RUNE = 65533;
  let UNICODE_BOM_CHARACTER_RUNE = 65279;
  let UTF8 = new Utf8Codec();
  let _allowMalformed = Symbol('_allowMalformed');
  class Utf8Codec extends Encoding {
    Utf8Codec(opts) {
      let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : false;
      this[_allowMalformed] = allowMalformed;
      super.Encoding();
    }
    get name() {
      return "utf-8";
    }
    decode(codeUnits, opts) {
      let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : null;
      if (allowMalformed == null)
        allowMalformed = this[_allowMalformed];
      return new Utf8Decoder({allowMalformed: allowMalformed}).convert(codeUnits);
    }
    get encoder() {
      return new Utf8Encoder();
    }
    get decoder() {
      return new Utf8Decoder({allowMalformed: this[_allowMalformed]});
    }
  }
  let _fillBuffer = Symbol('_fillBuffer');
  let _writeSurrogate = Symbol('_writeSurrogate');
  class Utf8Encoder extends Converter$(core.String, core.List$(core.int)) {
    Utf8Encoder() {
      super.Converter();
    }
    convert(string, start, end) {
      if (start === void 0)
        start = 0;
      if (end === void 0)
        end = null;
      let stringLength = string.length;
      core.RangeError.checkValidRange(start, end, stringLength);
      if (end == null)
        end = stringLength;
      let length = dart.notNull(end) - dart.notNull(start);
      if (length == 0)
        return new typed_data.Uint8List(0);
      let encoder = new _Utf8Encoder.withBufferSize(dart.notNull(length) * 3);
      let endPosition = encoder[_fillBuffer](string, start, end);
      dart.assert(dart.notNull(endPosition) >= dart.notNull(end) - 1);
      if (endPosition != end) {
        let lastCodeUnit = string.codeUnitAt(dart.notNull(end) - 1);
        dart.assert(_isLeadSurrogate(lastCodeUnit));
        let wasCombined = encoder[_writeSurrogate](lastCodeUnit, 0);
        dart.assert(!dart.notNull(wasCombined));
      }
      return encoder[_buffer][core.$sublist](0, encoder[_bufferIndex]);
    }
    startChunkedConversion(sink) {
      if (!dart.is(sink, ByteConversionSink)) {
        sink = new ByteConversionSink.from(sink);
      }
      return new _Utf8EncoderSink(dart.as(sink, ByteConversionSink));
    }
    bind(stream) {
      return dart.as(super.bind(stream), async.Stream$(core.List$(core.int)));
    }
  }
  let _DEFAULT_BYTE_BUFFER_SIZE = Symbol('_DEFAULT_BYTE_BUFFER_SIZE');
  let _createBuffer = Symbol('_createBuffer');
  class _Utf8Encoder extends core.Object {
    _Utf8Encoder() {
      this.withBufferSize(_Utf8Encoder[_DEFAULT_BYTE_BUFFER_SIZE]);
    }
    withBufferSize(bufferSize) {
      this[_buffer] = _Utf8Encoder[_createBuffer](bufferSize);
      this[_carry] = 0;
      this[_bufferIndex] = 0;
    }
    static [_createBuffer](size) {
      return new typed_data.Uint8List(size);
    }
    [_writeSurrogate](leadingSurrogate, nextCodeUnit) {
      if (_isTailSurrogate(nextCodeUnit)) {
        let rune = _combineSurrogatePair(leadingSurrogate, nextCodeUnit);
        dart.assert(dart.notNull(rune) > dart.notNull(_THREE_BYTE_LIMIT));
        dart.assert(dart.notNull(rune) <= dart.notNull(_FOUR_BYTE_LIMIT));
        this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 240 | dart.notNull(rune) >> 18);
        this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 128 | dart.notNull(rune) >> 12 & 63);
        this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 128 | dart.notNull(rune) >> 6 & 63);
        this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 128 | dart.notNull(rune) & 63);
        return true;
      } else {
        this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 224 | dart.notNull(leadingSurrogate) >> 12);
        this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 128 | dart.notNull(leadingSurrogate) >> 6 & 63);
        this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 128 | dart.notNull(leadingSurrogate) & 63);
        return false;
      }
    }
    [_fillBuffer](str, start, end) {
      if (start != end && dart.notNull(_isLeadSurrogate(str.codeUnitAt(dart.notNull(end) - 1)))) {
        end = dart.notNull(end) - 1;
      }
      let stringIndex = null;
      for (stringIndex = start; dart.notNull(stringIndex) < dart.notNull(end); stringIndex = dart.notNull(stringIndex) + 1) {
        let codeUnit = str.codeUnitAt(stringIndex);
        if (dart.notNull(codeUnit) <= dart.notNull(_ONE_BYTE_LIMIT)) {
          if (dart.notNull(this[_bufferIndex]) >= dart.notNull(this[_buffer][core.$length]))
            break;
          this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), codeUnit);
        } else if (_isLeadSurrogate(codeUnit)) {
          if (dart.notNull(this[_bufferIndex]) + 3 >= dart.notNull(this[_buffer][core.$length]))
            break;
          let nextCodeUnit = str.codeUnitAt(dart.notNull(stringIndex) + 1);
          let wasCombined = this[_writeSurrogate](codeUnit, nextCodeUnit);
          if (wasCombined)
            stringIndex = dart.notNull(stringIndex) + 1;
        } else {
          let rune = codeUnit;
          if (dart.notNull(rune) <= dart.notNull(_TWO_BYTE_LIMIT)) {
            if (dart.notNull(this[_bufferIndex]) + 1 >= dart.notNull(this[_buffer][core.$length]))
              break;
            this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 192 | dart.notNull(rune) >> 6);
            this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 128 | dart.notNull(rune) & 63);
          } else {
            dart.assert(dart.notNull(rune) <= dart.notNull(_THREE_BYTE_LIMIT));
            if (dart.notNull(this[_bufferIndex]) + 2 >= dart.notNull(this[_buffer][core.$length]))
              break;
            this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 224 | dart.notNull(rune) >> 12);
            this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 128 | dart.notNull(rune) >> 6 & 63);
            this[_buffer][core.$set](((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 128 | dart.notNull(rune) & 63);
          }
        }
      }
      return stringIndex;
    }
  }
  dart.defineNamedConstructor(_Utf8Encoder, 'withBufferSize');
  _Utf8Encoder._DEFAULT_BYTE_BUFFER_SIZE = 1024;
  class _Utf8EncoderSink extends dart.mixin(_Utf8Encoder, StringConversionSinkMixin) {
    _Utf8EncoderSink(sink$) {
      this[_sink] = sink$;
      super._Utf8Encoder();
    }
    close() {
      if (this[_carry] != 0) {
        this.addSlice("", 0, 0, true);
        return;
      }
      this[_sink].close();
    }
    addSlice(str, start, end, isLast) {
      this[_bufferIndex] = 0;
      if (start == end && !dart.notNull(isLast)) {
        return;
      }
      if (this[_carry] != 0) {
        let nextCodeUnit = 0;
        if (start != end) {
          nextCodeUnit = str.codeUnitAt(start);
        } else {
          dart.assert(isLast);
        }
        let wasCombined = this[_writeSurrogate](this[_carry], nextCodeUnit);
        dart.assert(!dart.notNull(wasCombined) || start != end);
        if (wasCombined)
          start = dart.notNull(start) + 1;
        this[_carry] = 0;
      }
      do {
        start = this[_fillBuffer](str, start, end);
        let isLastSlice = dart.notNull(isLast) && start == end;
        if (start == dart.notNull(end) - 1 && dart.notNull(_isLeadSurrogate(str.codeUnitAt(start)))) {
          if (dart.notNull(isLast) && dart.notNull(this[_bufferIndex]) < dart.notNull(this[_buffer][core.$length]) - 3) {
            let hasBeenCombined = this[_writeSurrogate](str.codeUnitAt(start), 0);
            dart.assert(!dart.notNull(hasBeenCombined));
          } else {
            this[_carry] = str.codeUnitAt(start);
          }
          start = dart.notNull(start) + 1;
        }
        this[_sink].addSlice(this[_buffer], 0, this[_bufferIndex], isLastSlice);
        this[_bufferIndex] = 0;
      } while (dart.notNull(start) < dart.notNull(end));
      if (isLast)
        this.close();
    }
  }
  class Utf8Decoder extends Converter$(core.List$(core.int), core.String) {
    Utf8Decoder(opts) {
      let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : false;
      this[_allowMalformed] = allowMalformed;
      super.Converter();
    }
    convert(codeUnits, start, end) {
      if (start === void 0)
        start = 0;
      if (end === void 0)
        end = null;
      let length = codeUnits[core.$length];
      core.RangeError.checkValidRange(start, end, length);
      if (end == null)
        end = length;
      let buffer = new core.StringBuffer();
      let decoder = new _Utf8Decoder(buffer, this[_allowMalformed]);
      decoder.convert(codeUnits, start, end);
      decoder.close();
      return buffer.toString();
    }
    startChunkedConversion(sink) {
      let stringSink = null;
      if (dart.is(sink, StringConversionSink)) {
        stringSink = sink;
      } else {
        stringSink = new StringConversionSink.from(sink);
      }
      return stringSink.asUtf8Sink(this[_allowMalformed]);
    }
    bind(stream) {
      return dart.as(super.bind(stream), async.Stream$(core.String));
    }
    fuse(next) {
      return super.fuse(next);
    }
  }
  let _ONE_BYTE_LIMIT = 127;
  let _TWO_BYTE_LIMIT = 2047;
  let _THREE_BYTE_LIMIT = 65535;
  let _FOUR_BYTE_LIMIT = 1114111;
  let _SURROGATE_MASK = 63488;
  let _SURROGATE_TAG_MASK = 64512;
  let _SURROGATE_VALUE_MASK = 1023;
  let _LEAD_SURROGATE_MIN = 55296;
  let _TAIL_SURROGATE_MIN = 56320;
  // Function _isSurrogate: (int) → bool
  function _isSurrogate(codeUnit) {
    return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_MASK)) == _LEAD_SURROGATE_MIN;
  }
  // Function _isLeadSurrogate: (int) → bool
  function _isLeadSurrogate(codeUnit) {
    return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_TAG_MASK)) == _LEAD_SURROGATE_MIN;
  }
  // Function _isTailSurrogate: (int) → bool
  function _isTailSurrogate(codeUnit) {
    return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_TAG_MASK)) == _TAIL_SURROGATE_MIN;
  }
  // Function _combineSurrogatePair: (int, int) → int
  function _combineSurrogatePair(lead, tail) {
    return 65536 + ((dart.notNull(lead) & dart.notNull(_SURROGATE_VALUE_MASK)) << 10) | dart.notNull(tail) & dart.notNull(_SURROGATE_VALUE_MASK);
  }
  let _isFirstCharacter = Symbol('_isFirstCharacter');
  let _value = Symbol('_value');
  let _expectedUnits = Symbol('_expectedUnits');
  let _extraUnits = Symbol('_extraUnits');
  let _LIMITS = Symbol('_LIMITS');
  class _Utf8Decoder extends core.Object {
    _Utf8Decoder(stringSink$, allowMalformed$) {
      this[_stringSink] = stringSink$;
      this[_allowMalformed] = allowMalformed$;
      this[_isFirstCharacter] = true;
      this[_value] = 0;
      this[_expectedUnits] = 0;
      this[_extraUnits] = 0;
    }
    get hasPartialInput() {
      return dart.notNull(this[_expectedUnits]) > 0;
    }
    close() {
      this.flush();
    }
    flush() {
      if (this.hasPartialInput) {
        if (!dart.notNull(this[_allowMalformed])) {
          throw new core.FormatException("Unfinished UTF-8 octet sequence");
        }
        this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
        this[_value] = 0;
        this[_expectedUnits] = 0;
        this[_extraUnits] = 0;
      }
    }
    convert(codeUnits, startIndex, endIndex) {
      let value = this[_value];
      let expectedUnits = this[_expectedUnits];
      let extraUnits = this[_extraUnits];
      this[_value] = 0;
      this[_expectedUnits] = 0;
      this[_extraUnits] = 0;
      // Function scanOneByteCharacters: (dynamic, int) → int
      function scanOneByteCharacters(units, from) {
        let to = endIndex;
        let mask = _ONE_BYTE_LIMIT;
        for (let i = from; dart.notNull(i) < dart.notNull(to); i = dart.notNull(i) + 1) {
          let unit = dart.dindex(units, i);
          if (!dart.equals(dart.dbinary(unit, '&', mask), unit))
            return dart.notNull(i) - dart.notNull(from);
        }
        return dart.notNull(to) - dart.notNull(from);
      }
      // Function addSingleBytes: (int, int) → void
      function addSingleBytes(from, to) {
        dart.assert(dart.notNull(from) >= dart.notNull(startIndex) && dart.notNull(from) <= dart.notNull(endIndex));
        dart.assert(dart.notNull(to) >= dart.notNull(startIndex) && dart.notNull(to) <= dart.notNull(endIndex));
        this[_stringSink].write(new core.String.fromCharCodes(codeUnits, from, to));
      }
      let i = startIndex;
      loop:
        while (true) {
          multibyte:
            if (dart.notNull(expectedUnits) > 0) {
              do {
                if (i == endIndex) {
                  break loop;
                }
                let unit = codeUnits[core.$get](i);
                if ((dart.notNull(unit) & 192) != 128) {
                  expectedUnits = 0;
                  if (!dart.notNull(this[_allowMalformed])) {
                    throw new core.FormatException(`Bad UTF-8 encoding 0x${unit.toRadixString(16)}`);
                  }
                  this[_isFirstCharacter] = false;
                  this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
                  break multibyte;
                } else {
                  value = dart.notNull(value) << 6 | dart.notNull(unit) & 63;
                  expectedUnits = dart.notNull(expectedUnits) - 1;
                  i = dart.notNull(i) + 1;
                }
              } while (dart.notNull(expectedUnits) > 0);
              if (dart.notNull(value) <= dart.notNull(_Utf8Decoder[_LIMITS][core.$get](dart.notNull(extraUnits) - 1))) {
                if (!dart.notNull(this[_allowMalformed])) {
                  throw new core.FormatException(`Overlong encoding of 0x${value.toRadixString(16)}`);
                }
                expectedUnits = extraUnits = 0;
                value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
              }
              if (dart.notNull(value) > dart.notNull(_FOUR_BYTE_LIMIT)) {
                if (!dart.notNull(this[_allowMalformed])) {
                  throw new core.FormatException("Character outside valid Unicode range: " + `0x${value.toRadixString(16)}`);
                }
                value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
              }
              if (!dart.notNull(this[_isFirstCharacter]) || value != UNICODE_BOM_CHARACTER_RUNE) {
                this[_stringSink].writeCharCode(value);
              }
              this[_isFirstCharacter] = false;
            }
          while (dart.notNull(i) < dart.notNull(endIndex)) {
            let oneBytes = scanOneByteCharacters(codeUnits, i);
            if (dart.notNull(oneBytes) > 0) {
              this[_isFirstCharacter] = false;
              addSingleBytes(i, dart.notNull(i) + dart.notNull(oneBytes));
              i = oneBytes;
              if (i == endIndex)
                break;
            }
            let unit = codeUnits[core.$get](((x$) => i = dart.notNull(x$) + 1, x$)(i));
            if (dart.notNull(unit) < 0) {
              if (!dart.notNull(this[_allowMalformed])) {
                throw new core.FormatException(`Negative UTF-8 code unit: -0x${(-dart.notNull(unit)).toRadixString(16)}`);
              }
              this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
            } else {
              dart.assert(dart.notNull(unit) > dart.notNull(_ONE_BYTE_LIMIT));
              if ((dart.notNull(unit) & 224) == 192) {
                value = dart.notNull(unit) & 31;
                expectedUnits = extraUnits = 1;
                continue loop;
              }
              if ((dart.notNull(unit) & 240) == 224) {
                value = dart.notNull(unit) & 15;
                expectedUnits = extraUnits = 2;
                continue loop;
              }
              if ((dart.notNull(unit) & 248) == 240 && dart.notNull(unit) < 245) {
                value = dart.notNull(unit) & 7;
                expectedUnits = extraUnits = 3;
                continue loop;
              }
              if (!dart.notNull(this[_allowMalformed])) {
                throw new core.FormatException(`Bad UTF-8 encoding 0x${unit.toRadixString(16)}`);
              }
              value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
              expectedUnits = extraUnits = 0;
              this[_isFirstCharacter] = false;
              this[_stringSink].writeCharCode(value);
            }
          }
          break loop;
        }
      if (dart.notNull(expectedUnits) > 0) {
        this[_value] = value;
        this[_expectedUnits] = expectedUnits;
        this[_extraUnits] = extraUnits;
      }
    }
  }
  _Utf8Decoder._LIMITS = /* Unimplemented const */new core.List$(core.int).from([_ONE_BYTE_LIMIT, _TWO_BYTE_LIMIT, _THREE_BYTE_LIMIT, _FOUR_BYTE_LIMIT]);
  let _processed = Symbol('_processed');
  let _computeKeys = Symbol('_computeKeys');
  let _original = Symbol('_original');
  // Function _convertJsonToDart: (dynamic, (dynamic, dynamic) → dynamic) → dynamic
  function _convertJsonToDart(json, reviver) {
    dart.assert(reviver != null);
    // Function walk: (dynamic) → dynamic
    function walk(e) {
      if (e == null || typeof e != "object") {
        return e;
      }
      if (Object.getPrototypeOf(e) === Array.prototype) {
        for (let i = 0; dart.notNull(i) < e.length; i = dart.notNull(i) + 1) {
          let item = e[i];
          e[i] = dart.dinvokef(reviver, i, walk(item));
        }
        return e;
      }
      let map = new _JsonMap(e);
      let processed = map[_processed];
      let keys = map[_computeKeys]();
      for (let i = 0; dart.notNull(i) < dart.notNull(keys[core.$length]); i = dart.notNull(i) + 1) {
        let key = keys[core.$get](i);
        let revived = dart.dinvokef(reviver, key, walk(e[key]));
        processed[key] = revived;
      }
      map[_original] = processed;
      return map;
    }
    return dart.dinvokef(reviver, null, walk(json));
  }
  // Function _convertJsonToDartLazy: (dynamic) → dynamic
  function _convertJsonToDartLazy(object) {
    if (object == null)
      return null;
    if (typeof object != "object") {
      return object;
    }
    if (Object.getPrototypeOf(object) !== Array.prototype) {
      return new _JsonMap(object);
    }
    for (let i = 0; dart.notNull(i) < object.length; i = dart.notNull(i) + 1) {
      let item = object[i];
      object[i] = _convertJsonToDartLazy(item);
    }
    return object;
  }
  let _newJavaScriptObject = Symbol('_newJavaScriptObject');
  let _data = Symbol('_data');
  let _isUpgraded = Symbol('_isUpgraded');
  let _upgradedMap = Symbol('_upgradedMap');
  let _getProperty = Symbol('_getProperty');
  let _isUnprocessed = Symbol('_isUnprocessed');
  let _process = Symbol('_process');
  let _setProperty = Symbol('_setProperty');
  let _upgrade = Symbol('_upgrade');
  let _hasProperty = Symbol('_hasProperty');
  let _getPropertyNames = Symbol('_getPropertyNames');
  class _JsonMap extends core.Object {
    _JsonMap(original$) {
      this[_processed] = _JsonMap[_newJavaScriptObject]();
      this[_original] = original$;
      this[_data] = null;
    }
    get(key) {
      if (this[_isUpgraded]) {
        return this[_upgradedMap].get(key);
      } else if (!(typeof key == 'string')) {
        return null;
      } else {
        let result = _JsonMap[_getProperty](this[_processed], dart.as(key, core.String));
        if (_JsonMap[_isUnprocessed](result))
          result = this[_process](dart.as(key, core.String));
        return result;
      }
    }
    get length() {
      return this[_isUpgraded] ? this[_upgradedMap].length : this[_computeKeys]()[core.$length];
    }
    get isEmpty() {
      return this.length == 0;
    }
    get isNotEmpty() {
      return dart.notNull(this.length) > 0;
    }
    get keys() {
      if (this[_isUpgraded])
        return this[_upgradedMap].keys;
      return new _JsonMapKeyIterable(this);
    }
    get values() {
      if (this[_isUpgraded])
        return this[_upgradedMap].values;
      return new _internal.MappedIterable(this[_computeKeys](), ((each) => this.get(each)).bind(this));
    }
    set(key, value) {
      if (this[_isUpgraded]) {
        this[_upgradedMap].set(key, value);
      } else if (this.containsKey(key)) {
        let processed = this[_processed];
        _JsonMap[_setProperty](processed, dart.as(key, core.String), value);
        let original = this[_original];
        if (!dart.notNull(core.identical(original, processed))) {
          _JsonMap[_setProperty](original, dart.as(key, core.String), null);
        }
      } else {
        this[_upgrade]().set(key, value);
      }
    }
    addAll(other) {
      other.forEach(((key, value) => {
        this.set(key, value);
      }).bind(this));
    }
    containsValue(value) {
      if (this[_isUpgraded])
        return this[_upgradedMap].containsValue(value);
      let keys = this[_computeKeys]();
      for (let i = 0; dart.notNull(i) < dart.notNull(keys[core.$length]); i = dart.notNull(i) + 1) {
        let key = keys[core.$get](i);
        if (dart.equals(this.get(key), value))
          return true;
      }
      return false;
    }
    containsKey(key) {
      if (this[_isUpgraded])
        return this[_upgradedMap].containsKey(key);
      if (!(typeof key == 'string'))
        return false;
      return _JsonMap[_hasProperty](this[_original], dart.as(key, core.String));
    }
    putIfAbsent(key, ifAbsent) {
      if (this.containsKey(key))
        return this.get(key);
      let value = ifAbsent();
      this.set(key, value);
      return value;
    }
    remove(key) {
      if (!dart.notNull(this[_isUpgraded]) && !dart.notNull(this.containsKey(key)))
        return null;
      return this[_upgrade]().remove(key);
    }
    clear() {
      if (this[_isUpgraded]) {
        this[_upgradedMap].clear();
      } else {
        if (this[_data] != null) {
          dart.dinvoke(this[_data], 'clear');
        }
        this[_original] = this[_processed] = null;
        this[_data] = dart.map();
      }
    }
    forEach(f) {
      if (this[_isUpgraded])
        return this[_upgradedMap].forEach(f);
      let keys = this[_computeKeys]();
      for (let i = 0; dart.notNull(i) < dart.notNull(keys[core.$length]); i = dart.notNull(i) + 1) {
        let key = keys[core.$get](i);
        let value = _JsonMap[_getProperty](this[_processed], key);
        if (_JsonMap[_isUnprocessed](value)) {
          value = _convertJsonToDartLazy(_JsonMap[_getProperty](this[_original], key));
          _JsonMap[_setProperty](this[_processed], key, value);
        }
        dart.dinvokef(f, key, value);
        if (!dart.notNull(core.identical(keys, this[_data]))) {
          throw new core.ConcurrentModificationError(this);
        }
      }
    }
    toString() {
      return collection.Maps.mapToString(this);
    }
    get [_isUpgraded]() {
      return this[_processed] == null;
    }
    get [_upgradedMap]() {
      dart.assert(this[_isUpgraded]);
      return dart.as(this[_data], core.Map);
    }
    [_computeKeys]() {
      dart.assert(!dart.notNull(this[_isUpgraded]));
      let keys = dart.as(this[_data], core.List);
      if (keys == null) {
        keys = this[_data] = _JsonMap[_getPropertyNames](this[_original]);
      }
      return dart.as(keys, core.List$(core.String));
    }
    [_upgrade]() {
      if (this[_isUpgraded])
        return this[_upgradedMap];
      let result = dart.map();
      let keys = this[_computeKeys]();
      for (let i = 0; dart.notNull(i) < dart.notNull(keys[core.$length]); i = dart.notNull(i) + 1) {
        let key = keys[core.$get](i);
        result.set(key, this.get(key));
      }
      if (keys[core.$isEmpty]) {
        keys[core.$add](null);
      } else {
        keys[core.$clear]();
      }
      this[_original] = this[_processed] = null;
      this[_data] = result;
      dart.assert(this[_isUpgraded]);
      return result;
    }
    [_process](key) {
      if (!dart.notNull(_JsonMap[_hasProperty](this[_original], key)))
        return null;
      let result = _convertJsonToDartLazy(_JsonMap[_getProperty](this[_original], key));
      return _JsonMap[_setProperty](this[_processed], key, result);
    }
    static [_hasProperty](object, key) {
      return Object.prototype.hasOwnProperty.call(object, key);
    }
    static [_getProperty](object, key) {
      return object[key];
    }
    static [_setProperty](object, key, value) {
      return object[key] = value;
    }
    static [_getPropertyNames](object) {
      return dart.as(Object.keys(object), core.List);
    }
    static [_isUnprocessed](object) {
      return typeof object == "undefined";
    }
    static [_newJavaScriptObject]() {
      return Object.create(null);
    }
  }
  _JsonMap[dart.implements] = () => [collection.LinkedHashMap];
  let _parent = Symbol('_parent');
  class _JsonMapKeyIterable extends _internal.ListIterable {
    _JsonMapKeyIterable(parent) {
      this[_parent] = parent;
      super.ListIterable();
    }
    get [core.$length]() {
      return this[_parent].length;
    }
    [core.$elementAt](index) {
      return dart.as(this[_parent][_isUpgraded] ? this[_parent].keys[core.$elementAt](index) : this[_parent][_computeKeys]()[core.$get](index), core.String);
    }
    get [core.$iterator]() {
      return dart.as(this[_parent][_isUpgraded] ? this[_parent].keys[core.$iterator] : this[_parent][_computeKeys]()[core.$iterator], core.Iterator);
    }
    [core.$contains](key) {
      return this[_parent].containsKey(key);
    }
  }
  class _JsonDecoderSink extends _StringSinkConversionSink {
    _JsonDecoderSink(reviver$, sink$) {
      this[_reviver] = reviver$;
      this[_sink] = sink$;
      super._StringSinkConversionSink(new core.StringBuffer());
    }
    close() {
      super.close();
      let buffer = dart.as(this[_stringSink], core.StringBuffer);
      let accumulated = buffer.toString();
      buffer.clear();
      let decoded = _parseJson(accumulated, this[_reviver]);
      this[_sink].add(decoded);
      this[_sink].close();
    }
  }
  // Exports:
  exports.ASCII = ASCII;
  exports.AsciiCodec = AsciiCodec;
  exports.Encoding = Encoding;
  exports.Codec$ = Codec$;
  exports.Codec = Codec;
  exports.Converter$ = Converter$;
  exports.Converter = Converter;
  exports.AsciiEncoder = AsciiEncoder;
  exports.StringConversionSinkBase = StringConversionSinkBase;
  exports.StringConversionSinkMixin = StringConversionSinkMixin;
  exports.AsciiDecoder = AsciiDecoder;
  exports.ByteConversionSinkBase = ByteConversionSinkBase;
  exports.ByteConversionSink = ByteConversionSink;
  exports.ChunkedConversionSink$ = ChunkedConversionSink$;
  exports.ChunkedConversionSink = ChunkedConversionSink;
  exports.HTML_ESCAPE = HTML_ESCAPE;
  exports.HtmlEscapeMode = HtmlEscapeMode;
  exports.HtmlEscape = HtmlEscape;
  exports.JsonUnsupportedObjectError = JsonUnsupportedObjectError;
  exports.JsonCyclicError = JsonCyclicError;
  exports.JSON = JSON;
  exports.JsonCodec = JsonCodec;
  exports.JsonEncoder = JsonEncoder;
  exports.JsonUtf8Encoder = JsonUtf8Encoder;
  exports.JsonDecoder = JsonDecoder;
  exports.LATIN1 = LATIN1;
  exports.Latin1Codec = Latin1Codec;
  exports.Latin1Encoder = Latin1Encoder;
  exports.Latin1Decoder = Latin1Decoder;
  exports.LineSplitter = LineSplitter;
  exports.StringConversionSink = StringConversionSink;
  exports.ClosableStringSink = ClosableStringSink;
  exports.UNICODE_REPLACEMENT_CHARACTER_RUNE = UNICODE_REPLACEMENT_CHARACTER_RUNE;
  exports.UNICODE_BOM_CHARACTER_RUNE = UNICODE_BOM_CHARACTER_RUNE;
  exports.UTF8 = UTF8;
  exports.Utf8Codec = Utf8Codec;
  exports.Utf8Encoder = Utf8Encoder;
  exports.Utf8Decoder = Utf8Decoder;
})(convert || (convert = {}));