anchor.diff:  
     Rotation._(this._proxy);
   
  -  call(location) => rotation(location);
  -
     /// Rotate the given location around the sphere.
  -  rotation(location) {
  -    return _proxy.callMethod('rotation', []);
  +  List call(List location) {
  +    return _proxy.callMethod('call', [_proxy, location]);
     }
   
     /// Inverse-rotate the given location around the sphere.
  -  invert(location) {
  -    return _proxy.callMethod('invert', []);
  +  List invert(List location) {
  +    return _proxy.callMethod('invert', [location]);
     }
   }
   
   /// Create a standard projection from a raw projection.
  -Projection projection(raw) {
  -  return _geo.callMethod('projection', []);
  +Projection projection(Function raw) {
  +  return new Projection._(_geo.callMethod('projection', [raw]));
   }
   
   class Projection {
  
positive.code:   StreamTransform._(this._proxy);
  
    /// Wraps a given stream.
    stream(listener) {
      return _proxy.callMethod('stream', []);
    }
  }
  
  /// A stream transform that clips geometries to a given axis-aligned rectangle.
  ClipExtent clipExtent() {
    return _geo.callMethod('clipExtent', []);
  }
  
  class ClipExtent {
    final JsObject _proxy;
  
negative.code: library d3.src.geo;
  
  import 'dart:js';
  import 'd3.dart';
  
  JsObject _geo = context['d3']['geo'];
  
  /// Create a new geographic path generator.
  Path path() => new Path._(_geo.callMethod('path'));
  
  class Path {
    final JsObject _proxy;
  
    Path._(this._proxy);
  
    /// Project the specified feature and render it to the context.
    String call(Map feature, [num index = undefined]) {
      var args = [_proxy, new JsObject.jsify(feature)];
      if (index != undefined) {
        args.add(index);
      }
      return _proxy.callMethod('call', args);
    }
  
    /// Get or set the geographic projection.
    projection([projection(coords) = undefined]) {
      var args = [];
      if (projection != undefined) {
        args.add(projection);
      }
      var retval = _proxy.callMethod('projection', args);
      if (projection == undefined) {
        return retval;
      } else {
        return new Path._(retval);
      }
    }
  
    /// Get or set the render context.
    context([context = undefined]) {
      var args = [];
      if (context != undefined) {
        args.add(context);
      }
      var retval = _proxy.callMethod('context', args);
      if (context == undefined) {
        return retval;
      } else {
        return new Path._(retval);
      }
    }
  
    /// Compute the projected area of a given feature.
    num area(Map feature) {
      return _proxy.callMethod('area', [new JsObject.jsify(feature)]);
    }
  
    /// Compute the projected centroid of a given feature.
    List centroid(Map feature) {
      return _proxy.callMethod('centroid', [new JsObject.jsify(feature)]);
    }
  
    /// Compute the projected bounds of a given feature.
    List bounds(Map feature) {
      return _proxy.callMethod('bounds', [new JsObject.jsify(feature)]);
    }
  
    /// Get or set the radius to display point features.
    pointRadius([radius = undefined]) {
      var args = [];
      if (radius is Function) {
        args.add(func4VarArgs(radius));
      } else if (radius != undefined) {
        args.add(radius);
      }
      var retval = _proxy.callMethod('pointRadius', args);
      if (radius == undefined) {
        return retval;
      } else {
        return new Path._(retval);
      }
    }
  }
  
  /// Create a graticule generator.
  Graticule graticule() => new Graticule._(_geo.callMethod('graticule'));
  
  class Graticule {
    final JsObject _proxy;
  
    Graticule._(this._proxy);
  
    /// Generate a MultiLineString of meridians and parallels.
    call() => _proxy.callMethod('call', [_proxy]);
  
    /// Generate an array of LineStrings of meridians and parallels.
    List lines() => _proxy.callMethod('lines');
  
    /// Generate a Polygon of the graticule's extent.
    outline() => _proxy.callMethod('outline');
  
    /// Get or set the major & minor extents.
    extent([List extent = undefined]) {
      var args = [];
      if (extent != undefined) {
        args.add(extent);
      }
      var retval = _proxy.callMethod('extent', args);
      if (extent == undefined) {
        return retval;
      } else {
        return new Graticule._(retval);
      }
    }
  
    /// Get or set the major extent.
    majorExtent([List extent = undefined]) {
      var args = [];
      if (extent != undefined) {
        args.add(extent);
      }
      var retval = _proxy.callMethod('majorExtent', args);
      if (extent == undefined) {
        return retval;
      } else {
        return new Graticule._(retval);
      }
    }
  
    /// Get or set the minor extent.
    minorExtent([List extent = undefined]) {
      var args = [];
      if (extent != undefined) {
        args.add(extent);
      }
      var retval = _proxy.callMethod('minorExtent', args);
      if (extent == undefined) {
        return retval;
      } else {
        return new Graticule._(retval);
      }
    }
  
    /// Get or set the major & minor step intervals.
    step([List step = undefined]) {
      var args = [];
      if (step != undefined) {
        args.add(step);
      }
      var retval = _proxy.callMethod('step', args);
      if (step == undefined) {
        return retval;
      } else {
        return new Graticule._(retval);
      }
    }
  
    /// Get or set the major step intervals.
    majorStep([List step = undefined]) {
      var args = [];
      if (step != undefined) {
        args.add(step);
      }
      var retval = _proxy.callMethod('majorStep', args);
      if (step == undefined) {
        return retval;
      } else {
        return new Graticule._(retval);
      }
    }
  
    /// Get or set the minor step intervals.
    minorStep([List step = undefined]) {
      var args = [];
      if (step != undefined) {
        args.add(step);
      }
      var retval = _proxy.callMethod('minorStep', args);
      if (step == undefined) {
        return retval;
      } else {
        return new Graticule._(retval);
      }
    }
  
    /// Get or set the latitudinal precision.
    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 Graticule._(retval);
      }
    }
  }
  
  /// Create a circle generator.
  Circle circle() => new Circle._(_geo.callMethod('circle'));
  
  class Circle {
    final JsObject _proxy;
  
    Circle._(this._proxy);
  
    /// Generate a piecewise circle as a Polygon.
    call(List arguments) {
      var args = [_proxy]..addAll(arguments);
      return _proxy.callMethod('call', args);
    }
  
    /// Specify the origin in latitude and longitude.
    origin([origin = undefined]) {
      var args = [];
      if (origin != undefined) {
        args.add(origin);
      }
      var retval = _proxy.callMethod('origin', args);
      if (origin == undefined) {
        return retval;
      } else {
        return new Circle._(retval);
      }
    }
  
    /// Specify the angular radius in degrees.
    angle([num angle = undefined]) {
      var args = [];
      if (angle != undefined) {
        args.add(angle);
      }
      var retval = _proxy.callMethod('angle', args);
      if (angle == undefined) {
        return retval;
      } else {
        return new Circle._(retval);
      }
    }
  
    /// Specify the precision of the piecewise circle.
    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 Circle._(retval);
      }
    }
  }
  
  /// Compute the spherical area of a given feature.
  num area(feature) => _geo.callMethod('area', [feature]);
  
  /// Compute the spherical centroid of a given feature.
  List centroid(feature) => _geo.callMethod('centroid', [feature]);
  
  /// Compute the latitude-longitude bounding box for a given feature.
  List bounds(feature) => _geo.callMethod('bounds', [feature]);
  
  /// Compute the great-arc distance between two points.
  num distance(List a, List b) => _geo.callMethod('distance', [a, b]);
  
  /// Compute the length of a line string or the perimeter of a polygon.
  num length(feature) => _geo.callMethod('length', [feature]);
  
  /// Interpolate between two points along a great arc.
  Function interpolate(List a, List b) => _geo.callMethod('interpolate', [a, b]);
  
  /// Create a rotation function for the specified angles [λ, φ, γ].
  Rotation rotation(rotate) {
    return new Rotation._(_geo.callMethod('rotation', [rotate]));
  }
  
  class Rotation {
  