evalcode
diff --git a/‎pages/Basic Types.md‎
Lines changed: 19 additions & 19 deletions b/‎pages/Basic Types.md‎
Lines changed: 19 additions & 19 deletions
diff --git a/‎pages/Classes.md‎
Lines changed: 16 additions & 16 deletions b/‎pages/Classes.md‎
Lines changed: 16 additions & 16 deletions
diff --git a/‎pages/Declaration Merging.md‎
Lines changed: 9 additions & 9 deletions b/‎pages/Declaration Merging.md‎
Lines changed: 9 additions & 9 deletions
@@ -7,7 +7,7 @@ In TypeScript, we support much the same types as you would expected in JavaScrip
 
 The most basic datatype is the simple true/false value, which JavaScript and TypeScript (as well as other languages) call a `boolean` value.
 
-```TypeScript
+```ts
 var isDone: boolean = false;
 ```
 
@@ -17,7 +17,7 @@ As in JavaScript, all numbers in TypeScript are floating point values.
 These floating point numbers get the type `number`.
 In addition to hexadecimal and decimal literals, TypeScript also supports binary and octal literals introduced in ECMAScript 2015.
 
-```TypeScript
+```ts
 var decLiteral: number = 6;
 var hexLiteral: number = 0x9837abdef;
 var binaryLiteral: number = 0b0010;
@@ -30,15 +30,15 @@ Another fundamental part of creating programs in JavaScript for webpages and ser
 As in other languages, we use the type `string` to refer to these textual datatypes.
 Just like JavaScript, TypeScript also uses the double quote (`"`) or single quote (`'`) to surround string data.
 
-```TypeScript
+```ts
 var name: string = "bob";
 name = 'smith';
 ```
 
 You can also use *template strings*, which can span multiple lines and have embedded expressions.
 These strings are surrounded by the backtick/backquote (`` ` ``) character, and embedded expressions are of the form `${ expr }`
 
-```TypeScript
+```ts
 var name: string = `Gene`;
 var age: number = 37;
 var sentence: string = `Hello, my name is ${ name }.
@@ -48,7 +48,7 @@ I'll be ${ age + 1 } years old next month.`
 
 This is equivalent to declaring `sentence` like so:
 
-```TypeScript
+```ts
 var sentence: string = "Hello, my name is " + name + ".\n\n" +
     "I'll be " + (age + 1) + " years old next month."
 ```
@@ -59,13 +59,13 @@ TypeScript, like JavaScript, allows you to work with arrays of values.
 Array types can be written in one of two ways.
 In the first, you use the type of the elements followed by `[]` to denote an array of that element type:
 
-```TypeScript
+```ts
 var list: number[] = [1, 2, 3];
 ```
 
 The second way uses a generic array type, `Array<elemType>`:
 
-```TypeScript
+```ts
 var list: Array<number> = [1, 2, 3];
 ```
 
@@ -74,7 +74,7 @@ var list: Array<number> = [1, 2, 3];
 Tuple types allow you to express an array where the type of a fixed number of elements is known, but need not be the same.
 For example, you may want to represent a value as a pair of a `string` and a `number`:
 
-```TypeScript
+```ts
 // Declare a tuple type
 var x: [string, number];
 // Initialize it
@@ -85,14 +85,14 @@ x = [10, 'hello']; // Error
 
 When accessing an element with a known index, the correct type is retrieved:
 
-```TypeScript
+```ts
 console.log(x[0].substr(1)); // OK
 console.log(x[1].substr(1)); // Error, 'number' does not have 'substr'
 ```
 
 When accessing an element outside the set of known indices, a union type is used instead:
 
-```TypeScript
+```ts
 x[3] = 'world'; // OK, string can be assigned to (string | number)
 console.log(x[5].toString()); // OK, 'string' and 'number' both have toString
 x[6] = true; // Error, boolean isn't (string | number)
@@ -105,7 +105,7 @@ Union types are an advanced topic that we'll cover in a later chapter.
 A helpful addition to the standard set of datatypes from JavaScript is the `enum`.
 As in languages like C#, an enum is a way of giving more friendly names to sets of numeric values.
 
-```TypeScript
+```ts
 enum Color {Red, Green, Blue};
 var c: Color = Color.Green;
 ```
@@ -114,22 +114,22 @@ By default, enums begin numbering their members starting at `0`.
 You can change this by manually setting the value of one its members.
 For example, we can start the previous example at `1` instead of `0`:
 
-```TypeScript
+```ts
 enum Color {Red = 1, Green, Blue};
 var c: Color = Color.Green;
 ```
 
 Or, even manually set all the values in the enum:
 
