anchor.diff:    /// and no callback is invoked for them.
     /// The [tick] count reflects the number of durations that have passed and
     /// not the number of callback invocations that have happened.
  +  ///
  +  /// Example:
  +  /// ```dart
  +  /// final stopwatch = Stopwatch()..start();
  +  /// Timer.periodic(const Duration(seconds: 1), (timer) {
  +  ///   print(timer.tick);
  +  ///   if (timer.tick == 1) {
  +  ///     while (stopwatch.elapsedMilliseconds < 4500) {
  +  ///       // Run uninterrupted for another 3.5 seconds!
  +  ///       // The latest due tick after that is the 4-second tick.
  +  ///     }
  +  ///   } else {
  +  ///     timer.cancel();
  +  ///   }
  +  /// });
  +  /// // Outputs:
  +  /// // 1
  +  /// // 4
  +  /// ```
     int get tick;
   
     /// Returns whether the timer is still active.
  
positive.code:   /// Once a [Timer] has been canceled, the callback function will not be called
    /// by the timer. Calling [cancel] more than once on a [Timer] is allowed, and
    /// will have no further effect.
    void cancel();
  
    /// The number of durations preceding the most recent timer event.
  
negative.code:   /// scheduled for - even if the actual callback was delayed.
    ///
    /// [duration] must a non-negative [Duration].
    ///
    /// Example:
    /// ```dart
    /// var counter = 3;
    /// Timer.periodic(const Duration(seconds: 2), (timer) {
    ///   print(timer.tick);
    ///   counter--;
    ///   if (counter == 0) {
    ///     print('Cancel timer');
    ///     timer.cancel();
    ///   }
    /// });
    /// // Outputs:
    /// // 1
    /// // 2
    /// // 3
    /// // "Cancel timer"
    /// ```
    factory Timer.periodic(Duration duration, void callback(Timer timer)) {
      if (Zone.current == Zone.root) {
        // No need to bind the callback. We know that the root's timer will
  