fixing var compilation issue in docs

docs/js/classes.md

@@ -10,7 +10,7 @@ down to JavaScript that works across all major browsers and platforms, without h
 
 Let's take a look at a simple class-based example:
 
-```ts
+```typescript
 class Greeter {
     greeting: string;
     constructor(message: string) {
@@ -43,7 +43,7 @@ Of course, one of the most fundamental patterns in class-based programming is be
 
 Let's take a look at an example:
 
-```ts-ignore
+```typescript-ignore
 class Animal {
     name: string;
     constructor(theName: string) { this.name = theName; }
@@ -105,7 +105,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:
 
-```ts-ignore
+```typescript-ignore
 class Animal {
     public name: string;
     public constructor(theName: string) { this.name = theName; }
@@ -119,7 +119,7 @@ class Animal {
 
 When a member is marked `private`, it cannot be accessed from outside of its containing class. For example:
 
-```ts-ignore
+```typescript-ignore
 class Animal {
     private name: string;
     constructor(theName: string) { this.name = theName; }
@@ -138,7 +138,7 @@ The same applies to `protected` members.
 
 Let's look at an example to better see how this plays out in practice:
 
-```ts-ignore
+```typescript-ignore
 class Animal {
     private name: string;
     constructor(theName: string) { this.name = theName; }
@@ -174,7 +174,7 @@ Even though `Employee` also has a `private` member called `name`, it's not the o
 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,
 
-```ts-ignore
+```typescript-ignore
 class Person {
     protected name: string;
     constructor(name: string) { this.name = name; }
@@ -204,7 +204,7 @@ we can still use it from within an instance method of `Employee` because `Employ
 A constructor may also be marked `protected`.
 This means that the class cannot be instantiated outside of its containing class, but can be extended. For example,
 
-```ts-ignore
+```typescript-ignore
 class Person {
     protected name: string;
     protected constructor(theName: string) { this.name = theName; }
@@ -233,7 +233,7 @@ let john = new Person("John"); // Error: The 'Person' constructor is protected
 You can make properties readonly by using the `readonly` keyword.
 Readonly properties must be initialized at their declaration or in the constructor.
 
-```ts-ignore
+```typescript-ignore
 class Octopus {
     readonly name: string;
     readonly numberOfLegs: number = 8;
@@ -252,7 +252,7 @@ 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 `Octopus` class using a parameter property:
 
-```ts-ignore
+```typescript-ignore
 class Octopus {
     readonly numberOfLegs: number = 8;
     constructor(readonly name: string) {

docs/js/functions.md

@@ -3,7 +3,7 @@
 Functions are the fundamental building block of programs. Here is the simplest
 way to make a function that adds two numbers:
 
-```ts
+```typescript
 // Named function
 function add(x : number, y : number) {
     return x + y;
@@ -19,7 +19,7 @@ For the @boardname@, you must specify a [type](/js/types) for each function para
 Functions can refer to variables outside of the function body.
 When they do so, they're said to `capture` these variables.
 
-```ts
+```typescript
 let z = 100;
 
 function addToZ(x: number, y: number) {
@@ -33,7 +33,7 @@ basic.showNumber(addToZ(1, 2))
 
 Let's add a return type to our add function:
 
-```ts
+```typescript
 function add(x: number, y: number): number {
     return x + y;
 }
@@ -45,7 +45,7 @@ TypeScript can figure the return type out by looking at the return statements, s
 
 In TypeScript, the number of arguments given to a function has to match the number of parameters the function expects.
 
-```ts-ignore
+```typescript-ignore
 function buildName(firstName: string, lastName: string) {
     return firstName + " " + lastName;
 }
@@ -60,7 +60,7 @@ When they do, their value is `undefined`.
 We can get this functionality in TypeScript by adding a `?` to the end of parameters we want to be optional.
 For example, let's say we want the last name parameter from above to be optional:
 
-```ts-ignore
+```typescript-ignore
 function buildName(firstName: string, lastName?: string) {
     if (lastName)
         return firstName + " " + lastName;
@@ -80,7 +80,7 @@ In TypeScript, we can also set a value that a parameter will be assigned if the
 These are called default-initialized parameters.
 Let's take the previous example and default the last name to `"Smith"`.
 
-```ts-ignore
+```typescript-ignore
 function buildName(firstName: string, lastName = "Smith") {
     return firstName + " " + lastName;
 }
@@ -94,7 +94,7 @@ let result4 = buildName("Bob", "Adams");         // ah, just right
 Default-initialized parameters that come after all required parameters are treated as optional, and just like optional parameters, can be omitted when calling their respective function.
 This means optional parameters and trailing default parameters will share commonality in their types, so both
 
-```ts
+```typescript
 function buildName(firstName: string, lastName?: string) {
     // ...
 }
@@ -102,7 +102,7 @@ function buildName(firstName: string, lastName?: string) {
 
 and
 
-```ts
+```typescript
 function buildName(firstName: string, lastName = "Smith") {
     // ...
 }
@@ -115,7 +115,7 @@ Unlike plain optional parameters, default-initialized parameters don't *need* to
 If a default-initialized parameter comes before a required parameter, users need to explicitly pass `undefined` to get the default initialized value.
 For example, we could write our last example with only a default initializer on `firstName`:
 
-```ts-ignore
+```typescript-ignore
 function buildName(firstName = "Will", lastName: string) {
     return firstName + " " + lastName;
 }
@@ -134,7 +134,7 @@ In JavaScript, you can work with the arguments directly using the `arguments` va
 
 In TypeScript, you can gather these arguments together into a variable:
 
-```ts-ignore
+```typescript-ignore
 function buildName(firstName: string, ...restOfName: string[]) {
     return firstName + " " + restOfName.join(" ");
 }
@@ -148,7 +148,7 @@ The compiler will build an array of the arguments passed in with the name given
 
 The ellipsis is also used in the type of the function with rest parameters:
 
-```ts-ignore
+```typescript-ignore
 function buildName(firstName: string, ...restOfName: string[]) {
     return firstName + " " + restOfName.join(" ");
 }

docs/js/types.md

@@ -7,7 +7,7 @@ numbers, strings, structures, boolean values, and the like.
 
 The most basic datatype is the simple true/false value, which is called a `boolean` value.
 
-```ts
+```typescript
 let isDone: boolean = false;
 ```
 
@@ -20,7 +20,7 @@ However, for the @boardname@, `numbers` are integer values.
 
 Integer values can be specified via decimal, hexadecimal and octal notation:
 
-```ts
+```typescript
 let decimal: number = 42;
 let hex: number = 0xf00d;
 let binary: number = 0b1010;
@@ -32,7 +32,7 @@ let octal: number = 0o744;
 As in other languages, we use the type `string` to refer to textual data.
 Use double quotes (`"`) or single quotes (`'`) to surround string data.
 
-```ts
+```typescript
 let color: string = "blue";
 color = 'red';
 ```
@@ -40,7 +40,7 @@ color = 'red';
 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 }`.
 
-```ts
+```typescript
 let fullName: string = `Bob Bobbington`;
 let age: number = 37;
 let sentence: string = `Hello, my name is ${ fullName }.
@@ -50,7 +50,7 @@ I'll be ${ age + 1 } years old next month.`
 
 This is equivalent to declaring `sentence` like so:
 
-```ts
+```typescript
 let fullName: string = `Bob Bobbington`;
 let age: number = 37;
 let sentence: string = "Hello, my name is " + fullName + ".\n\n" +
@@ -63,13 +63,13 @@ Arrays allow you to work with an expandable sequence of values, addressed by an
 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:
 
-```ts
+```typescript
 let list: number[] = [1, 2, 3];
 ```
 
 The second way uses a generic array type, `Array<elemType>`:
 
-```ts
+```typescript
 let list: Array<number> = [1, 2, 3];
 ```
 
@@ -83,7 +83,7 @@ For the @boardname@, all elements of an array must have the same type.
 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.
 
-```ts
+```typescript
 enum Color {Red, Green, Blue}
 let c: Color = Color.Green;
 ```
@@ -92,14 +92,14 @@ By default, enums begin numbering their members starting at `0`.
 You can change this by manually setting the value of one of its members.
 For example, we can start the previous example at `1` instead of `0`:
 
-```ts
+```typescript
 enum Color {Red = 1, Green, Blue}
 let c: Color = Color.Green;
 ```
 
 Or, even manually set all the values in the enum:
 
-```ts
+```typescript
 enum Color {Red = 1, Green = 2, Blue = 4}
 let c: Color = Color.Green;
 ```
@@ -114,7 +114,7 @@ The TypeScript type `any` is not supported in the @boardname@.
 `void` is 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:
 
-```ts
+```typescript
 function warnUser(): void {
     basic.showString("This is my warning message");
 }
@@ -127,7 +127,7 @@ Declaring variables of type `void` is not useful.
 In TypeScript, there are several places where type inference is used to provide type information when there is
 no explicit type annotation. For example, in this code
 
-```ts
+```typescript
 let x = 3;
 let y = x + 3
 ```

docs/js/variables.md

@@ -1,8 +1,16 @@
 # Variable Declarations
 
+Declaring a variable should be done using the ``let`` keyworld:
+
+```typescript
+let a = 10;
+```
+
+## ``var`` vs ``let``
+
 Declaring a variable in JavaScript has always traditionally been done with the `var` keyword.
 
-```typescript
+```typescript-ignore
 var a = 10;
 ```
 

docs/lessons/headbands/quiz.md

@@ -39,8 +39,8 @@ coll.push("cat")
 
 ## 4. Write the five (5) lines of code that will add the following five words to `data->coll`: puppy, clock, night, cat, cow.
 
-```ts
-let coll = (<string[]>[])
+```typescript
+let coll : string[] = [];
 ```
 
 <br/>