message: chore(docs): Rephrase extension.mdx slightly and apply some corrections
diff: @@ -4,20 +4,24 @@ route: /extension
  ---
  # Extension
  -To make sure typings are correct we provide some functionality to identify mocks and the original type.
  -If you need your custom spies you can use our framework to specify and identify them.
  -In this way you will avoid casting and it will make your code much cleaner.
  +
  +To preserve type safety, we utilize the capability of the type checker to infer types through external interfaces, which enables us to easily inject spies from various testing frameworks without having to perform implicit type casts.
  +
  +If you need custom spies you can use our framework to wrap- and later extract them.
  ## Custom Method
  -(this example is taken from jasmine-ts-auto-mock)[https://github.com/Typescript-TDD/jasmine-ts-auto-mock]
  +
  +*This example is taken from: [`jasmine-ts-auto-mock`](https://github.com/Typescript-TDD/jasmine-ts-auto-mock)*
  To extend a method you need to:
  -1) set your spy function (jasmine.createSpy(name))
  -Please note that the value returned from provideMethodWithDeferredValue will be a function.
  -You will need to make sure that the method you are providing will not execute the function directly because it will cause Maximum call stack size.
  +1. Create your spy function (`jasmine.createSpy(name)`)
  -In the example below it's using callFake that will prevent to execute the function directly.
  + Please note that the value returned from `provideMethodWithDeferredValue` must be a function.
  +
  + Therefore, you will need to make sure that the method you are providing will not execute the function directly, otherwise it will cause an infinite recursion and crash the application almost immediately, once it exceeds the allowed call stack size.
  +
  + In the example below, the function to be spied upon is passed into `callFake` which will prevent the function from being executed directly.
  ```ts
  @@ -27,7 +31,9 @@ Provider.instance.provideMethodWithDeferredValue((name: string, value: () => any
  return jasmine.createSpy(name).and.callFake(value);
  });
  ```
  -2) override the type of the return value
  +
  +2. Infer the type of the return value
  +
  ```ts
  type ReturnType = jasmine.Spy;
  @@ -35,33 +41,37 @@ declare module 'ts-auto-mock/extension' {
  interface Method<TR> extends ReturnType {}
  }
  ```
  +
  ### Method Usage
  -1) create an interface
  +
  +1. Create an interface
  ```ts
  interface Interface {
  methodToSpy: () => string
  }
  ```
  -2) create a mock
  +
  +2. Create a mock
  ```ts
  const mock: Interface = createMock<Interface>();
  ```
  -3) get the spy from the method
  -You can get the method in two different way
  +3. Get the spy from the method.
  +
  + You can extract the method being spied in two different ways.
  -through a function that access to the mock
  + 1. Through a callback function that accesses the mock:
  ```ts
  import { On, method } from "ts-auto-mock/extension";
  const spy: jasmine.Spy = On(mock).get(method(mock => mock.methodToSpy));
  ```
  -directly as string
  + 2. Or, directly as string:
  ```ts
  import { On, method } from "ts-auto-mock/extension";
  const spy: jasmine.Spy = On(mock).get(method('methodToSpy'));
  ```
  -4) trigger the method
  +4. Trigger the method and perform your assertions
  ```ts
  someMethodThatWillTriggerInterfaceA();
  expect(spy).toHaveBeenCalled();
  