anchor.diff:    ConicConformal._(this._proxy);
   
     /// Get or set the projection's two standard parallels.
  -  parallels([parallels]) {
  -    return _proxy.callMethod('parallels', []);
  +  parallels([List parallels = undefined]) {
  +    var args = [];
  +    if (parallels != undefined) {
  +      args.add(parallels);
  +    }
  +    var retval = _proxy.callMethod('parallels', args);
  +    if (parallels == undefined) {
  +      return retval;
  +    } else {
  +      return new ConicConformal._(retval);
  +    }
     }
   }
   
   /// The conic equal-area (a.k.a. Albers) projection.
   ConicEqualArea conicEqualArea() {
  -  return _geo.callMethod('conicEqualArea', []);
  +  return new ConicEqualArea._(_geo.callMethod('conicEqualArea'));
   }
   
   class ConicEqualArea {
  
positive.code:   StreamListener._(this._proxy);
  
    /// Indicate an x, y (and optionally z) coordinate.
    point(x, y, [z]) {
      return _proxy.callMethod('point', []);
    }
  
    /// Indicate the start of a line or ring.
    lineStart() {
      return _proxy.callMethod('lineStart', []);
    }
  
    /// Indicate the end of a line or ring.
    lineEnd() {
      return _proxy.callMethod('lineEnd', []);
    }
  
    /// Indicate the start of a polygon.
    polygonStart() {
      return _proxy.callMethod('polygonStart', []);
    }
  
    /// Indicate the end of a polygon.
    polygonEnd() {
      return _proxy.callMethod('polygonEnd', []);
    }
  
    /// Indicate a sphere.
    sphere() {
      return _proxy.callMethod('sphere', []);
    }
  }
  
  /// Transform streaming geometries.
  StreamTransform transform(methods) {
    return _geo.callMethod('transform', []);
  }
  
  class StreamTransform {
  
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 {
  