anchor.diff:  ///
   /// The ScrollPosition knows the number of pixels a user wants to move the sheet.
   ///
  -/// The [currentExtent] will never be null.
  +/// The [currentSize] will never be null.
   /// The [availablePixels] will never be null, but may be `double.infinity`.
   class _DraggableSheetExtent {
     _DraggableSheetExtent({
  -    required this.minExtent,
  -    required this.maxExtent,
  +    required this.minSize,
  +    required this.maxSize,
       required this.snap,
       required this.snapSizes,
  -    required this.initialExtent,
  -    required this.onExtentChanged,
  -    ValueNotifier<double>? currentExtent,
  +    required this.initialSize,
  +    required this.onSizeChanged,
  +    ValueNotifier<double>? currentSize,
       bool? hasChanged,
  -  })  : assert(minExtent != null),
  -        assert(maxExtent != null),
  -        assert(initialExtent != null),
  -        assert(minExtent >= 0),
  -        assert(maxExtent <= 1),
  -        assert(minExtent <= initialExtent),
  -        assert(initialExtent <= maxExtent),
  -        _currentExtent = (currentExtent ?? ValueNotifier<double>(initialExtent))
  -          ..addListener(onExtentChanged),
  +  })  : assert(minSize != null),
  +        assert(maxSize != null),
  +        assert(initialSize != null),
  +        assert(minSize >= 0),
  +        assert(maxSize <= 1),
  +        assert(minSize <= initialSize),
  +        assert(initialSize <= maxSize),
  +        _currentSize = (currentSize ?? ValueNotifier<double>(initialSize))
  +          ..addListener(onSizeChanged),
           availablePixels = double.infinity,
           hasChanged = hasChanged ?? false;
   
  -  final double minExtent;
  -  final double maxExtent;
  +  final double minSize;
  +  final double maxSize;
     final bool snap;
     final List<double> snapSizes;
  -  final double initialExtent;
  -  final ValueNotifier<double> _currentExtent;
  -  final VoidCallback onExtentChanged;
  +  final double initialSize;
  +  final ValueNotifier<double> _currentSize;
  +  final VoidCallback onSizeChanged;
     double availablePixels;
   
  -  // Used to disable snapping until the extent has changed. We do this because
  -  // we don't want to snap away from the initial extent.
  +  // Used to disable snapping until the user interacts with the sheet. We set
  +  // this to false on initialization and after programmatic interaction with the
  +  // sheet to prevent snapping away from the initial size and after animateTo/jumpTo.
     bool hasChanged;
   
  -  bool get isAtMin => minExtent >= _currentExtent.value;
  -  bool get isAtMax => maxExtent <= _currentExtent.value;
  -
  -  set currentExtent(double value) {
  +  bool get isAtMin => minSize >= _currentSize.value;
  +  bool get isAtMax => maxSize <= _currentSize.value;
  +
  +  set currentSize(double value) {
       assert(value != null);
       hasChanged = true;
  -    _currentExtent.value = value.clamp(minExtent, maxExtent);
  -  }
  -  double get currentExtent => _currentExtent.value;
  -  double get currentPixels => extentToPixels(_currentExtent.value);
  -
  -  double get additionalMinExtent => isAtMin ? 0.0 : 1.0;
  -  double get additionalMaxExtent => isAtMax ? 0.0 : 1.0;
  -  List<double> get pixelSnapSizes => snapSizes.map(extentToPixels).toList();
  -
  -  /// The scroll position gets inputs in terms of pixels, but the extent is
  +    _currentSize.value = value.clamp(minSize, maxSize);
  +  }
  +  double get currentSize => _currentSize.value;
  +  double get currentPixels => sizeToPixels(_currentSize.value);
  +
  +  double get additionalMinSize => isAtMin ? 0.0 : 1.0;
  +  double get additionalMaxSize => isAtMax ? 0.0 : 1.0;
  +  List<double> get pixelSnapSizes => snapSizes.map(sizeToPixels).toList();
  +
  +  /// The scroll position gets inputs in terms of pixels, but the size is
     /// expected to be expressed as a number between 0..1.
     void addPixelDelta(double delta, BuildContext context) {
       if (availablePixels == 0) {
         return;
       }
  -    updateExtent(currentExtent + pixelsToExtent(delta), context);
  -  }
  -
  -  /// Set the extent to the new value. [newExtent] should be a number between
  -  /// 0..1.
  -  void updateExtent(double newExtent, BuildContext context) {
  -    currentExtent = newExtent;
  +    updateSize(currentSize + pixelsToSize(delta), context);
  +  }
  +
  +  /// Set the size to the new value. [newSize] should be a number between 0..1.
  +  void updateSize(double newSize, BuildContext context) {
  +    currentSize = newSize;
       DraggableScrollableNotification(
  -      minExtent: minExtent,
  -      maxExtent: maxExtent,
  -      extent: currentExtent,
  -      initialExtent: initialExtent,
  +      minExtent: minSize,
  +      maxExtent: maxSize,
  +      extent: currentSize,
  +      initialExtent: initialSize,
         context: context,
       ).dispatch(context);
     }
   
  -  double pixelsToExtent(double pixels) {
  -    return pixels / availablePixels * maxExtent;
  -  }
  -
  -  double extentToPixels(double extent) {
  -    return extent / maxExtent * availablePixels;
  +  double pixelsToSize(double pixels) {
  +    return pixels / availablePixels * maxSize;
  +  }
  +
  +  double sizeToPixels(double extent) {
  +    return extent / maxSize * availablePixels;
     }
   
     void dispose() {
  -    _currentExtent.removeListener(onExtentChanged);
  +    _currentSize.removeListener(onSizeChanged);
     }
   
     _DraggableSheetExtent copyWith({
  -    required double minExtent,
  -    required double maxExtent,
  +    required double minSize,
  +    required double maxSize,
       required bool snap,
       required List<double> snapSizes,
  -    required double initialExtent,
  -    required VoidCallback onExtentChanged,
  +    required double initialSize,
  +    required VoidCallback onSizeChanged,
     }) {
       return _DraggableSheetExtent(
  -      minExtent: minExtent,
  -      maxExtent: maxExtent,
  +      minSize: minSize,
  +      maxSize: maxSize,
         snap: snap,
         snapSizes: snapSizes,
  -      initialExtent: initialExtent,
  -      onExtentChanged: onExtentChanged,
  +      initialSize: initialSize,
  +      onSizeChanged: onSizeChanged,
         // Use the possibly updated initialExtent if the user hasn't dragged yet.
  -      currentExtent: ValueNotifier<double>(hasChanged
  -          ? _currentExtent.value.clamp(minExtent, maxExtent)
  -          : initialExtent),
  +      currentSize: ValueNotifier<double>(hasChanged
  +          ? _currentSize.value.clamp(minSize, maxSize)
  +          : initialSize),
         hasChanged: hasChanged,
       );
     }
  
positive.code:   bool get _isAtSnapSize {
      return extent.snapSizes.any(
        (double snapSize) {
          return (extent.currentExtent - snapSize).abs() <= extent.pixelsToExtent(physics.tolerance.distance);
        },
      );
    }
  
negative.code:   void initState() {
      super.initState();
      _extent = _DraggableSheetExtent(
        minSize: widget.minChildSize,
        maxSize: widget.maxChildSize,
        snap: widget.snap,
        snapSizes: _impliedSnapSizes(),
        initialSize: widget.initialChildSize,
        onSizeChanged: _setSize,
      );
      _scrollController = _DraggableScrollableSheetScrollController(extent: _extent);
    }
  