Merge pull request microsoft#1108 from microsoft/a11y

Accessibility fixes

Author: Orta

pages/release notes/TypeScript 1.1.md

@@ -1,8 +1,8 @@
-# Performance Improvements
+## Performance Improvements
 
 The 1.1 compiler is typically around 4x faster than any previous release. See [this blog post for some impressive charts.](http://blogs.msdn.com/b/typescript/archive/2014/10/06/announcing-typescript-1-1-ctp.aspx)
 
-# Better Module Visibility Rules
+## Better Module Visibility Rules
 
 TypeScript now only strictly enforces the visibility of types in modules if the `--declaration` flag is provided. This is very useful for Angular scenarios, for example:
 
@@ -18,4 +18,4 @@ module MyControllers {
     /* more code */
   }
 }
-```
+```

pages/release notes/TypeScript 1.3.md

@@ -1,4 +1,4 @@
-# Protected
+## Protected
 
 The new `protected` modifier in classes works like it does in familiar languages like C++, C#, and Java. A `protected` member of a class is visible only inside subclasses of the class in which it is declared:
 
@@ -17,7 +17,7 @@ var t = new MyThing();
 t.doSomething(); // Error, cannot call protected member from outside class
 ```
 
-# Tuple types
+## Tuple types
 
 Tuple types express an array where the type of certain elements is known, but need not be the same. For example, you may want to represent an array with a `string` at position 0 and a `number` at position 1:
 
@@ -43,4 +43,4 @@ Note that in TypeScript 1.4, when accessing an element outside the set of known
 x[3] = 'world'; // OK
 console.log(x[5].toString()); // OK, 'string' and 'number' both have toString
 x[6] = true; // Error, boolean isn't number or string
-```
+```

pages/release notes/TypeScript 1.4.md

@@ -1,4 +1,4 @@
-# Union types
+## Union types
 
 ### Overview
 
@@ -79,7 +79,7 @@ x[0] = 'world'; // OK
 x[0] = false; // Error, boolean is not string or number
 ```
 
-# `let` declarations
+## `let` declarations
 
 In JavaScript, `var` declarations are "hoisted" to the top of their enclosing scope. This can result in confusing bugs:
 
