anchor.diff:  
     /// The current value of the input element.
     ///
  -  /// Must be between [min] and [max], inclusive.
  -  @Input()
  -  int value = 0;
  -
  -  final _changeController = new StreamController<int>.broadcast(sync: true);
  +  /// Must be between [min] and [max], inclusive, and a multiple of [step].
  +  @Input()
  +  num value = 0;
  +
  +  final _changeController = new StreamController<num>.broadcast(sync: true);
   
     /// Publishes events when the value of the input is changed by the user.
     @Output()
  -  Stream<int> get valueChange => _changeController.stream;
  +  Stream<num> get valueChange => _changeController.stream;
   
     /// The minimum progress value.
     ///
     /// Defaults to 0, must be strictly smaller than max.
     @Input()
  -  int min = 0;
  +  num min = 0;
   
     /// The maximum progress value.
     ///
     /// Defaults to 100, must be strictly larger than min.
     @Input()
  -  int max = 100;
  +  num max = 100;
   
     /// The step size of the input.
     ///
  -  /// Must be a positive integer and a divisor of (max - min).
  -  @Input()
  -  int step = 1;
  +  /// Must be a positive number and a divisor of (max - min).
  +  @Input()
  +  num step = 1;
   
     /// The current progress of the input in percent.
     double get progressPercent => (100.0 * (value - min) / (max - min));
  
positive.code: /// keyboard. In LTR, Left/down arrow keys decrease the value by 1, up/right
  /// keys increase by 1, page up increases by 10% (rounded up) and page down
  /// decreases by 10% (rounded up). In RTL, the keys have the opposite effect.
  @Component(
    selector: 'material-slider',
    providers: const [
  
negative.code:       final fractionOfTrack =
            isRtl ? 1.0 - fractionOfTrackLtr : fractionOfTrackLtr;
  
        final scaledValue = (fractionOfTrack * (max - min));
        final halfStep = step / 2;
        // Clamp to the closest step value.
        final unboundedValue = min +
            (scaledValue ~/ step) * step +
            (scaledValue.remainder(step) > halfStep ? step : 0);
        final newValue = math.max(min, math.min(max, unboundedValue));
        if (newValue != value) {
          value = newValue;
  