anchor.diff:    StreamListener._(this._proxy);
   
     /// Indicate an x, y (and optionally z) coordinate.
  -  point(x, y, [z]) {
  -    return _proxy.callMethod('point', []);
  +  point(num x, num y, [num z = undefined]) {
  +    var args = [x, y];
  +    if (z != undefined) {
  +      args.add(z);
  +    }
  +    var retval = _proxy.callMethod('point', args);
  +    return new StreamListener._(retval);
     }
   
     /// Indicate the start of a line or ring.
  -  lineStart() {
  -    return _proxy.callMethod('lineStart', []);
  -  }
  +  lineStart() => new StreamListener._(_proxy.callMethod('lineStart'));
   
     /// Indicate the end of a line or ring.
  -  lineEnd() {
  -    return _proxy.callMethod('lineEnd', []);
  -  }
  +  lineEnd() => new StreamListener._(_proxy.callMethod('lineEnd'));
   
     /// Indicate the start of a polygon.
  -  polygonStart() {
  -    return _proxy.callMethod('polygonStart', []);
  -  }
  +  polygonStart() => new StreamListener._(_proxy.callMethod('polygonStart'));
   
     /// Indicate the end of a polygon.
  -  polygonEnd() {
  -    return _proxy.callMethod('polygonEnd', []);
  -  }
  +  polygonEnd() => new StreamListener._(_proxy.callMethod('polygonEnd'));
   
     /// Indicate a sphere.
  -  sphere() {
  -    return _proxy.callMethod('sphere', []);
  -  }
  +  sphere() => new StreamListener._(_proxy.callMethod('sphere'));
   }
   
   /// Transform streaming geometries.
  -StreamTransform transform(methods) {
  -  return _geo.callMethod('transform', []);
  +StreamTransform transform(Map methods) {
  +  var args = [new JsObject.jsify(methods)];
  +  return new StreamTransform._(_geo.callMethod('transform', args));
   }
   
   class StreamTransform {
  
positive.code:   ConicEquidistant._(this._proxy);
  
    /// Get or set the projection's two standard parallels.
    parallels([parallels]) {
      return _proxy.callMethod('parallels', []);
    }
  }
  
  /// The equirectangular (plate carreé) projection.
  equirectangular() {
    return _geo.callMethod('equirectangular', []);
  }
  
  /// The gnomonic projection.
  gnomonic() {
    return _geo.callMethod('gnomonic', []);
  }
  
  /// The spherical Mercator projection.
  mercator() {
    return _geo.callMethod('mercator', []);
  }
  
  /// The azimuthal orthographic projection.
  orthographic() {
    return _geo.callMethod('orthographic', []);
  }
  
  /// The azimuthal stereographic projection.
  stereographic() {
    return _geo.callMethod('stereographic', []);
  }
  
  /// The transverse Mercator projection.
  transverseMercator() {
    return _geo.callMethod('transverseMercator', []);
  }
  
  albersRaw(a0, a1) {
    return _geo['albers'].callMethod('raw', []);
  }
  
  /// The raw azimuthal equal-area projection.
  get azimuthalEqualAreaRaw => _geo['azimuthalEqualArea']['raw'];
  
  /// The azimuthal equidistant projection.
  get azimuthalEquidistantRaw => _geo['azimuthalEquidistant']['raw'];
  
  /// The raw conic conformal projection.
  conicConformalRaw(a0, a1) {
    return _geo['conicConformal'].callMethod('raw', []);
  }
  
  /// The raw conic equal-area (a.k.a. Albers) projection.
  conicEqualAreaRaw(a0, a1) {
    return _geo['conicEqualArea'].callMethod('raw', []);
  }
  
  /// The raw conic equidistant projection.
  conicEquidistantRaw(a0, a1) {
    return _geo['conicEquidistant'].callMethod('raw', []);
  }
  
  /// The raw equirectangular (plate carrée) projection.
  get equirectangularRaw => _geo['equirectangular']['raw'];
  
  /// The raw gnomonic projection.
  get gnomonicRaw => _geo['gnomonic']['raw'];
  
  /// The raw Mercator projection.
  get mercatorRaw => _geo['mercator']['raw'];
  
  /// The raw azimuthal orthographic projection.
  get orthographicRaw => _geo['orthographic']['raw'];
  
  /// The raw azimuthal stereographic projection.
  get stereographicRaw => _geo['stereographic']['raw'];
  
  /// Convert a GeoJSON object to a geometry stream.
  StreamListener stream(object, listener) {
    return _geo.callMethod('stream', []);
  }
  
  class StreamListener {
  
negative.code: 
    Projection._(this._proxy);
  
    /// Project the specified location.
    List call(List location) {
      return _proxy.callMethod('call', [_proxy, location]);
    }
  
    /// Invert the projection for the specified point.
    List invert(List point) {
      return _proxy.callMethod('invert', [point]);
    }
  
    /// Get or set the projection's three-axis rotation.
    rotate([List rotation = undefined]) {
      var args = [];
      if (rotation != undefined) {
        args.add(rotation);
      }
      var retval = _proxy.callMethod('rotate', args);
      if (rotation == undefined) {
        return retval;
      } else {
        return new Projection._(retval);
      }
    }
  
    /// Get or set the projection's center location.
    center([List location = undefined]) {
      var args = [];
      if (location != undefined) {
        args.add(location);
      }
      var retval = _proxy.callMethod('center', args);
      if (location == undefined) {
        return retval;
      } else {
        return new Projection._(retval);
      }
    }
  
    /// Get or set the projection's translation position.
    translate([List point = undefined]) {
      var args = [];
      if (point != undefined) {
        args.add(point);
      }
      var retval = _proxy.callMethod('translate', args);
      if (point == undefined) {
        return retval;
      } else {
        return new Projection._(retval);
      }
    }
  
    /// Get or set the projection's scale factor.
    scale([num scale = undefined]) {
      var args = [];
      if (scale != undefined) {
        args.add(scale);
      }
      var retval = _proxy.callMethod('scale', args);
      if (scale == undefined) {
        return retval;
      } else {
        return new Projection._(retval);
      }
    }
  
    /// Get or set the radius of the projection's clip circle.
    clipAngle([num angle = undefined]) {
      var args = [];
      if (angle != undefined) {
        args.add(angle);
      }
      var retval = _proxy.callMethod('clipAngle', args);
      if (angle == undefined) {
        return retval;
      } else {
        return new Projection._(retval);
      }
    }
  
    /// Get or set the projection's viewport clip extent, in pixels.
    clipExtent([List extent = undefined]) {
      var args = [];
      if (extent != undefined) {
        args.add(extent);
      }
      var retval = _proxy.callMethod('clipExtent', args);
      if (extent == undefined) {
        return retval;
      } else {
        return new Projection._(retval);
      }
    }
  
    /// Get or set the precision threshold for adaptive resampling.
    precision([num precision = undefined]) {
      var args = [];
      if (precision != undefined) {
        args.add(precision);
      }
      var retval = _proxy.callMethod('precision', args);
      if (precision == undefined) {
        return retval;
      } else {
        return new Projection._(retval);
      }
    }
  
    /// Wrap the specified stream listener, projecting input geometry.
    StreamListener stream(StreamListener listener) {
      return new StreamListener._(_proxy.callMethod('stream', [listener._proxy]));
    }
  }
  
  /// Create a standard projection from a mutable raw projection.
  Function projectionMutator(Function rawFactory) {
    return _geo.callMethod('projectionMutator', [rawFactory]);
  }
  
  /// The Albers equal-area conic projection.
  Projection albers() {
    return new Projection._(_geo.callMethod('albers'));
  }
  
  /// A composite Albers projection for the United States.
  Projection albersUsa() {
    return new Projection._(_geo.callMethod('albersUsa'));
  }
  
  /// The azimuthal equal-area projection.
  Projection azimuthalEqualArea() {
    return new Projection._(_geo.callMethod('azimuthalEqualArea'));
  }
  
  /// The azimuthal equidistant projection.
  Projection azimuthalEquidistant() {
    return new Projection._(_geo.callMethod('azimuthalEquidistant'));
  }
  
  /// The conic conformal projection.
  ConicConformal conicConformal() {
    return new ConicConformal._(_geo.callMethod('conicConformal'));
  }
  
  class ConicConformal {
  