-```TypeScript
+```ts
 enum Color {Red = 1, Green = 2, Blue = 4};
 var c: Color = Color.Green;
 ```
 
 A handy feature of enums is that you can also go from a numeric value to the name of that value in the enum.
 For example, if we had the value `2` but weren't sure what that mapped to in the `Color` enum above, we could look up the corresponding name:
 
-```TypeScript
+```ts
 enum Color {Red = 1, Green, Blue};
 var colorName: string = Color[2];
 
@@ -143,7 +143,7 @@ These values may come from dynamic content, e.g. from the user or a 3rd party li
 In these cases, we want to opt-out of type-checking and let the values pass through compile-time checks.
 To do so, we label these with the `any` type:
 
-```TypeScript
+```ts
 var notSure: any = 4;
 notSure = "maybe a string instead";
 notSure = false; // okay, definitely a boolean
@@ -153,7 +153,7 @@ The `any` type is a powerful way to work with existing JavaScript, allowing you
 You might expect `Object` to play a similar role, as it does in other languages.
 But variables of type `Object` only allow you to assign any value to them -- you can't call arbitrary methods on them, even ones that actually exist:
 
-```TypeScript
+```ts
 var notSure: any = 4;
 notSure.ifItExists(); // okay, ifItExists might exist at runtime
 notSure.toFixed(); // okay, toFixed exists (but the compiler doesn't check)
@@ -164,7 +164,7 @@ prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object
 The `any` type is also handy if you know some part of the type, but perhaps not all of it.
 For example, you may have an array but the array has a mix of different types:
 
-```TypeScript
+```ts
 var list: any[] = [1, true, "free"];
 
 list[1] = 100;
@@ -175,14 +175,14 @@ list[1] = 100;
 `void` is a little like the opposite of `any`: the absence of having any type at all.
 You may commonly see this as the return type of functions that do not return a value:
 
-```TypeScript
+```ts
 function warnUser(): void {
     alert("This is my warning message");
 }
 ```
 
 Declaring variables of type `void` is not useful because you can only assign `undefined` or `null` to them:
 
-```TypeScript
+```ts
 var unusable: void = undefined;
 ```
@@ -8,7 +8,7 @@ In TypeScript, we allow developers to use these techniques now, and compile them
 
 Let's take a look at a simple class-based example:
 
-```TypeScript
+```ts
 class Greeter {
     greeting: string;
     constructor(message: string) {
@@ -38,7 +38,7 @@ Of course, one of the most fundamental patterns in class-based programming is be
 
 Let's take a look at an example:
 
-```TypeScript
+```ts
 class Animal {
     name:string;
     constructor(theName: string) { this.name = theName; }
@@ -97,7 +97,7 @@ In TypeScript, each member is `public` by default.
 You may still mark a member `public` explicitly.
 We could have written the `Animal` class from the previous section in the following way:
 
-```TypeScript
+```ts
 class Animal {
     public name: string;
     public constructor(theName: string) { this.name = theName; }
@@ -111,7 +111,7 @@ class Animal {
 
 When a member is marked `private`, it cannot be accessed from outside of its containing class. For example:
 
-```TypeScript
+```ts
 class Animal {
     private name: string;
     constructor(theName: string) { this.name = theName; }
@@ -129,7 +129,7 @@ The same applies to `protected` members.
 
 Let's look at an example to better see how this plays out in practice:
 
-```TypeScript
+```ts
 class Animal {
     private name: string;
     constructor(theName: string) { this.name = theName; }
@@ -163,7 +163,7 @@ Even though `Employee` also has a `private` member called `name`, it's not the a
 
 The `protected` modifier acts much like the `private` modifier with the exception that members declared `protected` can also be accessed by instances of deriving classes. For example,
 
-```TypeScript
+```ts
 class Person {
     protected name: string;
     constructor(name: string) { this.name = name; }
@@ -195,7 +195,7 @@ In our last example, we had to declare a private member `name` and a constructor
 This turns out to be a very common practice. *Parameter properties* let you create and initialize a member in one place.
 Here's a further revision of the previous `Animal` class using a parameter property:
 
-```TypeScript
+```ts
 class Animal {
     constructor(private name: string) { }
     move(distanceInMeters: number) {
@@ -218,7 +218,7 @@ This gives you a way of having finer-grained control over how a member is access
 Let's convert a simple class to use `get` and `set`.
 First, let's start with an example without getters and setters.
 
-```TypeScript
+```ts
 class Employee {
     fullName: string;
 }
@@ -236,7 +236,7 @@ In this version, we check to make sure the user has a secret passcode available
 We do this by replacing the direct access to `fullName` with a `set` that will check the passcode.
 We add a corresponding `get` to allow the previous example to continue to work seamlessly.
 
-```TypeScript
+```ts
 var passcode = "secret passcode";
 
 class Employee {
@@ -275,7 +275,7 @@ In this example, we use `static` on the origin, as it's a general value for all
 Each instance accesses this value through prepending the name of the class.
 Similarly to prepending `this.` in front of instance accesses, here we prepend `Grid.` in front of static accesses.
 
-```TypeScript
+```ts
 class Grid {
     static origin = {x: 0, y: 0};
     calculateDistanceFromOrigin(point: {x: number; y: number;}) {
@@ -300,7 +300,7 @@ They may not be instantiated directly.
 Unlike an interface, an abstract class may contain implementation details for its members.
 The `abstract` keyword is used to define abstract classes as well as abstract methods within an abstract class.
 
-```TypeScript
+```ts
 abstract class Animal {
     abstract makeSound(): void;
     move(): void {
@@ -314,7 +314,7 @@ Abstract methods share a similar syntax to interface methods.
 Both define the signature of a method without including a method body.
 However, abstract methods must include the `abstract` keyword and may optionally include access modifiers.
 
-```TypeScript
+```ts
 abstract class Department {
 
     constructor(public name: string) {
@@ -357,7 +357,7 @@ department.generateReports(); // error: method doesn't exist on declared abstrac
 When you declare a class in TypeScript, you are actually creating multiple declarations at the same time.
 The first is the type of the *instance* of the class.
 
-```TypeScript
+```ts
 class Greeter {
     greeting: string;
     constructor(message: string) {
@@ -380,7 +380,7 @@ We're also creating another value that we call the *constructor function*.
 This is the function that is called when we `new` up instances of the class.
 To see what this looks like in practice, let's take a look at the JavaScript created by the above example:
 
-```TypeScript
+```ts
 var Greeter = (function () {
     function Greeter(message) {
         this.greeting = message;
@@ -403,7 +403,7 @@ Another way to think of each class is that there is an *instance* side and a *st
 
 Let's modify the example a bit to show this difference:
 
-```TypeScript
+```ts
 class Greeter {
     static standardGreeting = "Hello, there";
     greeting: string;
@@ -444,7 +444,7 @@ We show this by using `new` on `greeterMaker`, creating new instances of `Greete
 As we said in the previous section, a class declaration creates two things: a type representing instances of the class and a constructor function.
 Because classes create types, you can use them in the same places you would be able to use interfaces.
 
