docs: correct diagram in readme

Author: egil

README.md

@@ -16,15 +16,15 @@ For example, if we create an `ITimer` with a *due time* and *period* set to **1
 
 If we call `Advance(TimeSpan.FromSeconds(1))` three times, effectively moving time forward by three seconds, the timer callback will be invoked once at times `00:01`, `00:02`, and `00:03`, as illustrated in the drawing below. Both `FakeTimeProvider` and `ManualTimeProvider` behaves like this:
 
-![Advancing time by three seconds in one-second increments.](docs/advance-1-second.svg)
+![Advancing time by three seconds in one-second increments.](https://raw.githubusercontent.com/egil/TimeProviderExtensions/main/docs/advance-1-second.svg)
 
 However, if we instead call `Advance(TimeSpan.FromSeconds(3))` once, the two implementations behave differently. `ManualTimeProvider` will invoke the timer callback at the same time as if we had called `Advance(TimeSpan.FromSeconds(1))` three times, as illustrated in the drawing below:
 
-![Advancing time by three seconds in one step using ManualTimeProvider.](docs/ManualTimeProvider-advance-3-seconds.svg)
+![Advancing time by three seconds in one step using ManualTimeProvider.](https://raw.githubusercontent.com/egil/TimeProviderExtensions/main/docs/ManualTimeProvider-advance-3-seconds.svg)
 
 However, `FakeTimeProvider` will invoke the timer callback at time `00:03` three times, as illustrated in the drawings below:
 
-![Advancing time by three seconds in one step using FakeTimeProvider.](docs/FakeTimeProvider-advance-3-seconds.svg)
+![Advancing time by three seconds in one step using FakeTimeProvider.](https://raw.githubusercontent.com/egil/TimeProviderExtensions/main/docs/FakeTimeProvider-advance-3-seconds.svg)
 
 Technically, both implementations are correct since the `ITimer` abstractions only promise to invoke the callback timer *on or after the due time/period has elapsed*, never before.
 
@@ -33,15 +33,15 @@ However, I strongly prefer the `ManualTimeProvider` approach since it behaves co
 ## Known limitations:
 
 - If running on .NET versions earlier than .NET 8.0, there is a constraint when invoking `CancellationTokenSource.CancelAfter(TimeSpan)` on the `CancellationTokenSource` object returned by `CreateCancellationTokenSource(TimeSpan delay)`. This action will not terminate the initial timer indicated by the `delay` argument initially passed the `CreateCancellationTokenSource` method. However, this restriction does not apply to .NET 8.0 and later versions.
-- To enable controlling `PeriodicTimer` via `TimeProvider` in versions of .NET earlier than .NET 8.0, the `TimeProvider.CreatePeriodicTimer` returns a `PeriodicTimerWrapper` object instead of a `PeriodicTimer` object. The `PeriodicTimerWrapper` type is just a lightweight wrapper around the original `System.Threading.PeriodicTimer` and will behave identically to it. 
+- To enable controlling `PeriodicTimer` via `TimeProvider` in versions of .NET earlier than .NET 8.0, the `TimeProvider.CreatePeriodicTimer` returns a `PeriodicTimerWrapper` object instead of a `PeriodicTimer` object. The `PeriodicTimerWrapper` type is just a lightweight wrapper around the original `System.Threading.PeriodicTimer` and will behave identically to it.
 
 ## Installation
 
 Get the latest release from https://www.nuget.org/packages/TimeProviderExtensions
 
 ## Set up in production
 
-To use in production, pass in `TimeProvider.System` to the types that depend on `TimeProvider`. 
+To use in production, pass in `TimeProvider.System` to the types that depend on `TimeProvider`.
 This can be done directly or via an IoC Container, e.g., .NETs built-in `IServiceCollection` like so:
 
 ```c#
@@ -56,11 +56,11 @@ and in the existing constructor(s) you have, just new up `TimeProvider.System` d
 public class MyService
 {
   private readonly TimeProvider timeProvider;
-  
+
   public MyService() : this(TimeProvider.System)
   {
   }
-  
+
   public MyService(TimeProvider timeProvider)
   {
     this.timeProvider = timeProvider;
@@ -72,15 +72,15 @@ This allows you to explicitly pass in a `ManualTimeProvider` during testing.
 
 ## Example - control time during tests
 
-If a system under test (SUT) uses things like `Task.Delay`, `DateTimeOffset.UtcNow`, `Task.WaitAsync`, or `PeriodicTimer`, 
+If a system under test (SUT) uses things like `Task.Delay`, `DateTimeOffset.UtcNow`, `Task.WaitAsync`, or `PeriodicTimer`,
 it becomes hard to create tests that run fast and predictably.
 
 The idea is to replace the use of e.g. `Task.Delay` with an abstraction, the `TimeProvider`, that in production
 is represented by the `TimeProvider.System`, which just uses the real `Task.Delay`. During testing it is now possible to
 pass in `ManualTimeProvider`, which allows the test to control the progress of time, making it possible to skip ahead,
 e.g. 10 minutes, and also pause time, leading to fast and predictable tests.
 
-As an example, let us test the "Stuff Service" below that performs specific tasks every 10 seconds with an additional 
+As an example, let us test the "Stuff Service" below that performs specific tasks every 10 seconds with an additional
 1-second delay. We have two versions, one that uses the standard types in .NET, and one that uses the `TimeProvider`.
 
 ```c#
@@ -94,13 +94,13 @@ public class StuffService
   {
     this.container = container;
   }
-  
+
   public async Task DoStuff(CancellationToken cancelllationToken)
   {
     using var periodicTimer = new PeriodicTimer(doStuffDelay);
-    
+
     while (await periodicTimer.WaitForNextTickAsync(cancellationToken))
-    {      
+    {
       await Task.Delay(TimeSpan.FromSeconds(1));
       container.Add(DateTimeOffset.UtcNow);
     }
@@ -119,13 +119,13 @@ public class StuffServiceUsingTimeProvider
     this.timeProvider = timeProvider;
     this.container = container;
   }
-  
+
   public async Task DoStuff(CancellationToken cancelllationToken)
   {
     using var periodicTimer = timeProvider.CreatePeriodicTimer(doStuffDelay);
-    
+
     while (await periodicTimer.WaitForNextTickAsync(cancellationToken))
-    {      
+    {
       await timeProvider.Delay(TimeSpan.FromSeconds(1));
       container.Add(timeProvider.GetUtcNow());
     }
@@ -141,13 +141,13 @@ public void DoStuff_does_stuff_every_11_seconds()
 {
   // Arrange
   var timeProvider = new ManualTimeProvider();
-  var container = new List<DateTimeOffset>();  
+  var container = new List<DateTimeOffset>();
   var sut = new StuffServiceUsingTimeProvider(timeProvider, container);
-  
+
   // Act
   _ = sut.DoStuff(CancellationToken.None);
   timeProvider.Advance(TimeSpan.FromSeconds(11));
-  
+
   // Assert
   container
     .Should()
@@ -167,13 +167,13 @@ Compare that to the similar test below for `StuffService` that needs to wait for
 public async Task DoStuff_does_stuff_every_11_seconds()
 {
   // Arrange
-  var container = new List<DateTimeOffset>();  
+  var container = new List<DateTimeOffset>();
   var sut = new StuffService(container);
-  
+
   // Act
   _ = sut.DoStuff(CancellationToken.None);
   await Task.Delay(TimeSpan.FromSeconds(11));
-  
+
   // Assert
   container
     .Should()