anchor.diff:  /// DateTimes can represent time values that are at a distance of at most
   /// 100,000,000 days from epoch (1970-01-01 UTC): -271821-04-20 to 275760-09-13.
   ///
  -/// Create a DateTime object by using one of the constructors
  +/// Create a `DateTime` object by using one of the constructors
   /// or by parsing a correctly formatted string,
   /// which complies with a subset of ISO 8601.
  -/// Note that hours are specified between 0 and 23,
  +/// **Note:** hours are specified between 0 and 23,
   /// as in a 24-hour clock.
  +///
   /// For example:
  -///
   /// ```dart
  -/// var now = DateTime.now();
  -/// var berlinWallFell = DateTime.utc(1989, 11, 9);
  -/// var moonLanding = DateTime.parse("1969-07-20 20:18:04Z");  // 8:18pm
  -/// ```
  -///
  -/// A DateTime object is anchored either in the UTC time zone
  +/// final now = DateTime.now();
  +/// final berlinWallFell = DateTime.utc(1989, 11, 9);
  +/// final moonLanding = DateTime.parse('1969-07-20 20:18:04Z'); // 8:18pm
  +/// ```
  +///
  +/// A `DateTime` object is anchored either in the UTC time zone
   /// or in the local time zone of the current computer
   /// when the object is created.
   ///
   /// Once created, neither the value nor the time zone
  -/// of a DateTime object may be changed.
  +/// of a `DateTime` object may be changed.
   ///
   /// You can use properties to get
  -/// the individual units of a DateTime object.
  -///
  -/// ```dart
  -/// assert(berlinWallFell.month == 11);
  -/// assert(moonLanding.hour == 20);
  -/// ```
  -///
  +/// the individual units of a `DateTime` object.
  +/// ```
  +/// print(berlinWallFell.year); // 1989
  +/// print(berlinWallFell.month); // 11
  +/// print(berlinWallFell.day); // 9
  +/// print(moonLanding.hour); // 20
  +/// print(moonLanding.minute); // 18
  +/// ```
   /// For convenience and readability,
  -/// the DateTime class provides a constant for each day and month
  +/// the `DateTime` class provides a constant for each `day` and `month`
   /// name - for example, [august] and [friday].
   /// You can use these constants to improve code readability:
  -///
   /// ```dart
  -/// var berlinWallFell = DateTime.utc(1989, DateTime.november, 9);
  +/// final berlinWallFell = DateTime.utc(1989, DateTime.november, 9);
  +/// print(DateTime.november); // 11
  +/// assert(berlinWallFell.month == DateTime.november);
   /// assert(berlinWallFell.weekday == DateTime.thursday);
   /// ```
   ///
  -/// Day and month values begin at 1, and the week starts on Monday.
  +/// `Day` and `month` values begin at 1, and the week starts on `Monday`.
   /// That is, the constants [january] and [monday] are both 1.
   ///
   /// ## Working with UTC and local time
   ///
  -/// A DateTime object is in the local time zone
  +/// A `DateTime` object is in the local time zone
   /// unless explicitly created in the UTC time zone.
  +/// Use [isUtc] to determine whether a `DateTime` object is based in UTC.
   ///
   /// ```dart
  -/// var dDay = DateTime.utc(1944, 6, 6);
  -/// ```
  -///
  -/// Use [isUtc] to determine whether a DateTime object is based in UTC.
  +/// final dDay = DateTime.utc(1944, 6, 6);
  +/// print(dDay.isUtc); // true
  +///
  +/// final dDayLocal = DateTime(1944, 6, 6);
  +/// print(dDayLocal.isUtc); // false
  +/// ```
   /// Use the methods [toLocal] and [toUtc]
   /// to get the equivalent date/time value specified in the other time zone.
  +/// ```
  +/// final localDay = dDay.toLocal(); // e.g. 1944-06-06 02:00:00.000
  +/// print(localDay.isUtc); // false
  +///
  +/// final utcFromLocal = localDay.toUtc(); // 1944-06-06 00:00:00.000Z
  +/// print(utcFromLocal.isUtc); // true
  +/// ```
   /// Use [timeZoneName] to get an abbreviated name of the time zone
  -/// for the DateTime object.
  +/// for the `DateTime` object.
  +/// ```
  +/// print(dDay.timeZoneName); // UTC
  +/// print(localDay.timeZoneName); // e.g. EET
  +/// ```
   /// To find the difference
  -/// between UTC and the time zone of a DateTime object
  +/// between UTC and the time zone of a `DateTime` object
   /// call [timeZoneOffset].
  +/// ```
  +/// print(dDay.timeZoneOffset); // 0:00:00.000000
  +/// print(localDay.timeZoneOffset); // e.g. 2:00:00.000000
  +/// ```
   ///
   /// ## Comparing DateTime objects
   ///
  -/// The DateTime class contains several handy methods,
  -/// such as [isAfter], [isBefore], and [isAtSameMomentAs],
  -/// for comparing DateTime objects.
  -///
  +/// The `DateTime` class contains methods for comparing `DateTime`s
  +/// chronologically, such as [isAfter], [isBefore], and [isAtSameMomentAs].
  +/// ```
  +/// print(berlinWallFell.isAfter(moonLanding)); // true
  +/// print(berlinWallFell.isBefore(moonLanding)); // false
  +/// print(dDay.isAtSameMomentAs(localDay)); // true
  +/// ```
  +///
  +/// ## Using DateTime with Duration
  +///
  +/// Use the [add] and [subtract] methods with a [Duration] object
  +/// to create a `DateTime` object based on another.
  +/// For example, to find the point in time that is 36 hours after now,
  +/// you can write:
   /// ```dart
  -/// assert(berlinWallFell.isAfter(moonLanding) == true);
  -/// assert(berlinWallFell.isBefore(moonLanding) == false);
  -/// ```
  -///
  -/// ## Using DateTime with Duration
  -///
  -/// Use the [add] and [subtract] methods with a [Duration] object
  -/// to create a DateTime object based on another.
  -/// For example, to find the date that is sixty days (24 * 60 hours) after today,
  -/// write:
  -///
  -/// ```dart
  -/// var now = DateTime.now();
  -/// var sixtyDaysFromNow = now.add(const Duration(days: 60));
  -/// ```
  -///
  -/// To find out how much time is between two DateTime objects use
  +/// final now = DateTime.now();
  +/// final later = now.add(const Duration(hours: 36));
  +/// ```
  +///
  +/// To find out how much time is between two `DateTime` objects use
   /// [difference], which returns a [Duration] object:
  -///
  -/// ```dart
  -/// var difference = berlinWallFell.difference(moonLanding);
  -/// assert(difference.inDays == 7416);
  +/// ```
  +/// final difference = berlinWallFell.difference(moonLanding);
  +/// print(difference.inDays); // 7416
   /// ```
   ///
   /// The difference between two dates in different time zones
  
