Update inheritance.md

Fix code formatting

Author: badsyntax

Diff for: wiki/inheritance.md

@@ -4,7 +4,7 @@ We try to provide developers with useful error feedback like:
 
 > Error: Missing required @injectable annotation in: SamuraiMaster
 
-This works fine in most cases but it causes some problem when using inheritance. 
+This works fine in most cases but it causes some problem when using inheritance.
 
 For example, the following code snippet throws a misleading error:
 
@@ -20,9 +20,9 @@ class Warrior {
 }
 
 @injectable()
-class SamuraiMaster extends Warrior  {
+class SamuraiMaster extends Warrior {
     public constructor() { // args count = 0
-       super("master");
+        super("master");
     }
 }
 ```
@@ -39,18 +39,17 @@ If you don't follow this rule an exception will be thrown:
 
 The users have a few ways to overcome this limitation available:
 
-### WORKAROUND A) Use the @unmanaged decorator 
+### WORKAROUND A) Use the @unmanaged decorator
+
 The `@unmanaged()` decorator allow users to flag that an argument will
-be manually injected into a base class. We use the word "unmanaged" 
-because InversifyJS does not have control under user provided values 
+be manually injected into a base class. We use the word "unmanaged"
+because InversifyJS does not have control under user provided values
 and it doesn't manage their injection.
 
 The following code snippet showcases how to apply this decorator:
 
 ```ts
-import { 
-    Container, injectable, unmanaged 
-} from "../src/inversify";
+import { Container, injectable, unmanaged } from "../src/inversify";
 
 const BaseId = "Base";
 
@@ -78,7 +77,7 @@ derived.prop; // "unmanaged-injected-value"
 
 ### WORKAROUND B) Property setter
 
-You can use the `public`, `protected` or `private` access modifier and a 
+You can use the `public`, `protected` or `private` access modifier and a
 property setter to avoid injecting into the base class:
 
 ```ts
@@ -93,8 +92,8 @@ class Warrior {
 @injectable()
 class SamuraiMaster extends Warrior {
     public constructor() { // args count = 0
-       super();
-	   this.rank = "master";
+        super();
+        this.rank = "master";
     }
 }
 ```
@@ -113,26 +112,26 @@ class Warrior {
 let TYPES = { Rank: "Rank" };
 
 @injectable()
-class SamuraiMaster extends Warrior  {
-
+class SamuraiMaster extends Warrior {
     @injectNamed(TYPES.Rank, "master")
     @named("master")
     protected rank: string;
-	
+
     public constructor() { // args count = 0
-       super();
+        super();
     }
 }
 
-container.bind<string>(TYPES.Rank)
-      .toConstantValue("master")
-	  .whenTargetNamed("master");
+container
+    .bind<string>(TYPES.Rank)
+    .toConstantValue("master")
+    .whenTargetNamed("master");
 ```
 
 ### WORKAROUND D) Inject into the derived class
 
-If we don't want to avoid injecting into the base class we can 
-inject into the derived class and then into the base class using 
+If we don't want to avoid injecting into the base class we can
+inject into the derived class and then into the base class using
 its constructor (super).
 
 ```ts
@@ -147,17 +146,18 @@ class Warrior {
 let TYPES = { Rank: "Rank" };
 
 @injectable()
-class SamuraiMaster extends Warrior  {
+class SamuraiMaster extends Warrior {
     public constructor(
-		@inject(TYPES.Rank) @named("master") rank: string // args count = 1
-	) {
-       super(rank);
+        @inject(TYPES.Rank) @named("master") rank: string // args count = 1
+    ) {
+        super(rank);
     }
 }
 
-container.bind<string>(TYPES.Rank)
-      .toConstantValue("master")
-	  .whenTargetNamed("master");
+container
+    .bind<string>(TYPES.Rank)
+    .toConstantValue("master")
+    .whenTargetNamed("master");
 ```
 
 The following should also work:
@@ -172,40 +172,40 @@ class Warrior {
 }
 
 interface Weapon {
-	name: string;
+    name: string;
 }
 
 @injectable()
 class Katana implements Weapon {
-	public name: string;
-	public constructor() {
-		this.name = "Katana";
-	}
+    public name: string;
+    public constructor() {
+        this.name = "Katana";
+    }
 }
 
-let TYPES = { 
+let TYPES = {
     Rank: "Rank",
-    Weapon: "Weapon"
+    Weapon: "Weapon",
 };
 
 @injectable()
-class SamuraiMaster extends Warrior  {
-	public weapon: Weapon;
+class SamuraiMaster extends Warrior {
+    public weapon: Weapon;
     public constructor(
-		@inject(TYPES.Rank) @named("master") rank: string, // args count = 2
-		@inject(TYPES.Weapon) weapon: Weapon
-	) {
-       super(rank);
-	   this.weapon = weapon;
+        @inject(TYPES.Rank) @named("master") rank: string, // args count = 2
+        @inject(TYPES.Weapon) weapon: Weapon
+    ) {
+        super(rank);
+        this.weapon = weapon;
     }
 }
 
 container.bind<Weapon>(TYPES.Weapon).to(Katana);
 
-container.bind<string>(TYPES.Rank)
-      .toConstantValue("master")
-      .whenTargetNamed("master");
-
+container
+    .bind<string>(TYPES.Rank)
+    .toConstantValue("master")
+    .whenTargetNamed("master");
 ```
 
 ### WORKAROUND E) Skip Base class `@injectable` checks
@@ -215,29 +215,26 @@ Setting the `skipBaseClassChecks` option to `true` for the container will disabl
 ```ts
 // Not injectable
 class UnmanagedBase {
-    public constructor(
-        public unmanagedDependency: string
-    ) {
-    }
+    public constructor(public unmanagedDependency: string) {}
 }
 
 @injectable()
-class InjectableDerived extends UnmanagedBase  {
-    public constructor(
-        // Any arguments defined here will be injected like normal
-    ) {
+class InjectableDerived extends UnmanagedBase {
+    public constructor() // Any arguments defined here will be injected like normal
+    {
         super("Don't forget me...");
     }
 }
 
-const container = new Container({skipBaseClassChecks: true});
+const container = new Container({ skipBaseClassChecks: true });
 container.bind(InjectableDerived).toSelf();
 ```
 
 This will work, and you'll be able to use your `InjectableDerived` class just like normal, including injecting dependencies from elsewhere in the container through the constructor. The one caveat is that you must make sure your `UnmanagedBase` receives the correct arguments.
 
 ## What can I do when my base class is provided by a third party module?
-In some cases, you may get errors about missing annotations in classes 
+
+In some cases, you may get errors about missing annotations in classes
 provided by a third party module like:
 
 > Error: Missing required @injectable annotation in: SamuraiMaster