anchor.diff:    }
   
     /// Set the scale's output range, and enable rounding.
  -  rangeRound(values) {
  -    return _proxy.callMethod('rangeRound', []);
  +  LinearScale rangeRound(List values) {
  +    var args = [];
  +    if (values != undefined) {
  +      args.add(values);
  +    }
  +    return new LinearScale._(_proxy.callMethod('rangeRound', args));
     }
   
     /// Get or set the scale's output interpolator.
  -  interpolate([factory]) {
  -    return _proxy.callMethod('interpolate', []);
  +  interpolate([Function factory = undefined]) {
  +    var args = [];
  +    if (factory != undefined) {
  +      args.add(factory);
  +    }
  +    var retval = _proxy.callMethod('interpolate', args);
  +    if (factory == undefined) {
  +      return retval;
  +    } else {
  +      return new LinearScale._(retval);
  +    }
     }
   
     /// Enable or disable clamping of the output range.
  -  clamp([boolean]) {
  -    return _proxy.callMethod('clamp', []);
  +  clamp([bool boolean = undefined]) {
  +    var args = [];
  +    if (boolean != undefined) {
  +      args.add(boolean);
  +    }
  +    var retval = _proxy.callMethod('clamp', args);
  +    if (boolean == undefined) {
  +      return retval;
  +    } else {
  +      return new LinearScale._(retval);
  +    }
     }
   
     /// Extend the scale domain to nice round numbers.
  -  nice([count]) {
  -    return _proxy.callMethod('nice', []);
  +  LinearScale nice([int count = undefined]) {
  +    var args = [];
  +    if (count != undefined) {
  +      args.add(count);
  +    }
  +    return new LinearScale._(_proxy.callMethod('nice', args));
     }
   
     /// Get representative values from the input domain.
  -  ticks([count]) {
  -    return _proxy.callMethod('ticks', []);
  +  LinearScale ticks([int count = 10]) {
  +    return new LinearScale._(_proxy.callMethod('ticks', [count]));
     }
   
     /// Get a formatter for displaying tick values.
  -  tickFormat(count, [format]) {
  -    return _proxy.callMethod('tickFormat', []);
  -  }
  -
  -  /// Create a new scale from an existing scale.
  -  copy() {
  -    return _proxy.callMethod('copy', []);
  -  }
  +  LinearScale tickFormat(int count, [String format = undefined]) {
  +    var args = [count];
  +    if (format != undefined) {
  +      args.add(format);
  +    }
  +    return new LinearScale._(_proxy.callMethod('tickFormat', args));
  +  }
  +
  +  /// Create a new scale from an existing scale.
  +  copy() => new LinearScale._(_proxy.callMethod('copy'));
   }
   
   /// Construct a linear identity scale.
   IdentityScale identity() {
  -  return _scale.callMethod('identity', []);
  +  return new IdentityScale._(_scale.callMethod('identity'));
   }
   
   class IdentityScale {
  
positive.code:   }
  
    /// Get or set the scale's output range.
    LinearScale range([List values = undefined]) {
      var args = [];
      if (values != undefined) {
        args.add(values);
  
negative.code: JsObject _scale = context['d3']['scale'];
  
  /// Construct a linear quantitative scale.
  LinearScale linear() => new LinearScale._(_scale.callMethod('linear'));
  
  class LinearScale {
    final JsObject _proxy;
  
    LinearScale._(this._proxy);
  
    /// Get the range value corresponding to a given domain value.
    call(x) => _proxy.callMethod('call', [_proxy, x]);
  
    /// Get the domain value corresponding to a given range value.
    invert(y) => _proxy.callMethod('invert', [y]);
  
    /// Get or set the scale's input domain.
    domain([List<num> numbers = undefined]) {
  