-```TypeScript
+```ts
 class Point {
     x: number;
     y: number;
 
@@ -35,7 +35,7 @@ Understanding what is created with each declaration will help you understand wha
 The simplest, and perhaps most common, type of declaration merging is interface merging.
 At the most basic level, the merge mechanically joins the members of both declarations into a single interface with the same name.
 
-```TypeScript
+```ts
 interface Box {
     height: number;
     width: number;
@@ -56,7 +56,7 @@ Of note, too, is that in the case of interface `A` merging with later interface
 
 That is, in the example:
 
-```TypeScript
+```ts
 interface Document {
     createElement(tagName: any): Element;
 }
@@ -73,7 +73,7 @@ interface Document {
 The two interfaces will merge to create a single declaration.
 Notice that the elements of each group maintains the same order, just the groups themselves are merged with later overload sets coming first:
 
-```TypeScript
+```ts
 interface Document {
     createElement(tagName: "div"): HTMLDivElement;
     createElement(tagName: "span"): HTMLSpanElement;
@@ -95,7 +95,7 @@ To merge the value, at each declaration site, if a namespace already exists with
 
 The declaration merge of `Animals` in this example:
 
-```TypeScript
+```ts
 namespace Animals {
     export class Zebra { }
 }
@@ -108,7 +108,7 @@ namespace Animals {
 
 is equivalent to:
 
-```TypeScript
+```ts
 namespace Animals {
     export interface Legged { numberOfLegs: number; }
 
@@ -122,7 +122,7 @@ Non-exported members are only visible in the original (un-merged) namespace. Thi
 
 We can see this more clearly in this example:
 
-```TypeScript
+```ts
 namespace Animal {
     var haveMuscles = true;
 
@@ -150,7 +150,7 @@ TypeScript uses this capability to model some of patterns in JavaScript as well
 The first namespace merge we'll cover is merging a namespace with a class.
 This gives the user a way of describing inner classes.
 
-```TypeScript
+```ts
 class Album {
     label: Album.AlbumLabel;
 }
@@ -166,7 +166,7 @@ You can also use namespaces to add more static members to an existing class.
 In addition to the pattern of inner classes, you may also be familiar with JavaScript practice of creating a function and then extending the function further by adding properties onto the function.
 TypeScript uses declaration merging to build up definitions like this in a type-safe way.
 
-```TypeScript
+```ts
 function buildLabel(name: string): string {
     return buildLabel.prefix + name + buildLabel.suffix;
 }
@@ -181,7 +181,7 @@ alert(buildLabel("Sam Smith"));
 
 Similarly, namespaces can be used to extend enums with static members:
 
-```TypeScript
+```ts
 enum Color {
     red = 1,
     green = 2,