positive.code:   /// True if this [DateTime] is set to UTC time.
    ///
    /// ```dart
    /// var dDay = DateTime.utc(1944, 6, 6);
    /// assert(dDay.isUtc);
    /// ```
    ///
    final bool isUtc;
  
    /// Constructs a [DateTime] instance specified in the local time zone.
    ///
    /// For example,
    /// to create a DateTime object representing the 7th of September 2017,
    /// 5:30pm
    ///
    /// ```dart
    /// var dentistAppointment = DateTime(2017, 9, 7, 17, 30);
    /// ```
    DateTime(int year,
        [int month = 1,
  
negative.code:   /// The constructed [DateTime] represents
    /// 1970-01-01T00:00:00Z + [millisecondsSinceEpoch] ms in the given
    /// time zone (local or UTC).
    /// ```dart
    /// final newYearsDay =
    ///     DateTime.fromMillisecondsSinceEpoch(1640979000000, isUtc:true);
    /// print(newYearsDay); // 2022-01-01 10:00:00.000Z
    /// ```
    external DateTime.fromMillisecondsSinceEpoch(int millisecondsSinceEpoch,
        {bool isUtc = false});
  
    /// Constructs a new [DateTime] instance
    /// with the given [microsecondsSinceEpoch].
    ///
    /// If [isUtc] is false, then the date is in the local time zone.
    ///
    /// The constructed [DateTime] represents
    /// 1970-01-01T00:00:00Z + [microsecondsSinceEpoch] us in the given
    /// time zone (local or UTC).
    /// ```dart
    /// final newYearsEve =
    ///     DateTime.fromMicrosecondsSinceEpoch(1640901600000000, isUtc:true);
    /// print(newYearsEve); // 2021-12-31 19:30:00.000Z
    /// ```
    external DateTime.fromMicrosecondsSinceEpoch(int microsecondsSinceEpoch,
        {bool isUtc = false});
  
    /// Constructs a new [DateTime] instance with the given value.
    ///
    /// If [isUtc] is false, then the date is in the local time zone.
    DateTime._withValue(this._value, {required this.isUtc}) {
      if (millisecondsSinceEpoch.abs() > _maxMillisecondsSinceEpoch ||
          (millisecondsSinceEpoch.abs() == _maxMillisecondsSinceEpoch &&
  