anchor.diff:    Color resolve(Set<MaterialState> states) => _resolve(states);
   }
   
  -
   /// Defines a [MouseCursor] whose value depends on a set of [MaterialState]s which
   /// represent the interactive state of a component.
   ///
  -/// This kind of [MouseCursor] is useful when the set of interactive actions a
  -/// widget supports varies with its state. For example, a mouse pointer hovering
  -/// over a disabled [FlatButton] should not display [SystemMouseCursors.click],
  -/// since the button is not clickable. To solve this, you can use
  -/// [MaterialStateMouseCursor] to assign a different cursor (such as
  -/// [SystemMouseCursors.basic]) when the [FlatButton] is disabled.
  +/// This kind of [MouseCursor] is useful when the set of interactive
  +/// actions a widget supports varies with its state. For example, a
  +/// mouse pointer hovering over a disabled [ListTile] should not
  +/// display [SystemMouseCursors.click], since a disabled list tile
  +/// doesn't respond to mouse clicks. [ListTile]'s default mouse cursor
  +/// is a [MaterialStateMouseCursor.clickable], which resolves to
  +/// [SystemMouseCursors.basic] when the button is disabled.
   ///
   /// To use a [MaterialStateMouseCursor], you should create a subclass of
   /// [MaterialStateMouseCursor] and implement the abstract `resolve` method.
   ///
  -/// {@tool snippet}
  -///
  -/// In this next example, we see how you can create a `MaterialStateMouseCursor` by
  -/// extending the abstract class and overriding the `resolve` method.
  -///
  -/// ```dart
  -/// class ButtonCursor extends MaterialStateMouseCursor {
  -///   const ButtonCursor();
  -///
  +/// {@tool dartpad --template=stateless_widget_scaffold_center}
  +///
  +/// This example defines a mouse cursor that resolves to
  +/// [SystemMouseCursors.forbidden] when its widget is disabled.
  +///
  +/// ```dart imports
  +/// import 'package:flutter/rendering.dart';
  +/// ```
  +///
  +/// ```dart preamble
  +/// class ListTileCursor extends MaterialStateMouseCursor {
   ///   @override
   ///   MouseCursor resolve(Set<MaterialState> states) {
   ///     if (states.contains(MaterialState.disabled)) {
  
positive.code: /// set of states.
  typedef MaterialPropertyResolver<T> = T Function(Set<MaterialState> states);
  
  /// Defines a [Color] whose value depends on a set of [MaterialState]s which
  /// represent the interactive state of a component.
  ///
  /// This is useful for improving the accessibility of text in different states
  /// of a component. For example, in a [FlatButton] with blue text, the text will
  /// become more difficult to read when the button is hovered, focused, or pressed,
  /// because the contrast ratio between the button and the text will decrease. To
  /// solve this, you can use [MaterialStateColor] to make the text darker when the
  /// [FlatButton] is hovered, focused, or pressed.
  ///
  /// To use a [MaterialStateColor], you can either:
  ///   1. Create a subclass of [MaterialStateColor] and implement the abstract `resolve` method.
  ///   2. Use [MaterialStateColor.resolveWith] and pass in a callback that
  ///      will be used to resolve the color in the given states.
  ///
  /// This should only be used as parameters when they are documented to take
  /// [MaterialStateColor], otherwise only the default state will be used.
  ///
  /// {@tool snippet}
  ///
  /// This example shows how you could pass a `MaterialStateColor` to `FlatButton.textColor`.
  /// Here, the text color will be `Colors.blue[900]` when the button is being
  /// pressed, hovered, or focused. Otherwise, the text color will be `Colors.blue[600]`.
  ///
  /// ```dart
  /// Color getTextColor(Set<MaterialState> states) {
  ///   const Set<MaterialState> interactiveStates = <MaterialState>{
  ///     MaterialState.pressed,
  ///     MaterialState.hovered,
  ///     MaterialState.focused,
  ///   };
  ///   if (states.any(interactiveStates.contains)) {
  ///     return Colors.blue[900];
  ///   }
  ///   return Colors.blue[600];
  /// }
  ///
  /// FlatButton(
  ///   child: Text('FlatButton'),
  ///   onPressed: () {},
  ///   textColor: MaterialStateColor.resolveWith(getTextColor),
  /// ),
  /// ```
  /// {@end-tool}
  abstract class MaterialStateColor extends Color implements MaterialStateProperty<Color> {
    /// Creates a [MaterialStateColor].
    ///
    /// If you want a `const` [MaterialStateColor], you'll need to extend
    /// [MaterialStateColor] and override the [resolve] method. You'll also need
    /// to provide a `defaultValue` to the super constructor, so that we can know
    /// at compile-time what the value of the default [Color] is.
    ///
    /// {@tool snippet}
    ///
    /// In this next example, we see how you can create a `MaterialStateColor` by
    /// extending the abstract class and overriding the `resolve` method.
    ///
    /// ```dart
    /// class TextColor extends MaterialStateColor {
    ///   static const int _defaultColor = 0xcafefeed;
    ///   static const int _pressedColor = 0xdeadbeef;
    ///
    ///   const TextColor() : super(_defaultColor);
    ///
    ///   @override
    ///   Color resolve(Set<MaterialState> states) {
    ///     if (states.contains(MaterialState.pressed)) {
    ///       return const Color(_pressedColor);
    ///     }
    ///     return const Color(_defaultColor);
    ///   }
    /// }
    /// ```
    /// {@end-tool}
    const MaterialStateColor(int defaultValue) : super(defaultValue);
  
    /// Creates a [MaterialStateColor] from a [MaterialPropertyResolver<Color>]
  
negative.code: ///     }
  ///     return SystemMouseCursors.click;
  ///   }
  ///   @override
  ///   String get debugDescription => 'ListTileCursor()';
  /// }
  /// ```
  ///
  /// ```dart
  /// Widget build(BuildContext context) {
  ///   return ListTile(
  ///     title: Text('Disabled ListTile'),
  ///     enabled: false,
  ///     mouseCursor: ListTileCursor(),
  ///   );
  /// }
  /// ```
  /// {@end-tool}
  ///
  /// This class should only be used for parameters which are documented to take
  /// [MaterialStateMouseCursor], otherwise only the default state will be used.
  ///
  /// See also:
  ///
  