@@ -103,7 +103,7 @@ else {
 
 `let` is only available when targeting ECMAScript 6 (`--target ES6`).
 
-# `const` declarations
+## `const` declarations
 
 The other new ES6 declaration type supported in TypeScript is `const`. A `const` variable may not be assigned to, and must be initialized where it is declared. This is useful for declarations where you don't want to change the value after its initialization:
 
@@ -114,7 +114,7 @@ halfPi = 2; // Error, can't assign to a `const`
 
 `const` is only available when targeting ECMAScript 6 (`--target ES6`).
 
-# Template strings
+## Template strings
 
 TypeScript now supports ES6 template strings. These are an easy way to embed arbitrary expressions in strings:
 
@@ -130,7 +130,7 @@ var name = "TypeScript!";
 var greeting = "Hello, " + name + "! Your name has " + name.length + " characters";
 ```
 
-# Type Guards
+## Type Guards
 
 A common pattern in JavaScript is to use `typeof` or `instanceof` to examine the type of an expression at runtime. TypeScript now understands these conditions and will change type inference accordingly when used in an `if` block.
 
@@ -172,7 +172,7 @@ else {
 }
 ```
 
-# Type Aliases
+## Type Aliases
 
 You can now define an *alias* for a type using the `type` keyword:
 
@@ -185,7 +185,7 @@ type Callback = () => void;
 
 Type aliases are exactly the same as their original types; they are simply alternative names.
 
-# `const enum` (completely inlined enums)
+## `const enum` (completely inlined enums)
 
 Enums are very useful, but some programs don't actually need the generated code and would benefit from simply inlining all instances of enum members with their numeric equivalents. The new `const enum` declaration works just like a regular `enum` for type safety, but erases completely at compile time.
 
@@ -213,13 +213,13 @@ enum MyFlags {
 var b = MyFlags.Best; // emits var b = 7;
 ```
 
-# `-noEmitOnError` commandline option
+## `-noEmitOnError` commandline option
 
 The default behavior for the TypeScript compiler is to still emit .js files if there were type errors (for example, an attempt to assign a `string` to a `number`). This can be undesirable on build servers or other scenarios where only output from a "clean" build is desired. The new flag `noEmitOnError` prevents the compiler from emitting .js code if there were any errors.
 
 This is now the default for MSBuild projects; this allows MSBuild incremental build to work as expected, as outputs are only generated on clean builds.
 
-# AMD Module names
+## AMD Module names
 
 By default AMD modules are generated anonymous. This can lead to problems when other tools are used to process the resulting modules like a bundlers (e.g. `r.js`).
 

pages/release notes/TypeScript 1.5.md

@@ -1,4 +1,4 @@
-# ES6 Modules
+## ES6 Modules
 
 TypeScript 1.5 supports ECMAScript 6 (ES6) modules.
 ES6 modules are effectively TypeScript external modules with a new syntax: ES6 modules are separately loaded source files that possibly import other modules and provide a number of externally accessible exports.
@@ -78,7 +78,7 @@ import "./polyfills";
 
 For more information about module, please see the [ES6 module support spec](https://github.com/Microsoft/TypeScript/issues/2242).
 
-# Destructuring in declarations and assignments
+## Destructuring in declarations and assignments
 
 TypeScript 1.5 adds support to ES6 destructuring declarations and assignments.
 
@@ -121,7 +121,7 @@ var y = 2;
 [x, y] = [y, x];
 ```
 
-# `namespace` keyword
+## `namespace` keyword
 
 TypeScript used the `module` keyword to define both "internal modules" and "external modules";
 this has been a bit of confusion for developers new to TypeScript.
@@ -145,7 +145,7 @@ namespace Math {
 }
 ```
 
-# `let` and `const` support
+## `let` and `const` support
 
 ES6 `let` and `const` declarations are now supported when targeting ES3 and ES5.
 
@@ -173,7 +173,7 @@ else {
 alert(a); // Error: a is not defined in this scope.
 ```
 
-# for..of support
+## for..of support
 
 TypeScript 1.5 adds support to ES6 for..of loops on arrays for ES3/ES5 as well as full support for Iterator interfaces when targeting ES6.
 
@@ -193,7 +193,7 @@ for (var _i = 0, _a = expr; _i < _a.length; _i++) {
 }
 ```
 
-# Decorators
+## Decorators
 
 > TypeScript decorators are based on the [ES7 decorator proposal](https://github.com/wycats/javascript-decorators).
 
@@ -229,7 +229,7 @@ function enumerable(value) {
 }
 ```
 
-# Computed properties
+## Computed properties
 
 Initializing an object with dynamic properties can be a bit of a burden. Take the following example:
 
@@ -258,7 +258,7 @@ function makeNode(name: string, initialNeighbor: Node): Node {
 }
 ```
 
-# Support for `UMD` and `System` module output
+## Support for `UMD` and `System` module output
 
 In addition to `AMD` and `CommonJS` module loaders, TypeScript now supports emitting modules `UMD` ([Universal Module Definition](https://github.com/umdjs/umd)) and [`System`](https://github.com/systemjs/systemjs) module formats.
 
@@ -269,7 +269,7 @@ and
 
 > tsc --module system
 
-# Unicode codepoint escapes in strings
+## Unicode codepoint escapes in strings
 
 ES6 introduces escapes that allow users to represent a Unicode codepoint using just a single escape.
 
@@ -281,7 +281,7 @@ This has the major downside that it’s difficult to discern two independent cha
 With ES6’s codepoint escapes, you can cleanly represent that exact character in strings and template strings with a single escape: `"\u{20bb7}"`.
 TypeScript will emit the string in ES3/ES5 as `"\uD842\uDFB7"`.
 
-# Tagged template strings in ES3/ES5
+## Tagged template strings in ES3/ES5
 
 In TypeScript 1.4, we added support for template strings for all targets, and tagged templates for just ES6.
 Thanks to some considerable work done by [@ivogabe](https://github.com/ivogabe), we bridged the gap for for tagged templates in ES3 and ES5.
@@ -308,7 +308,7 @@ function oddRawStrings(strs, n1, n2) {
 var _a;
 ```
 
-# AMD-dependency optional names
+## AMD-dependency optional names
 
 `/// <amd-dependency path="x" />` informs the compiler about a non-TS module dependency that needs to be injected in the resulting module's require call;
 however, there was no way to consume this module in the TS code.
@@ -329,7 +329,7 @@ define(["require", "exports", "legacy/moduleA"], function (require, exports, mod
 });
 ```
 
-# Project support through `tsconfig.json`
+## Project support through `tsconfig.json`
 
 Adding a `tsconfig.json` file in a directory indicates that the directory is the root of a TypeScript project.
 The tsconfig.json file specifies the root files and the compiler options required to compile the project. A project is compiled in one of the following ways:
@@ -351,7 +351,7 @@ The tsconfig.json file specifies the root files and the compiler options require
 
 See the [tsconfig.json wiki page](https://github.com/Microsoft/TypeScript/wiki/tsconfig.json) for more details.
 
-# `--rootDir` command line option
+## `--rootDir` command line option
 
 Option `--outDir` duplicates the input hierarchy in the output.
 The compiler computes the root of the input files as the longest common path of all input files;
@@ -362,18 +362,18 @@ Now if a new file `FolderA\3.ts` is added to the input, the output structure wil
 
 `--rootDir` specifies the input directory to be mirrored in output instead of computing it.
 
-# `--noEmitHelpers` command line option
+## `--noEmitHelpers` command line option
 
 The TypeSript compiler emits a few helpers like `__extends` when needed.
 The helpers are emitted in every file they are referenced in.
 If you want to consolidate all helpers in one place, or override the default behavior, use `--noEmitHelpers` to instructs the compiler not to emit them.
 
-# `--newLine` command line option
+## `--newLine` command line option
 
 By default the output new line character is `\r\n` on Windows based systems and `\n` on *nix based systems.
 `--newLine` command line flag allows overriding this behavior and specifying the new line character to be used in generated output files.
 
-# `--inlineSourceMap` and `inlineSources` command line options
+## `--inlineSourceMap` and `inlineSources` command line options
 
 `--inlineSourceMap` causes source map files to be written inline in the generated `.js` files instead of in a independent `.js.map` file.
 `--inlineSources` allows for additionally inlining the source `.ts` file into the `.js` file.

pages/release notes/TypeScript 1.6.md

@@ -1,4 +1,4 @@
-# JSX support
+## JSX support
 
 JSX is an embeddable XML-like syntax.
 It is meant to be transformed into valid JavaScript, but the semantics of that transformation are implementation-specific.
@@ -52,7 +52,7 @@ TypeScript ships with two JSX modes: `preserve` and `react`.
 
 See the [[JSX]] wiki page for more information on using JSX in TypeScript.
 
-# Intersection types
+## Intersection types
 
 TypeScript 1.6 introduces intersection types, the logical complement of union types.
 A union type `A | B` represents an entity that is either of type `A` or type `B`, whereas an intersection type `A & B` represents an entity that is both of type `A` *and* type `B`.
@@ -105,7 +105,7 @@ abc.c = "hello";
 
 See [issue #1256](https://github.com/Microsoft/TypeScript/issues/1256) for more information.
 
-# Local type declarations
+## Local type declarations
 
 Local class, interface, enum, and type alias declarations can now appear inside function declarations. Local types are block scoped, similar to variables declared with `let` and `const`. For example:
 
@@ -165,7 +165,7 @@ function f3() {
 }
 ```
 
-# Class expressions
+## Class expressions
 
 TypeScript 1.6 adds support for ES6 class expressions. In a class expression, the class name is optional and, if specified, is only in scope in the class expression itself. This is similar to the optional name of a function expression. It is not possible to refer to the class instance type of a class expression outside the class expression, but the type can of course be matched structurally. For example:
 
@@ -180,7 +180,7 @@ var p = new Point(3, 4);  // p has anonymous class type
 console.log(p.length());
 ```
 
-# Extending expressions
+## Extending expressions
 
 TypeScript 1.6 adds support for classes extending arbitrary expression that computes a constructor function. This means that built-in types can now be extended in class declarations.
 
@@ -223,7 +223,7 @@ class Test extends getGreeterBase() {
 }
 ```
 
-# `abstract` classes and methods
+## `abstract` classes and methods
 
 TypeScript 1.6 adds support for `abstract` keyword for classes and their methods. An abstract class is allowed to have methods with no implementation, and cannot be constructed.
 
@@ -253,7 +253,7 @@ y.getThing(); // OK
 y.getOtherThing(); // OK
 ```
 
-# Generic type aliases
+## Generic type aliases
 
 With TypeScript 1.6, type aliases can be generic. For example:
 
@@ -272,7 +272,7 @@ interface Tuple<A, B> {
 type Pair<T> = Tuple<T, T>;
 ```
 
-# Stricter object literal assignment checks
+## Stricter object literal assignment checks
 
 TypeScript 1.6 enforces stricter object literal assignment checks for the purpose of catching excess or misspelled properties. Specifically, when a fresh object literal is assigned to a variable or passed as an argument for a non-empty target type, it is an error for the object literal to specify properties that don't exist in the target type.
 
@@ -293,7 +293,7 @@ var x: { foo: number, [x: string]: any };
 x = { foo: 1, baz: 2 };  // Ok, `baz` matched by index signature
 ```
 
-# ES6 generators
+## ES6 generators
 
 TypeScript 1.6 adds support for generators when targeting ES6.
 
@@ -320,7 +320,7 @@ function *g() {
 }
 ```
 
-# Experimental support for `async` functions
+## Experimental support for `async` functions
 
 TypeScript 1.6 introduces experimental support of `async` functions when targeting ES6.
 Async functions are expected to invoke an asynchronous operation and await its result without blocking normal execution of the program.
@@ -358,15 +358,15 @@ class C {
 }
 ```
 
-# Nightly builds
+## Nightly builds
 
 While not strictly a language change, nightly builds are now available by installing with the following command:
 
 ```Shell
 npm install -g typescript@next
 ```
 
-# Adjustments in module resolution logic
+## Adjustments in module resolution logic
 
 Starting from release 1.6 TypeScript compiler will use different set of rules to resolve module names when targeting 'commonjs'.
 These [rules](https://github.com/Microsoft/TypeScript/issues/2338) attempted to model module lookup procedure used by Node.
@@ -376,7 +376,7 @@ User however can override module resolution rules picked by the compiler by usin
 * 'classic' - module resolution rules used by pre 1.6 TypeScript compiler
 * 'node' - node-like module resolution
 
-# Merging ambient class and interface declaration
+## Merging ambient class and interface declaration
 
 The instance side of an ambient class declaration can be extended using an interface declaration The class constructor object is unmodified.
 For example:
@@ -396,7 +396,7 @@ function bar(foo : Foo)  {
 }
 ```
 
-# User-defined type guard functions
+## User-defined type guard functions
 
 TypeScript 1.6 adds a new way to narrow a variable type inside an `if` block, in addition to `typeof` and `instanceof`.
 A user-defined type guard functions is one with a return type annotation of the form `x is T`, where `x` is a declared parameter in the signature, and `T` is any type.
@@ -415,7 +415,7 @@ if(isCat(x)) {
 }
 ```
 
-# `exclude` property support in tsconfig.json
+## `exclude` property support in tsconfig.json
 
 A tsconfig.json file that doesn't specify a files property (and therefore implicitly references all *.ts files in all subdirectories) can now contain an exclude property that specifies a list of files and/or directories to exclude from the compilation.
 The exclude property must be an array of strings that each specify a file or folder name relative to the location of the tsconfig.json file.
@@ -436,7 +436,7 @@ For example:
 
 The `exclude` list does not support wilcards. It must simply be a list of files and/or directories.
 
-# `--init` command line option
+## `--init` command line option
 
 Run `tsc --init` in a directory to create an initial `tsconfig.json` in this directory with preset defaults.
-Optionally pass command line arguments along with `--init` to be stored in your initial tsconfig.json on creation.
+Optionally pass command line arguments along with `--init` to be stored in your initial tsconfig.json on creation.