chore(changelog): update change log to alpha-45

chore: bump version to 2.0.0-alpha.45
2015-10-28 17:36:56 -07:00 · 2015-10-28 17:32:43 -07:00
2646 changed files with 159466 additions and 179175 deletions
--- a/.bowerrc
+++ b/.bowerrc
@ -1,3 +1,3 @@
 {
-  "directory" : "bower_components"
-}
+  "directory": "bower_components"
+}
--- a/.gitattributes
+++ b/.gitattributes
@ -1,9 +1,5 @@
 # Auto detect text files and perform LF normalization
 * text=auto

-# JS and TS files must always use LF for tools to work
+# JS files must always use LF for tools to work
 *.js eol=lf
-*.ts eol=lf
-
-# Must keep Windows line ending to be parsed correctly
-scripts/windows/packages.txt eol=crlf
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@ -1,39 +0,0 @@
-<!--
-IF YOU DON'T FILL OUT THE FOLLOWING INFORMATION WE MIGHT CLOSE YOUR ISSUE WITHOUT INVESTIGATING
-->
-
-**I'm submitting a ...**  (check one with "x")
-```
-[ ] bug report => search github for a similar issue or PR before submitting
-[ ] feature request
-[ ] support request => Please do not submit support request here, instead see https://github.com/angular/angular/blob/master/CONTRIBUTING.md#question
-```
-
-**Current behavior**
-<!-- Describe how the bug manifests. -->
-
-**Expected behavior**
-<!-- Describe what the behavior would be without the bug. -->
-
-**Minimal reproduction of the problem with instructions**
-<!--
-If the current behavior is a bug or you can illustrate your feature request better with an example, 
-please provide the *STEPS TO REPRODUCE* and if possible a *MINIMAL DEMO* of the problem via
-https://plnkr.co or similar (you can use this template as a starting point: http://plnkr.co/edit/tpl:AvJOMERrnz94ekVua0u5).
-->
-
-**What is the motivation / use case for changing the behavior?**
-<!-- Describe the motivation or the concrete use case -->
-
-**Please tell us about your environment:**
-<!-- Operating system, IDE, package manager, HTTP server, ... -->
-
-* **Angular version:** 2.0.X
-<!-- Check whether this is still an issue in the most recent Angular version -->
-
-* **Browser:** [all | Chrome XX | Firefox XX | IE XX | Safari XX | Mobile Chrome XX | Android X.X Web Browser | iOS XX Safari | iOS XX UIWebView | iOS XX WKWebView ]
-<!-- All browsers where this could be reproduced -->
- 
-* **Language:** [all | TypeScript X.X | ES6/7 | ES5]
-
-* **Node (for AoT issues):** `node --version` =   
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,36 +0,0 @@
-**Please check if the PR fulfills these requirements**
- [ ] The commit message follows our guidelines: https://github.com/angular/angular/blob/master/CONTRIBUTING.md#commit
- [ ] Tests for the changes have been added (for bug fixes / features)
- [ ] Docs have been added / updated (for bug fixes / features)
-
-
-**What kind of change does this PR introduce?** (check one with "x")
-```
-[ ] Bugfix
-[ ] Feature
-[ ] Code style update (formatting, local variables)
-[ ] Refactoring (no functional changes, no api changes)
-[ ] Build related changes
-[ ] CI related changes
-[ ] Other... Please describe:
-```
-
-**What is the current behavior?** (You can also link to an open issue here)
-
-
-
-**What is the new behavior?**
-
-
-
-**Does this PR introduce a breaking change?** (check one with "x")
-```
-[ ] Yes
-[ ] No
-```
-
-If this PR contains a breaking change, please describe the impact and migration path for existing applications: ...
-
-
-**Other information**:
-
--- a/.gitignore
+++ b/.gitignore
@ -1,14 +1,34 @@
 .DS_STORE

+# Don’t commit the following directories created by pub.
+packages
+pubspec.lock
+.pub
+.packages
+
 /dist/
+.buildlog
 node_modules
 bower_components

+# Or broccoli working directory
+tmp
+
+# Or the files created by dart2js.
+*.dart.js
+*.dart.precompiled.js
+*.js_
+*.js.deps
+*.js.map
+
+# Or type definitions we mirror from github
+**/typings/**/*.d.ts
+**/typings/tsd.cached.json
+
 # Include when developing application packages.
 pubspec.lock
 .c9
 .idea/
-.settings/
 *.swo
 modules/.settings
 .vscode
@ -20,8 +40,7 @@ modules/.vscode
 # Ignore npm debug log
 npm-debug.log

+/docs/bower_components/
+
 # build-analytics
 .build-analytics
-
-# rollup-test output
-/modules/rollup-test/dist/
--- a/.nvmrc
+++ b/.nvmrc
@ -1 +1 @@
-6.6.0
+4.2.1
--- a/.settings/settings.json
+++ b/.settings/settings.json
@ -0,0 +1,12 @@
+{
+	"search.exclude": {
+		".git" : true,
+		".idea": true,
+		"node_modules" : true,
+		"bower_components" : true,
+		"packages" : true,
+		"build" : true,
+		"dist" : true,
+		"tmp" : true
+	}
+}
--- a/.travis.yml
+++ b/.travis.yml
@ -1,51 +1,123 @@
 language: node_js
 sudo: false
 node_js:
-  - '6.6.0'
-
-addons:
-#  firefox: "38.0"
-  apt:
-    sources:
-      # needed to install g++ that is used by npms's native modules
-      - ubuntu-toolchain-r-test
-    packages:
-      - g++-4.8
+- '4.2.1'

 branches:
  except:
-    - g3_v2_0
+    - g3sync

 cache:
  directories:
-     - ./node_modules
-     - ./.chrome/chromium
+    - node_modules
+    - $HOME/.pub-cache

 env:
  global:
-    # GITHUB_TOKEN_ANGULAR
-    # This is needed for the e2e Travis matrix task to publish packages to github for continuous packages delivery.
-    - secure: "fq/U7VDMWO8O8SnAQkdbkoSe2X92PVqg4d044HmRYVmcf6YbO48+xeGJ8yOk0pCBwl3ISO4Q2ot0x546kxfiYBuHkZetlngZxZCtQiFT9kyId8ZKcYdXaIW9OVdw3Gh3tQyUwDucfkVhqcs52D6NZjyE2aWZ4/d1V4kWRO/LMgo="
+  - KARMA_BROWSERS=DartiumWithWebPlatform
+  - E2E_BROWSERS=Dartium
+  - LOGS_DIR=/tmp/angular-build/logs
+  - SAUCE_USERNAME=angular-ci
+  - SAUCE_ACCESS_KEY=9b988f434ff8-fbca-8aa4-4ae3-35442987
+  - ARCH=linux-x64
+  - DART_DEV_VERSION=latest
+  - DART_STABLE_VERSION=latest
+  # Token for tsd to increase github rate limit
+  # See https://github.com/DefinitelyTyped/tsd#tsdrc
+  # This does not use http://docs.travis-ci.com/user/environment-variables/#Secure-Variables
+  # because those are not visible for pull requests, and those should also be reliable.
+  # This SSO token belongs to github account angular-github-ratelimit-token which has no access
+  # (password is in Valentine)
+  - TSDRC='{"token":"ef474500309daea53d5991b3079159a29520a40b"}'
+  # GITHUB_TOKEN_ANGULAR
+  - secure: "fq/U7VDMWO8O8SnAQkdbkoSe2X92PVqg4d044HmRYVmcf6YbO48+xeGJ8yOk0pCBwl3ISO4Q2ot0x546kxfiYBuHkZetlngZxZCtQiFT9kyId8ZKcYdXaIW9OVdw3Gh3tQyUwDucfkVhqcs52D6NZjyE2aWZ4/d1V4kWRO/LMgo="
  matrix:
-    # Order: a slower build first, so that we don't occupy an idle travis worker waiting for others to complete.
-   - CI_MODE=js
-   - CI_MODE=e2e
-   - CI_MODE=saucelabs_required
-   - CI_MODE=browserstack_required
-   - CI_MODE=saucelabs_optional
-   - CI_MODE=browserstack_optional
+    # Order: slowest build on top, so that we don't hog VMs while waiting for others to complete.
+    - MODE=dart DART_CHANNEL=stable DART_VERSION=$DART_STABLE_VERSION
+    - MODE=dart DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=saucelabs DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=dart_experimental DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=js DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=router DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=lint DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION

 matrix:
-  fast_finish: true
  allow_failures:
-    - env: "CI_MODE=saucelabs_optional"
-    - env: "CI_MODE=browserstack_optional"
+  - env: "MODE=saucelabs DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION"
+  - env: "MODE=dart_experimental DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION"
+
+addons:
+  firefox: "38.0"
+
+before_install:
+- echo ${TSDRC} > .tsdrc
+- export DISPLAY=:99.0
+- export GIT_SHA=$(git rev-parse HEAD)
+- ./scripts/ci/init_android.sh
+- ./scripts/ci/install_dart.sh ${DART_CHANNEL} ${DART_VERSION} ${ARCH}
+- sh -e /etc/init.d/xvfb start
+- if [[ -e SKIP_TRAVIS_TESTS ]]; then { cat SKIP_TRAVIS_TESTS ; exit 0; } fi
+- '[ "${TRAVIS_PULL_REQUEST}" = "false" ] && [ "${TRAVIS_BRANCH}" = "master" ] && SAUCE_USERNAME="angular2-ci" && SAUCE_ACCESS_KEY="693ebc16208a-0b5b-1614-8d66-a2662f4e" || true'

 install:
-  - ./scripts/ci-lite/install.sh
+  # Check the size of caches
+  - du -sh ./node_modules || true
+  # Install npm dependecies
+  - npm install
+
+before_script:
+- mkdir -p $LOGS_DIR
+- ./scripts/ci/presubmit-queue-setup.sh

 script:
-  - ./scripts/ci-lite/build.sh && ./scripts/ci-lite/test.sh
+- ./scripts/ci/build_and_test.sh ${MODE}

 after_script:
-  - ./scripts/ci-lite/cleanup.sh
+- ./scripts/ci/print-logs.sh
+- ./scripts/ci/after-script.sh
+
+notifications:
+  webhooks:
+    urls:
+    - https://webhooks.gitter.im/e/1ef62e23078036f9cee4
+    # trigger Buildtime Trend Service to parse Travis CI log
+    - https://buildtimetrend.herokuapp.com/travis
+    on_success: always  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false
+  slack:
+    secure: EP4MzZ8JMyNQJ4S3cd5LEPWSMjC7ZRdzt3veelDiOeorJ6GwZfCDHncR+4BahDzQAuqyE/yNpZqaLbwRWloDi15qIUsm09vgl/1IyNky1Sqc6lEknhzIXpWSalo4/T9ZP8w870EoDvM/UO+LCV99R3wS8Nm9o99eLoWVb2HIUu0=
+
+deploy:
+  - provider: gcs
+    # This is for project angular-github-babysitter
+    access_key_id: GOOGIOQTDBEOPBUAWFZQ
+    secret_access_key:
+      secure: "MEDggllZ5fw4wI9CEUi8WR6jKsKXqdRF/DLxSNC2JpzM5RlVeBm0uqjntYT1Cf1dASvQ2/+vZCUikL/3A48NcoEYRHXGmxu8D6t/SvleQD8Xv434xFOdsa2QqP/HiCtqCLOI5jJz1JVoB5nNyKKZ33ogTUL1LV1TfcrAioyizW8="
+    # this bucket has a lifecycle to delete after 90 days:
+    # $ echo '{"rule": [{"action": {"type": "Delete"}, "condition": {"age": 90}}]}' > lifecycle.json
+    # $ gsutil lifecycle set lifecycle.json gs://angular2-snapshots
+    bucket: angular2-snapshots
+    # don't delete generated files
+    skip_cleanup: true
+    # serve to public at https://storage.googleapis.com/angular2-snapshots/SHA/dart_stable/dist.tgz
+    acl: public-read
+    # upload the .tgz archive created in scripts/ci/build_and_test.sh
+    local-dir: deploy
+    # create a "subdirectory" for each commit
+    upload-dir: $TRAVIS_COMMIT/dart_stable
+    on:
+      repo: angular/angular
+      condition: "$MODE = dart && $DART_CHANNEL = stable"
+  - provider: gcs
+    access_key_id: GOOGIOQTDBEOPBUAWFZQ
+    secret_access_key:
+      secure: "MEDggllZ5fw4wI9CEUi8WR6jKsKXqdRF/DLxSNC2JpzM5RlVeBm0uqjntYT1Cf1dASvQ2/+vZCUikL/3A48NcoEYRHXGmxu8D6t/SvleQD8Xv434xFOdsa2QqP/HiCtqCLOI5jJz1JVoB5nNyKKZ33ogTUL1LV1TfcrAioyizW8="
+    bucket: angular2-snapshots
+    skip_cleanup: true
+    acl: public-read
+    local-dir: deploy
+    upload-dir: $TRAVIS_COMMIT/js
+    on:
+      repo: angular/angular
+      condition: "$MODE = js"
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/COMMITTER.md
+++ b/COMMITTER.md
@ -11,11 +11,8 @@ Someone with committer access will do the rest.
 We have automated the process for merging pull requests into master. Our goal is to minimize the disruption for
 Angular committers and also prevent breakages on master.

-When a PR has `pr_state: LGTM` and is ready to merge, you should add the `pr_action: merge` label.
-Currently (late 2015), we need to ensure that each PR will cleanly merge into the Google-internal version control,
-so the caretaker reviews the changes manually.
-
-After this review, the caretaker adds `zomg_admin: do_merge` which is restricted to admins only. 
+When a PR is ready to merge, a project member in the CoreTeamMember list (see below) can add the special label,
+`PR: merge`.
 A robot running as [mary-poppins](https://github.com/mary-poppins)
 is notified that the label was added by an authorized person,
 and will create a new branch in the angular project, using the convention `presubmit-{username}-pr-{number}`.
@ -29,6 +26,6 @@ Finally, after merge `mary-poppins` removes the presubmit branch.

 ## Administration

-The list of users who can trigger a merge by adding the `zomg_admin: do_merge` label is stored in our appengine app datastore.
+The list of users who can trigger a merge by adding the label is stored in our appengine app datastore.
 Edit the contents of the [CoreTeamMember Table](
 https://console.developers.google.com/project/angular2-automation/datastore/query?queryType=KindQuery&namespace=&kind=CoreTeamMember)
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -1,6 +1,6 @@
-# Contributing to Angular
+# Contributing to Angular 2

-We would love for you to contribute to Angular and help make it even better than it is
+We would love for you to contribute to Angular 2 and help make it even better than it is
 today! As a contributor, here are the guidelines we would like you to follow:

 - [Code of Conduct](#coc)
@ -17,27 +17,19 @@ Help us keep Angular open and inclusive. Please read and follow our [Code of Con

 ## <a name="question"></a> Got a Question or Problem?

-Please, do not open issues for the general support questions as we want to keep GitHub issues for bug reports and feature requests. You've got much better chances of getting your question answered on [StackOverflow](https://stackoverflow.com/questions/tagged/angular) where the questions should be tagged with tag `angular`.
+If you have questions about how to *use* Angular, please direct them to the [Google Group][angular-group]
+discussion list or [StackOverflow][stackoverflow]. Please note that Angular 2 is still in early developer preview, and the core team's capacity to answer usage questions is limited. We are also available on [Gitter][gitter].

-StackOverflow is a much better place to ask questions since:
-
- there are thousands of people willing to help on StackOverflow
- questions and answers stay available for public viewing so your question / answer might help someone else
- StackOverflow's voting system assures that the best answers are prominently visible.
-
-To save your and our time we will be systematically closing all the issues that are requests for general support and redirecting people to StackOverflow.
-
-If you would like to chat about the question in real-time, you can reach out via [our gitter channel][gitter].
-
-## <a name="issue"></a> Found a Bug?
-If you find a bug in the source code, you can help us by
+## <a name="issue"></a> Found an Issue?
+If you find a bug in the source code or a mistake in the documentation, you can help us by
 [submitting an issue](#submit-issue) to our [GitHub Repository][github]. Even better, you can
 [submit a Pull Request](#submit-pr) with a fix.

-## <a name="feature"></a> Missing a Feature?
-You can *request* a new feature by [submitting an issue](#submit-issue) to our GitHub
-Repository. If you would like to *implement* a new feature, please submit an issue with
-a proposal for your work first, to be sure that we can use it.
+## <a name="feature"></a> Want a Feature?
+You can *request* a new feature by [submitting an issue](#submit-issue) to our [GitHub
+Repository][github]. If you would like to *implement* a new feature, please submit an issue with
+a proposal for your work first, to be sure that we can use it. Angular 2 is in developer preview
+and we are not ready to accept major contributions ahead of the full release.
 Please consider what kind of change it is:

 * For a **Major Feature**, first open an issue and outline your proposal so that it can be
@ -48,23 +40,21 @@ and help you to craft the change so that it is successfully accepted into the pr
 ## <a name="submit"></a> Submission Guidelines

 ### <a name="submit-issue"></a> Submitting an Issue
+Before you submit an issue, search the archive, maybe your question was already answered.

-Before you submit an issue, please search the issue tracker, maybe an issue for your problem already exists and the discussion might inform you of workarounds readily available.
-
-We want to fix all the issues as soon as possible, but before fixing a bug we need to reproduce and confirm it. In order to reproduce bugs we will systematically ask you to provide a minimal reproduction scenario using http://plnkr.co. Having a live, reproducible scenario gives us wealth of important information without going back & forth to you with additional questions like:
-
- version of Angular used
- 3rd-party libraries and their versions
- and most importantly - a use-case that fails
-
-A minimal reproduce scenario using http://plnkr.co/ allows us to quickly confirm a bug (or point out coding problem) as well as confirm that we are fixing the right problem. If plunker is not a suitable way to demostrate the problem (for example for issues related to our npm packaging), please create a standalone git repository demostrating the problem.
-
-We will be insisting on a minimal reproduce scenario in order to save maintainers time and ultimately be able to fix more bugs. Interestingly, from our experience users often find coding problems themselves while preparing a minimal plunk. We understand that sometimes it might be hard to extract essentials bits of code from a larger code-base but we really need to isolate the problem before we can fix it.
-
-Unfortunately we are not able to investigate / fix bugs without a minimal reproduction, so if we don't hear back from you we are going to close an issue that don't have enough info to be reproduced.
-
-You can file new issues by filling out our [new issue form](https://github.com/angular/angular/issues/new).
+If your issue appears to be a bug, and hasn't been reported, open a new issue.
+Help us to maximize the effort we can spend fixing issues and adding new
+features, by not reporting duplicate issues.  Providing the following information will increase the
+chances of your issue being dealt with quickly:

+* **Overview of the Issue** - if an error is being thrown a non-minified stack trace helps
+* **Motivation for or Use Case** - explain why this is a bug for you
+* **Browsers and Operating System** - is this a problem with all browsers?
+* **Reproduce the Error** - provide a live example (using [Plunker][plunker],
+  [JSFiddle][jsfiddle] or [Runnable][runnable]) or a unambiguous set of steps.
+* **Related Issues** - has a similar issue been reported before?
+* **Suggest a Fix** - if you can't fix the bug yourself, perhaps you can point to what might be
+  causing the problem (line of code or commit)

 ### <a name="submit-pr"></a> Submitting a Pull Request (PR)
 Before you submit your Pull Request (PR) consider the following guidelines:
@ -101,7 +91,7 @@ Before you submit your Pull Request (PR) consider the following guidelines:
 * In GitHub, send a pull request to `angular:master`.
 * If we suggest changes then:
  * Make the required updates.
-  * Re-run the Angular test suites to ensure tests are still passing.
+  * Re-run the Angular 2 test suites for JS and Dart to ensure tests are still passing.
  * Rebase your branch and force push to your GitHub repository (this will update your Pull Request):

    ```shell
@ -172,19 +162,6 @@ The **header** is mandatory and the **scope** of the header is optional.
 Any line of the commit message cannot be longer 100 characters! This allows the message to be easier
 to read on GitHub as well as in various git tools.

-Footer should contain a [closing reference to an issue](https://help.github.com/articles/closing-issues-via-commit-messages/) if any.
-
-Samples: (even more [samples](https://github.com/angular/angular/commits/master))
-
-```
-docs(changelog): update change log to beta.5
-```
-```
-fix(release): need to depend on latest rxjs and zone.js
-
-The version in our package.json gets copied to the one we publish, and users need the latest of these.
-```
-
 ### Revert
 If the commit reverts a previous commit, it should begin with `revert: `, followed by the header of the reverted commit. In the body it should say: `This reverts commit <hash>.`, where the hash is the SHA of the commit being reverted.

@ -198,10 +175,9 @@ Must be one of the following:
  semi-colons, etc)
 * **refactor**: A code change that neither fixes a bug nor adds a feature
 * **perf**: A code change that improves performance
-* **test**: Adding missing tests or correcting existing tests
-* **build**: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
-* **ci**: Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)
-* **chore**: Other changes that don't modify `src` or `test` files
+* **test**: Adding missing tests
+* **chore**: Changes to the build process or auxiliary tools and libraries such as documentation
+  generation

 ### Scope
 The scope could be anything specifying place of the commit change. For example
@ -244,8 +220,8 @@ changes to be accepted, the CLA must be signed. It's a quick process, we promise
 [github]: https://github.com/angular/angular
 [gitter]: https://gitter.im/angular/angular
 [individual-cla]: http://code.google.com/legal/individual-cla-v1.0.html
-[js-style-guide]: https://google.github.io/styleguide/javascriptguide.xml
-[jsfiddle]: http://jsfiddle.net
+[js-style-guide]: http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml
+[jsfiddle]: http://jsfiddle.net/
 [plunker]: http://plnkr.co/edit
-[runnable]: http://runnable.com
+[runnable]: http://runnable.com/
 [stackoverflow]: http://stackoverflow.com/questions/tagged/angular
--- a/DEVELOPER.md
+++ b/DEVELOPER.md
@ -1,13 +1,18 @@
-# Building and Testing Angular 2 for JS
+# Building and Testing Angular 2 for JS and Dart

-This document describes how to set up your development environment to build and test Angular 2 JS version. 
-It also explains the basic mechanics of using `git`, `node`, and `npm`.
+This document describes how to set up your development environment to build and test Angular, both
+JS and Dart versions. It also explains the basic mechanics of using `git`, `node`, and `npm`.

 * [Prerequisite Software](#prerequisite-software)
 * [Getting the Sources](#getting-the-sources)
-* [Installing NPM Modules](#installing-npm-modules)
-* [Building](#building)
+* [Environment Variable Setup](#environment-variable-setup)
+* [Installing NPM Modules and Dart Packages](#installing-npm-modules-and-dart-packages)
 * [Running Tests Locally](#running-tests-locally)
+* [Formatting](#clang-format)
+* [Project Information](#project-information)
+* [CI using Travis](#ci-using-travis)
+* [Transforming Dart code](#transforming-dart-code)
+* [Debugging](#debugging)

 See the [contribution guidelines](https://github.com/angular/angular/blob/master/CONTRIBUTING.md)
 if you'd like to contribute to Angular.
@ -17,17 +22,30 @@ if you'd like to contribute to Angular.
 Before you can build and test Angular, you must install and configure the
 following products on your development machine:

+* [Dart](https://www.dartlang.org) (version ` >=1.12.0 <2.0.0`), specifically the Dart-SDK and
+  Dartium (a version of [Chromium](http://www.chromium.org) with native support for Dart through
+  the Dart VM). One of the **simplest** ways to get both is to install the **Dart Editor bundle**,
+  which includes the editor, SDK and Dartium. See the [Dart tools](https://www.dartlang.org/tools)
+  download [page for instructions](https://www.dartlang.org/tools/download.html).  
+  You can also download both **stable** and **dev** channel versions from the [download
+  archive](https://www.dartlang.org/tools/download-archive). In that case, on Windows, Dart must be added
+  to the `Path` (e.g. `path-to-dart-sdk-folder\bin`) and a new `DARTIUM_BIN` environment variable must be
+  created, pointing to the executable (e.g. `path-to-dartium-folder\chrome.exe).`
+
 * [Git](http://git-scm.com) and/or the **GitHub app** (for [Mac](http://mac.github.com) or
  [Windows](http://windows.github.com)); [GitHub's Guide to Installing
  Git](https://help.github.com/articles/set-up-git) is a good source of information.

-* [Node.js](http://nodejs.org), (version `>=5.4.1 <6`) which is used to run a development web server,
-  run tests, and generate distributable files. We also use Node's Package Manager, `npm`
-  (version `>=3.5.3 <4.0`), which comes with Node. Depending on your system, you can install Node either from
+* [Node.js](http://nodejs.org), (version `>=4.2.1 <5`) which is used to run a development web server, 
+  run tests, and generate distributable files. We also use Node's Package Manager, `npm` 
+  (version `>=2.14.7 <3.0`), which comes with Node. Depending on your system, you can install Node either from 
  source or as a pre-packaged bundle.

-* [Java Development Kit](http://www.oracle.com/technetwork/es/java/javase/downloads/index.html) which is used
-  to execute the selenium standalone server for e2e testing.
+* [Chrome Canary](https://www.google.com/chrome/browser/canary.html), a version of Chrome with
+  bleeding edge functionality, built especially for developers (and early adopters).
+
+* [Bower](http://bower.io/).
+

 ## Getting the Sources

@ -50,9 +68,44 @@ cd angular
 # Add the main Angular repository as an upstream remote to your repository:
 git remote add upstream https://github.com/angular/angular.git
 ```
-## Installing NPM Modules

-Next, install the JavaScript modules needed to build and test Angular:
+## Environment Variable Setup
+
+Define the environment variables listed below. These are mainly needed for the testing. The
+notation shown here is for [`bash`](http://www.gnu.org/software/bash); adapt as appropriate for
+your favorite shell.
+
+Examples given below of possible values for initializing the environment variables assume **Mac OS
+X** and that you have installed the Dart Editor in the directory named by
+`DART_EDITOR_DIR=/Applications/dart`. This is only for illustrative purposes.
+
+```shell
+# DARTIUM_BIN: path to a Dartium browser executable; used by Karma to run Dart tests
+export DARTIUM_BIN="$DART_EDITOR_DIR/chromium/Chromium.app/Contents/MacOS/Chromium"
+```
+
+Add the Dart SDK `bin` directory to your path and/or define `DART_SDK` (this is also detailed
+[here](https://www.dartlang.org/tools/pub/installing.html)):
+
+```shell
+# DART_SDK: path to a Dart SDK directory
+export DART_SDK="$DART_EDITOR_DIR/dart-sdk"
+
+# Update PATH to include the Dart SDK bin directory
+PATH+=":$DART_SDK/bin"
+```
+
+And specify where the pub’s dependencies are downloaded. By default, this directory is located under .pub_cache 
+in your home directory (on Mac and Linux), or in AppData\Roaming\Pub\Cache (on Windows).
+
+```shell
+# PUB_CACHE: location of pub dependencies
+export PUB_CACHE="/Users/<user>/.pub-cache"
+```
+
+## Installing NPM Modules and Dart Packages
+
+Next, install the JavaScript modules and Dart packages needed to build and test Angular:

 ```shell
 # Install Angular project dependencies (package.json)
@ -74,67 +127,219 @@ use in these instructions.
 *Option 2*: defining a bash alias like `alias nbin='PATH=$(npm bin):$PATH'` as detailed in this
 [Stackoverflow answer](http://stackoverflow.com/questions/9679932/how-to-use-package-installed-locally-in-node-modules/15157360#15157360) and used like this: e.g., `nbin gulp build`.

-## Windows only
+## Build commands
+
+To build Angular and prepare tests, run:

-In order to create the right symlinks, run **as administrator**:
 ```shell
-./scripts/windows/create-symlinks.sh
+$(npm bin)/gulp build
 ```

-Before submitting a PR, do not forget to remove them:
-```shell
- ./scripts/windows/remove-symlinks.sh
- ```
+Notes:
+* Results are put in the `dist` folder.
+* This will also run `pub get` for the subfolders in `modules` and run `dartanalyzer` for
+  every file that matches `<module>/src/<module>.dart`, e.g. `di/src/di.dart`.

-## Building
+You can selectively build either the JS or Dart versions as follows:

-To build Angular run:
+* `$(npm bin)/gulp build.js`
+* `$(npm bin)/gulp build.dart`
+
+Also note that in order for the whole test suite to succeed you will need to generate the type definitions by running:

 ```shell
-./build.sh
+$(npm bin)/gulp docs/typings
 ```

-* Results are put in the dist folder.
+To clean out the `dist` folder, run:
+
+```shell
+$(npm bin)/gulp clean
+```

 ## Running Tests Locally

-To run tests:
+### Full test suite

+* `npm test`: full test suite for both JS and Dart versions of Angular. These are the same tests
+  that run on Travis.
+
+You can selectively run either the JS or Dart versions as follows:
+
+* `$(npm bin)/gulp test.all.js`
+* `$(npm bin)/gulp test.all.dart`
+
+### Unit tests
+
+You can run just the unit tests as follows:
+
+* `$(npm bin)/gulp test.unit.js`: JS tests in a browser; runs in **watch mode** (i.e.
+   watches the test files for changes and re-runs tests when files are updated).
+* `$(npm bin)/gulp test.unit.cjs`: JS tests in NodeJS; runs in **watch mode**.
+* `$(npm bin)/gulp test.unit.dart`: Dart tests in Dartium; runs in **watch mode**.
+
+If you prefer running tests in "single-run" mode rather than watch mode use:
+
+* `$(npm bin)/gulp test.unit.js/ci`
+* `$(npm bin)/gulp test.unit.cjs/ci`
+* `$(npm bin)/gulp test.unit.dart/ci`
+
+The task updates the dist folder with transpiled code whenever a source or test file changes, and
+Karma is run against the new output.
+
+**Note**: If you want to only run a single test you can alter the test you wish to run by changing
+`it` to `iit` or `describe` to `ddescribe`. This will only run that individual test and make it
+much easier to debug. `xit` and `xdescribe` can also be useful to exclude a test and a group of
+tests respectively.
+
+**Note**: **watch mode** needs symlinks to work, so if you're using windows, ensure you have the
+rights to built them in your operating system.
+
+### E2E tests
+
+1. `$(npm bin)/gulp build.js.cjs` (builds benchpress and tests into `dist/js/cjs` folder).
+2. `$(npm bin)/gulp serve.js.prod serve.dart` (runs a local webserver).
+3. `$(npm bin)/protractor protractor-js.conf.js`: JS e2e tests.
+4. `$(npm bin)/protractor protractor-dart2js.conf.js`: dart2js e2e tests.
+
+Angular specific command line options when running protractor:
+  - `$(npm bin)/protractor protractor-{js|dart2js}-conf.js --ng-help`
+
+### Performance tests
+
+1. `$(npm bin)/gulp build.js.cjs` (builds benchpress and tests into `dist/js/cjs` folder)
+2. `$(npm bin)/gulp serve.js.prod serve.dart` (runs a local webserver)
+3. `$(npm bin)/protractor protractor-js.conf.js --benchmark`: JS performance tests
+4. `$(npm bin)/protractor protractor-dart2js.conf.js --benchmark`: dart2js performance tests
+
+Angular specific command line options when running protractor (e.g. force gc, ...):
+`$(npm bin)/protractor protractor-{js|dart2js}-conf.js --ng-help`
+
+## Formatting with <a name="clang-format">clang-format</a>
+
+We use [clang-format](http://clang.llvm.org/docs/ClangFormat.html) to automatically enforce code
+style for our TypeScript code. This allows us to focus our code reviews more on the content, and
+less on style nit-picking. It also lets us encode our style guide in the `.clang-format` file in the
+repository, allowing many tools and editors to share our settings.
+
+To check the formatting of your code, run
+
+    gulp check-format
+
+Note that the continuous build on Travis runs `gulp enforce-format`. Unlike the `check-format` task,
+this will actually fail the build if files aren't formatted according to the style guide.
+
+Your life will be easier if you include the formatter in your standard workflow. Otherwise, you'll
+likely forget to check the formatting, and waste time waiting for a build on Travis that fails due
+to some whitespace difference.
+
+* Install clang-format with `npm install -g clang-format`.
+* Use `clang-format -i [file name]` to format a file (or multiple).
+  Note that `clang-format` tries to load a `clang-format` node module close to the sources being
+  formatted, or from the `$CWD`, and only then uses the globally installed one - so the version used
+  should automatically match the one required by the project.
+  Use `clang-format -version` in case you get confused.
+* Use `gulp enforce-format` to check if your code is `clang-format` clean. This also gives
+  you a command line to format your code.
+* `clang-format` also includes a git hook, run `git clang-format` to format all files you
+  touched.
+* You can run this as a **git pre-commit hook** to automatically format your delta regions when you
+  commit a change. In the angular repo, run
+
+```
+    $ echo -e '#!/bin/sh\nexec git clang-format' > .git/hooks/pre-commit
+    $ chmod u+x !$
+```
+
+* **WebStorm** can run clang-format on the current file.
+  1. Under Preferences, open Tools > External Tools.
+  1. Plus icon to Create Tool
+  1. Fill in the form:
+    - Name: clang-format
+    - Description: Format
+    - Synchronize files after execution: checked
+    - Open console: not checked
+    - Show in: Editor menu
+    - Program: [path to clang-format, try `$ echo $(npm config get prefix)/bin/clang-format`]
+    - Parameters: `-i -style=file $FilePath$`
+    - Working directory: `$ProjectFileDir$`
+* `clang-format` integrations are also available for many popular editors (`vim`, `emacs`,
+  `Sublime Text`, etc.).
+  
+## Generating the API documentation
+
+The following gulp task will generate the API docs in the `dist/angular.io/partials/api/angular2`:  
+  
 ```shell
-$ ./test.sh node             # Run all angular tests on node
-
-$ ./test.sh browser          # Run all angular tests in browser
-$ ./test.sh browserNoRouter  # Optionally run all angular tests without router in browser
-
-$ ./test.sh tools            # Run angular tooling (not framework) tests
+$(npm bin)/gulp docs/angular.io
 ```

-You should execute the 3 test suites before submitting a PR to github.
+You can serve the generated documentation to check how it would render on [angular.io](https://angular.io/):
+- check out the [angular.io repo](https://github.com/angular/angular.io) locally,
+- install dependencies as described in the [angular.io README](https://github.com/angular/angular.io/blob/master/README.md),
+- copy the generated documentation from your local angular repo at `angular/dist/angular.io/partials/api/angular2` to your local angular.io repo at `angular.io/public/docs/js/latest/api`,
+- run `harp compile` at the root of the angular.io repo to check the generated documentation for errors,
+- run `harp server` and open a browser at `http://localhost:9000/docs/js/latest/api/` to check the rendered documentation. 
+ 
+## Project Information

-All the tests are executed on our Continuous Integration infrastructure and a PR could only be merged once the tests pass.
+### Folder structure

- CircleCI fails if your code is not formatted properly,
- Travis CI fails if any of the test suites described above fails.
+* `modules/*`: modules that will be loaded in the browser
+* `tools/*`: tools that are needed to build Angular
+* `dist/*`: build files are placed here.

-## Update the public API tests
+### File suffixes

-If you happen to modify the public API of Angular, API golden files must be updated using:
+* `*.ts`: TypeScript files that get transpiled to Dart and EcmaScript 5/6
+* `*.dart`: Dart files that don't get transpiled

-``` shell
-$ gulp public-api:update
-```
+## CI using Travis

-Note: The command `./test.sh tools` fails when the API doesn't match the golden files.
+For instructions on setting up Continuous Integration using Travis, see the instructions given
+[here](https://github.com/angular/angular.dart/blob/master/travis.md).

-## Formatting your source code
+## Transforming Dart code

-Angular uses [clang-format](http://clang.llvm.org/docs/ClangFormat.html) to format the source code. If the source code
-is not properly formatted, the CI will fail and the PR can not be merged.
+See the [wiki](//github.com/angular/angular/wiki/Angular-2-Dart-Transformer).

-You can automatically format your code by running:
+## Debugging

-``` shell
-$ gulp format
-```
+### Debug the transpiler

+If you need to debug the transpiler:

+- add a `debugger;` statement in the transpiler code,
+- from the root folder, execute `node debug $(npm bin)/gulp build` to enter the node
+  debugger
+- press "c" to execute the program until you reach the `debugger;` statement,
+- you can then type "repl" to enter the REPL and inspect variables in the context.
+
+See the [Node.js manual](http://nodejs.org/api/debugger.html) for more information.
+
+Notes:
+- You can also execute `node $(npm bin)/karma start karma-dart.conf.js` depending on which
+  code you want to debug (the former will process the "modules" folder while the later processes
+  the transpiler specs).
+- You can also add `debugger;` statements in the specs (JavaScript). The execution will halt when
+  the developer tools are opened in the browser running Karma.
+
+### Debug the tests
+
+If you need to debug the tests:
+
+- add a `debugger;` statement to the test you want to debug (or the source code),
+- execute karma `$(npm bin)/gulp test.js`,
+- press the top right "DEBUG" button,
+- open the DevTools and press F5,
+- the execution halts at the `debugger;` statement
+
+**Note (WebStorm users)**:
+
+1. Create a Karma run config from WebStorm.
+2. Then in the "Run" menu, press "Debug 'karma-js.conf.js'", and WebStorm will stop in the generated
+   code on the `debugger;` statement.
+3. You can then step into the code and add watches.
+
+The `debugger;` statement is needed because WebStorm will stop in a transpiled file. Breakpoints in
+the original source files are not supported at the moment.
--- a/215
+++ b/215
@ -1,21 +1,202 @@
-The MIT License
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/

-Copyright (c) 2014-2016 Google, Inc. http://angular.io
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+   1. Definitions.

-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
--- a/README.md
+++ b/README.md
@ -1,37 +1,43 @@
-[![Build Status](https://travis-ci.org/angular/angular.svg?branch=master)](https://travis-ci.org/angular/angular)
-[![CircleCI](https://circleci.com/gh/angular/angular/tree/master.svg?style=shield)](https://circleci.com/gh/angular/angular/tree/master)
+[![Build Status](https://travis-ci.org/angular/angular.svg?branch=master)](https://travis-ci.org/angular/angular) 
 [![Join the chat at https://gitter.im/angular/angular](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/angular/angular?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-[![Issue Stats](http://issuestats.com/github/angular/angular/badge/pr?style=flat)](http://issuestats.com/github/angular/angular)
-[![Issue Stats](http://issuestats.com/github/angular/angular/badge/issue?style=flat)](http://issuestats.com/github/angular/angular)
-[![npm version](https://badge.fury.io/js/%40angular%2Fcore.svg)](https://badge.fury.io/js/%40angular%2Fcore)
+[![Issue Stats](http://issuestats.com/github/angular/angular/badge/pr)](http://issuestats.com/github/angular/angular)
+[![Issue Stats](http://issuestats.com/github/angular/angular/badge/issue)](http://issuestats.com/github/angular/angular)
+[![npm version](https://badge.fury.io/js/angular2.svg)](http://badge.fury.io/js/angular2)
+[![Downloads](http://img.shields.io/npm/dm/angular2.svg)](https://npmjs.org/package/angular2)
+[![Sauce Test Status](https://saucelabs.com/browser-matrix/angular2-ci.svg)](https://saucelabs.com/u/angular2-ci)

-[![Sauce Test Status](https://saucelabs.com/browser-matrix/angular2-ci.svg)](https://saucelabs.com/u/angular2-ci)  
-*Safari (7+), iOS (7+), Edge (14) and IE mobile (11) are tested on [BrowserStack][browserstack].*
-
-Angular
+Angular 
 =========

 Angular is a development platform for building mobile and desktop web applications. This is the
-repository for [Angular 2][ng2] Typescript/JavaScript (JS).
- 
-Angular2 for [Dart][dart] can be found at [dart-lang/angular2][ng2dart].
+repository for [Angular 2][ng2], both the JavaScript (JS) and [Dart][dart] versions.

+Angular 2 is currently in **Developer Preview**. We recommend using Angular 1.X for production
+applications:
+
+* [AngularJS][ngJS]: [angular/angular.js](http://github.com/angular/angular.js).
+* [AngularDart][ngDart]: [angular/angular.dart](http://github.com/angular/angular.dart).

 ## Quickstart

 [Get started in 5 minutes][quickstart].

+## Setup & Install Angular 2
+
+Follow the instructions given on the [Angular download page][download].
+

 ## Want to help?

 Want to file a bug, contribute some code, or improve documentation? Excellent! Read up on our
 guidelines for [contributing][contributing] and then check out one of our issues in the [hotlist: community-help](https://github.com/angular/angular/labels/hotlist%3A%20community-help).

-[browserstack]: https://www.browserstack.com/
+
 [contributing]: http://github.com/angular/angular/blob/master/CONTRIBUTING.md
 [dart]: http://www.dartlang.org
-[quickstart]: https://angular.io/docs/ts/latest/quickstart.html
+[dartium]: http://www.dartlang.org/tools/dartium
+[download]: http://angular.io/download/
+[quickstart]: https://angular.io/docs/js/latest/quickstart.html
 [ng2]: http://angular.io
 [ngDart]: http://angulardart.org
 [ngJS]: http://angularjs.org
-[ng2dart]: https://github.com/dart-lang/angular2
--- a/SAVED_REPLIES.md
+++ b/SAVED_REPLIES.md
@ -1,62 +0,0 @@
-# Saved Responses for Angular's Issue Tracker
-
-The following are canned responses that the Angular team should use to close issues on our issue tracker that fall into the listed resolution categories.
-
-Since GitHub currently doesn't allow us to have a repository-wide or organization-wide list of [saved replies](https://help.github.com/articles/working-with-saved-replies/), these replies need to be maintained by individual team members. Since the responses can be modified in the future, all responses are versioned to simplify the process of keeping the responses up to date.
-
-
-## Angular: Already Fixed (v1)
-```
-Thanks for reporting this issue. Luckily it has already been fixed in one of the recent releases. Please update to the most recent version to resolve the problem.
-
-If after upgrade the problem still exists in your application please open a new issue and provide a plunker reproducing the problem and describing the difference between the expected and current behavior. You can use this plunker template: http://plnkr.co/edit/tpl:AvJOMERrnz94ekVua0u5?p=catalogue
-```
-
-## Angular: Don't Understand (v1)
-```
-I'm sorry but we don't understand the problem you are reporting.
-
-If the problem still exists please open a new issue and provide a plunker reproducing the problem and describing the difference between the expected and current behavior. You can use this plunker template: http://plnkr.co/edit/tpl:AvJOMERrnz94ekVua0u5?p=catalogue
-```
-
-
-## Angular: Duplicate (v1)
-```
-Thanks for reporting this issue. However this issue is a duplicate of an existing issue #<ISSUE_NUMBER>. Please subscribe to that issue for future updates.
-```
-
-
-## Angular: Insufficient Information Provided (v1)
-```
-Thanks for reporting this issue. However, you didn't provide sufficient information for us to understand and reproduce the problem. Please check out [our submission guidelines](https://github.com/angular/angular/blob/master/CONTRIBUTING.md#-submitting-an-issue) to understand why we can't act on issues that are lacking important information.
-
-If the problem still persists, please file a new issue and ensure you provide all of the required information when filling out the issue template.
-```
-
-## Angular: Issue Outside of Angular (v1)
-```
-I'm sorry but this issue is not caused by Angular. Please contact the author(s) of project <PROJECT NAME> or file issue on their issue tracker.
-```
-
-
-## Angular: Non-reproducible (v1)
-```
-I'm sorry but we can't reproduce the problem following the instructions you provided.
-
-If the problem still exists please open a new issue following [our submission guidelines](https://github.com/angular/angular/blob/master/CONTRIBUTING.md#-submitting-an-issue).
-```
-
-## Angular: Obsolete (v1)
-```
-Thanks for reporting this issue. This issue is now obsolete due to changes in the recent releases. Please update to the most recent Angular version.
-
-If the problem still persists, please file a new issue and ensure you provide the version of Angular affected and include the steps to reproduce the problem when filling out the issue template.
-```
-
-
-## Angular: Support Request (v1)
-```
-Hello, we reviewed this issue and determined that it doesn't fall into the bug report or feature request category. This issue tracker is not suitable for support requests, please repost your issue on [StackOverflow](http://stackoverflow.com/) using tag `angular`.
-
-If you are wondering why we don't resolve support issues via the issue tracker, please [check out this explanation](https://github.com/angular/angular/blob/master/CONTRIBUTING.md#-got-a-question-or-problem).
-```
--- a/TOOLS.md
+++ b/TOOLS.md
@ -1,140 +1,4 @@
 # Developer Tools for Angular 2

-Here you will find a collection of tools and tips for keeping your application
-perform well and contain fewer bugs.
-
-## Angular debug tools in the dev console
-
-Angular provides a set of debug tools that are accessible from any browser's
-developer console. In Chrome the dev console can be accessed by pressing
-Ctrl + Shift + j.
-
-### Enabling debug tools
-
-By default the debug tools are disabled. You can enable debug tools as follows:
-
-```typescript
-import {enableDebugTools} from '@angular/platform-browser';
-
-bootstrap(Application).then((appRef) => {
-  enableDebugTools(appRef);
-});
-```
-
-### Using debug tools
-
-In the browser open the developer console (Ctrl + Shift + j in Chrome). The
-top level object is called `ng` and contains more specific tools inside it.
-
-Example:
-
-```javascript
-ng.profiler.timeChangeDetection();
-```
-
-## Performance
-
-### Change detection profiler
-
-If your application is janky (it misses frames) or is slow according to other
-metrics it is important to find the root cause of the issue. Change detection
-is a phase in Angular's lifecycle that detects changes in values that are
-bound to UI, and if it finds a change it performs the corresponding UI update.
-However, sometimes it is hard to tell if the slowness is due to the act of
-computing the changes being slow, or due to the act of applying those changes
-to the UI. For your application to be performant it is important that the
-process of computing changes is very fast. For best results it should be under
-3 milliseconds in order to leave room for the application logic, the UI updates
-and browser's rendering pipeline to fit withing the 16 millisecond frame
-(assuming the 60 FPS target frame rate).
-
-Change detection profiler repeatedly performs change detection without invoking
-any user actions, such as clicking buttons or entering text in input fields. It
-then computes the average amount of time it took to perform a single cycle of
-change detection in milliseconds and prints it to the console. This number
-depends on the current state of the UI. You will likely see different numbers
-as you go from one screen in your application to another.
-
-#### Running the profiler
-
-Enable debug tools (see above), then in the dev console enter the following:
-
-```javascript
-ng.profiler.timeChangeDetection();
-```
-
-The results will be printed to the console.
-
-#### Recording CPU profile
-
-Pass `{record: true}` an argument:
-
-```javascript
-ng.profiler.timeChangeDetection({record: true});
-```
-
-Then open the "Profiles" tab. You will see the recorded profile titled
-"Change Detection". In Chrome, if you record the profile repeatedly, all the
-profiles will be nested under "Change Detection".
-
-#### Interpreting the numbers
-
-In a properly-designed application repeated attempts to detect changes without
-any user actions should result in no changes to be applied on the UI. It is
-also desirable to have the cost of a user action be proportional to the amount
-of UI changes required. For example, popping up a menu with 5 items should be
-vastly faster than rendering a table of 500 rows and 10 columns. Therefore,
-change detection with no UI updates should be as fast as possible. Ideally the
-number printed by the profiler should be well below the length of a single
-animation frame (16ms). A good rule of thumb is to keep it under 3ms.
-
-#### Investigating slow change detection
-
-So you found a screen in your application on which the profiler reports a very
-high number (i.e. >3ms). This is where a recorded CPU profile can help. Enable
-recording while profiling:
-
-```javascript
-ng.profiler.timeChangeDetection({record: true});
-```
-
-Then look for hot spots using
-[Chrome CPU profiler](https://developer.chrome.com/devtools/docs/cpu-profiling).
-
-#### Reducing change detection cost
-
-There are many reasons for slow change detection. To gain intuition about
-possible causes it would help to understand how change detection works. Such a
-discussion is outside the scope of this document (TODO link to docs), but here
-are some key concepts in brief.
-
-By default Angular uses "dirty checking" mechanism for finding model changes.
-This mechanism involves evaluating every bound expression that's active on the
-UI. These usually include text interpolation via `{{expression}}` and property
-bindings via `[prop]="expression"`. If any of the evaluated expressions are
-costly to compute they could contribute to slow change detection. A good way to
-speed things up is to use plain class fields in your expressions and avoid any
-kinds of computation. Example:
-
-```typescript
-@Component({
-  template: '<button [enabled]="isEnabled">{{title}}</button>'
-})
-class FancyButton {
-  // GOOD: no computation, just return the value
-  isEnabled: boolean;
-
-  // BAD: computes the final value upon request
-  _title: String;
-  get title(): String { return this._title.trim().toUpperCase(); }
-}
-```
-
-Most cases like these could be solved by precomputing the value and storing the
-final value in a field.
-
-Angular also supports a second type of change detection - the "push" model. In
-this model Angular does not poll your component for changes. Instead, the
-component "tells" Angular when it changes and only then does Angular perform
-the update. This model is suitable in situations when your data model uses
-observable or immutable objects (also a discussion for another time).
+- [JavaScript](TOOLS_JS.md)
+- [Dart](TOOLS_DART.md)
--- a/TOOLS_DART.md
+++ b/TOOLS_DART.md
@ -0,0 +1,376 @@
+# Developer Tools for Dart
+
+Use these tools and techniques to increase your app's performance
+and reliability.
+
+* [Angular debugging tools](#angular-debugging-tools)
+* [Code size](#code-size)
+* [Performance](#performance)
+
+
+## Angular debugging tools
+
+Starting with alpha.38, Angular provides a set of debugging tools
+that are accessible from any browser's developer console.
+In Chrome, you can get to the dev console by pressing
+Ctrl + Shift + J (on Mac: Cmd + Opt + J).
+
+### Enabling the debugging tools
+
+By default the debugging tools are disabled.
+Enable the debugging tools as follows:
+
+```dart
+import 'package:angular2/tools.dart';
+
+main() async {
+  var appRef = await bootstrap(Application);
+  enableDebugTools(appRef);
+}
+```
+
+<!-- Change function name to enableDebuggingTools? -->
+
+
+### Using the debugging tools
+
+In the browser, open the dev console. The top-level object is called `ng` and
+contains more specific tools inside it.
+
+For example, to run the change detection profiler on your app:
+
+```javascript
+// In the dev console:
+ng.profiler.timeChangeDetection();
+```
+
+The [Change detection profiler](#change-detection-profiler) section
+has more details.
+<!-- Point to API docs when they're published, if they're useful.
+They should be under
+http://www.dartdocs.org/documentation/angular2/latest
+and/or
+https://angular.io/docs/js/latest/api/. -->
+
+
+## Code size
+
+Code must be downloaded, parsed, and executed. Too much code can lead to
+slow application start-up time, especially on slow networks and low-end devices.
+The tools and techniques in this section can help you to identify
+unnecessarily large code and to reduce code size.
+
+### Finding contributors to code size
+
+Options for investigating code size include the `--dump-info` dart2js option,
+ng2soyc, `reflector.trackUsage()`, and code coverage information
+from the Dart VM.
+
+#### Use --dump-info
+
+The `--dump-info` option of `dart2js` outputs information about what happened
+during compilation. You can specify `--dump-info` in `pubspec.yaml`:
+
+```yaml
+transformers:
+...
+- $dart2js:
+    commandLineOptions:
+    - --dump-info
+```
+
+The [Dump Info Visualizer](https://github.com/dart-lang/dump-info-visualizer)
+can help you analyze the output.
+For more information, see the
+[dart2js_info API reference](http://dart-lang.github.io/dart2js_info/doc/api/).
+
+#### Use ng2soyc.dart
+
+[ng2soyc](https://github.com/angular/ng2soyc.dart) is a utility for analyzing
+code size contributors in Angular 2 applications. It groups code size by
+library and, assuming your library names follow
+[standard naming conventions](https://www.dartlang.org/articles/style-guide/#do-prefix-library-names-with-the-package-name-and-a-dot-separated-path)
+(package.library.sublibrary...), gives the code size breakdown at
+each level. To reduce noise in the output of very large apps, ng2soyc provides
+an option to hide libraries that are too small, so you can focus on the biggest
+contributors.
+
+#### Find unused reflection data
+
+Your app might have types that are annotated with `@Component` or `@Injectable`
+but never used.
+To find these unused types, use `reflector.trackUsage()` and then,
+after exercising your app, `reflector.listUnusedKeys()`.
+For example:
+
+```
+import 'package:angular2/src/core/reflection/reflection.dart';
+...
+main() async {
+  reflector.trackUsage();
+  await bootstrap(AppComponent);
+  print('Unused keys: ${reflector.listUnusedKeys()}');
+}
+```
+
+When you run that code (in Dartium or another browser),
+you'll see a list of types that Angular _can_ inject but hasn't needed to.
+Consider removing those types or their `@Component`/`@Injectable` annotation
+to decrease your app's code size.
+
+Three conditions must be true for `listUnusedKeys()` to return helpful data:
+
+1. The angular2 transformer must run on the app.
+2. If you're running a JavaScript version of the app,
+   the app must not be minified, so that the names are readable.
+3. You must exercise your app in as many ways as possible
+   before calling `listUnusedKeys()`.
+   Otherwise, you might get false positives:
+   keys that haven't been used only because you didn't exercise
+   the relevant feature of the app.
+
+To run the angular2 transformer, first specify it in `pubspec.yaml`:
+
+```
+name: hello_world
+...
+transformers:
+- angular2:
+    entry_points: web/main.dart
+```
+
+Then use pub to run the transformer. If you use `pub serve`,
+it provides both Dart and unminified (by default) JavaScript versions.
+If you want to serve actual files, then use `pub build` in debug mode
+to generate Dart and unminified JavaScript files:
+`pub build --mode=debug`.
+
+The `reflector.trackUsage()` method makes Angular track the reflection
+information used by the app. Reflection information (`ReflectionInfo`) is a data
+structure that stores information that Angular uses for locating DI factories
+and for generating change detectors and other code related to a
+given type.
+
+#### Use code coverage to find dead code
+
+When running in Dartium (or in the Dart VM, in general) you can request code
+coverage information from the VM. You can either use
+[observatory](https://www.dartlang.org/tools/observatory/) or download
+the coverage file and use your own tools to inspect it. Lines of code that are
+not covered are top candidates for dead code.
+
+Keep in mind, however, that uncovered code is not sufficient evidence of dead
+code, only necessary evidence. It is perfectly possible that you simply didn't
+exercise your application in a way that triggers the execution of uncovered
+code. A common example is error handling code. Just because your testing never
+encountered an error does not mean the error won't happen in production. You
+therefore don't have to rush and remove all the `catch` blocks.
+
+### Reducing code size
+
+To reduce code size, you can disable reflection,
+enable minification, and manually remove dead code.
+You can also try less safe options such as
+telling dart2js to trust type annotations.
+
+
+#### Disable reflection
+
+`dart:mirrors` allows discovering program metadata at runtime. However, this
+means that `dart2js` needs to retain that metadata and thus increase the size
+of resulting JS output. In practice, however, it is possible to extract most
+metadata necessary for your metaprogramming tasks statically using a
+transformer and `package:analyzer`, and act on it before compiling to JS.
+
+#### Enable minification
+
+Minification shortens all your `longMethodNames` into 2- or 3-letter long
+symbols. `dart2js` ensures that this kind of renaming is done safely, without
+breaking the functionality of your programs. You can enable it in `pubspec.yaml`
+under `$dart2js` transformer:
+
+```yaml
+transformers:
+...
+- $dart2js:
+    minify: true
+```
+
+#### Manually remove dead code
+
+`dart2js` comes with dead code elimination out-of-the-box. However, it may not
+always be able to tell if a piece of code could be used. Consider the following
+example:
+
+```dart
+/// This function decides which serialization format to use
+void setupSerializers() {
+  if (server.doYouSupportProtocolBuffers()) {
+    useProtobufSerializers();
+  } else {
+    useJsonSerializers();
+  }
+}
+```
+
+In this example the application asks the server what kind of serialization
+format it uses and dynamically chooses one or the other. `dart2js` can't
+tell whether the server responds with yes or no, so it must retain both
+kinds of serializers. However, if you know that your server supports
+protocol buffers, you can remove that `if` block entirely and default to
+protocol buffers.
+
+Code coverage (see above) is a good way to find dead code in your app.
+
+#### Unsafe options
+
+Dart also provides more aggressive optimization options. However, you have to
+be careful when using them and as of today the benefits aren't that clear. If
+your type annotations are inaccurate you may end up with non-Darty runtime
+behavior, including the classic "undefined is not a function" tautology, as
+well as the "keep on truckin'" behavior, e.g. `null + 1 == 1` and
+`{} + [] == 0`.
+
+`--trust-type-annotations` tells `dart2js` to trust that your type annotations
+are correct. So if you have a function `foo(Bar bar)` the compiler can omit the
+check that `bar` is truly `Bar` when calling methods on it.
+
+`--trust-primitives` tells `dart2js` that primitive types, such as numbers and
+booleans are never `null` when performing arithmetic, and that your program
+does not run into range error when operating on lists, letting the compiler
+remove some of the error checking code.
+
+Specify these options in `pubspec.yaml`.
+
+Example:
+
+```yaml
+transformers:
+...
+- $dart2js:
+    commandLineOptions:
+    - --trust-type-annotations
+    - --trust-primitives
+```
+
+## Performance
+
+### Change detection profiler
+
+If your application is janky (it misses frames) or is slow according to other
+metrics, you need to find out why. This tool helps by measuring the average
+speed of _change detection_, a phase in Angular's
+lifecycle that detects changes in values that are bound to the UI.
+Janky UI updates can result from slowness either in _computing_ the changes or
+in _applying_ those changes to the UI.
+
+For your app to be performant, the process of _computing_ changes must be very
+fast—preferably **under 3 milliseconds**.
+Fast change computation leaves room for
+the application logic, UI updates, and browser rendering pipeline
+to fit within a 16 ms frame (assuming a target frame rate of 60 FPS).
+
+The change detection profiler repeatedly performs change detection
+without invoking any user actions, such as clicking buttons or entering
+text in input fields. It then computes the average amount of time
+(in milliseconds) to perform a single cycle of change detection and
+prints that to the console. This number depends on the current state of the UI. You are likely to see different numbers
+as you go from one screen in your application to another.
+
+#### Running the profiler
+
+Before running the profiler, enable the debugging tools
+and put the app into the state you want to measure:
+
+1. If you haven't already done so,
+   [enable the debugging tools](#enabling-the-debugging-tools).
+2. Navigate the app to a screen whose performance you want to profile.
+3. Make sure the screen is in a state that you want to measure.
+   For example, you might want to profile the screen several times,
+   with different amounts and kinds of data.
+
+To run the profiler, enter the following in the dev console:
+
+```javascript
+ng.profiler.timeChangeDetection();
+```
+
+The results are visible in the console.
+
+
+#### Recording CPU profiles
+
+To record a profile, pass `{record: true}` to `timeChangeDetection()`:
+
+```javascript
+ng.profiler.timeChangeDetection({record: true});
+```
+
+Then open the **Profiles** tab. The recorded profile has the title
+**Change Detection**. In Chrome, if you record the profile repeatedly, all the
+profiles are nested under Change Detection.
+
+
+#### Interpreting the numbers
+
+In a properly designed application, repeated attempts to detect changes without
+any user actions result in no changes to the UI. It is
+also desirable to have the cost of a user action be proportional to the amount
+of UI changes required. For example, popping up a menu with 5 items should be
+vastly faster than rendering a table of 500 rows and 10 columns. Therefore,
+change detection with no UI updates should be as fast as possible.
+
+#### Investigating slow change detection
+
+So you found a screen in your application on which the profiler reports a very
+high number (i.e. >3ms). This is where a recorded CPU profile can help. Enable
+recording while profiling:
+
+```javascript
+ng.profiler.timeChangeDetection({record: true});
+```
+
+Then look for hot spots using
+[Chrome CPU profiler](https://developer.chrome.com/devtools/docs/cpu-profiling).
+
+#### Reducing change detection cost
+
+There are many reasons for slow change detection. To gain intuition about
+possible causes it helps to understand how change detection works. Such a
+discussion is outside the scope of this document,
+but here are some key concepts.
+
+<!-- TODO: link to change detection docs -->
+
+By default, Angular uses a _dirty checking_ mechanism to find model changes.
+This mechanism involves evaluating every bound expression that's active on the
+UI. These usually include text interpolation via `{{expression}}` and property
+bindings via `[prop]="expression"`. If any of the evaluated expressions are
+costly to compute, they might contribute to slow change detection. A good way to
+speed things up is to use plain class fields in your expressions and avoid any
+kind of computation. For example:
+
+```dart
+@View(
+  template: '<button [enabled]="isEnabled">{{title}}</button>'
+)
+class FancyButton {
+  // GOOD: no computation, just returns the value
+  bool isEnabled;
+
+  // BAD: computes the final value upon request
+  String _title;
+  String get title => _title.trim().toUpperCase();
+}
+```
+
+Most cases like these can be solved by precomputing the value and storing the
+final value in a field.
+
+Angular also supports a second type of change detection: the _push_ model. In
+this model, Angular does not poll your component for changes. Instead, the
+component tells Angular when it changes, and only then does Angular perform
+the update. This model is suitable in situations when your data model uses
+observable or immutable objects.
+
+<!-- TODO: link to discussion of push model -->
--- a/TOOLS_JS.md
+++ b/TOOLS_JS.md
@ -0,0 +1,140 @@
+# Developer Tools for JavaScript
+
+Here you will find a collection of tools and tips for keeping your application
+perform well and contain fewer bugs.
+
+## Angular debug tools in the dev console
+
+Angular provides a set of debug tools that are accessible from any browser's
+developer console. In Chrome the dev console can be accessed by pressing
+Ctrl + Shift + j.
+
+### Enabling debug tools
+
+By default the debug tools are disabled. You can enable debug tools as follows:
+
+```typescript
+import 'angular2/tools';
+
+bootstrap(Application).then((appRef) => {
+  enableDebugTools(appRef);
+});
+```
+
+### Using debug tools
+
+In the browser open the developer console (Ctrl + Shift + j in Chrome). The
+top level object is called `ng` and contains more specific tools inside it.
+
+Example:
+
+```javascript
+ng.profiler.timeChangeDetection();
+```
+
+## Performance
+
+### Change detection profiler
+
+If your application is janky (it misses frames) or is slow according to other
+metrics it is important to find the root cause of the issue. Change detection
+is a phase in Angular's lifecycle that detects changes in values that are
+bound to UI, and if it finds a change it performs the corresponding UI update.
+However, sometimes it is hard to tell if the slowness is due to the act of
+computing the changes being slow, or due to the act of applying those changes
+to the UI. For your application to be performant it is important that the
+process of computing changes is very fast. For best results it should be under
+3 milliseconds in order to leave room for the application logic, the UI updates
+and browser's rendering pipeline to fit withing the 16 millisecond frame
+(assuming the 60 FPS target frame rate).
+
+Change detection profiler repeatedly performs change detection without invoking
+any user actions, such as clicking buttons or entering text in input fields. It
+then computes the average amount of time it took to perform a single cycle of
+change detection in milliseconds and prints it to the console. This number
+depends on the current state of the UI. You will likely see different numbers
+as you go from one screen in your application to another.
+
+#### Running the profiler
+
+Enable debug tools (see above), then in the dev console enter the following:
+
+```javascript
+ng.profiler.timeChangeDetection();
+```
+
+The results will be printed to the console.
+
+#### Recording CPU profile
+
+Pass `{record: true}` an argument:
+
+```javascript
+ng.profiler.timeChangeDetection({record: true});
+```
+
+Then open the "Profiles" tab. You will see the recorded profile titled
+"Change Detection". In Chrome, if you record the profile repeatedly, all the
+profiles will be nested under "Change Detection".
+
+#### Interpreting the numbers
+
+In a properly-designed application repeated attempts to detect changes without
+any user actions should result in no changes to be applied on the UI. It is
+also desirable to have the cost of a user action be proportional to the amount
+of UI changes required. For example, popping up a menu with 5 items should be
+vastly faster than rendering a table of 500 rows and 10 columns. Therefore,
+change detection with no UI updates should be as fast as possible. Ideally the
+number printed by the profiler should be well below the length of a single
+animation frame (16ms). A good rule of thumb is to keep it under 3ms.
+
+#### Investigating slow change detection
+
+So you found a screen in your application on which the profiler reports a very
+high number (i.e. >3ms). This is where a recorded CPU profile can help. Enable
+recording while profiling:
+
+```javascript
+ng.profiler.timeChangeDetection({record: true});
+```
+
+Then look for hot spots using
+[Chrome CPU profiler](https://developer.chrome.com/devtools/docs/cpu-profiling).
+
+#### Reducing change detection cost
+
+There are many reasons for slow change detection. To gain intuition about
+possible causes it would help to understand how change detection works. Such a
+discussion is outside the scope of this document (TODO link to docs), but here
+are some key concepts in brief.
+
+By default Angular uses "dirty checking" mechanism for finding model changes.
+This mechanism involves evaluating every bound expression that's active on the
+UI. These usually include text interpolation via `{{expression}}` and property
+bindings via `[prop]="expression"`. If any of the evaluated expressions are
+costly to compute they could contribute to slow change detection. A good way to
+speed things up is to use plain class fields in your expressions and avoid any
+kinds of computation. Example:
+
+```typescript
+@View({
+  template: '<button [enabled]="isEnabled">{{title}}</button>'
+})
+class FancyButton {
+  // GOOD: no computation, just return the value
+  isEnabled: boolean;
+
+  // BAD: computes the final value upon request
+  _title: String;
+  get title(): String { return this._title.trim().toUpperCase(); }
+}
+```
+
+Most cases like these could be solved by precomputing the value and storing the
+final value in a field.
+
+Angular also supports a second type of change detection - the "push" model. In
+this model Angular does not poll your component for changes. Instead, the
+component "tells" Angular when it changes and only then does Angular perform
+the update. This model is suitable in situations when your data model uses
+observable or immutable objects (also a discussion for another time).
--- a/TRIAGE_AND_LABELS.md
+++ b/TRIAGE_AND_LABELS.md
@ -1,104 +1,31 @@
 # Triage Process and Github Labels for Angular 2

-This document describes how the Angular team uses labels and milestones 
-to triage issues on github. The basic idea of the process is that
-caretaker only assigns a component and type (bug, feature) label. The 
-owner of the component than is in full control of how the issues should 
-be triaged further.
+This document describes how the Angular team uses labels and milestones to triage issues on github.

-Once this process is implemented and in use, we will revisit it to see 
-if further labeling is needed.
+# Issues and PRs
+## Triaged vs Untriaged Issues

-## Components
+Every triaged issue must have four attributes assigned to it:

-A caretaker should be able to determine which component the issue 
-belongs to. The components have a clear piece of source code associated
-with it.
+* `priority` -- P0 through P4. P0 issues are "drop everything and do this now". P4 are nice to have.
+* `component` -- Which area of Angular knowledge this relates to.
+* `effort` -- Rough assessment of how much work this issue is. E.g. `effort: easy` means 
+"probably a few hours of work".
+* `type` -- Whether this issue is a bug, feature, or other kind of task.

-* `comp: animations`: `@matsko`
-* `comp: benchpress`: `@tbosch`
-* `comp: build & ci`: `@IgorMinar` -- All build and CI scripts 
-* `comp: common`: `@mhevery`  -- This includes core components / pipes.
-* `comp: core & compiler`: `@tbosch` -- Because core and compiler are very 
-  intertwined, we will be treating them as one.
-* `comp: forms`: `@kara`
-* `comp: http`: `@jeffbcross`
-* `comp: i18n`: `@vicb`
-* `comp: metadata-extractor`: `@chuckjaz`
-* `comp: router`: `@vsavkin`
-* `comp: testing`: `@juliemr`
-* `comp: upgrade`: `@mhevery`
-* `comp: web-worker`: `@vicb`
-* `comp: zones`: `@mhevery`
+Untriaged issues are any issues in the queue that don't yet have these four attributes. 

-There are few components which are cross-cutting. They don't have
-a clear location in the source tree. We will treat them as a component
-even thought no specific source tree is associated with them.
-
-* `comp: docs`: `@naomiblack`
-* `comp: packaging`: `@IgorMinar`
-* `comp: performance`: `@tbosch`
-* `comp: security`: `@IgorMinar`
-
-
-## Type
-What kind of problem is this?
-
-* `type: RFC / discussion / question`
-* `type: bug`
-* `type: chore`
-* `type: feature`
-* `type: performance`
-* `type: refactor`
-
-## Caretaker Triage Process
-
-It is the caretaker's responsibility to assign `comp:  *` to each new
-issue as they come in. The reason why we limit the responsibility of the
-caretaker to this one label is that it is likely that without domain
-knowledge the caretaker could mislabel issues or lack knowledge of
-duplicate issues.
-
-
-## Component's owner Triage Process
-
-At this point we are leaving each component owner to determine their own
-process for their component.
-
-It will be up to the component owner to determine the order in which the
-issues within the component will be resolved.
-
-Several owners have adopted the issue categorization based on
-[user pain](http://www.lostgarden.com/2008/05/improving-bug-triage-with-user-pain.html)
-used by Angular 1. In this system every issue is assigned frequency and
-severity based on which the total user pain score is calculated.
-
-Following is the definition of various frequency and severity levels:
-
-1. `freq(score): *` – How often does this issue come up? How many developers does this affect?
-    * low (1) - obscure issue affecting a handful of developers
-    * moderate (2) - impacts auxiliary usage patterns, only small number of applications are affected
-    * high (3) - impacts primary usage patterns, affecting most Angular apps
-    * critical (4) - impacts all Angular apps
-1. `severity(score): *` - How bad is the issue?
-    * inconvenience (1) - causes ugly/boilerplate code in apps
-    * confusing (2) - unexpected or inconsistent behavior; hard-to-debug
-    * broken expected use (3) - it's hard or impossible for a developer using Angular to accomplish something that Angular should be able to do
-    * memory leak (4)
-    * regression (5) - functionality that used to work no longer works in a new release due to an unintentional change
-    * security issue (6)
-
-
-These criteria are then used to calculate a "user pain" score as follows:
-
-`pain = severity × frequency`
+You can view a report of untriaged issues here, in our 
+[Angular Triage Dashboard](http://mhevery.github.io/github_issues/).

+Issues should also have a clear action to complete that can be addressed or resolved within the 
+scope of Angular 2. We'll close issues that don't meet these criteria. 

 ### Assigning Issues to Milestones

 Any issue that is being worked on must have:

-* An `Assignee`: The person doing the work.
+* An `assignee`: The person doing the work.
 * A `Milestone`: When we expect to complete this work.

 We aim to only have at most three milestones open at a time:
@ -110,10 +37,7 @@ We aim to only have at most three milestones open at a time:
 The [backlog](https://github.com/angular/angular/issues?q=is%3Aopen+is%3Aissue+no%3Amilestone) 
 consists of all issues that have been triaged but do not have an assignee or milestone.  

-## Triaged vs Untrained PRs
-
-PRs should also be label with a `comp: *` so that it is clear which 
-primary area the PR effects.
+## Triaged vs Untriaged PRs

 Because of the cumulative pain associated with rebasing PRs, we triage PRs daily, and 
 closing or reviewing PRs is a top priority ahead of other ongoing work. 
@ -139,6 +63,90 @@ uncontroversial change.
 PRs do not need to be assigned to milestones, unless a milestone release should be held for that 
 PR to land.

+Victor (`vsavkin`) and Tobias (`tbosch`) are owners of the PR queue. Here is a list of [current 
+untriaged PRs](https://github.com/angular/angular/pulls?utf8=%E2%9C%93&q=is%3Aopen+no%3Amilestone+is%3Apr+-label%3A%22pr_action%3A+cleanup%22+-label%3A%22pr_action%3A+merge%22+-label%3A%22pr_action%3A+review%22+-label%3A%22pr_action%3A+discuss%22+-label%3A%22pr_state%3A+blocked%22+-label%3A%22pr_state%3A+WIP%22+).
+ 
+# Prioritization of Work
+
+What should you be working on?
+
+1. Any PRs that are assigned to you that don't have `pr_state: WIP` or `pr_state: blocked`
+1. Any issues that are assigned to you in the lowest-numbered Milestone
+1. Any issues that are assigned to you in any Milestone
+
+If there are no issues assigned to you in any Milestone, pick an issue, self-assign it, and add 
+it to the most appropriate Milestone based on effort.
+
+Here are some suggestions for what to work on next:
+
+* Filter for issues in a component that you are knowledgeable about, and pick something that has a
+ high priority.
+* Filter for any small effort task that has the special `cust: GT` or `cust:Ionic` tags, 
+and priority > P3.
+* Add a new task that's really important, add `component`, `priority`, `effort`, `type` and 
+assign it to yourself and the most appropriate milestone.
+
+# Labels Used in Triage
+
+## Priority
+How urgent is this issue? We use priority to determine what should be worked on in each new 
+milestone.
+
+* `P0: critical` -- drop everything to work on this
+* `P1: urgent` -- resolve quickly in the current milestone. people are blocked
+* `P2: required` -- needed for development but not urgent yet. workaround exists, or e.g. new API
+* `P3: important` -- must complete before Angular 2 is ready for release
+* `P4: nice to have` -- a good idea, but maybe not until after release
+
+
+## Effort
+Rough, non-binding estimate of how much work this issue represents. Please change this assessment
+for anything you're working on to better reflect reality.
+
+* `effort: easy` -- straightforward issue that can be resolved in a few hours, e.g. < 1 day of work.
+* `effort: medium` -- issue that will be a few days of work. Can be completed within a single 
+milestone.
+* `effort: tough` -- issue that will likely take more than 1 milestone to complete.
+
+<!-- We don't like these label names as 
+they're not absolute (what is one developer-hour, really?) but decided it wasn't worth arguing 
+over terms. -->
+
+## Component
+Which area of Angular knowledge is this issue most closely related to? Helpful when deciding what
+to work on next.
+
+ * `comp: benchpress` -- benchmarks and performance testing &rarr; *tbosch*, *crossj*
+ * `comp: build/dev-productivity` -- build process, e.g. CLI and related tasks &rarr; *iminar*, *caitp*
+ * `comp: build/pipeline` -- build pipeline, e.g. ts2dart &rarr; *mprobst*, *alexeagle*
+ * `comp: core` -- general core Angular issues, not related to a sub-category (see below) &rarr; 
+   *mhevery*
+ * `comp: core/animations` -- animations framework &rarr; *matsko*
+ * `comp: core/change_detection` -- change detection &rarr; *vsavkin*
+ * `comp: core/di` -- dependency injection &rarr; *vicb*, *rkirov*
+ * `comp: core/directives` -- directives 
+ * `comp: core/forms` -- forms &rarr; *vsavkin*
+ * `comp: core/pipes` -- pipes
+ * `comp: core/view` -- runtime processing of the `View`s
+ * `comp: core/view/compiler` -- static analysis of the templates which generate `ProtoView`s.
+ * `comp: core/testbed` -- e2e tests and support for them
+ * `comp: core/webworker` -- core web worker infrastructure
+ * `comp: dart-transformer` -- Dart transforms &rarr; *kegluneq*, *jakemac* 
+ * `comp: data-access` -- &rarr; *jeffbcross*
+ * `comp: docs` -- API docs and doc generation &rarr; *naomiblack*, *petebacondarwin*
+ * `comp: material-components` -- Angular Material components built in Angular 2 &rarr; *jelbourn*
+ * `comp: router` -- Component Router &rarr; *btford*, *igorminar*, *matsko*
+ * `comp: wrenchjs`
+
+## Type
+What kind of problem is this?
+
+* `type RFC / discussion / question`
+* `type bug`
+* `type chore`
+* `type feature`
+* `type performance`
+* `type refactor`

 ## Special Labels

@ -152,6 +160,9 @@ More active discussion is needed before the issue can be worked on further. Typi
 Managed by googlebot. Indicates whether a PR has a CLA on file for its author(s). Only issues with 
 `cla:yes` should be merged into master.

+### cust
+This is an issue causing user pain for early adopter customers `cust: GT` or `cust: Ionic`.
+
 ### WORKS_AS_INTENDED

 Only used on closed issues, to indicate to the reporter why we closed it.
--- a/bower.json
+++ b/bower.json
@ -1,6 +1,6 @@
 {
  "name": "angular2",
  "dependencies": {
-    "polymer": "Polymer/polymer#^1.6.0"
+    "polymer": "Polymer/polymer"
  }
 }
--- a/browser-providers.conf.js
+++ b/browser-providers.conf.js
@ -1,177 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-// Unique place to configure the browsers which are used in the different CI jobs in Sauce Labs (SL)
-// and BrowserStack (BS).
-// If the target is set to null, then the browser is not run anywhere during CI.
-// If a category becomes empty (e.g. BS and required), then the corresponding job must be commented
-// out in Travis configuration.
-var CIconfiguration = {
-  'Chrome': {unitTest: {target: 'SL', required: true}, e2e: {target: null, required: true}},
-  'Firefox': {unitTest: {target: 'SL', required: true}, e2e: {target: null, required: true}},
-  // FirefoxBeta and ChromeBeta should be target:'BS' or target:'SL', and required:true
-  // Currently deactivated due to https://github.com/angular/angular/issues/7560
-  'ChromeBeta': {unitTest: {target: null, required: true}, e2e: {target: null, required: false}},
-  'FirefoxBeta': {unitTest: {target: null, required: false}, e2e: {target: null, required: false}},
-  'ChromeDev': {unitTest: {target: null, required: true}, e2e: {target: null, required: true}},
-  'FirefoxDev': {unitTest: {target: null, required: true}, e2e: {target: null, required: true}},
-  'IE9': {unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
-  'IE10': {unitTest: {target: 'SL', required: true}, e2e: {target: null, required: true}},
-  'IE11': {unitTest: {target: 'SL', required: true}, e2e: {target: null, required: true}},
-  'Edge': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
-  'Android4.1': {unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
-  'Android4.2': {unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
-  'Android4.3': {unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
-  'Android4.4': {unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
-  'Android5': {unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
-  'Safari7': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
-  'Safari8': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
-  'Safari9': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
-  'Safari10': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
-  'iOS7': {unitTest: {target: 'BS', required: true}, e2e: {target: null, required: true}},
-  'iOS8': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
-  'iOS9': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
-  'iOS10': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
-  'WindowsPhone': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}}
-};
-
-var customLaunchers = {
-  'DartiumWithWebPlatform':
-      {base: 'Dartium', flags: ['--enable-experimental-web-platform-features']},
-  'ChromeNoSandbox': {base: 'Chrome', flags: ['--no-sandbox']},
-  'SL_CHROME': {base: 'SauceLabs', browserName: 'chrome', version: '52'},
-  'SL_CHROMEBETA': {base: 'SauceLabs', browserName: 'chrome', version: 'beta'},
-  'SL_CHROMEDEV': {base: 'SauceLabs', browserName: 'chrome', version: 'dev'},
-  'SL_FIREFOX': {base: 'SauceLabs', browserName: 'firefox', version: '46'},
-  'SL_FIREFOXBETA': {base: 'SauceLabs', browserName: 'firefox', version: 'beta'},
-  'SL_FIREFOXDEV': {base: 'SauceLabs', browserName: 'firefox', version: 'dev'},
-  'SL_SAFARI7': {base: 'SauceLabs', browserName: 'safari', platform: 'OS X 10.9', version: '7.0'},
-  'SL_SAFARI8': {base: 'SauceLabs', browserName: 'safari', platform: 'OS X 10.10', version: '8.0'},
-  'SL_SAFARI9': {base: 'SauceLabs', browserName: 'safari', platform: 'OS X 10.11', version: '9.0'},
-  'SL_SAFARI10':
-      {base: 'SauceLabs', browserName: 'safari', platform: 'OS X 10.12', version: '10.0'},
-  'SL_IOS7': {base: 'SauceLabs', browserName: 'iphone', platform: 'OS X 10.10', version: '7.1'},
-  'SL_IOS8': {base: 'SauceLabs', browserName: 'iphone', platform: 'OS X 10.10', version: '8.4'},
-  'SL_IOS9': {base: 'SauceLabs', browserName: 'iphone', platform: 'OS X 10.10', version: '9.3'},
-  'SL_IOS10': {base: 'SauceLabs', browserName: 'iphone', platform: 'OS X 10.10', version: '10.0'},
-  'SL_IE9':
-      {base: 'SauceLabs', browserName: 'internet explorer', platform: 'Windows 2008', version: '9'},
-  'SL_IE10': {
-    base: 'SauceLabs',
-    browserName: 'internet explorer',
-    platform: 'Windows 2012',
-    version: '10'
-  },
-  'SL_IE11':
-      {base: 'SauceLabs', browserName: 'internet explorer', platform: 'Windows 8.1', version: '11'},
-  'SL_EDGE': {
-    base: 'SauceLabs',
-    browserName: 'MicrosoftEdge',
-    platform: 'Windows 10',
-    version: '13.10586'
-  },
-  'SL_ANDROID4.1': {base: 'SauceLabs', browserName: 'android', platform: 'Linux', version: '4.1'},
-  'SL_ANDROID4.2': {base: 'SauceLabs', browserName: 'android', platform: 'Linux', version: '4.2'},
-  'SL_ANDROID4.3': {base: 'SauceLabs', browserName: 'android', platform: 'Linux', version: '4.3'},
-  'SL_ANDROID4.4': {base: 'SauceLabs', browserName: 'android', platform: 'Linux', version: '4.4'},
-  'SL_ANDROID5': {base: 'SauceLabs', browserName: 'android', platform: 'Linux', version: '5.1'},
-
-  'BS_CHROME': {base: 'BrowserStack', browser: 'chrome', os: 'OS X', os_version: 'Yosemite'},
-  'BS_FIREFOX': {base: 'BrowserStack', browser: 'firefox', os: 'Windows', os_version: '10'},
-  'BS_SAFARI7': {base: 'BrowserStack', browser: 'safari', os: 'OS X', os_version: 'Mavericks'},
-  'BS_SAFARI8': {base: 'BrowserStack', browser: 'safari', os: 'OS X', os_version: 'Yosemite'},
-  'BS_SAFARI9': {base: 'BrowserStack', browser: 'safari', os: 'OS X', os_version: 'El Capitan'},
-  'BS_SAFARI10': {base: 'BrowserStack', browser: 'safari', os: 'OS X', os_version: 'Sierra'},
-  'BS_IOS7': {base: 'BrowserStack', device: 'iPhone 5S', os: 'ios', os_version: '7.0'},
-  'BS_IOS8': {base: 'BrowserStack', device: 'iPhone 6', os: 'ios', os_version: '8.3'},
-  'BS_IOS9': {base: 'BrowserStack', device: 'iPhone 6S', os: 'ios', os_version: '9.1'},
-  'BS_IOS10': {base: 'BrowserStack', device: 'iPhone SE', os: 'ios', os_version: '10.0'},
-  'BS_IE9':
-      {base: 'BrowserStack', browser: 'ie', browser_version: '9.0', os: 'Windows', os_version: '7'},
-  'BS_IE10': {
-    base: 'BrowserStack',
-    browser: 'ie',
-    browser_version: '10.0',
-    os: 'Windows',
-    os_version: '8'
-  },
-  'BS_IE11': {
-    base: 'BrowserStack',
-    browser: 'ie',
-    browser_version: '11.0',
-    os: 'Windows',
-    os_version: '10'
-  },
-  'BS_EDGE': {base: 'BrowserStack', browser: 'edge', os: 'Windows', os_version: '10'},
-  'BS_WINDOWSPHONE':
-      {base: 'BrowserStack', device: 'Nokia Lumia 930', os: 'winphone', os_version: '8.1'},
-  'BS_ANDROID5': {base: 'BrowserStack', device: 'Google Nexus 5', os: 'android', os_version: '5.0'},
-  'BS_ANDROID4.4': {base: 'BrowserStack', device: 'HTC One M8', os: 'android', os_version: '4.4'},
-  'BS_ANDROID4.3':
-      {base: 'BrowserStack', device: 'Samsung Galaxy S4', os: 'android', os_version: '4.3'},
-  'BS_ANDROID4.2':
-      {base: 'BrowserStack', device: 'Google Nexus 4', os: 'android', os_version: '4.2'},
-  'BS_ANDROID4.1':
-      {base: 'BrowserStack', device: 'Google Nexus 7', os: 'android', os_version: '4.1'}
-};
-
-var sauceAliases = {
-  'ALL': Object.keys(customLaunchers).filter(function(item) {
-    return customLaunchers[item].base == 'SauceLabs';
-  }),
-  'DESKTOP': [
-    'SL_CHROME', 'SL_FIREFOX', 'SL_IE9', 'SL_IE10', 'SL_IE11', 'SL_EDGE', 'SL_SAFARI7',
-    'SL_SAFARI8', 'SL_SAFARI9', 'SL_SAFARI10'
-  ],
-  'MOBILE': [
-    'SL_ANDROID4.1', 'SL_ANDROID4.2', 'SL_ANDROID4.3', 'SL_ANDROID4.4', 'SL_ANDROID5', 'SL_IOS7',
-    'SL_IOS8', 'SL_IOS9', 'SL_IOS10'
-  ],
-  'ANDROID': ['SL_ANDROID4.1', 'SL_ANDROID4.2', 'SL_ANDROID4.3', 'SL_ANDROID4.4', 'SL_ANDROID5'],
-  'IE': ['SL_IE9', 'SL_IE10', 'SL_IE11'],
-  'IOS': ['SL_IOS7', 'SL_IOS8', 'SL_IOS9', 'SL_IOS10'],
-  'SAFARI': ['SL_SAFARI7', 'SL_SAFARI8', 'SL_SAFARI9', 'SL_SAFARI10'],
-  'BETA': ['SL_CHROMEBETA', 'SL_FIREFOXBETA'],
-  'DEV': ['SL_CHROMEDEV', 'SL_FIREFOXDEV'],
-  'CI_REQUIRED': buildConfiguration('unitTest', 'SL', true),
-  'CI_OPTIONAL': buildConfiguration('unitTest', 'SL', false)
-};
-
-var browserstackAliases = {
-  'ALL': Object.keys(customLaunchers).filter(function(item) {
-    return customLaunchers[item].base == 'BrowserStack';
-  }),
-  'DESKTOP': [
-    'BS_CHROME', 'BS_FIREFOX', 'BS_IE9', 'BS_IE10', 'BS_IE11', 'BS_EDGE', 'BS_SAFARI7',
-    'BS_SAFARI8', 'BS_SAFARI9', 'BS_SAFARI10'
-  ],
-  'MOBILE': [
-    'BS_ANDROID4.3', 'BS_ANDROID4.4', 'BS_IOS7', 'BS_IOS8', 'BS_IOS9', 'BS_IOS10', 'BS_WINDOWSPHONE'
-  ],
-  'ANDROID': ['BS_ANDROID4.3', 'BS_ANDROID4.4'],
-  'IE': ['BS_IE9', 'BS_IE10', 'BS_IE11'],
-  'IOS': ['BS_IOS7', 'BS_IOS8', 'BS_IOS9', 'BS_IOS10'],
-  'SAFARI': ['BS_SAFARI7', 'BS_SAFARI8', 'BS_SAFARI9', 'BS_SAFARI10'],
-  'CI_REQUIRED': buildConfiguration('unitTest', 'BS', true),
-  'CI_OPTIONAL': buildConfiguration('unitTest', 'BS', false)
-};
-
-module.exports = {
-  customLaunchers: customLaunchers,
-  sauceAliases: sauceAliases,
-  browserstackAliases: browserstackAliases
-};
-
-function buildConfiguration(type, target, required) {
-  return Object.keys(CIconfiguration)
-      .filter((item) => {
-        var conf = CIconfiguration[item][type];
-        return conf.required === required && conf.target === target;
-      })
-      .map((item) => target + '_' + item.toUpperCase());
-}
--- a/build.sh
+++ b/build.sh
@ -1,232 +0,0 @@
-#!/usr/bin/env bash
-
-set -e -o pipefail
-
-cd `dirname $0`
-
-PACKAGES=(core
-  compiler
-  common
-  forms
-  platform-browser
-  platform-browser-dynamic
-  platform-server
-  platform-webworker
-  platform-webworker-dynamic
-  http
-  upgrade
-  router
-  compiler-cli
-  benchpress)
-BUILD_ALL=true
-BUNDLE=true
-VERSION_PREFIX=$(node -p "require('./package.json').version")
-VERSION_SUFFIX="-$(git log --oneline -1 | awk '{print $1}')"
-ROUTER_VERSION_PREFIX=$(node -p "require('./package.json').version.replace(/^2/, '3')")
-REMOVE_BENCHPRESS=false
-
-for ARG in "$@"; do
-  case "$ARG" in
-    --packages=*)
-      PACKAGES_STR=${ARG#--packages=}
-      PACKAGES=( ${PACKAGES_STR//,/ } )
-      BUILD_ALL=false
-      ;;
-    --bundle=*)
-      BUNDLE=( "${ARG#--bundle=}" )
-      ;;
-    --publish)
-      VERSION_SUFFIX=""
-      REMOVE_BENCHPRESS=true
-      ;;
-    *)
-      echo "Unknown option $ARG."
-      exit 1
-      ;;
-  esac
-done
-
-VERSION="${VERSION_PREFIX}${VERSION_SUFFIX}"
-ROUTER_VERSION="${ROUTER_VERSION_PREFIX}${VERSION_SUFFIX}"
-echo "====== BUILDING: Version ${VERSION} (Router ${ROUTER_VERSION})"
-
-export NODE_PATH=${NODE_PATH}:$(pwd)/dist/all:$(pwd)/dist/tools
-TSC="node --max-old-space-size=3000 dist/tools/@angular/tsc-wrapped/src/main"
-UGLIFYJS=`pwd`/node_modules/.bin/uglifyjs
-TSCONFIG=./tools/tsconfig.json
-echo "====== (tools)COMPILING: \$(npm bin)/tsc -p ${TSCONFIG} ====="
-rm -rf ./dist/tools/
-mkdir -p ./dist/tools/
-$(npm bin)/tsc -p ${TSCONFIG}
-
-cp ./tools/@angular/tsc-wrapped/package.json ./dist/tools/@angular/tsc-wrapped
-
-if [[ ${BUILD_ALL} == true ]]; then
-  rm -rf ./dist/all/
-  mkdir -p ./dist/all/
-
-  echo "====== Copying files needed for e2e tests ====="
-  cp -r ./modules/playground ./dist/all/
-  cp -r ./modules/playground/favicon.ico ./dist/
-  #rsync -aP ./modules/playground/* ./dist/all/playground/
-  mkdir ./dist/all/playground/vendor
-  cd ./dist/all/playground/vendor
-  ln -s ../../../../node_modules/core-js/client/core.js .
-  ln -s ../../../../node_modules/zone.js/dist/zone.js .
-  ln -s ../../../../node_modules/zone.js/dist/long-stack-trace-zone.js .
-  ln -s ../../../../node_modules/systemjs/dist/system.src.js .
-  ln -s ../../../../node_modules/base64-js .
-  ln -s ../../../../node_modules/reflect-metadata/Reflect.js .
-  ln -s ../../../../node_modules/rxjs .
-  ln -s ../../../../node_modules/angular/angular.js .
-  ln -s ../../../../node_modules/hammerjs/hammer.js .
-  cd -
-
-  echo "====== Copying files needed for benchmarks ====="
-  cp -r ./modules/benchmarks ./dist/all/
-  cp -r ./modules/benchmarks/favicon.ico ./dist/
-  mkdir ./dist/all/benchmarks/vendor
-  cd ./dist/all/benchmarks/vendor
-  ln -s ../../../../node_modules/core-js/client/core.js .
-  ln -s ../../../../node_modules/zone.js/dist/zone.js .
-  ln -s ../../../../node_modules/zone.js/dist/long-stack-trace-zone.js .
-  ln -s ../../../../node_modules/systemjs/dist/system.src.js .
-  ln -s ../../../../node_modules/reflect-metadata/Reflect.js .
-  ln -s ../../../../node_modules/rxjs .
-  ln -s ../../../../node_modules/angular/angular.js .
-  ln -s ../../../../bower_components/polymer .
-  ln -s ../../../../node_modules/incremental-dom/dist/incremental-dom-cjs.js
-  cd -
-
-  TSCONFIG=./modules/tsconfig.json
-  echo "====== (all)COMPILING: \$(npm bin)/tsc -p ${TSCONFIG} ====="
-  # compile ts code
-  $TSC -p modules/tsconfig.json
-
-  rm -rf ./dist/packages-dist
-fi
-
-for PACKAGE in ${PACKAGES[@]}
-do
-  PWD=`pwd`
-  SRCDIR=${PWD}/modules/@angular/${PACKAGE}
-  DESTDIR=${PWD}/dist/packages-dist/${PACKAGE}
-  UMD_ES5_PATH=${DESTDIR}/bundles/${PACKAGE}.umd.js
-  UMD_TESTING_ES5_PATH=${DESTDIR}/bundles/${PACKAGE}-testing.umd.js
-  UMD_STATIC_ES5_PATH=${DESTDIR}/bundles/${PACKAGE}-static.umd.js
-  UMD_UPGRADE_ES5_PATH=${DESTDIR}/bundles/${PACKAGE}-upgrade.umd.js
-  UMD_ES5_MIN_PATH=${DESTDIR}/bundles/${PACKAGE}.umd.min.js
-  UMD_STATIC_ES5_MIN_PATH=${DESTDIR}/bundles/${PACKAGE}-static.umd.min.js
-  UMD_UPGRADE_ES5_MIN_PATH=${DESTDIR}/bundles/${PACKAGE}-upgrade.umd.min.js
-
-  if [[ ${PACKAGE} != router ]]; then
-    LICENSE_BANNER=${PWD}/modules/@angular/license-banner.txt
-  fi
-  if [[ ${PACKAGE} == router ]]; then
-    LICENSE_BANNER=${PWD}/modules/@angular/router-license-banner.txt
-  fi
-
-  rm -rf ${DESTDIR}
-
-  echo "======      COMPILING: ${TSC} -p ${SRCDIR}/tsconfig-build.json        ====="
-  $TSC -p ${SRCDIR}/tsconfig-build.json
-
-  if [[ -e ${SRCDIR}/tsconfig-upgrade.json ]]; then
-    echo "======      COMPILING: ${TSC} -p ${SRCDIR}/tsconfig-upgrade.json        ====="
-    $TSC -p ${SRCDIR}/tsconfig-upgrade.json
-  fi
-
-  cp ${SRCDIR}/package.json ${DESTDIR}/
-  cp ${PWD}/modules/@angular/README.md ${DESTDIR}/
-
-  if [[ -e ${SRCDIR}/tsconfig-testing.json ]]; then
-    echo "======      COMPILING TESTING: ${TSC} -p ${SRCDIR}/tsconfig-testing.json"
-    $TSC -p ${SRCDIR}/tsconfig-testing.json
-  fi
-
-  echo "======      TSC 1.8 d.ts compat for ${DESTDIR}   ====="
-  # safely strips 'readonly' specifier from d.ts files to make them compatible with tsc 1.8
-  if [ "$(uname)" == "Darwin" ]; then
-    find ${DESTDIR} -type f -name '*.d.ts' -print0 | xargs -0 sed -i '' -e 's/\(^ *(static |private )*\)*readonly  */\1/g'
-    find ${DESTDIR} -type f -name '*.d.ts' -print0 | xargs -0 sed -i '' -e 's/\/\/\/ <reference types="node" \/>//g'
-    find ${DESTDIR} -type f -name '*.d.ts' -print0 | xargs -0 sed -i '' -E 's/^( +)abstract ([[:alnum:]]+\:)/\1\2/g'
-  else
-    find ${DESTDIR} -type f -name '*.d.ts' -print0 | xargs -0 sed -i -e 's/\(^ *(static |private )*\)*readonly  */\1/g'
-    find ${DESTDIR} -type f -name '*.d.ts' -print0 | xargs -0 sed -i -e 's/\/\/\/ <reference types="node" \/>//g'
-    find ${DESTDIR} -type f -name '*.d.ts' -print0 | xargs -0 sed -i -E 's/^( +)abstract ([[:alnum:]]+\:)/\1\2/g'
-  fi
-
-  if [[ ${PACKAGE} == benchpress ]]; then
-    cp ${SRCDIR}/*.md ${DESTDIR}
-    cp -r ${SRCDIR}/docs ${DESTDIR}
-  fi
-
-  if [[ ${BUNDLE} == true && ${PACKAGE} != compiler-cli && ${PACKAGE} != benchpress ]]; then
-
-    echo "======      BUNDLING: ${SRCDIR} ====="
-    mkdir ${DESTDIR}/bundles
-
-    (
-      cd  ${SRCDIR}
-      echo "======         Rollup ${PACKAGE} index"
-      ../../../node_modules/.bin/rollup -c rollup.config.js
-      cat ${LICENSE_BANNER} > ${UMD_ES5_PATH}.tmp
-      cat ${UMD_ES5_PATH} >> ${UMD_ES5_PATH}.tmp
-      mv ${UMD_ES5_PATH}.tmp ${UMD_ES5_PATH}
-      $UGLIFYJS -c --screw-ie8 --comments -o ${UMD_ES5_MIN_PATH} ${UMD_ES5_PATH}
-
-
-      if [[ -e rollup-testing.config.js ]]; then
-        echo "======         Rollup ${PACKAGE} testing"
-        ../../../node_modules/.bin/rollup -c rollup-testing.config.js
-        echo "{\"main\": \"../bundles/${PACKAGE}-testing.umd.js\"}" > ${DESTDIR}/testing/package.json
-        cat ${LICENSE_BANNER} > ${UMD_TESTING_ES5_PATH}.tmp
-        cat ${UMD_TESTING_ES5_PATH} >> ${UMD_TESTING_ES5_PATH}.tmp
-        mv ${UMD_TESTING_ES5_PATH}.tmp ${UMD_TESTING_ES5_PATH}
-      fi
-
-      if [[ -e rollup-static.config.js ]]; then
-        echo "======         Rollup ${PACKAGE} static"
-        ../../../node_modules/.bin/rollup -c rollup-static.config.js
-        # create dir because it doesn't exist yet, we should move the src code here and remove this line
-        mkdir ${DESTDIR}/static
-        echo "{\"main\": \"../bundles/${PACKAGE}-static.umd.js\"}" > ${DESTDIR}/static/package.json
-        cat ${LICENSE_BANNER} > ${UMD_STATIC_ES5_PATH}.tmp
-        cat ${UMD_STATIC_ES5_PATH} >> ${UMD_STATIC_ES5_PATH}.tmp
-        mv ${UMD_STATIC_ES5_PATH}.tmp ${UMD_STATIC_ES5_PATH}
-        $UGLIFYJS -c --screw-ie8 --comments -o ${UMD_STATIC_ES5_MIN_PATH} ${UMD_STATIC_ES5_PATH}
-      fi
-
-      if [[ -e rollup-upgrade.config.js ]]; then
-        echo "======         Rollup ${PACKAGE} upgrade"
-        ../../../node_modules/.bin/rollup -c rollup-upgrade.config.js
-        # create dir because it doesn't exist yet, we should move the src code here and remove this line
-        mkdir ${DESTDIR}/upgrade
-        echo "{\"main\": \"../bundles/${PACKAGE}-upgrade.umd.js\"}" > ${DESTDIR}/upgrade/package.json
-        cat ${LICENSE_BANNER} > ${UMD_UPGRADE_ES5_PATH}.tmp
-        cat ${UMD_UPGRADE_ES5_PATH} >> ${UMD_UPGRADE_ES5_PATH}.tmp
-        mv ${UMD_UPGRADE_ES5_PATH}.tmp ${UMD_UPGRADE_ES5_PATH}
-        $UGLIFYJS -c --screw-ie8 --comments -o ${UMD_UPGRADE_ES5_MIN_PATH} ${UMD_UPGRADE_ES5_PATH}
-      fi
-    ) 2>&1 | grep -v "as external dependency"
-  fi
-  
-  (
-    echo "======      VERSION: Updating version references"
-    cd ${DESTDIR}
-    echo "======       EXECUTE: perl -p -i -e \"s/0\.0\.0\-PLACEHOLDER/${VERSION}/g\" $""(grep -ril 0\.0\.0\-PLACEHOLDER .)"
-    perl -p -i -e "s/0\.0\.0\-PLACEHOLDER/${VERSION}/g" $(grep -ril 0\.0\.0\-PLACEHOLDER .) < /dev/null 2> /dev/null
-    echo "======       EXECUTE: perl -p -i -e \"s/0\.0\.0\-ROUTERPLACEHOLDER/${ROUTER_VERSION}/g\" $""(grep -ril 0\.0\.0\-ROUTERPLACEHOLDER .)"
-    perl -p -i -e "s/0\.0\.0\-ROUTERPLACEHOLDER/${ROUTER_VERSION}/g" $(grep -ril 0\.0\.0\-ROUTERPLACEHOLDER .) < /dev/null 2> /dev/null
-  )
-done
-
-echo ""
-echo "====== Building examples: ./modules/@angular/examples/build.sh ====="
-./modules/@angular/examples/build.sh
-
-if [[ ${REMOVE_BENCHPRESS} == true ]]; then
-  echo ""
-  echo "==== Removing benchpress from publication"
-  rm -r dist/packages-dist/benchpress
-fi
--- a/circle.yml
+++ b/circle.yml
@ -1,11 +0,0 @@
-machine:
-  node:
-    version: 5.4.1
-
-dependencies:
-  pre:
-    - npm install -g npm@3.6.0
-
-test:
-  override:
-    - gulp lint
--- a/docs/PUBLIC_API.md
+++ b/docs/PUBLIC_API.md
@ -1,40 +0,0 @@
-# Supported Public API Surface of Angular
-
-Our SemVer, timed-release cycle and deprecation policy currently applies to these npm packages:
-
- `@angular/core`
- `@angular/common`
- `@angular/platform-browser`
- `@angular/platform-browser-dynamic`
- `@angular/platform-server`
- `@angular/platform-webworker`
- `@angular/platform-webworker-dynamic`
- `@angular/upgrade`
- `@angular/router`
- `@angular/forms`
- `@angular/http`
-
-
-One intentional omission from this list is `@angular/compiler`, which is currently considered a low level api and is subject to internal changes. These changes will not affect any applications or libraries using the higher-level apis (the command line interface or JIT compilation via `@angular/platform-browser-dynamic`). Only very specific use-cases require direct access to the compiler API (mostly tooling integration for IDEs, linters, etc). If you are working on this kind of integration, please reach out to us first.
-
-Additionally only the command line usage (not direct use of APIs) of `@angular/compiler-cli` is covered.
-
-Other projects developed by the Angular team like angular-cli, Angular Material, benchpress, will be covered by these or similar guarantees in the future as they mature.
-
-Within the supported packages, we provide guarantees for:
-
- symbols exported via the main entry point (e.g. `@angular/core`) and testing entry point (e.g. `@angular/core/testing`). This applies to both runtime/JavaScript values and TypeScript types.
- symbols exported via global namespace `ng` (e.g. `ng.core`)
- bundles located in the `bundles/` directory of our npm packages (e.g. `@angular/core/bundles/core.umd.js`)
-
-
-We explicitly don't consider the following to be our public API surface:
-
- any file/import paths within our package except for the `/`, `/testing` and `/bundles/*`
- constructors of injectable classes (services and directives) - please use DI to obtain instances of these classes
- any class members or symbols marked as `private` or prefixed with underscore
- extending any of our classes unless the support for this is specifically documented in the API docs
- the contents and API surface of the code generated by Angular's compiler (with one notable exception: the existence and name of `NgModuleFactory` instances exported from generated code is guaranteed)
-
-
-Our peer dependencies (e.g. typescript, zone.js, or rxjs) are not considered part of our API surface, but they are included in our SemVer policies. We might update the required version of any of these dependencies in minor releases if the update doesn't cause breaking changes for Angular applications. Peer dependency updates that result in non-trivial breaking changes must be deferred to major Angular releases.
--- a/docs/typescript-definition-package/index.js
+++ b/docs/typescript-definition-package/index.js
@ -0,0 +1,121 @@
+var Package = require('dgeni').Package;
+var jsdocPackage = require('dgeni-packages/jsdoc');
+var nunjucksPackage = require('dgeni-packages/nunjucks');
+var typescriptPackage = require('../typescript-package');
+var gitPackage = require('dgeni-packages/git');
+var path = require('canonical-path');
+
+// Define the dgeni package for generating the docs
+module.exports = new Package('angular-v2-docs', [jsdocPackage, nunjucksPackage, typescriptPackage, gitPackage])
+
+// Register the processors
+.processor(require('./processors/createTypeDefinitionFile'))
+
+.config(function(readFilesProcessor, inlineTagProcessor) {
+  readFilesProcessor.basePath = path.resolve(__dirname, '../..');
+  // Don't run unwanted processors
+  readFilesProcessor.$enabled = false;
+  inlineTagProcessor.$enabled = false;
+})
+
+
+// Configure the log service
+.config(function(log) {
+  log.level = 'info';
+})
+
+
+.config(function(renderDocsProcessor, versionInfo) {
+  renderDocsProcessor.extraData.versionInfo = versionInfo;
+})
+
+.config(function(readFilesProcessor, inlineTagProcessor, readTypeScriptModules, createTypeDefinitionFile) {
+
+  // Don't run unwanted processors
+  readFilesProcessor.$enabled = false; // We are not using the normal file reading processor
+  inlineTagProcessor.$enabled = false; // We are not actually processing the inline link tags
+
+  // Configure file reading
+  readFilesProcessor.basePath = path.resolve(__dirname, '../..');
+  readTypeScriptModules.sourceFiles = [
+    'angular2/angular2.ts',
+    'angular2/web_worker/worker.ts',
+    'angular2/web_worker/ui.ts',
+    'angular2/router.ts',
+    'angular2/http.ts',
+    'angular2/testing.ts'
+  ];
+  readTypeScriptModules.basePath = path.resolve(path.resolve(__dirname, '../../modules'));
+
+  createTypeDefinitionFile.typeDefinitions = [
+    {
+      id: 'angular2/angular2',
+      references: [],
+      modules: {
+        'angular2/angular2': {namespace: 'ng', id: 'angular2/angular2'},
+        'angular2/web_worker/worker': {namespace: 'ngWorker', id: 'angular2/web_worker/worker'},
+        'angular2/web_worker/ui': {namespace: 'ngUi', id: 'angular2/web_worker/ui'}
+      }
+    },
+    {
+      id: 'angular2/router',
+      references: ['./angular2.d.ts'],
+      remapTypes: {Type: 'ng.Type', InjectableReference: 'ng.InjectableReference', ElementRef: 'ng.ElementRef', DynamicComponentLoader: 'ng.DynamicComponentLoader'},
+      modules: {'angular2/router': {namespace: 'ngRouter', id: 'angular2/router'}}
+    },
+    {
+      id: 'angular2/http',
+      references: ['./angular2.d.ts'],
+      remapTypes: {Type: 'ng.Type', Observable: 'ng.Observable', EventEmitter: 'ng.EventEmitter', InjectableReference: 'ng.InjectableReference' },
+      modules: {'angular2/http': {namespace: 'ngHttp', id: 'angular2/http'}}
+    },
+    {
+      id: 'angular2/testing',
+      references: ['./angular2.d.ts'],
+      remapTypes: { Type: 'ng.Type', Binding: 'ng.Binding', Provider: 'ng.Provider', ViewMetadata: 'ng.ViewMetadata', Injector: 'ng.Injector',
+                    Predicate: 'ng.Predicate', ElementRef: 'ng.ElementRef', DebugElement: 'ng.DebugElement',
+                    InjectableReference: 'ng.InjectableReference', ComponentRef: 'ng.ComponentRef' },
+      modules: {'angular2/testing': {namespace: 'ngTesting', id: 'angular2/testing'}}
+    }
+  ];
+})
+
+
+.config(function(parseTagsProcessor, getInjectables) {
+  // We actually don't want to parse param docs in this package as we are getting the data out using TS
+  parseTagsProcessor.tagDefinitions.forEach(function(tagDef) {
+    if (tagDef.name === 'param') {
+      tagDef.docProperty = 'paramData';
+      tagDef.transforms = [];
+    }
+  });
+
+})
+
+
+// Configure file writing
+.config(function(writeFilesProcessor) {
+  writeFilesProcessor.outputFolder  = 'dist/docs';
+})
+
+
+// Configure rendering
+.config(function(templateFinder, templateEngine) {
+
+  // Nunjucks and Angular conflict in their template bindings so change Nunjucks
+  templateEngine.config.tags = {
+    variableStart: '{$',
+    variableEnd: '$}'
+  };
+
+  templateFinder.templateFolders
+      .unshift(path.resolve(__dirname, 'templates'));
+
+  templateFinder.templatePatterns = [
+    '${ doc.template }',
+    '${ doc.id }.${ doc.docType }.template.html',
+    '${ doc.id }.template.html',
+    '${ doc.docType }.template.html',
+    'common.template.html'
+  ];
+});
--- a/docs/typescript-definition-package/mocks/mockPackage.js
+++ b/docs/typescript-definition-package/mocks/mockPackage.js
@ -0,0 +1,11 @@
+var Package = require('dgeni').Package;
+
+module.exports = function mockPackage() {
+
+  return new Package('mockPackage', [require('../')])
+
+  // provide a mock log service
+  .factory('log', function() { return require('dgeni/lib/mocks/log')(false); })
+//  .factory('templateEngine', function() { return {}; });
+
+};
--- a/docs/typescript-definition-package/processors/code_gen.js
+++ b/docs/typescript-definition-package/processors/code_gen.js
@ -0,0 +1,220 @@
+'use strict';
+
+function DtsSerializer(remap) {
+  this.remap = remap;
+}
+
+DtsSerializer.prototype = {
+  _initializerRegex: /\s*=[^>][^,}]*/g,
+
+  constructor: DtsSerializer,
+
+  declaration: function(buffer, ast) {
+    buffer.push(ast.name);
+    if (ast.optional) buffer.push('?');
+    if (ast.typeParameters) {
+      buffer.push('<');
+      buffer.push(ast.typeParameters.join(', '));
+      buffer.push('>');
+    }
+    if (ast.parameters) {
+      buffer.push('(');
+      var parameters = ast.parameters;
+      for (var i = 0; i < parameters.length; i++) {
+        parameters[i] = parameters[i].replace(this._initializerRegex, '');
+      }
+      buffer.push(parameters.join(', '));
+      buffer.push(')');
+    }
+    if (!isConstructor(ast)) {
+      if (ast.returnType) {
+        buffer.push(': ', ast.returnType);
+      } else if (ast.parameters) {
+        buffer.push(': void');
+      } else {
+        buffer.push(': any');
+      }
+    }
+    buffer.push(';\n');
+  },
+
+  comment: function(buffer, commentText) {
+    if (!(commentText && commentText.match(/\S/))) return;
+
+    buffer.push('/**\n');
+    commentText.replace(/\n*$/, '').split('\n').forEach(function(line) {
+      buffer.push(' * ' + line + '\n');
+    });
+    buffer.push(' */\n');
+  },
+
+  member: function(buffer, ast) {
+    if (ast.private || ast.internal) return;
+
+    buffer.push('\n');
+    this.comment(buffer, ast.content);
+
+    if (ast.isStatic) buffer.push('static ');
+    this.declaration(buffer, ast);
+  },
+
+  interfaceOrClass: function(buffer, ast, isInterface) {
+    if (ast.abstract) {
+      buffer.push('abstract ');
+    }
+
+    buffer.push(isInterface ? 'interface ' : 'class ');
+    buffer.push(ast.name);
+    buffer.push(ast.typeParams);
+    buffer.push(ast.heritage);
+    buffer.push(' {');
+    buffer.indent();
+    if (ast.newMember) this.member(buffer, ast.newMember);
+    if (ast.callMember) this.member(buffer, ast.callMember);
+    if (ast.constructorDoc) this.member(buffer, ast.constructorDoc);
+
+    ast.statics.forEach(function(staticMember) {
+      this.member(buffer, staticMember);
+    }.bind(this));
+
+    ast.members.forEach(function(member) {
+      this.member(buffer, member);
+    }.bind(this));
+
+    buffer.unindent();
+    buffer.push('}');
+  },
+
+  enum: function(buffer, ast) {
+    buffer.push('enum ');
+    buffer.push(ast.name);
+    buffer.push(ast.typeParams);
+    buffer.push(ast.heritage);
+    buffer.push(' {');
+    buffer.indent();
+
+    ast.members.forEach(function(member, index) {
+      buffer.push('\n');
+      this.comment(buffer, member.content);
+      buffer.push(member.name);
+      if (index !== (ast.members.length - 1)) {
+        buffer.push(',\n');
+      }
+    }.bind(this));
+
+    buffer.unindent();
+    buffer.push('}\n');
+  },
+
+  function: function(buffer, ast) {
+    buffer.push('function ');
+    this.declaration(buffer, ast);
+  },
+
+  var: function(buffer, ast) {
+    buffer.push('var ');
+    this.declaration(buffer, ast);
+  },
+
+  let: function(buffer, ast) {
+    buffer.push('let ');
+    this.declaration(buffer, ast);
+  },
+
+  const: function(buffer, ast) {
+    buffer.push('const ');
+    this.declaration(buffer, ast);
+  },
+
+  typeAlias: function(buffer, ast) {
+    buffer.push('type ', ast.name, ' = ', ast.returnType);
+  },
+
+  serializeExport: function(ast) {
+    var buffer = new Buffer();
+    buffer.push('\n');
+
+    try {
+      this.comment(buffer, ast.content);
+
+      switch (ast.docType) {
+        case 'class': this.interfaceOrClass(buffer, ast, false); break;
+        case 'interface': this.interfaceOrClass(buffer, ast, true); break;
+        case 'function': this.function(buffer, ast); break;
+        case 'enum': this.enum(buffer, ast); break;
+        case 'var': this.var(buffer, ast); break;
+        case 'let': this.let(buffer, ast); break;
+        case 'const': this.const(buffer, ast); break;
+        case 'type-alias': this.typeAlias(buffer, ast); break;
+        default: throw new Error("unknown docType: " + ast.docType);
+      }
+
+      var string = buffer.toString();
+      for (var key in this.remap) {
+        if (this.remap.hasOwnProperty(key)) {
+          string = string.replace(new RegExp('\\b' + key + '\\b', 'gm'), this.remap[key]);
+        }
+      }
+
+      return string;
+    } catch (e) {
+      console.log(e.toString(), e.stack);
+      return 'ERROR: ' + e.toString();
+    }
+  }
+};
+
+function Buffer() {
+  this._globalBuffer = [];
+  this._indentedBuffer = [];
+  this._indentationLevel = 1;
+}
+
+Buffer.prototype = {
+  constructor: Buffer,
+
+  push: function() {
+    this._indentedBuffer.push.apply(this._indentedBuffer, arguments);
+  },
+
+  indent: function() {
+    this._globalBuffer.push({indentationLevel: this._indentationLevel, content: this._indentedBuffer.join('')});
+    this._indentationLevel++;
+    this._indentedBuffer = [];
+  },
+
+  unindent: function() {
+    this._globalBuffer.push({indentationLevel: this._indentationLevel, content: this._indentedBuffer.join('')});
+    this._indentationLevel--;
+    this._indentedBuffer = [];
+  },
+
+  toString: function() {
+    if (this._indentationLevel !== 1) {
+      throw new Exception("Forgot to unindent? Indentation level: " + this._indentationLevel);
+    }
+
+    this.unindent();
+
+    var string = '';
+
+    this._globalBuffer.forEach(function(indentedChunk) {
+      var indentation = (new Array(indentedChunk.indentationLevel * 2 + 1)).join(' ');
+      indentedChunk.content.split('\n').forEach(function(line) {
+        string += indentation + line + '\n';
+      });
+
+    });
+
+    return string;
+  }
+};
+
+function isConstructor(ast) {
+  return ast.parameters && ast.name === "constructor";
+}
+
+module.exports = {
+  DtsSerializer: DtsSerializer
+};
+
--- a/docs/typescript-definition-package/processors/createTypeDefinitionFile.js
+++ b/docs/typescript-definition-package/processors/createTypeDefinitionFile.js
@ -0,0 +1,72 @@
+var _ = require('lodash');
+var path = require('canonical-path');
+var codeGen = require('./code_gen.js');
+
+module.exports = function createTypeDefinitionFile(log, convertPrivateClassesToInterfaces) {
+
+  return {
+    $runAfter: ['processing-docs'],
+    $runBefore: ['docs-processed'],
+    $validate: {
+      dtsPath: { presence: true },
+      dtsExtension: { presence: true },
+      typeDefinitions: { presence: true }
+    },
+    dtsPath: 'typings',
+    dtsExtension: '.d.ts',
+    typeDefinitions: [],
+    $process: function(docs) {
+      var dtsPath = this.dtsPath;
+      var dtsExtension = this.dtsExtension;
+
+      // For each type definition that we wish to create we define a dgeni "doc" for it
+      var typeDefDocs = _.map(this.typeDefinitions, function(def) {
+
+        var id = def.id + dtsExtension;
+        var docPath = path.join(dtsPath, id);
+
+        return {
+          docType: 'type-definition',
+          id: id,
+          aliases: [id],
+          path: docPath,
+          outputPath: docPath,
+          // A type definition may include a number of top level modules
+          // And those modules could be aliased (such as 'angular2/angular2.api' ->
+          // 'angular2/angular2')
+          moduleDocs: _.transform(def.modules,
+                                  function(moduleDocs, props, alias) {
+                                    moduleDocs[props.id] = {
+                                      id: alias,
+                                      doc: null, namespace: props.namespace,
+                                      references: def.references
+                                    };
+                                  }),
+          dts: new codeGen.DtsSerializer(def.remapTypes)
+        };
+      });
+
+      // Now add all the module docs to their corresponding type definition doc
+      _.forEach(docs, function(doc) {
+        _.forEach(typeDefDocs, function(typeDefDoc) {
+          if(typeDefDoc.moduleDocs[doc.id]) {
+            // Add a copy, because we are going to modify it
+            typeDefDoc.moduleDocs[doc.id].doc = doc;
+          }
+        });
+      });
+
+      return _.filter(typeDefDocs, function(doc) {
+        _.forEach(doc.moduleDocs, function(modDoc, alias) {
+          if (!doc || !modDoc.doc) {
+            log.error('createTypeDefinitionFile processor: no such module "' + alias + '" (Did you forget to add it to the modules to load?)');
+            doc = null;
+            return;
+          }
+          convertPrivateClassesToInterfaces(modDoc.doc.exports, true);
+        });
+        return !!doc;
+      });
+    }
+  };
+};
--- a/docs/typescript-definition-package/processors/createTypeDefinitionFile.spec.js
+++ b/docs/typescript-definition-package/processors/createTypeDefinitionFile.spec.js
@ -0,0 +1,53 @@
+var mockPackage = require('../mocks/mockPackage');
+var Dgeni = require('dgeni');
+var path = require('canonical-path');
+var _ = require('lodash');
+
+describe('createTypeDefinitionFile processor', function() {
+  var dgeni, injector, processor;
+
+  beforeEach(function() {
+    dgeni = new Dgeni([mockPackage()]);
+    injector = dgeni.configureInjector();
+    processor = injector.get('createTypeDefinitionFile');
+
+    // Initialize the processor
+    processor.typeDefinitions = [{
+      id: 'angular2/angular2',
+      modules: {
+        'angular2/angular2': {
+          id: 'angular2/angular2',
+          namespace: 'ng'
+        }
+      }
+    }];
+  });
+
+
+
+  describe('classes with @internal constructors', function() {
+
+    it('should convert heritage from `implements` into `extends`', function() {
+
+      // Create some mock docs for testing
+      var docs = [
+        {
+          id: 'angular2/angular2',
+          exports: [
+            { docType: 'class', heritage: 'implements Xyz', constructorDoc: { internal: true }  }
+          ]
+        }
+      ];
+
+      docs = processor.$process(docs);
+
+      expect(docs.length).toEqual(1);
+      expect(docs[0].docType).toEqual('type-definition');
+
+      var moduleDoc = docs[0].moduleDocs['angular2/angular2'].doc;
+      expect(moduleDoc.exports.length).toEqual(2);
+      expect(moduleDoc.exports[0].heritage).toEqual('extends Xyz');
+    });
+  });
+
+});
--- a/docs/typescript-definition-package/templates/angular2/angular2.d.ts.template.html
+++ b/docs/typescript-definition-package/templates/angular2/angular2.d.ts.template.html
@ -0,0 +1,17 @@
+{% extends '../type-definition.template.html' %}
+{% block staticDeclarations %}
+
+interface Map<K,V> {}
+
+{% for alias, module in doc.moduleDocs %}
+declare module {$ module.namespace $} {
+  // See https://github.com/Microsoft/TypeScript/issues/1168
+  class BaseException /* extends Error */ {
+    message: string;
+    stack: string;
+    toString(): string;
+  }
+  interface InjectableReference {}
+}
+{% endfor %}
+{% endblock %}
--- a/docs/typescript-definition-package/templates/type-definition.template.html
+++ b/docs/typescript-definition-package/templates/type-definition.template.html
@ -0,0 +1,43 @@
+
+{%- macro commentBlock(doc, level) -%}
+{%- if doc.content | trim %}
+
+{% if level > 1 %}{$ '/**' | indent(level-1, true) | replace(r/\n$/, "") $}{% else %}/**{% endif %}
+{$ doc.content | trim | replace(r/^/gm, "* ") | indent(level, true) | replace(r/\n$/, "") $}
+{$ '*/' | indent(level, true) | replace(r/\n$/, "") $}{% endif -%}
+{%- endmacro -%}
+
+
+// Type definitions for Angular v{$ versionInfo.currentVersion.full | replace(r/\+/, "_") $}
+// Project: http://angular.io/
+// Definitions by: angular team <https://github.com/angular/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// ***********************************************************
+// This file is generated by the Angular build process.
+// Please do not create manual edits or send pull requests
+// modifying this file.
+// ***********************************************************
+{% for alias, module in doc.moduleDocs %}
+{%- if module.references.length %}
+// {$ alias $} depends transitively on these libraries.
+// If you don't have them installed you can install them using TSD
+// https://github.com/DefinitelyTyped/tsd
+{%- endif %}
+{% for reference in module.references %}
+///<reference path="{$ reference $}"/>{% endfor %}{% endfor %}
+{% block staticDeclarations %}{% endblock %}
+{% for alias, module in doc.moduleDocs %}
+{$ commentBlock(module.doc, 1) $}
+declare module {$ module.namespace $} {
+
+  {%- for export in module.doc.exports -%}
+    {$ doc.dts.serializeExport(export) $}
+  {% endfor %}
+}
+
+declare module "{$ alias $}" {
+  export = {$ module.namespace $};
+}
+
+{% endfor %}
--- a/docs/typescript-package/index.js
+++ b/docs/typescript-package/index.js
@ -0,0 +1,74 @@
+var basePackage = require('dgeni-packages/base');
+var jsdocPackage = require('dgeni-packages/jsdoc');
+var Package = require('dgeni').Package;
+var path = require('canonical-path');
+
+// Define the dgeni package for generating the docs
+module.exports = new Package('typescript-parsing', [basePackage, jsdocPackage])
+
+// Register the services and file readers
+.factory(require('./services/modules'))
+.factory(require('./services/tsParser'))
+.factory(require('./services/tsParser/createCompilerHost'))
+.factory(require('./services/tsParser/getFileInfo'))
+.factory(require('./services/tsParser/getExportDocType'))
+.factory(require('./services/tsParser/getContent'))
+
+.factory(require('./services/convertPrivateClassesToInterfaces'))
+
+.factory('EXPORT_DOC_TYPES', function() {
+  return [
+    'class',
+    'interface',
+    'function',
+    'var',
+    'const',
+    'enum',
+    'type-alias'
+  ];
+})
+
+
+// Register the processors
+.processor(require('./processors/readTypeScriptModules'))
+
+
+// Configure the log service
+.config(function(log) {
+  log.level = 'warn';
+})
+
+.config(function(parseTagsProcessor) {
+  parseTagsProcessor.tagDefinitions.push({ name: 'internal', transforms: function() { return true; } });
+})
+
+// Configure ids and paths
+.config(function(computeIdsProcessor, computePathsProcessor, EXPORT_DOC_TYPES) {
+
+  computeIdsProcessor.idTemplates.push({
+    docTypes: ['member'],
+    idTemplate: '${classDoc.id}.${name}',
+    getAliases: function(doc) { return [doc.id]; }
+  });
+
+  computePathsProcessor.pathTemplates.push({
+    docTypes: ['member'],
+    pathTemplate: '${classDoc.path}/${name}',
+    getOutputPath: function() {} // These docs are not written to their own file, instead they are part of their class doc
+  });
+
+  var MODULES_DOCS_PATH = 'partials/modules';
+
+  computePathsProcessor.pathTemplates.push({
+    docTypes: ['module'],
+    pathTemplate: '/${id}',
+    outputPathTemplate: MODULES_DOCS_PATH + '/${id}/index.html'
+  });
+
+  computePathsProcessor.pathTemplates.push({
+    docTypes: EXPORT_DOC_TYPES,
+    pathTemplate: '${moduleDoc.path}/${name}',
+    outputPathTemplate: MODULES_DOCS_PATH + '/${path}/index.html'
+  });
+
+});
--- a/docs/typescript-package/mocks/mockPackage.js
+++ b/docs/typescript-package/mocks/mockPackage.js
@ -0,0 +1,11 @@
+var Package = require('dgeni').Package;
+
+module.exports = function mockPackage() {
+
+  return new Package('mockPackage', [require('../')])
+
+  // provide a mock log service
+  .factory('log', function() { return require('dgeni/lib/mocks/log')(false); })
+  .factory('templateEngine', function() { return {}; });
+
+};
--- a/docs/typescript-package/mocks/readTypeScriptModules/ignoreExportsMatching.ts
+++ b/docs/typescript-package/mocks/readTypeScriptModules/ignoreExportsMatching.ts
@ -0,0 +1,4 @@
+export var __esModule = true;
+export class OKToExport {}
+export function _thisIsPrivate() {}
+export var thisIsOK = '!';
--- a/docs/typescript-package/mocks/readTypeScriptModules/interfaces.ts
+++ b/docs/typescript-package/mocks/readTypeScriptModules/interfaces.ts
@ -0,0 +1,5 @@
+export interface MyInterface {
+  optionalProperty? : string
+  <T, U extends Findable<T>>(param: T) : U
+  new (param: number) : MyInterface
+}
--- a/docs/typescript-package/mocks/readTypeScriptModules/orderingOfMembers.ts
+++ b/docs/typescript-package/mocks/readTypeScriptModules/orderingOfMembers.ts
@ -0,0 +1,6 @@
+export class Test {
+  firstItem;
+  constructor() { this.doStuff(); }
+  otherMethod() {}
+  doStuff() {}
+}
--- a/docs/typescript-package/mocks/readTypeScriptModules/privateModule.ts
+++ b/docs/typescript-package/mocks/readTypeScriptModules/privateModule.ts
@ -0,0 +1 @@
+export var x = 10;
--- a/docs/typescript-package/mocks/readTypeScriptModules/publicModule.ts
+++ b/docs/typescript-package/mocks/readTypeScriptModules/publicModule.ts
@ -0,0 +1 @@
+export { x as y} from './privateModule';
--- a/docs/typescript-package/mocks/tsParser/importedSrc.ts
+++ b/docs/typescript-package/mocks/tsParser/importedSrc.ts
@ -0,0 +1 @@
+export var x = 100;
--- a/docs/typescript-package/mocks/tsParser/testSrc.ts
+++ b/docs/typescript-package/mocks/tsParser/testSrc.ts
@ -0,0 +1,34 @@
+/**
+ * @module
+ * @description
+ * This is the module description
+ */
+
+export * from 'importedSrc';
+
+/**
+ * This is some random other comment
+ */
+
+/**
+ * This is MyClass
+ */
+export class MyClass {
+  message: String;
+
+  /**
+   * Create a new MyClass
+   * @param {String} name The name to say hello to
+   */
+  constructor(name) { this.message = 'hello ' + name; }
+
+  /**
+   * Return a greeting message
+   */
+  greet() { return this.message; }
+}
+
+/**
+ * An exported function
+ */
+export var myFn = (val: number) => return val * 2;
--- a/docs/typescript-package/processors/readTypeScriptModules.js
+++ b/docs/typescript-package/processors/readTypeScriptModules.js
@ -0,0 +1,413 @@
+var glob = require('glob');
+var path = require('canonical-path');
+var _ = require('lodash');
+var ts = require('typescript');
+
+module.exports = function readTypeScriptModules(tsParser, modules, getFileInfo,
+                                                getExportDocType, getContent, log) {
+
+  return {
+    $runAfter: ['files-read'],
+    $runBefore: ['parsing-tags'],
+
+    $validate: {
+      sourceFiles: {presence: true},
+      basePath: {presence: true},
+      hidePrivateMembers: {inclusion: [true, false]},
+      sortClassMembers: {inclusion: [true, false]},
+      ignoreExportsMatching: {}
+    },
+
+    // A collection of globs that identify those modules for which we should create docs
+    sourceFiles: [],
+    // The base path from which to load the source files
+    basePath: '.',
+    // We can ignore members of classes that are private
+    hidePrivateMembers: true,
+    // We leave class members sorted in order of declaration
+    sortClassMembers: false,
+    // We can provide a collection of strings or regexes to ignore exports whose export names match
+    ignoreExportsMatching: ['___esModule'],
+
+    $process: function(docs) {
+
+      // Convert ignoreExportsMatching to an array of regexes
+      var ignoreExportsMatching = convertToRegexCollection(this.ignoreExportsMatching);
+
+      var hidePrivateMembers = this.hidePrivateMembers;
+      var sortClassMembers = this.sortClassMembers;
+
+      var basePath = path.resolve(this.basePath);
+      var filesPaths = expandSourceFiles(this.sourceFiles, basePath);
+      var parseInfo = tsParser.parse(filesPaths, this.basePath);
+      var moduleSymbols = parseInfo.moduleSymbols;
+
+      // Iterate through each of the modules that were parsed and generate a module doc
+      // as well as docs for each module's exports.
+      moduleSymbols.forEach(function(moduleSymbol) {
+
+        var moduleDoc = createModuleDoc(moduleSymbol, basePath);
+
+        // Add this module doc to the module lookup collection and the docs collection
+        modules[moduleDoc.id] = moduleDoc;
+        docs.push(moduleDoc);
+
+        // Iterate through this module's exports and generate a doc for each
+        moduleSymbol.exportArray.forEach(function(exportSymbol) {
+
+          // Ignore exports starting with an underscore
+          if (anyMatches(ignoreExportsMatching, exportSymbol.name)) return;
+
+          // If the symbol is an Alias then for most things we want the original resolved symbol
+          var resolvedExport = exportSymbol.resolvedSymbol || exportSymbol;
+          var exportDoc = createExportDoc(exportSymbol.name, resolvedExport, moduleDoc, basePath, parseInfo.typeChecker);
+          log.debug('>>>> EXPORT: ' + exportDoc.name + ' (' + exportDoc.docType + ') from ' + moduleDoc.id);
+
+          exportDoc.members = [];
+          exportDoc.statics = [];
+
+          // Generate docs for each of the export's members
+          if (resolvedExport.flags & ts.SymbolFlags.HasMembers) {
+
+            for(var memberName in resolvedExport.members) {
+              // FIXME(alexeagle): why do generic type params appear in members?
+              if (memberName === 'T') {
+                continue;
+              }
+              log.silly('>>>>>> member: ' + memberName + ' from ' + exportDoc.id + ' in ' + moduleDoc.id);
+              var memberSymbol = resolvedExport.members[memberName];
+              var memberDoc = createMemberDoc(memberSymbol, exportDoc, basePath, parseInfo.typeChecker);
+
+              // We special case the constructor and sort the other members alphabetically
+              if (memberSymbol.flags & ts.SymbolFlags.Constructor) {
+                exportDoc.constructorDoc = memberDoc;
+                docs.push(memberDoc);
+              } else if (!hidePrivateMembers || memberSymbol.name.charAt(0) !== '_') {
+                docs.push(memberDoc);
+                exportDoc.members.push(memberDoc);
+              } else if (memberSymbol.name === '__call' && memberSymbol.flags & ts.SymbolFlags.Signature) {
+                docs.push(memberDoc);
+                exportDoc.callMember = memberDoc;
+              } else if (memberSymbol.name === '__new' && memberSymbol.flags & ts.SymbolFlags.Signature) {
+                docs.push(memberDoc);
+                exportDoc.newMember = memberDoc;
+              }
+            }
+          }
+
+          if (exportDoc.docType === 'enum') {
+            for(var memberName in resolvedExport.exports) {
+              log.silly('>>>>>> member: ' + memberName + ' from ' + exportDoc.id + ' in ' + moduleDoc.id);
+              var memberSymbol = resolvedExport.exports[memberName];
+              var memberDoc = createMemberDoc(memberSymbol, exportDoc, basePath, parseInfo.typeChecker);
+              docs.push(memberDoc);
+              exportDoc.members.push(memberDoc);
+            }
+          } else if (resolvedExport.flags & ts.SymbolFlags.HasExports) {
+            for (var exported in resolvedExport.exports) {
+              if (exported === 'prototype') continue;
+              if (hidePrivateMembers && exported.charAt(0) === '_') continue;
+              var memberSymbol = resolvedExport.exports[exported];
+              var memberDoc = createMemberDoc(memberSymbol, exportDoc, basePath, parseInfo.typeChecker);
+              memberDoc.isStatic = true;
+              docs.push(memberDoc);
+              exportDoc.statics.push(memberDoc);
+            }
+          }
+
+          if (sortClassMembers) {
+            exportDoc.members.sort(function(a, b) {
+              if (a.name > b.name) return 1;
+              if (a.name < b.name) return -1;
+              return 0;
+            });
+          }
+
+          // Add this export doc to its module doc
+          moduleDoc.exports.push(exportDoc);
+          docs.push(exportDoc);
+        });
+      });
+    }
+  };
+
+
+  function createModuleDoc(moduleSymbol, basePath) {
+    var id = moduleSymbol.name.replace(/^"|"$/g, '');
+    var moduleDoc = {
+      docType: 'module',
+      id: id,
+      aliases: [id],
+      moduleTree: moduleSymbol,
+      content: getContent(moduleSymbol),
+      exports: [],
+      fileInfo: getFileInfo(moduleSymbol, basePath),
+      location: getLocation(moduleSymbol)
+    };
+    return moduleDoc;
+  }
+
+  function createExportDoc(name, exportSymbol, moduleDoc, basePath, typeChecker) {
+    var typeParamString = '';
+    var heritageString = '';
+    var typeDefinition = '';
+
+    exportSymbol.declarations.forEach(function(decl) {
+      var sourceFile = ts.getSourceFileOfNode(decl);
+
+      if (decl.typeParameters) {
+        typeParamString = '<' + getText(sourceFile, decl.typeParameters) + '>';
+      }
+
+      if (decl.symbol.flags & ts.SymbolFlags.TypeAlias) {
+        typeDefinition = getText(sourceFile, decl.type);
+      }
+
+      if (decl.heritageClauses) {
+        decl.heritageClauses.forEach(function(heritage) {
+
+          if (heritage.token == ts.SyntaxKind.ExtendsKeyword) {
+            heritageString += " extends";
+            heritage.types.forEach(function(typ, idx) {
+              heritageString += (idx > 0 ? ',' : '') + typ.getFullText();
+            });
+          }
+
+          if (heritage.token == ts.SyntaxKind.ImplementsKeyword) {
+            heritageString += " implements";
+            heritage.types.forEach(function(typ, idx) {
+              heritageString += (idx > 0 ? ', ' : '') + typ.getFullText();
+            });
+          }
+        });
+      }
+    });
+
+    //Make sure duplicate aliases aren't created, so "Ambiguous link" warnings are prevented
+    var aliasNames = [name, moduleDoc.id + '/' + name];
+    if (typeParamString) {
+      aliasNames.push(name + typeParamString);
+      aliasNames.push(moduleDoc.id + '/' + name + typeParamString);
+    }
+
+    var exportDoc = {
+      docType: getExportDocType(exportSymbol),
+      name: name,
+      id: moduleDoc.id + '/' + name,
+      typeParams: typeParamString,
+      heritage: heritageString,
+      decorators: getDecorators(exportSymbol),
+      aliases: aliasNames,
+      moduleDoc: moduleDoc,
+      content: getContent(exportSymbol),
+      fileInfo: getFileInfo(exportSymbol, basePath),
+      location: getLocation(exportSymbol)
+    };
+
+    if (exportDoc.docType === 'var' || exportDoc.docType === 'const') {
+      exportDoc.symbolTypeName = exportSymbol.valueDeclaration.type &&
+                                 exportSymbol.valueDeclaration.type.typeName &&
+                                 exportSymbol.valueDeclaration.type.typeName.text;
+    }
+
+    if (exportDoc.docType === 'type-alias') {
+      exportDoc.returnType = getReturnType(typeChecker, exportSymbol);
+    }
+
+    if(exportSymbol.flags & ts.SymbolFlags.Function) {
+      exportDoc.parameters = getParameters(typeChecker, exportSymbol);
+    }
+    if(exportSymbol.flags & ts.SymbolFlags.Value) {
+      exportDoc.returnType = getReturnType(typeChecker, exportSymbol);
+    }
+    if (exportSymbol.flags & ts.SymbolFlags.TypeAlias) {
+      exportDoc.typeDefinition = typeDefinition;
+    }
+    if (isAbstract(exportSymbol)) {
+      exportDoc.abstract = true;
+    }
+
+    // Compute the original module name from the relative file path
+    exportDoc.originalModule = exportDoc.fileInfo.relativePath
+        .replace(new RegExp('\.' + exportDoc.fileInfo.extension + '$'), '');
+
+    return exportDoc;
+  }
+
+  function createMemberDoc(memberSymbol, classDoc, basePath, typeChecker) {
+    var memberDoc = {
+      docType: 'member',
+      classDoc: classDoc,
+      name: memberSymbol.name,
+      decorators: getDecorators(memberSymbol),
+      content: getContent(memberSymbol),
+      fileInfo: getFileInfo(memberSymbol, basePath),
+      location: getLocation(memberSymbol)
+    };
+
+    memberDoc.typeParameters = getTypeParameters(typeChecker, memberSymbol);
+
+    if(memberSymbol.flags & (ts.SymbolFlags.Signature) ) {
+      memberDoc.parameters = getParameters(typeChecker, memberSymbol);
+      memberDoc.returnType = getReturnType(typeChecker, memberSymbol);
+      switch(memberDoc.name) {
+        case '__call':
+          memberDoc.name = '';
+          break;
+        case '__new':
+          memberDoc.name = 'new';
+          break;
+      }
+    }
+
+    if (memberSymbol.flags & ts.SymbolFlags.Method) {
+      // NOTE: we use the property name `parameters` here so we don't conflict
+      // with the `params` property that will be updated by dgeni reading the
+      // `@param` tags from the docs
+      memberDoc.parameters = getParameters(typeChecker, memberSymbol);
+    }
+
+    if (memberSymbol.flags & ts.SymbolFlags.Constructor) {
+      memberDoc.parameters = getParameters(typeChecker, memberSymbol);
+      memberDoc.name = 'constructor';
+    }
+
+    if(memberSymbol.flags & ts.SymbolFlags.Value) {
+      memberDoc.returnType = getReturnType(typeChecker, memberSymbol);
+    }
+
+    if(memberSymbol.flags & ts.SymbolFlags.Optional) {
+      memberDoc.optional = true;
+    }
+
+    return memberDoc;
+  }
+
+
+  function getDecorators(symbol) {
+    var declaration = symbol.valueDeclaration || symbol.declarations[0];
+    var sourceFile = ts.getSourceFileOfNode(declaration);
+
+    var decorators = declaration.decorators && declaration.decorators.map(function(decorator) {
+      decorator = decorator.expression;
+      return {
+        name: decorator.expression ? decorator.expression.text : decorator.text,
+        arguments: decorator.arguments && decorator.arguments.map(function(argument) {
+          return getText(sourceFile, argument).trim();
+        })
+      };
+    });
+    return decorators;
+  }
+
+  function getParameters(typeChecker, symbol) {
+    var declaration = symbol.valueDeclaration || symbol.declarations[0];
+    var sourceFile = ts.getSourceFileOfNode(declaration);
+    if (!declaration.parameters) {
+      var location = getLocation(symbol);
+      throw new Error('missing declaration parameters for "' + symbol.name +
+        '" in ' + sourceFile.fileName +
+        ' at line ' + location.start.line);
+    }
+    return declaration.parameters.map(function(parameter) {
+      var paramText = '';
+      if (parameter.dotDotDotToken) {
+        paramText += '...';
+      }
+      paramText += getText(sourceFile, parameter.name);
+      if (parameter.questionToken || parameter.initializer) {
+        paramText += '?';
+      }
+      if (parameter.type) {
+        paramText += ':' + getType(sourceFile, parameter.type);
+      } else {
+        paramText += ': any';
+        if (parameter.dotDotDotToken) {
+          paramText += '[]';
+        }
+      }
+      return paramText.trim();
+    });
+  }
+
+  function getTypeParameters(typeChecker, symbol) {
+    var declaration = symbol.valueDeclaration || symbol.declarations[0];
+    var sourceFile = ts.getSourceFileOfNode(declaration);
+    if (!declaration.typeParameters) return;
+    var typeParams = declaration.typeParameters.map(function(type) {
+      return getText(sourceFile, type).trim();
+    });
+    return typeParams;
+  }
+
+  function getReturnType(typeChecker, symbol) {
+    var declaration = symbol.valueDeclaration || symbol.declarations[0];
+    var sourceFile = ts.getSourceFileOfNode(declaration);
+    if (declaration.type) {
+      return getType(sourceFile, declaration.type).trim();
+    }
+  }
+
+  function isAbstract(symbol) {
+    var declaration = symbol.valueDeclaration || symbol.declarations[0];
+    return declaration.flags & ts.NodeFlags.Abstract;
+  }
+
+  function expandSourceFiles(sourceFiles, basePath) {
+    var filePaths = [];
+    sourceFiles.forEach(function(sourcePattern) {
+      filePaths = filePaths.concat(glob.sync(sourcePattern, { cwd: basePath }));
+    });
+    return filePaths;
+  }
+
+
+  function getText(sourceFile, node) {
+    return sourceFile.text.substring(node.pos, node.end);
+  }
+
+
+  // Strip any local renamed imports from the front of types
+  function getType(sourceFile, type) {
+    var text = getText(sourceFile, type);
+    while (text.indexOf(".") >= 0) {
+      // Keep namespaced symbols in RxNext
+      if (text.match(/^\s*RxNext\./)) break;
+      // handle the case List<thing.stuff> -> List<stuff>
+      text = text.replace(/([^.<]*)\.([^>]*)/, "$2");
+    }
+    return text;
+  }
+
+  function getLocation(symbol) {
+    var node = symbol.valueDeclaration || symbol.declarations[0];
+    var sourceFile = ts.getSourceFileOfNode(node);
+    var location = {
+      start: ts.getLineAndCharacterOfPosition(sourceFile, node.pos),
+      end: ts.getLineAndCharacterOfPosition(sourceFile, node.end)
+    };
+    return location;
+  }
+
+};
+
+function convertToRegexCollection(items) {
+  if (!items) return [];
+
+  // Must be an array
+  if (!_.isArray(items)) {
+    items = [items];
+  }
+
+  // Convert string to exact matching regexes
+  return items.map(function(item) {
+    return _.isString(item) ? new RegExp('^' + item + '$') : item;
+  });
+}
+
+function anyMatches(regexes, item) {
+  for(var i=0; i<regexes.length; ++i) {
+    if ( item.match(regexes[i]) ) return true;
+  }
+  return false;
+}
--- a/docs/typescript-package/processors/readTypeScriptModules.spec.js
+++ b/docs/typescript-package/processors/readTypeScriptModules.spec.js
@ -0,0 +1,127 @@
+var mockPackage = require('../mocks/mockPackage');
+var Dgeni = require('dgeni');
+var path = require('canonical-path');
+var _ = require('lodash');
+
+describe('readTypeScriptModules', function() {
+  var dgeni, injector, processor;
+
+  beforeEach(function() {
+    dgeni = new Dgeni([mockPackage()]);
+    injector = dgeni.configureInjector();
+    processor = injector.get('readTypeScriptModules');
+    processor.basePath = path.resolve(__dirname, '../mocks/readTypeScriptModules');
+  });
+
+
+  describe('exportDocs', function() {
+    it('should provide the original module if the export is re-exported', function() {
+      processor.sourceFiles = [ 'publicModule.ts' ];
+      var docs = [];
+      processor.$process(docs);
+
+      var exportedDoc = docs[1];
+      expect(exportedDoc.originalModule).toEqual('privateModule');
+    });
+  });
+
+
+  describe('ignoreExportsMatching', function() {
+    it('should ignore exports that match items in the `ignoreExportsMatching` property', function() {
+      processor.sourceFiles = [ 'ignoreExportsMatching.ts'];
+      processor.ignoreExportsMatching = [/^_/];
+      var docs = [];
+      processor.$process(docs);
+
+      var moduleDoc = docs[0];
+      expect(moduleDoc.docType).toEqual('module');
+      expect(moduleDoc.exports).toEqual([
+        jasmine.objectContaining({ name: 'OKToExport' }),
+        jasmine.objectContaining({ name: 'thisIsOK' })
+      ]);
+    });
+
+    it('should only ignore `___esModule` exports by default', function() {
+      processor.sourceFiles = [ 'ignoreExportsMatching.ts'];
+      var docs = [];
+      processor.$process(docs);
+
+      var moduleDoc = docs[0];
+      expect(moduleDoc.docType).toEqual('module');
+      expect(getNames(moduleDoc.exports)).toEqual([
+        'OKToExport',
+        '_thisIsPrivate',
+        'thisIsOK'
+      ]);
+    });
+  });
+
+
+  describe('interfaces', function() {
+
+    it('should mark optional properties', function() {
+      processor.sourceFiles = [ 'interfaces.ts'];
+      var docs = [];
+      processor.$process(docs);
+
+      var moduleDoc = docs[0];
+      var exportedInterface = moduleDoc.exports[0];
+      var member = exportedInterface.members[0];
+      expect(member.name).toEqual('optionalProperty');
+      expect(member.optional).toEqual(true);
+    });
+
+
+    it('should handle "call" type interfaces', function() {
+      processor.sourceFiles = [ 'interfaces.ts'];
+      var docs = [];
+      processor.$process(docs);
+
+      var moduleDoc = docs[0];
+      var exportedInterface = moduleDoc.exports[0];
+
+      expect(exportedInterface.callMember).toBeDefined();
+      expect(exportedInterface.callMember.parameters).toEqual(['param: T']);
+      expect(exportedInterface.callMember.returnType).toEqual('U');
+      expect(exportedInterface.callMember.typeParameters).toEqual(['T', 'U extends Findable<T>']);
+      expect(exportedInterface.newMember).toBeDefined();
+      expect(exportedInterface.newMember.parameters).toEqual(['param: number']);
+      expect(exportedInterface.newMember.returnType).toEqual('MyInterface');
+    });
+  });
+
+
+  describe('ordering of members', function() {
+    it('should order class members in order of appearance (by default)', function() {
+      processor.sourceFiles = ['orderingOfMembers.ts'];
+      var docs = [];
+      processor.$process(docs);
+      var classDoc = _.find(docs, { docType: 'class' });
+      expect(classDoc.docType).toEqual('class');
+      expect(getNames(classDoc.members)).toEqual([
+        'firstItem',
+        'otherMethod',
+        'doStuff',
+      ]);
+    });
+
+
+    it('should not order class members if not sortClassMembers is false', function() {
+      processor.sourceFiles = ['orderingOfMembers.ts'];
+      processor.sortClassMembers = false;
+      var docs = [];
+      processor.$process(docs);
+      var classDoc = _.find(docs, { docType: 'class' });
+      expect(classDoc.docType).toEqual('class');
+      expect(getNames(classDoc.members)).toEqual([
+        'firstItem',
+        'otherMethod',
+        'doStuff'
+      ]);
+    });
+  });
+});
+
+function getNames(collection) {
+  return collection.map(function(item) { return item.name; });
+}
--- a/docs/typescript-package/services/convertPrivateClassesToInterfaces.js
+++ b/docs/typescript-package/services/convertPrivateClassesToInterfaces.js
@ -0,0 +1,31 @@
+var _ = require('lodash');
+
+module.exports = function convertPrivateClassesToInterfaces() {
+  return function(exportDocs, addInjectableReference) {
+    _.forEach(exportDocs, function(exportDoc) {
+
+      // Search for classes with a constructor marked as `@internal`
+      if (exportDoc.docType === 'class' && exportDoc.constructorDoc && exportDoc.constructorDoc.internal) {
+
+        // Convert this class to an interface with no constructor
+        exportDoc.docType = 'interface';
+        exportDoc.constructorDoc = null;
+
+        if (exportDoc.heritage) {
+          // convert the heritage since interfaces use `extends` not `implements`
+          exportDoc.heritage = exportDoc.heritage.replace('implements', 'extends');
+        }
+
+        if (addInjectableReference) {
+          // Add the `declare var SomeClass extends InjectableReference` construct
+          exportDocs.push({
+            docType: 'var',
+            name: exportDoc.name,
+            id: exportDoc.id,
+            returnType: 'InjectableReference'
+          });
+        }
+      }
+    });
+  };
+};
--- a/docs/typescript-package/services/convertPrivateClassesToInterfaces.spec.js
+++ b/docs/typescript-package/services/convertPrivateClassesToInterfaces.spec.js
@ -0,0 +1,76 @@
+var mockPackage = require('../mocks/mockPackage');
+var Dgeni = require('dgeni');
+var _ = require('lodash');
+
+describe('readTypeScriptModules', function() {
+  var dgeni, injector, convertPrivateClassesToInterfaces;
+
+  beforeEach(function() {
+    dgeni = new Dgeni([mockPackage()]);
+    injector = dgeni.configureInjector();
+    convertPrivateClassesToInterfaces = injector.get('convertPrivateClassesToInterfaces');
+  });
+
+  it('should convert @internal class docs to interface docs', function() {
+    var docs = [
+      {
+        docType: 'class',
+        name: 'privateClass',
+        id: 'privateClass',
+        constructorDoc: { internal: true }
+      }
+    ];
+    convertPrivateClassesToInterfaces(docs, false);
+    expect(docs[0].docType).toEqual('interface');
+  });
+
+
+  it('should not touch non-internal class docs', function() {
+    var docs = [
+      {
+        docType: 'class',
+        name: 'privateClass',
+        id: 'privateClass',
+        constructorDoc: { }
+      }
+    ];
+    convertPrivateClassesToInterfaces(docs, false);
+    expect(docs[0].docType).toEqual('class');
+  });
+
+
+  it('should convert the heritage since interfaces use `extends` not `implements`', function() {
+    var docs = [
+      {
+        docType: 'class',
+        name: 'privateClass',
+        id: 'privateClass',
+        constructorDoc: { internal: true },
+        heritage: 'implements parentInterface'
+      }
+    ];
+    convertPrivateClassesToInterfaces(docs, false);
+    expect(docs[0].heritage).toEqual('extends parentInterface');
+  });
+
+
+  it('should add new injectable reference types, if specified, to the passed in collection', function() {
+    var docs = [
+      {
+        docType: 'class',
+        name: 'privateClass',
+        id: 'privateClass',
+        constructorDoc: { internal: true },
+        heritage: 'implements parentInterface'
+      }
+    ];
+    convertPrivateClassesToInterfaces(docs, true);
+    expect(docs[1]).toEqual({
+      docType : 'var',
+      name : 'privateClass',
+      id : 'privateClass',
+      returnType : 'InjectableReference'
+    });
+  });
+
+});
--- a/docs/typescript-package/services/modules.js
+++ b/docs/typescript-package/services/modules.js
@ -0,0 +1,3 @@
+module.exports = function modules() {
+  return {};
+};
--- a/docs/typescript-package/services/tsParser/createCompilerHost.js
+++ b/docs/typescript-package/services/tsParser/createCompilerHost.js
@ -0,0 +1,75 @@
+var ts = require('typescript');
+var fs = require('fs');
+var path = require('canonical-path');
+
+// We need to provide our own version of CompilerHost because we want to set the
+// base directory and specify what extensions to consider when trying to load a source
+// file
+module.exports = function createCompilerHost(log) {
+
+  return function createCompilerHost(options, baseDir, extensions) {
+
+    return {
+      getSourceFile: function(fileName, languageVersion, onError) {
+        var text, resolvedPath, resolvedPathWithExt;
+
+        // Strip off the extension and resolve relative to the baseDir
+        baseFilePath = fileName.replace(/\.[^.]+$/, '');
+        resolvedPath = path.resolve(baseDir, baseFilePath);
+
+        // Iterate through each possible extension and return the first source file that is actually found
+        for(var i=0; i<extensions.length; i++) {
+
+          // Try reading the content from files using each of the given extensions
+          try {
+            resolvedPathWithExt = resolvedPath + extensions[i];
+            log.silly('getSourceFile:', resolvedPathWithExt);
+            text = fs.readFileSync(resolvedPathWithExt, { encoding: options.charset });
+            log.debug('found source file:', fileName, resolvedPathWithExt);
+            return ts.createSourceFile(baseFilePath + extensions[i], text, languageVersion);
+          }
+          catch(e) {
+            // Try again if the file simply did not exist, otherwise report the error as a warning
+            if(e.code !== 'ENOENT') {
+              if (onError) onError(e.message);
+              log.warn('Error reading ' + resolvedPathWithExt + ' : ' + e.message);
+            }
+          }
+        }
+      },
+      getDefaultLibFileName: function(options) {
+        return path.resolve(path.dirname(ts.sys.getExecutingFilePath()), ts.getDefaultLibFileName(options));
+      },
+      writeFile: function(fileName, data, writeByteOrderMark, onError) {
+        // no-op
+      },
+      getCurrentDirectory: function() {
+        return baseDir;
+      },
+      useCaseSensitiveFileNames: function() {
+        return ts.sys.useCaseSensitiveFileNames;
+      },
+      getCanonicalFileName: function(fileName) {
+        // if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form.
+        // otherwise use toLowerCase as a canonical form.
+        return ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+      },
+      getNewLine: function() {
+        return ts.sys.newLine;
+      },
+      fileExists: function(fileName) {
+        var resolvedPath = path.resolve(baseDir, fileName);
+        try {
+          fs.statSync(resolvedPath);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      },
+      readFile: function(fileName) {
+        var resolvedPath = path.resolve(baseDir, fileName);
+        return fs.readFileSync(resolvedPath, { encoding: options.charset });
+      }
+    };
+  };
+};
--- a/docs/typescript-package/services/tsParser/createCompilerHost.spec.js
+++ b/docs/typescript-package/services/tsParser/createCompilerHost.spec.js
@ -0,0 +1,80 @@
+var mockPackage = require('../../mocks/mockPackage');
+var Dgeni = require('dgeni');
+var path = require('canonical-path');
+var ts = require('typescript');
+
+describe('createCompilerHost', function() {
+  var dgeni, injector, options, host, baseDir, extensions;
+
+  beforeEach(function() {
+    dgeni = new Dgeni([mockPackage()]);
+    injector = dgeni.configureInjector();
+    var createCompilerHost = injector.get('createCompilerHost');
+
+    options = { charset: 'utf8' };
+    baseDir = path.resolve(__dirname, '../../mocks/tsParser');
+    extensions = ['.ts', '.js'];
+
+    host = createCompilerHost(options, baseDir, extensions);
+  });
+
+  describe('getSourceFile', function() {
+    it('should return a SourceFile object for a given path, with fileName relative to baseDir', function() {
+      var sourceFile = host.getSourceFile('testSrc.ts');
+      expect(sourceFile.fileName).toEqual('testSrc.ts');
+      expect(sourceFile.pos).toEqual(0);
+      expect(sourceFile.text).toEqual(jasmine.any(String));
+    });
+
+    it('should try each of the configured extensions and update the filename to the correct extension', function() {
+      var sourceFile = host.getSourceFile('testSrc.js');
+      expect(sourceFile.fileName).toEqual('testSrc.ts');
+
+      sourceFile = host.getSourceFile('../mockPackage.ts');
+      expect(sourceFile.fileName).toEqual('../mockPackage.js');
+    });
+  });
+
+
+  describe('getDefaultLibFileName', function() {
+    it('should return a path to the default library', function() {
+      expect(host.getDefaultLibFileName(options)).toContain('typescript/lib/lib.d.ts');
+    });
+  });
+
+
+  describe('writeFile', function() {
+    it('should do nothing', function() {
+      host.writeFile();
+    });
+  });
+
+
+  describe('getCurrentDirectory', function() {
+    it('should return the baseDir', function() {
+      expect(host.getCurrentDirectory()).toEqual(baseDir);
+    });
+  });
+
+
+  describe('useCaseSensitiveFileNames', function() {
+    it('should return true if the OS is case sensitive', function() {
+      expect(host.useCaseSensitiveFileNames()).toBe(ts.sys.useCaseSensitiveFileNames);
+    });
+  });
+
+
+  describe('getCanonicalFileName', function() {
+    it('should lower case the filename', function() {
+      var expectedFilePath = host.useCaseSensitiveFileNames() ? 'SomeFile.ts' : 'somefile.ts';
+      expect(host.getCanonicalFileName('SomeFile.ts')).toEqual(expectedFilePath);
+    });
+  });
+
+
+  describe('getNewLine', function() {
+    it('should return the newline character for the OS', function() {
+      expect(host.getNewLine()).toEqual(require('os').EOL);
+    });
+  });
+});
--- a/docs/typescript-package/services/tsParser/getContent.js
+++ b/docs/typescript-package/services/tsParser/getContent.js
@ -0,0 +1,49 @@
+var ts = require('typescript');
+var LEADING_STAR = /^[^\S\r\n]*\*[^\S\n\r]?/gm;
+
+module.exports = function getContent() {
+  return function(symbol) {
+
+    var content = "";
+
+    if (!symbol.declarations) return content;
+
+    symbol.declarations.forEach(function(declaration) {
+
+      // If this is left side of dotted module declaration, there is no doc comment associated with this declaration
+      if (declaration.kind === ts.SyntaxKind.ModuleDeclaration && declaration.body.kind === ts.SyntaxKind.ModuleDeclaration) {
+          return content;
+      }
+
+      // If this is dotted module name, get the doc comments from the parent
+      while (declaration.kind === ts.SyntaxKind.ModuleDeclaration && declaration.parent.kind === ts.SyntaxKind.ModuleDeclaration) {
+          declaration = declaration.parent;
+      }
+
+      // If this is a variable declaration then we get the doc comments from the grand parent
+      if (declaration.kind === ts.SyntaxKind.VariableDeclaration) {
+        declaration = declaration.parent.parent;
+      }
+
+      // Get the source file of this declaration
+      var sourceFile = ts.getSourceFileOfNode(declaration);
+      var commentRanges = ts.getJsDocComments(declaration, sourceFile);
+
+      if (commentRanges) {
+        commentRanges.forEach(function(commentRange) {
+          content += sourceFile.text
+              .substring(commentRange.pos+ '/**'.length, commentRange.end - '*/'.length)
+              .replace(LEADING_STAR, '')
+              .trim();
+          if (commentRange.hasTrailingNewLine) {
+            content += '\n';
+          }
+        });
+      }
+
+      content += '\n';
+    });
+
+    return content;
+  };
+};
--- a/docs/typescript-package/services/tsParser/getExportDocType.js
+++ b/docs/typescript-package/services/tsParser/getExportDocType.js
@ -0,0 +1,54 @@
+var ts = require('typescript');
+
+module.exports = function getExportDocType(log) {
+
+  return function(symbol) {
+    if(symbol.flags & ts.SymbolFlags.Function) {
+      return 'function';
+    }
+    if(symbol.flags & ts.SymbolFlags.Class) {
+      return 'class';
+    }
+    if(symbol.flags & ts.SymbolFlags.Interface) {
+      return 'interface';
+    }
+    if(symbol.flags & ts.SymbolFlags.ConstEnum) {
+      return 'enum';
+    }
+    if(symbol.flags & ts.SymbolFlags.RegularEnum) {
+      return 'enum';
+    }
+    if(symbol.flags & ts.SymbolFlags.Property) {
+      return 'module-property';
+    }
+    if(symbol.flags & ts.SymbolFlags.TypeAlias) {
+      return 'type-alias';
+    }
+    if(symbol.flags & ts.SymbolFlags.FunctionScopedVariable) {
+      return 'var';
+    }
+    if(symbol.flags & ts.SymbolFlags.BlockScopedVariable) {
+      return getBlockScopedVariableDocType(symbol);
+    }
+
+    log.warn('getExportDocType(): Unknown symbol type', {
+      symbolName: symbol.name,
+      symbolType: symbol.flags,
+      symbolTarget: symbol.target,
+      file: ts.getSourceFileOfNode(symbol.declarations[0]).fileName
+    });
+    return 'unknown';
+  };
+
+  function getBlockScopedVariableDocType(symbol) {
+
+    var node = symbol.valueDeclaration;
+    while(node) {
+      if ( node.flags & 0x2000 /* const */) {
+        return 'const';
+      }
+      node = node.parent;
+    }
+    return 'let';
+  }
+};
--- a/docs/typescript-package/services/tsParser/getFileInfo.js
+++ b/docs/typescript-package/services/tsParser/getFileInfo.js
@ -0,0 +1,20 @@
+var path = require('canonical-path');
+var ts = require('typescript');
+
+module.exports = function getFileInfo(log) {
+
+  return function (symbol, basePath) {
+    var fileName = ts.getSourceFileOfNode(symbol.declarations[0]).fileName;
+
+    var file = path.resolve(basePath, fileName);
+    var fileInfo = {
+      filePath: file,
+      baseName: path.basename(file, path.extname(file)),
+      extension: path.extname(file).replace(/^\./, ''),
+      basePath: basePath,
+      relativePath: fileName,
+      projectRelativePath: fileName
+    };
+    return fileInfo;
+  };
+};
--- a/docs/typescript-package/services/tsParser/index.js
+++ b/docs/typescript-package/services/tsParser/index.js
@ -0,0 +1,74 @@
+var ts = require('typescript');
+var path = require('canonical-path');
+
+module.exports = function tsParser(createCompilerHost, log) {
+
+  return {
+
+    // These are the extension that we should consider when trying to load a module
+    // During migration from Traceur, there is a mix of `.ts`, `.es6` and `.js` (atScript)
+    // files in the project and the TypeScript compiler only looks for `.ts` files when trying
+    // to load imports.
+    extensions: ['.ts', '.js'],
+
+    // The options for the TS compiler
+    options: {
+      allowNonTsExtensions: true,
+      charset: 'utf8'
+    },
+
+    parse: function(fileNames, baseDir) {
+
+      // "Compile" a program from the given module filenames, to get hold of a
+      // typeChecker that can be used to interrogate the modules, exports and so on.
+      var host = createCompilerHost(this.options, baseDir, this.extensions);
+      var program = ts.createProgram(fileNames, this.options, host);
+      var typeChecker = program.getTypeChecker();
+
+      // Create an array of module symbols for each file we were given
+      var moduleSymbols = [];
+      fileNames.forEach(function(fileName) {
+        var sourceFile = program.getSourceFile(fileName);
+
+        if (!sourceFile) {
+          throw new Error('Invalid source file: ' + fileName);
+        } else if (!sourceFile.symbol) {
+          // Some files contain only a comment and no actual module code
+          log.warn('No module code found in ' + fileName);
+        } else {
+          moduleSymbols.push(sourceFile.symbol);
+        }
+      });
+
+
+      moduleSymbols.forEach(function(tsModule) {
+
+        // The type checker has a nice helper function that returns an array of Symbols
+        // representing the exports for a given module
+        tsModule.exportArray = typeChecker.getExportsOfModule(tsModule);
+
+        // Although 'star' imports (e.g. `export * from 'some/module';) get resolved automatically
+        // by the compiler/binder, it seems that explicit imports (e.g. `export {SomeClass} from 'some/module'`)
+        // do not so we have to do a little work.
+        tsModule.exportArray.forEach(function(moduleExport) {
+          if (moduleExport.flags & ts.SymbolFlags.Alias) {
+            // To maintain the alias information (particularly the alias name)
+            // we just attach the original "resolved" symbol to the alias symbol
+            moduleExport.resolvedSymbol = typeChecker.getAliasedSymbol(moduleExport);
+          }
+        });
+      });
+
+      moduleSymbols.typeChecker = typeChecker;
+
+      return {
+        moduleSymbols: moduleSymbols,
+        typeChecker: typeChecker,
+        program: program,
+        host: host
+      };
+    }
+  };
+
+
+};
--- a/docs/typescript-package/services/tsParser/index.spec.js
+++ b/docs/typescript-package/services/tsParser/index.spec.js
@ -0,0 +1,21 @@
+var mockPackage = require('../../mocks/mockPackage');
+var Dgeni = require('dgeni');
+var path = require('canonical-path');
+
+describe('tsParser', function() {
+  var dgeni, injector, parser;
+
+  beforeEach(function() {
+    dgeni = new Dgeni([mockPackage()]);
+    injector = dgeni.configureInjector();
+    parser = injector.get('tsParser');
+  });
+
+  it("should parse a TS file", function() {
+    var parseInfo = parser.parse(['testSrc.ts'], path.resolve(__dirname, '../../mocks/tsParser'));
+    var tsModules = parseInfo.moduleSymbols;
+    expect(tsModules.length).toEqual(1);
+    expect(tsModules[0].exportArray.length).toEqual(3);
+    expect(tsModules[0].exportArray.map(function(i) { return i.name; })).toEqual(['MyClass', 'myFn', 'x']);
+  });
+});
--- a/gulpfile.js
+++ b/gulpfile.js
--- a/karma-dart-evalcache.js
+++ b/karma-dart-evalcache.js
@ -0,0 +1,86 @@
+// This module provides a customFileHandler for karma
+// that serves files with urls like /packages_<timestamp>/...
+// with maximum cache.
+// We are using these urls when we spawn isolates
+// so that the isolates don't reload files every time.
+
+var common = require('karma/lib/middleware/common');
+var fs = require('fs');
+
+var DART_EVAL_PATH_RE = /.*\/packages_\d+\/(.*)$/;
+
+module.exports = createFactory;
+
+function createFactory(proxyPaths) {
+  return {
+    'framework:dart-evalcache': ['factory', dartEvalCacheFactory]
+  };
+
+  function dartEvalCacheFactory(emitter, logger, customFileHandlers) {
+    var filesPromise = new common.PromiseContainer();
+    emitter.on('file_list_modified', function(files) {
+      filesPromise.set(Promise.resolve(files));
+    });
+
+    var serveFile = common.createServeFile(fs);
+    var log = logger.create('dart-evalcache');
+
+    customFileHandlers.push({
+      urlRegex: DART_EVAL_PATH_RE,
+      handler: handler
+    });
+
+    // See source_files handler
+    function handler(request, response, fa, fb, basePath) {
+      return filesPromise.then(function(files) {
+        try {
+          var requestedFilePath = mapUrlToFile(request.url, proxyPaths, basePath, log);
+          // TODO(vojta): change served to be a map rather then an array
+          var file = findByPath(files.served, requestedFilePath);
+          if (file) {
+            serveFile(file.contentPath || file.path, response, function() {
+              common.setHeavyCacheHeaders(response);
+            }, file.content);
+          } else {
+            response.writeHead(404);
+            response.end('Not found');
+          }
+        } catch (e) {
+          log.error(e.stack);
+          response.writeHead(500);
+          response.end('Error', e.stack);
+        }
+      });
+    }
+  };
+}
+
+function mapUrlToFile(url, proxyPaths, basePath, log) {
+  var originalUrl = url;
+  url = url.indexOf('?') > -1 ? url.substring(0, url.indexOf('?')) : url;
+  var match = DART_EVAL_PATH_RE.exec(url);
+  var packagePath = match[1];
+  var result = null;
+  var lastProxyFromLength = 0;
+  Object.keys(proxyPaths).forEach(function(proxyFrom) {
+    if (startsWith(packagePath, proxyFrom) && proxyFrom.length > lastProxyFromLength) {
+      lastProxyFromLength = proxyFrom.length;
+      result = proxyPaths[proxyFrom] + packagePath.substring(proxyFrom.length);
+    }
+  });
+  return basePath + '/' + result;
+}
+
+function startsWith(string, subString) {
+  return string.length >= subString.length && string.slice(0, subString.length) === subString;
+}
+
+function findByPath(files, path) {
+  for (var i = 0; i < files.length; i++) {
+    if (files[i].path === path) {
+      return files[i];
+    }
+  }
+
+  return null;
+}
--- a/karma-dart.conf.js
+++ b/karma-dart.conf.js
@ -0,0 +1,82 @@
+var sauceConf = require('./sauce.conf');
+
+var packageSources = {
+  // Dependencies installed with `pub install`.
+  'unittest': 'packages/unittest',
+  'guinness': 'packages/guinness',
+  'matcher': 'packages/matcher',
+  'stack_trace': 'packages/stack_trace',
+  'collection': 'packages/collection',
+  'path': 'packages/path',
+  'observe': 'packages/observe',
+  'quiver': 'packages/quiver',
+  'intl': 'packages/intl',
+  'smoke': 'packages/smoke',
+  'logging': 'packages/logging',
+  'utf': 'packages/utf',
+
+  // Local dependencies, transpiled from the source.
+  'angular2': 'dist/dart/angular2/lib',
+  'angular2/test/': 'dist/dart/angular2/test/',
+  'http': 'dist/dart/http/lib',
+  'angular2_material': 'dist/dart/angular2_material/lib',
+  'benchpress': 'dist/dart/benchpress/lib',
+  'examples': 'dist/dart/examples/lib'
+};
+
+var proxyPaths = {};
+Object.keys(packageSources).map(function(packageName) {
+  var filePath = packageSources[packageName];
+  proxyPaths['/packages/'+packageName] = '/base/'+filePath;
+});
+
+// Karma configuration
+// Generated on Thu Sep 25 2014 11:52:02 GMT-0700 (PDT)
+module.exports = function(config) {
+  config.set({
+
+    frameworks: ['dart-unittest', 'dart-evalcache'],
+
+    files: [
+      // Init and configure guiness.
+      {pattern: 'test-init.dart', included: true},
+      // Unit test files needs to be included.
+      {pattern: 'dist/dart/**/*_spec.dart', included: true, watched: false},
+
+      // Karma-dart via the dart-unittest framework generates
+      // `__adapter_unittest.dart` that imports these files.
+      {pattern: 'dist/dart/**', included: false, watched: false},
+
+      // Dependencies, installed with `pub install`.
+      {pattern: 'packages/**/*.dart', included: false, watched: false},
+
+      // Init and configure guiness.
+      {pattern: 'test-main.dart', included: true},
+      {pattern: 'modules/**/test/**/static_assets/**', included: false, watched: false},
+    ],
+
+    exclude: [
+      'dist/dart/**/packages/**',
+      'modules/angular1_router/**'
+    ],
+
+    karmaDartImports: {
+      guinness: 'package:guinness/guinness_html.dart'
+    },
+
+    // Map packages to the correct urls where Karma serves them.
+    proxies: proxyPaths,
+
+    customLaunchers: sauceConf.customLaunchers,
+    browsers: ['DartiumWithWebPlatform'],
+
+    port: 9877,
+
+    plugins: [
+      require('karma-dart'),
+      require('karma-chrome-launcher'),
+      require('karma-sauce-launcher'),
+      require('./karma-dart-evalcache')(packageSources)
+    ]
+  });
+};
--- a/karma-js.conf.js
+++ b/karma-js.conf.js
@ -1,13 +1,4 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-var browserProvidersConf = require('./browser-providers.conf.js');
-var internalAngularReporter = require('./tools/karma/reporter.js');
+var sauceConf = require('./sauce.conf');

 // Karma configuration
 // Generated on Thu Sep 25 2014 11:52:02 GMT-0700 (PDT)
@ -19,107 +10,56 @@ module.exports = function(config) {
    files: [
      // Sources and specs.
      // Loaded through the System loader, in `test-main.js`.
-      {pattern: 'dist/all/@angular/**/*.js', included: false, watched: true},
+      {pattern: 'dist/js/dev/es5/**', included: false, watched: false},

-      'node_modules/core-js/client/core.js',
+      'node_modules/es6-shim/es6-shim.js',
      // include Angular v1 for upgrade module testing
-      'node_modules/angular/angular.js',
+      'node_modules/angular/angular.min.js',

-      'node_modules/zone.js/dist/zone.js', 'node_modules/zone.js/dist/long-stack-trace-zone.js',
-      'node_modules/zone.js/dist/proxy.js', 'node_modules/zone.js/dist/sync-test.js',
-      'node_modules/zone.js/dist/jasmine-patch.js', 'node_modules/zone.js/dist/async-test.js',
-      'node_modules/zone.js/dist/fake-async-test.js',
+      // zone-microtask must be included first as it contains a Promise monkey patch
+      'node_modules/zone.js/dist/zone-microtask.js',
+      'node_modules/zone.js/dist/long-stack-trace-zone.js',
+      'node_modules/zone.js/dist/jasmine-patch.js',

      // Including systemjs because it defines `__eval`, which produces correct stack traces.
-      'shims_for_IE.js', 'node_modules/systemjs/dist/system.src.js',
-      {pattern: 'node_modules/rxjs/**', included: false, watched: false, served: true},
-      'node_modules/reflect-metadata/Reflect.js', 'tools/build/file2modulename.js', 'test-main.js',
-      {pattern: 'dist/all/empty.*', included: false, watched: false}, {
-        pattern: 'modules/@angular/platform-browser/test/static_assets/**',
-        included: false,
-        watched: false
-      },
-      {
-        pattern: 'modules/@angular/platform-browser/test/browser/static_assets/**',
-        included: false,
-        watched: false,
-      }
+      'modules/angular2/src/testing/shims_for_IE.js',
+      'node_modules/systemjs/dist/system.src.js',
+      {pattern: 'node_modules/@reactivex/rxjs/**', included: false, watched: false, served: true},
+      'node_modules/reflect-metadata/Reflect.js',
+      'tools/build/file2modulename.js',
+      'test-main.js',
+      {pattern: 'modules/**/test/**/static_assets/**', included: false, watched: false}
    ],

-    exclude: [
-      'dist/all/@angular/**/e2e_test/**',
-      'dist/all/@angular/router/**',
-      'dist/all/@angular/compiler-cli/**',
-      'dist/all/@angular/compiler/test/aot/**',
-      'dist/all/@angular/benchpress/**',
-      'dist/all/angular1_router.js',
-      'dist/all/@angular/platform-browser/testing/e2e_util.js',
-      'dist/examples/**/e2e_test/**',
-    ],
+    exclude: ['dist/js/dev/es5/**/e2e_test/**', 'dist/js/dev/es5/angular2/examples/**', 'dist/angular1_router.js'],

-    customLaunchers: browserProvidersConf.customLaunchers,
+    customLaunchers: sauceConf.customLaunchers,

-    plugins: [
-      'karma-jasmine',
-      'karma-browserstack-launcher',
-      'karma-sauce-launcher',
-      'karma-chrome-launcher',
-      'karma-sourcemap-loader',
-      internalAngularReporter,
-    ],
-
-    preprocessors: {
-      '**/*.js': ['sourcemap'],
-    },
-
-    reporters: ['internal-angular'],
    sauceLabs: {
      testName: 'Angular2',
-      retryLimit: 3,
      startConnect: false,
      recordVideo: false,
      recordScreenshots: false,
      options: {
-        'selenium-version': '2.53.0',
+        'selenium-version': '2.47.1',
        'command-timeout': 600,
        'idle-timeout': 600,
-        'max-duration': 5400,
+        'max-duration': 5400
      }
    },

-    browserStack: {
-      project: 'Angular2',
-      startTunnel: false,
-      retryLimit: 3,
-      timeout: 1800,
-      pollingTimeout: 10000,
-    },
-
    browsers: ['Chrome'],

-    port: 9876,
-    captureTimeout: 180000,
-    browserDisconnectTimeout: 180000,
-    browserDisconnectTolerance: 3,
-    browserNoActivityTimeout: 300000,
+    port: 9876
  });

-  if (process.env.TRAVIS) {
-    var buildId =
-        'TRAVIS #' + process.env.TRAVIS_BUILD_NUMBER + ' (' + process.env.TRAVIS_BUILD_ID + ')';
-    if (process.env.CI_MODE.startsWith('saucelabs')) {
-      config.sauceLabs.build = buildId;
-      config.sauceLabs.tunnelIdentifier = process.env.TRAVIS_JOB_NUMBER;
+  if (process.env.TRAVIS && process.env.MODE === 'saucelabs') {
+    config.sauceLabs.build = 'TRAVIS #' + process.env.TRAVIS_BUILD_NUMBER + ' (' + process.env.TRAVIS_BUILD_ID + ')';
+    config.sauceLabs.tunnelIdentifier = process.env.TRAVIS_JOB_NUMBER;

-      // TODO(mlaval): remove once SauceLabs supports websockets.
-      // This speeds up the capturing a bit, as browsers don't even try to use websocket.
-      console.log('>>>> setting socket.io transport to polling <<<<');
-      config.transports = ['polling'];
-    }
-
-    if (process.env.CI_MODE.startsWith('browserstack')) {
-      config.browserStack.build = buildId;
-      config.browserStack.tunnelIdentifier = process.env.TRAVIS_JOB_NUMBER;
-    }
+    // TODO(mlaval): remove once SauceLabs supports websockets.
+    // This speeds up the capturing a bit, as browsers don't even try to use websocket.
+    console.log('>>>> setting socket.io transport to polling <<<<');
+    config.transports = ['polling'];
  }
 };
--- a/modules/@angular/README.md
+++ b/modules/@angular/README.md
@ -1,6 +0,0 @@
-Angular
-=======
-
-The sources for this package are in the main [Angular](https://github.com/angular/angular) repo. Please file issues and pull requests against that repo.
-
-License: MIT
--- a/modules/@angular/benchpress/README.md
+++ b/modules/@angular/benchpress/README.md
@ -1,305 +0,0 @@
-# Benchpress
-
-Benchpress is a framework for e2e performance tests.
-See [here for an example project](https://github.com/angular/benchpress-tree).
-
-The sources for this package are in the main [Angular2](https://github.com/angular/angular) repo. Please file issues and pull requests against that repo.
-
-License: MIT
-
-# Why?
-
-There are so called "micro benchmarks" that essentially use a stop watch in the browser to measure time
-(e.g. via `performance.now()`). This approach is limited to time, and in some cases memory
-(Chrome with special flags), as metric. It does not allow to measure:
-
- rendering time: e.g. the time the browser spends to layout or paint elements. This can e.g. used to
-  test the performance impact of stylesheet changes.
- garbage collection: e.g. how long the browser paused script execution, and how much memory was collected.
-  This can be used to stabilize script execution time, as garbage collection times are usually very
-  unpredictable. This data can also be used to measure and improve memory usage of applications,
-  as the garbage collection amount directly affects garbage collection time.
- distinguish script execution time from waiting: e.g. to measure the client side only time that is spent
-  in a complex user interaction, ignoring backend calls.
- measure fps to assert the smoothness of scrolling and animations.
-
-This kind of data is already available in the DevTools of modern browsers. However, there is no standard way to
-use those tools in an automated way to measure web app performance, especially not across platforms.
-
-Benchpress tries to fill this gap, i.e. allow to access all kinds of performance metrics in an automated way.
-
-
-# How it works
-
-Benchpress uses webdriver to read out the so called "performance log" of browsers. This contains all kinds of interesting
-data, e.g. when a script started/ended executing, gc started/ended, the browser painted something to the screen, ...
-
-As browsers are different, benchpress has plugins to normalizes these events.
-
-
-# Features
-
-* Provides a loop (so called "Sampler") that executes the benchmark multiple times
-* Automatically waits/detects until the browser is "warm"
-* Reporters provide a normalized way to store results:
-  - console reporter
-  - file reporter
-  - Google Big Query reporter (coming soon)
-* Supports micro benchmarks as well via `console.time()` / `console.timeEnd()`
-  - `console.time()` / `console.timeEnd()` mark the timeline in the DevTools, so it makes sense
-    to use them in micro benchmark to visualize and understand them, with or without benchpress.
-  - running micro benchmarks in benchpress leverages the already existing reporters,
-    the sampler and the auto warmup feature of benchpress.
-
-
-# Supported browsers
-
-* Chrome on all platforms
-* Mobile Safari (iOS)
-* Firefox (work in progress)
-
-
-# How to write a benchmark
-
-A benchmark in benchpress is made by an application under test
-and a benchmark driver. The application under test is the
-actual application consisting of html/css/js that should be tests.
-A benchmark driver is a webdriver test that interacts with the
-application under test.
-
-
-## A simple benchmark
-
-Let's assume we want to measure the script execution time, as well as the render time
-that it takes to fill a container element with a complex html string.
-
-The application under test could look like this:
-
-```
-index.html:
-
-<button id="reset" onclick="reset()">Reset</button>
-<button id="fill" onclick="fill()">fill innerHTML</button>
-<div id="container"></div>
-<script>
-  var container = document.getElementById('container');
-  var complexHtmlString = '...'; // TODO
-
-  function reset() { container.innerHTML = ''; }
-
-  function fill() {
-    container.innerHTML = complexHtmlString;
-  }
-</script>
-```
-
-A benchmark driver could look like this:
-
-```
-// A runner contains the shared configuration
-// and can be shared across multiple tests.
-var runner = new Runner(...);
-
-driver.get('http://myserver/index.html');
-
-var resetBtn = driver.findElement(By.id('reset'));
-var fillBtn = driver.findElement(By.id('fill'));
-
-runner.sample({
-  id: 'fillElement',
-  // Prepare is optional...
-  prepare: () {
-    resetBtn.click();
-  },
-  execute: () {
-    fillBtn.click();
-    // Note: if fillBtn would use some asynchronous code,
-    // we would need to wait here for its end.
-  }
-});
-```
-
-## Measuring in the browser
-
-If the application under test would like to, it can measure on its own.
-E.g.
-
-```
-index.html:
-
-<button id="measure" onclick="measure()">Measure document.createElement</button>
-<script>
-  function measure() {
-    console.time('createElement*10000');
-    for (var i=0; i<100000; i++) {
-      document.createElement('div');
-    }
-    console.timeEnd('createElement*10000');
-  }
-</script>
-```
-
-When the `measure` button is clicked, it marks the timeline and creates 10000 elements.
-It uses the special names `createElement*10000` to tell benchpress that the
-time that was measured is for 10000 calls to createElement and that benchpress should
-take the average for it.
-
-A test driver for this would look like this:
-
-````
-driver.get('.../index.html');
-
-var measureBtn = driver.findElement(By.id('measure'));
-runner.sample({
-  id: 'createElement test',
-  microMetrics: {
-    'createElement': 'time to create an element (ms)'
-  },
-  execute: () {
-    measureBtn.click();
-  }
-});
-````
-
-When looking into the DevTools Timeline, we see a marker as well:
-![Marked Timeline](docs/marked_timeline.png)
-
-### Custom Metrics Without Using `console.time`
-
-It's also possible to measure any "user metric" within the browser
-by setting a numeric value on the `window` object. For example:
-
-```js
-bootstrap(App)
-  .then(() => {
-    window.timeToBootstrap = Date.now() - performance.timing.navigationStart;
-  });
-```
-
-A test driver for this user metric could be written as follows:
-
-```js
-
-describe('home page load', function() {
-  it('should log load time for a 2G connection', done => {
-    runner.sample({
-      execute: () => {
-        browser.get(`http://localhost:8080`);
-      },
-      userMetrics: {
-        timeToBootstrap: 'The time in milliseconds to bootstrap'
-      },
-      providers: [
-        {provide: RegressionSlopeValidator.METRIC, useValue: 'timeToBootstrap'}
-      ]
-    }).then(done);
-  });
-});
-```
-
-Using this strategy, benchpress will wait until the specified property name,
-`timeToBootstrap` in this case, is defined as a number on the `window` object
-inside the application under test.
-
-# Smoothness Metrics
-
-Benchpress can also measure the "smoothness" of scrolling and animations. In order to do that, the following set of metrics can be collected by benchpress:
-
- `frameTime.mean`: mean frame time in ms (target: 16.6ms for 60fps)
- `frameTime.worst`: worst frame time in ms
- `frameTime.best`: best frame time in ms
- `frameTime.smooth`: percentage of frames that hit 60fps
-
-To collect these metrics, you need to execute `console.time('frameCapture')` and `console.timeEnd('frameCapture')` either in your benchmark application or in you benchmark driver via webdriver. The metrics mentioned above will only be collected between those two calls and it is recommended to wrap the time/timeEnd calls as closely as possible around the action you want to evaluate to get accurate measurements.
-
-In addition to that, one extra provider needs to be passed to benchpress in tests that want to collect these metrics:
-
-    benchpress.sample(providers: [{provide: bp.Options.CAPTURE_FRAMES, useValue: true}], ... )
-
-# Requests Metrics
-
-Benchpress can also record the number of requests sent and count the received "encoded" bytes since [window.performance.timing.navigationStart](http://www.w3.org/TR/navigation-timing/#dom-performancetiming-navigationstart):
-
- `receivedData`: number of bytes received since the last navigation start
- `requestCount`: number of requests sent since the last navigation start
-
-To collect these metrics, you need the following corresponding extra providers:
-
-    benchpress.sample(providers: [
-      {provide: bp.Options.RECEIVED_DATA, useValue: true},
-      {provide: bp.Options.REQUEST_COUNT, useValue: true}
-    ], ... )
-
-# Best practices
-
-* Use normalized environments
-  - metrics that are dependent on the performance of the execution environment must be executed on a normalized machine
-  - e.g. a real mobile device whose cpu frequency is set to a fixed value.
-      * see our [build script](https://github.com/angular/angular/blob/master/scripts/ci/android_cpu.sh)
-      * this requires root access, e.g. via a userdebug build of Android on a Google Nexus device
-        (see [here](https://source.android.com/source/building-running.html) and [here](https://source.android.com/source/building-devices.html#obtaining-proprietary-binaries))
-  - e.g. a calibrated machine that does not run background jobs, has a fixed cpu frequency, ...
-
-* Use relative comparisons
-  - relative comparisons are less likely to change over time and help to interpret the results of benchmarks
-  - e.g. compare an example written using a ui framework against a hand coded example and track the ratio
-
-* Assert post-commit for commit ranges
-  - running benchmarks can take some time. Running them before every commit is usually too slow.
-  - when a regression is detected for a commit range, use bisection to find the problematic commit
-
-* Repeat benchmarks multiple times in a fresh window
-  - run the same benchmark multiple times in a fresh window and then take the minimal average value of each benchmark run
-
-* Use force gc with care
-  - forcing gc can skew the script execution time and gcTime numbers,
-    but might be needed to get stable gc time / gc amount numbers
-
-* Open a new window for every test
-  - browsers (e.g. chrome) might keep JIT statistics over page reloads and optimize pages differently depending on what has been loaded before
-
-# Detailed overview
-
-![Overview](docs/overview.png)
-
-Definitions:
-
-* valid sample: a sample that represents the world that should be measured in a good way.
-* complete sample: sample of all measure values collected so far
-
-Components:
-
-* Runner
-  - contains a default configuration
-  - creates a new injector for every sample call, via which all other components are created
-
-* Sampler
-  - gets data from the metrics
-  - reports measure values immediately to the reporters
-  - loops until the validator is able to extract a valid sample out of the complete sample (see below).
-  - reports the valid sample and the complete sample to the reporters
-
-* Metric
-  - gets measure values from the browser
-  - e.g. reads out performance logs, DOM values, JavaScript values
-
-* Validator
-  - extracts a valid sample out of the complete sample of all measure values.
-  - e.g. wait until there are 10 samples and take them as valid sample (would include warmup time)
-  - e.g. wait until the regression slope for the metric `scriptTime` through the last 10 measure values is >=0, i.e. the values for the `scriptTime` metric are no more decreasing
-
-* Reporter
-  - reports measure values, the valid sample and the complete sample to backends
-  - e.g. a reporter that prints to the console, a reporter that reports values into Google BigQuery, ...
-
-* WebDriverAdapter
-  - abstraction over the used web driver client
-  - one implementation for every webdriver client
-    E.g. one for selenium-webdriver Node.js module, dart async webdriver, dart sync webdriver, ...
-
-* WebDriverExtension
-  - implements additional methods that are standardized in the webdriver protocol using the WebDriverAdapter
-  - provides functionality like force gc, read out performance logs in a normalized format
-  - one implementation per browser, e.g. one for Chrome, one for mobile Safari, one for Firefox
-
-
--- a/modules/@angular/benchpress/index.ts
+++ b/modules/@angular/benchpress/index.ts
@ -1,34 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-// Must be imported first, because angular2 decorators throws on load.
-import 'reflect-metadata';
-
-export {Injector, OpaqueToken, Provider, ReflectiveInjector} from '@angular/core';
-export {Options} from './src/common_options';
-export {MeasureValues} from './src/measure_values';
-export {Metric} from './src/metric';
-export {MultiMetric} from './src/metric/multi_metric';
-export {PerflogMetric} from './src/metric/perflog_metric';
-export {UserMetric} from './src/metric/user_metric';
-export {Reporter} from './src/reporter';
-export {ConsoleReporter} from './src/reporter/console_reporter';
-export {JsonFileReporter} from './src/reporter/json_file_reporter';
-export {MultiReporter} from './src/reporter/multi_reporter';
-export {Runner} from './src/runner';
-export {SampleDescription} from './src/sample_description';
-export {SampleState, Sampler} from './src/sampler';
-export {Validator} from './src/validator';
-export {RegressionSlopeValidator} from './src/validator/regression_slope_validator';
-export {SizeValidator} from './src/validator/size_validator';
-export {WebDriverAdapter} from './src/web_driver_adapter';
-export {PerfLogEvent, PerfLogFeatures, WebDriverExtension} from './src/web_driver_extension';
-export {ChromeDriverExtension} from './src/webdriver/chrome_driver_extension';
-export {FirefoxDriverExtension} from './src/webdriver/firefox_driver_extension';
-export {IOsDriverExtension} from './src/webdriver/ios_driver_extension';
-export {SeleniumWebDriverAdapter} from './src/webdriver/selenium_webdriver_adapter';
--- a/modules/@angular/benchpress/package.json
+++ b/modules/@angular/benchpress/package.json
@ -1,31 +0,0 @@
-{
-  "name": "@angular/benchpress",
-  "version": "0.1.0",
-  "description": "Benchpress - a framework for e2e performance tests",
-  "main": "index.js",
-  "typings": "index.d.ts",
-  "dependencies": {
-    "@angular/core": "^2.0.0-rc.7",
-    "reflect-metadata": "^0.1.2",
-    "rxjs": "5.0.0-beta.12",
-    "jpm": "1.1.4",
-    "firefox-profile": "0.4.0",
-    "selenium-webdriver": "^2.53.3"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/angular/angular.git"
-  },
-  "keywords": [
-    "angular",
-    "benchmarks"
-  ],
-  "contributors": [
-    "Tobias Bosch <tbosch@google.com> (https://angular.io/)"
-  ],
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/angular/angular/issues"
-  },
-  "homepage": "https://github.com/angular/angular/tree/master/modules/@angular/compiler-cli"
-}
--- a/modules/@angular/benchpress/publish.sh
+++ b/modules/@angular/benchpress/publish.sh
@ -1,16 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-
-cd $(dirname $0)/../../..
-ROOTDIR=$(pwd)
-SRCDIR=${ROOTDIR}/modules/@angular/benchpress
-DESTDIR=${ROOTDIR}/dist/packages-dist/benchpress
-
-rm -fr ${DESTDIR}
-
-echo "====== BUILDING... ====="
-./build.sh --packages=core,benchpress --bundle=false
-
-echo "====== PUBLISHING: ${DESTDIR} ====="
-npm publish ${DESTDIR} --access public
--- a/modules/@angular/benchpress/src/common_options.ts
+++ b/modules/@angular/benchpress/src/common_options.ts
@ -1,53 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {OpaqueToken} from '@angular/core';
-import * as fs from 'fs';
-
-export class Options {
-  static SAMPLE_ID = new OpaqueToken('Options.sampleId');
-  static DEFAULT_DESCRIPTION = new OpaqueToken('Options.defaultDescription');
-  static SAMPLE_DESCRIPTION = new OpaqueToken('Options.sampleDescription');
-  static FORCE_GC = new OpaqueToken('Options.forceGc');
-  static NO_PREPARE = () => true;
-  static PREPARE = new OpaqueToken('Options.prepare');
-  static EXECUTE = new OpaqueToken('Options.execute');
-  static CAPABILITIES = new OpaqueToken('Options.capabilities');
-  static USER_AGENT = new OpaqueToken('Options.userAgent');
-  static MICRO_METRICS = new OpaqueToken('Options.microMetrics');
-  static USER_METRICS = new OpaqueToken('Options.userMetrics');
-  static NOW = new OpaqueToken('Options.now');
-  static WRITE_FILE = new OpaqueToken('Options.writeFile');
-  static RECEIVED_DATA = new OpaqueToken('Options.receivedData');
-  static REQUEST_COUNT = new OpaqueToken('Options.requestCount');
-  static CAPTURE_FRAMES = new OpaqueToken('Options.frameCapture');
-  static DEFAULT_PROVIDERS = [
-    {provide: Options.DEFAULT_DESCRIPTION, useValue: {}},
-    {provide: Options.SAMPLE_DESCRIPTION, useValue: {}},
-    {provide: Options.FORCE_GC, useValue: false},
-    {provide: Options.PREPARE, useValue: Options.NO_PREPARE},
-    {provide: Options.MICRO_METRICS, useValue: {}}, {provide: Options.USER_METRICS, useValue: {}},
-    {provide: Options.NOW, useValue: () => new Date()},
-    {provide: Options.RECEIVED_DATA, useValue: false},
-    {provide: Options.REQUEST_COUNT, useValue: false},
-    {provide: Options.CAPTURE_FRAMES, useValue: false},
-    {provide: Options.WRITE_FILE, useValue: writeFile}
-  ];
-}
-
-function writeFile(filename: string, content: string): Promise<any> {
-  return new Promise(function(resolve, reject) {
-    fs.writeFile(filename, content, (error) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve();
-      }
-    });
-  });
-}
--- a/modules/@angular/benchpress/src/facade
+++ b/modules/@angular/benchpress/src/facade
@ -1 +0,0 @@
-../../facade/src
--- a/modules/@angular/benchpress/src/firefox_extension/data/installed_script.ts
+++ b/modules/@angular/benchpress/src/firefox_extension/data/installed_script.ts
@ -1,38 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-declare var exportFunction: any;
-declare var unsafeWindow: any;
-
-exportFunction(function() {
-  const curTime = unsafeWindow.performance.now();
-  (<any>self).port.emit('startProfiler', curTime);
-}, unsafeWindow, {defineAs: 'startProfiler'});
-
-exportFunction(function() {
-  (<any>self).port.emit('stopProfiler');
-}, unsafeWindow, {defineAs: 'stopProfiler'});
-
-exportFunction(function(cb: Function) {
-  (<any>self).port.once('perfProfile', cb);
-  (<any>self).port.emit('getProfile');
-}, unsafeWindow, {defineAs: 'getProfile'});
-
-exportFunction(function() {
-  (<any>self).port.emit('forceGC');
-}, unsafeWindow, {defineAs: 'forceGC'});
-
-exportFunction(function(name: string) {
-  const curTime = unsafeWindow.performance.now();
-  (<any>self).port.emit('markStart', name, curTime);
-}, unsafeWindow, {defineAs: 'markStart'});
-
-exportFunction(function(name: string) {
-  const curTime = unsafeWindow.performance.now();
-  (<any>self).port.emit('markEnd', name, curTime);
-}, unsafeWindow, {defineAs: 'markEnd'});
--- a/modules/@angular/benchpress/src/firefox_extension/lib/main.ts
+++ b/modules/@angular/benchpress/src/firefox_extension/lib/main.ts
@ -1,78 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-const {Cc, Ci, Cu} = require('chrome');
-const os = Cc['@mozilla.org/observer-service;1'].getService(Ci.nsIObserverService);
-const ParserUtil = require('./parser_util');
-
-class Profiler {
-  private _profiler: any;
-  private _markerEvents: any[];
-  private _profilerStartTime: number;
-
-  constructor() { this._profiler = Cc['@mozilla.org/tools/profiler;1'].getService(Ci.nsIProfiler); }
-
-  start(entries: any, interval: any, features: any, timeStarted: any) {
-    this._profiler.StartProfiler(entries, interval, features, features.length);
-    this._profilerStartTime = timeStarted;
-    this._markerEvents = [];
-  }
-
-  stop() { this._profiler.StopProfiler(); }
-
-  getProfilePerfEvents() {
-    const profileData = this._profiler.getProfileData();
-    let perfEvents = ParserUtil.convertPerfProfileToEvents(profileData);
-    perfEvents = this._mergeMarkerEvents(perfEvents);
-    perfEvents.sort(function(event1: any, event2: any) {
-      return event1.ts - event2.ts;
-    });  // Sort by ts
-    return perfEvents;
-  }
-
-  /** @internal */
-  private _mergeMarkerEvents(perfEvents: any[]): any[] {
-    this._markerEvents.forEach(function(markerEvent) { perfEvents.push(markerEvent); });
-    return perfEvents;
-  }
-
-  addStartEvent(name: string, timeStarted: number) {
-    this._markerEvents.push({ph: 'B', ts: timeStarted - this._profilerStartTime, name: name});
-  }
-
-  addEndEvent(name: string, timeEnded: number) {
-    this._markerEvents.push({ph: 'E', ts: timeEnded - this._profilerStartTime, name: name});
-  }
-}
-
-function forceGC() {
-  Cu.forceGC();
-  os.notifyObservers(null, 'child-gc-request', null);
-};
-
-const mod = require('sdk/page-mod');
-const data = require('sdk/self').data;
-const profiler = new Profiler();
-mod.PageMod({
-  include: ['*'],
-  contentScriptFile: data.url('installed_script.js'),
-  onAttach: (worker: any) => {
-    worker.port.on(
-        'startProfiler',
-        (timeStarted: any) => profiler.start(
-            /* = profiler memory */ 3000000, 0.1, ['leaf', 'js', 'stackwalk', 'gc'], timeStarted));
-    worker.port.on('stopProfiler', () => profiler.stop());
-    worker.port.on(
-        'getProfile', () => worker.port.emit('perfProfile', profiler.getProfilePerfEvents()));
-    worker.port.on('forceGC', forceGC);
-    worker.port.on(
-        'markStart', (name: string, timeStarted: any) => profiler.addStartEvent(name, timeStarted));
-    worker.port.on(
-        'markEnd', (name: string, timeEnded: any) => profiler.addEndEvent(name, timeEnded));
-  }
-});
--- a/modules/@angular/benchpress/src/firefox_extension/lib/parser_util.ts
+++ b/modules/@angular/benchpress/src/firefox_extension/lib/parser_util.ts
@ -1,92 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * @param {Object} perfProfile The perf profile JSON object.
- * @return {Object[]} An array of recognized events that are captured
- *     within the perf profile.
- */
-export function convertPerfProfileToEvents(perfProfile: any): any[] {
-  const inProgressEvents = new Map();                 // map from event name to start time
-  const finishedEvents: {[key: string]: any}[] = [];  // Event[] finished events
-  const addFinishedEvent = function(eventName: string, startTime: number, endTime: number) {
-    const categorizedEventName = categorizeEvent(eventName);
-    let args: {[key: string]: any} = undefined;
-    if (categorizedEventName == 'gc') {
-      // TODO: We cannot measure heap size at the moment
-      args = {usedHeapSize: 0};
-    }
-    if (startTime == endTime) {
-      // Finished instantly
-      finishedEvents.push({ph: 'X', ts: startTime, name: categorizedEventName, args: args});
-    } else {
-      // Has duration
-      finishedEvents.push({ph: 'B', ts: startTime, name: categorizedEventName, args: args});
-      finishedEvents.push({ph: 'E', ts: endTime, name: categorizedEventName, args: args});
-    }
-  };
-
-  const samples = perfProfile.threads[0].samples;
-  // In perf profile, firefox samples all the frames in set time intervals. Here
-  // we go through all the samples and construct the start and end time for each
-  // event.
-  for (let i = 0; i < samples.length; ++i) {
-    const sample = samples[i];
-    const sampleTime = sample.time;
-
-    // Add all the frames into a set so it's easier/faster to find the set
-    // differences
-    const sampleFrames = new Set();
-    sample.frames.forEach(function(frame: {[key: string]: any}) {
-      sampleFrames.add(frame['location']);
-    });
-
-    // If an event is in the inProgressEvents map, but not in the current sample,
-    // then it must have just finished. We add this event to the finishedEvents
-    // array and remove it from the inProgressEvents map.
-    const previousSampleTime = (i == 0 ? /* not used */ -1 : samples[i - 1].time);
-    inProgressEvents.forEach(function(startTime, eventName) {
-      if (!(sampleFrames.has(eventName))) {
-        addFinishedEvent(eventName, startTime, previousSampleTime);
-        inProgressEvents.delete(eventName);
-      }
-    });
-
-    // If an event is in the current sample, but not in the inProgressEvents map,
-    // then it must have just started. We add this event to the inProgressEvents
-    // map.
-    sampleFrames.forEach(function(eventName) {
-      if (!(inProgressEvents.has(eventName))) {
-        inProgressEvents.set(eventName, sampleTime);
-      }
-    });
-  }
-
-  // If anything is still in progress, we need to included it as a finished event
-  // since recording ended.
-  const lastSampleTime = samples[samples.length - 1].time;
-  inProgressEvents.forEach(function(startTime, eventName) {
-    addFinishedEvent(eventName, startTime, lastSampleTime);
-  });
-
-  // Remove all the unknown categories.
-  return finishedEvents.filter(function(event) { return event['name'] != 'unknown'; });
-}
-
-// TODO: this is most likely not exhaustive.
-export function categorizeEvent(eventName: string): string {
-  if (eventName.indexOf('PresShell::Paint') > -1) {
-    return 'render';
-  } else if (eventName.indexOf('FirefoxDriver.prototype.executeScript') > -1) {
-    return 'script';
-  } else if (eventName.indexOf('forceGC') > -1) {
-    return 'gc';
-  } else {
-    return 'unknown';
-  }
-}
--- a/modules/@angular/benchpress/src/firefox_extension/lib/test_helper.ts
+++ b/modules/@angular/benchpress/src/firefox_extension/lib/test_helper.ts
@ -1,51 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-const q = require('q');
-const FirefoxProfile = require('firefox-profile');
-const jpm = require('jpm/lib/xpi');
-const pathUtil = require('path');
-
-const PERF_ADDON_PACKAGE_JSON_DIR = '..';
-
-exports.getAbsolutePath = function(path: string) {
-  const normalizedPath = pathUtil.normalize(path);
-  if (pathUtil.resolve(normalizedPath) == normalizedPath) {
-    // Already absolute path
-    return normalizedPath;
-  } else {
-    return pathUtil.join(__dirname, normalizedPath);
-  }
-};
-
-exports.getFirefoxProfile = function(extensionPath: string) {
-  const deferred = q.defer();
-
-  const firefoxProfile = new FirefoxProfile();
-  firefoxProfile.addExtensions([extensionPath], () => {
-    firefoxProfile.encoded((encodedProfile: any) => {
-      const multiCapabilities = [{browserName: 'firefox', firefox_profile: encodedProfile}];
-      deferred.resolve(multiCapabilities);
-    });
-  });
-
-  return deferred.promise;
-};
-
-exports.getFirefoxProfileWithExtension = function() {
-  const absPackageJsonDir = pathUtil.join(__dirname, PERF_ADDON_PACKAGE_JSON_DIR);
-  const packageJson = require(pathUtil.join(absPackageJsonDir, 'package.json'));
-
-  const savedCwd = process.cwd();
-  process.chdir(absPackageJsonDir);
-
-  return jpm(packageJson).then((xpiPath: string) => {
-    process.chdir(savedCwd);
-    return exports.getFirefoxProfile(xpiPath);
-  });
-};
--- a/modules/@angular/benchpress/src/measure_values.ts
+++ b/modules/@angular/benchpress/src/measure_values.ts
@ -1,20 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-export class MeasureValues {
-  constructor(
-      public runIndex: number, public timeStamp: Date, public values: {[key: string]: any}) {}
-
-  toJson() {
-    return {
-      'timeStamp': this.timeStamp.toJSON(),
-      'runIndex': this.runIndex,
-      'values': this.values,
-    };
-  }
-}
--- a/modules/@angular/benchpress/src/metric.ts
+++ b/modules/@angular/benchpress/src/metric.ts
@ -1,31 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-
-/**
- * A metric is measures values
- */
-export abstract class Metric {
-  /**
-   * Starts measuring
-   */
-  beginMeasure(): Promise<any> { throw new Error('NYI'); }
-
-  /**
-   * Ends measuring and reports the data
-   * since the begin call.
-   * @param restart: Whether to restart right after this.
-   */
-  endMeasure(restart: boolean): Promise<{[key: string]: any}> { throw new Error('NYI'); }
-
-  /**
-   * Describes the metrics provided by this metric implementation.
-   * (e.g. units, ...)
-   */
-  describe(): {[key: string]: string} { throw new Error('NYI'); }
-}
--- a/modules/@angular/benchpress/src/metric/multi_metric.ts
+++ b/modules/@angular/benchpress/src/metric/multi_metric.ts
@ -1,63 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Injector, OpaqueToken} from '@angular/core';
-
-import {Metric} from '../metric';
-
-export class MultiMetric extends Metric {
-  static provideWith(childTokens: any[]): any[] {
-    return [
-      {
-        provide: _CHILDREN,
-        useFactory: (injector: Injector) => childTokens.map(token => injector.get(token)),
-        deps: [Injector]
-      },
-      {
-        provide: MultiMetric,
-        useFactory: (children: Metric[]) => new MultiMetric(children),
-        deps: [_CHILDREN]
-      }
-    ];
-  }
-
-  constructor(private _metrics: Metric[]) { super(); }
-
-  /**
-   * Starts measuring
-   */
-  beginMeasure(): Promise<any> {
-    return Promise.all(this._metrics.map(metric => metric.beginMeasure()));
-  }
-
-  /**
-   * Ends measuring and reports the data
-   * since the begin call.
-   * @param restart: Whether to restart right after this.
-   */
-  endMeasure(restart: boolean): Promise<{[key: string]: any}> {
-    return Promise.all(this._metrics.map(metric => metric.endMeasure(restart)))
-        .then(values => mergeStringMaps(<any>values));
-  }
-
-  /**
-   * Describes the metrics provided by this metric implementation.
-   * (e.g. units, ...)
-   */
-  describe(): {[key: string]: any} {
-    return mergeStringMaps(this._metrics.map((metric) => metric.describe()));
-  }
-}
-
-function mergeStringMaps(maps: {[key: string]: string}[]): {[key: string]: string} {
-  const result: {[key: string]: string} = {};
-  maps.forEach(map => { Object.keys(map).forEach(prop => { result[prop] = map[prop]; }); });
-  return result;
-}
-
-const _CHILDREN = new OpaqueToken('MultiMetric.children');
--- a/modules/@angular/benchpress/src/metric/perflog_metric.ts
+++ b/modules/@angular/benchpress/src/metric/perflog_metric.ts
@ -1,371 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Inject, Injectable, OpaqueToken} from '@angular/core';
-
-import {Options} from '../common_options';
-import {Metric} from '../metric';
-import {PerfLogEvent, PerfLogFeatures, WebDriverExtension} from '../web_driver_extension';
-
-
-/**
- * A metric that reads out the performance log
- */
-@Injectable()
-export class PerflogMetric extends Metric {
-  static SET_TIMEOUT = new OpaqueToken('PerflogMetric.setTimeout');
-  static PROVIDERS = [
-    PerflogMetric, {
-      provide: PerflogMetric.SET_TIMEOUT,
-      useValue: (fn: Function, millis: number) => <any>setTimeout(fn, millis)
-    }
-  ];
-
-  private _remainingEvents: PerfLogEvent[];
-  private _measureCount: number;
-  private _perfLogFeatures: PerfLogFeatures;
-
-  /**
-   * @param driverExtension
-   * @param setTimeout
-   * @param microMetrics Name and description of metrics provided via console.time / console.timeEnd
-   **/
-  constructor(
-      private _driverExtension: WebDriverExtension,
-      @Inject(PerflogMetric.SET_TIMEOUT) private _setTimeout: Function,
-      @Inject(Options.MICRO_METRICS) private _microMetrics: {[key: string]: string},
-      @Inject(Options.FORCE_GC) private _forceGc: boolean,
-      @Inject(Options.CAPTURE_FRAMES) private _captureFrames: boolean,
-      @Inject(Options.RECEIVED_DATA) private _receivedData: boolean,
-      @Inject(Options.REQUEST_COUNT) private _requestCount: boolean) {
-    super();
-
-    this._remainingEvents = [];
-    this._measureCount = 0;
-    this._perfLogFeatures = _driverExtension.perfLogFeatures();
-    if (!this._perfLogFeatures.userTiming) {
-      // User timing is needed for navigationStart.
-      this._receivedData = false;
-      this._requestCount = false;
-    }
-  }
-
-  describe(): {[key: string]: string} {
-    const res: {[key: string]: any} = {
-      'scriptTime': 'script execution time in ms, including gc and render',
-      'pureScriptTime': 'script execution time in ms, without gc nor render'
-    };
-    if (this._perfLogFeatures.render) {
-      res['renderTime'] = 'render time in ms';
-    }
-    if (this._perfLogFeatures.gc) {
-      res['gcTime'] = 'gc time in ms';
-      res['gcAmount'] = 'gc amount in kbytes';
-      res['majorGcTime'] = 'time of major gcs in ms';
-      if (this._forceGc) {
-        res['forcedGcTime'] = 'forced gc time in ms';
-        res['forcedGcAmount'] = 'forced gc amount in kbytes';
-      }
-    }
-    if (this._receivedData) {
-      res['receivedData'] = 'encoded bytes received since navigationStart';
-    }
-    if (this._requestCount) {
-      res['requestCount'] = 'count of requests sent since navigationStart';
-    }
-    if (this._captureFrames) {
-      if (!this._perfLogFeatures.frameCapture) {
-        const warningMsg = 'WARNING: Metric requested, but not supported by driver';
-        // using dot syntax for metric name to keep them grouped together in console reporter
-        res['frameTime.mean'] = warningMsg;
-        res['frameTime.worst'] = warningMsg;
-        res['frameTime.best'] = warningMsg;
-        res['frameTime.smooth'] = warningMsg;
-      } else {
-        res['frameTime.mean'] = 'mean frame time in ms (target: 16.6ms for 60fps)';
-        res['frameTime.worst'] = 'worst frame time in ms';
-        res['frameTime.best'] = 'best frame time in ms';
-        res['frameTime.smooth'] = 'percentage of frames that hit 60fps';
-      }
-    }
-    for (const name in this._microMetrics) {
-      res[name] = this._microMetrics[name];
-    }
-    return res;
-  }
-
-  beginMeasure(): Promise<any> {
-    let resultPromise = Promise.resolve(null);
-    if (this._forceGc) {
-      resultPromise = resultPromise.then((_) => this._driverExtension.gc());
-    }
-    return resultPromise.then((_) => this._beginMeasure());
-  }
-
-  endMeasure(restart: boolean): Promise<{[key: string]: number}> {
-    if (this._forceGc) {
-      return this._endPlainMeasureAndMeasureForceGc(restart);
-    } else {
-      return this._endMeasure(restart);
-    }
-  }
-
-  /** @internal */
-  private _endPlainMeasureAndMeasureForceGc(restartMeasure: boolean) {
-    return this._endMeasure(true).then((measureValues) => {
-      // disable frame capture for measurements during forced gc
-      const originalFrameCaptureValue = this._captureFrames;
-      this._captureFrames = false;
-      return this._driverExtension.gc()
-          .then((_) => this._endMeasure(restartMeasure))
-          .then((forceGcMeasureValues) => {
-            this._captureFrames = originalFrameCaptureValue;
-            measureValues['forcedGcTime'] = forceGcMeasureValues['gcTime'];
-            measureValues['forcedGcAmount'] = forceGcMeasureValues['gcAmount'];
-            return measureValues;
-          });
-    });
-  }
-
-  private _beginMeasure(): Promise<any> {
-    return this._driverExtension.timeBegin(this._markName(this._measureCount++));
-  }
-
-  private _endMeasure(restart: boolean): Promise<{[key: string]: number}> {
-    const markName = this._markName(this._measureCount - 1);
-    const nextMarkName = restart ? this._markName(this._measureCount++) : null;
-    return this._driverExtension.timeEnd(markName, nextMarkName)
-        .then((_) => this._readUntilEndMark(markName));
-  }
-
-  private _readUntilEndMark(
-      markName: string, loopCount: number = 0, startEvent: PerfLogEvent = null) {
-    if (loopCount > _MAX_RETRY_COUNT) {
-      throw new Error(`Tried too often to get the ending mark: ${loopCount}`);
-    }
-    return this._driverExtension.readPerfLog().then((events) => {
-      this._addEvents(events);
-      const result = this._aggregateEvents(this._remainingEvents, markName);
-      if (result) {
-        this._remainingEvents = events;
-        return result;
-      }
-      let resolve: (result: any) => void;
-      const promise = new Promise(res => { resolve = res; });
-      this._setTimeout(() => resolve(this._readUntilEndMark(markName, loopCount + 1)), 100);
-      return promise;
-    });
-  }
-
-  private _addEvents(events: PerfLogEvent[]) {
-    let needSort = false;
-    events.forEach(event => {
-      if (event['ph'] === 'X') {
-        needSort = true;
-        const startEvent: PerfLogEvent = {};
-        const endEvent: PerfLogEvent = {};
-        for (const prop in event) {
-          startEvent[prop] = event[prop];
-          endEvent[prop] = event[prop];
-        }
-        startEvent['ph'] = 'B';
-        endEvent['ph'] = 'E';
-        endEvent['ts'] = startEvent['ts'] + startEvent['dur'];
-        this._remainingEvents.push(startEvent);
-        this._remainingEvents.push(endEvent);
-      } else {
-        this._remainingEvents.push(event);
-      }
-    });
-    if (needSort) {
-      // Need to sort because of the ph==='X' events
-      this._remainingEvents.sort((a, b) => {
-        const diff = a['ts'] - b['ts'];
-        return diff > 0 ? 1 : diff < 0 ? -1 : 0;
-      });
-    }
-  }
-
-  private _aggregateEvents(events: PerfLogEvent[], markName: string): {[key: string]: number} {
-    const result: {[key: string]: number} = {'scriptTime': 0, 'pureScriptTime': 0};
-    if (this._perfLogFeatures.gc) {
-      result['gcTime'] = 0;
-      result['majorGcTime'] = 0;
-      result['gcAmount'] = 0;
-    }
-    if (this._perfLogFeatures.render) {
-      result['renderTime'] = 0;
-    }
-    if (this._captureFrames) {
-      result['frameTime.mean'] = 0;
-      result['frameTime.best'] = 0;
-      result['frameTime.worst'] = 0;
-      result['frameTime.smooth'] = 0;
-    }
-    for (const name in this._microMetrics) {
-      result[name] = 0;
-    }
-    if (this._receivedData) {
-      result['receivedData'] = 0;
-    }
-    if (this._requestCount) {
-      result['requestCount'] = 0;
-    }
-
-    let markStartEvent: PerfLogEvent = null;
-    let markEndEvent: PerfLogEvent = null;
-    events.forEach((event) => {
-      const ph = event['ph'];
-      const name = event['name'];
-      if (ph === 'B' && name === markName) {
-        markStartEvent = event;
-      } else if (ph === 'I' && name === 'navigationStart') {
-        // if a benchmark measures reload of a page, use the last
-        // navigationStart as begin event
-        markStartEvent = event;
-      } else if (ph === 'E' && name === markName) {
-        markEndEvent = event;
-      }
-    });
-    if (!markStartEvent || !markEndEvent) {
-      // not all events have been received, no further processing for now
-      return null;
-    }
-
-    let gcTimeInScript = 0;
-    let renderTimeInScript = 0;
-
-    const frameTimestamps: number[] = [];
-    const frameTimes: number[] = [];
-    let frameCaptureStartEvent: PerfLogEvent = null;
-    let frameCaptureEndEvent: PerfLogEvent = null;
-
-    const intervalStarts: {[key: string]: PerfLogEvent} = {};
-    const intervalStartCount: {[key: string]: number} = {};
-
-    let inMeasureRange = false;
-    events.forEach((event) => {
-      const ph = event['ph'];
-      let name = event['name'];
-      let microIterations = 1;
-      const microIterationsMatch = name.match(_MICRO_ITERATIONS_REGEX);
-      if (microIterationsMatch) {
-        name = microIterationsMatch[1];
-        microIterations = parseInt(microIterationsMatch[2], 10);
-      }
-      if (event === markStartEvent) {
-        inMeasureRange = true;
-      } else if (event === markEndEvent) {
-        inMeasureRange = false;
-      }
-      if (!inMeasureRange || event['pid'] !== markStartEvent['pid']) {
-        return;
-      }
-
-      if (this._requestCount && name === 'sendRequest') {
-        result['requestCount'] += 1;
-      } else if (this._receivedData && name === 'receivedData' && ph === 'I') {
-        result['receivedData'] += event['args']['encodedDataLength'];
-      }
-      if (ph === 'B' && name === _MARK_NAME_FRAME_CAPUTRE) {
-        if (frameCaptureStartEvent) {
-          throw new Error('can capture frames only once per benchmark run');
-        }
-        if (!this._captureFrames) {
-          throw new Error(
-              'found start event for frame capture, but frame capture was not requested in benchpress');
-        }
-        frameCaptureStartEvent = event;
-      } else if (ph === 'E' && name === _MARK_NAME_FRAME_CAPUTRE) {
-        if (!frameCaptureStartEvent) {
-          throw new Error('missing start event for frame capture');
-        }
-        frameCaptureEndEvent = event;
-      }
-
-      if (ph === 'I' && frameCaptureStartEvent && !frameCaptureEndEvent && name === 'frame') {
-        frameTimestamps.push(event['ts']);
-        if (frameTimestamps.length >= 2) {
-          frameTimes.push(
-              frameTimestamps[frameTimestamps.length - 1] -
-              frameTimestamps[frameTimestamps.length - 2]);
-        }
-      }
-
-      if (ph === 'B') {
-        if (!intervalStarts[name]) {
-          intervalStartCount[name] = 1;
-          intervalStarts[name] = event;
-        } else {
-          intervalStartCount[name]++;
-        }
-      } else if ((ph === 'E') && intervalStarts[name]) {
-        intervalStartCount[name]--;
-        if (intervalStartCount[name] === 0) {
-          const startEvent = intervalStarts[name];
-          const duration = (event['ts'] - startEvent['ts']);
-          intervalStarts[name] = null;
-          if (name === 'gc') {
-            result['gcTime'] += duration;
-            const amount =
-                (startEvent['args']['usedHeapSize'] - event['args']['usedHeapSize']) / 1000;
-            result['gcAmount'] += amount;
-            const majorGc = event['args']['majorGc'];
-            if (majorGc && majorGc) {
-              result['majorGcTime'] += duration;
-            }
-            if (intervalStarts['script']) {
-              gcTimeInScript += duration;
-            }
-          } else if (name === 'render') {
-            result['renderTime'] += duration;
-            if (intervalStarts['script']) {
-              renderTimeInScript += duration;
-            }
-          } else if (name === 'script') {
-            result['scriptTime'] += duration;
-          } else if (this._microMetrics[name]) {
-            (<any>result)[name] += duration / microIterations;
-          }
-        }
-      }
-    });
-
-    if (frameCaptureStartEvent && !frameCaptureEndEvent) {
-      throw new Error('missing end event for frame capture');
-    }
-    if (this._captureFrames && !frameCaptureStartEvent) {
-      throw new Error('frame capture requested in benchpress, but no start event was found');
-    }
-    if (frameTimes.length > 0) {
-      this._addFrameMetrics(result, frameTimes);
-    }
-    result['pureScriptTime'] = result['scriptTime'] - gcTimeInScript - renderTimeInScript;
-    return result;
-  }
-
-  private _addFrameMetrics(result: {[key: string]: number}, frameTimes: any[]) {
-    result['frameTime.mean'] = frameTimes.reduce((a, b) => a + b, 0) / frameTimes.length;
-    const firstFrame = frameTimes[0];
-    result['frameTime.worst'] = frameTimes.reduce((a, b) => a > b ? a : b, firstFrame);
-    result['frameTime.best'] = frameTimes.reduce((a, b) => a < b ? a : b, firstFrame);
-    result['frameTime.smooth'] =
-        frameTimes.filter(t => t < _FRAME_TIME_SMOOTH_THRESHOLD).length / frameTimes.length;
-  }
-
-  private _markName(index: number) { return `${_MARK_NAME_PREFIX}${index}`; }
-}
-
-const _MICRO_ITERATIONS_REGEX = /(.+)\*(\d+)$/;
-
-const _MAX_RETRY_COUNT = 20;
-const _MARK_NAME_PREFIX = 'benchpress';
-
-const _MARK_NAME_FRAME_CAPUTRE = 'frameCapture';
-// using 17ms as a somewhat looser threshold, instead of 16.6666ms
-const _FRAME_TIME_SMOOTH_THRESHOLD = 17;
--- a/modules/@angular/benchpress/src/metric/user_metric.ts
+++ b/modules/@angular/benchpress/src/metric/user_metric.ts
@ -1,69 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Inject, Injectable} from '@angular/core';
-
-import {Options} from '../common_options';
-import {Metric} from '../metric';
-import {WebDriverAdapter} from '../web_driver_adapter';
-
-@Injectable()
-export class UserMetric extends Metric {
-  static PROVIDERS = [UserMetric];
-
-  constructor(
-      @Inject(Options.USER_METRICS) private _userMetrics: {[key: string]: string},
-      private _wdAdapter: WebDriverAdapter) {
-    super();
-  }
-
-  /**
-   * Starts measuring
-   */
-  beginMeasure(): Promise<any> { return Promise.resolve(true); }
-
-  /**
-   * Ends measuring.
-   */
-  endMeasure(restart: boolean): Promise<{[key: string]: any}> {
-    let resolve: (result: any) => void;
-    let reject: (error: any) => void;
-    const promise = new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
-    const adapter = this._wdAdapter;
-    const names = Object.keys(this._userMetrics);
-
-    function getAndClearValues() {
-      Promise.all(names.map(name => adapter.executeScript(`return window.${name}`)))
-          .then((values: any[]) => {
-            if (values.every(v => typeof v === 'number')) {
-              Promise.all(names.map(name => adapter.executeScript(`delete window.${name}`)))
-                  .then((_: any[]) => {
-                    const map: {[k: string]: any} = {};
-                    for (let i = 0, n = names.length; i < n; i++) {
-                      map[names[i]] = values[i];
-                    }
-                    resolve(map);
-                  }, reject);
-            } else {
-              <any>setTimeout(getAndClearValues, 100);
-            }
-          }, reject);
-    }
-    getAndClearValues();
-    return promise;
-  }
-
-  /**
-   * Describes the metrics provided by this metric implementation.
-   * (e.g. units, ...)
-   */
-  describe(): {[key: string]: any} { return this._userMetrics; }
-}
--- a/modules/@angular/benchpress/src/reporter.ts
+++ b/modules/@angular/benchpress/src/reporter.ts
@ -1,20 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {MeasureValues} from './measure_values';
-
-/**
- * A reporter reports measure values and the valid sample.
- */
-export abstract class Reporter {
-  reportMeasureValues(values: MeasureValues): Promise<any> { throw new Error('NYI'); }
-
-  reportSample(completeSample: MeasureValues[], validSample: MeasureValues[]): Promise<any> {
-    throw new Error('NYI');
-  }
-}
--- a/modules/@angular/benchpress/src/reporter/console_reporter.ts
+++ b/modules/@angular/benchpress/src/reporter/console_reporter.ts
@ -1,83 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Inject, Injectable, OpaqueToken} from '@angular/core';
-import {print} from '../facade/lang';
-import {MeasureValues} from '../measure_values';
-import {Reporter} from '../reporter';
-import {SampleDescription} from '../sample_description';
-
-import {formatNum, formatStats, sortedProps} from './util';
-
-
-/**
- * A reporter for the console
- */
-@Injectable()
-export class ConsoleReporter extends Reporter {
-  static PRINT = new OpaqueToken('ConsoleReporter.print');
-  static COLUMN_WIDTH = new OpaqueToken('ConsoleReporter.columnWidth');
-  static PROVIDERS = [
-    ConsoleReporter, {provide: ConsoleReporter.COLUMN_WIDTH, useValue: 18},
-    {provide: ConsoleReporter.PRINT, useValue: print}
-  ];
-
-  private static _lpad(value: string, columnWidth: number, fill = ' ') {
-    let result = '';
-    for (let i = 0; i < columnWidth - value.length; i++) {
-      result += fill;
-    }
-    return result + value;
-  }
-
-  private _metricNames: string[];
-
-  constructor(
-      @Inject(ConsoleReporter.COLUMN_WIDTH) private _columnWidth: number,
-      sampleDescription: SampleDescription,
-      @Inject(ConsoleReporter.PRINT) private _print: Function) {
-    super();
-    this._metricNames = sortedProps(sampleDescription.metrics);
-    this._printDescription(sampleDescription);
-  }
-
-  private _printDescription(sampleDescription: SampleDescription) {
-    this._print(`BENCHMARK ${sampleDescription.id}`);
-    this._print('Description:');
-    const props = sortedProps(sampleDescription.description);
-    props.forEach((prop) => { this._print(`- ${prop}: ${sampleDescription.description[prop]}`); });
-    this._print('Metrics:');
-    this._metricNames.forEach((metricName) => {
-      this._print(`- ${metricName}: ${sampleDescription.metrics[metricName]}`);
-    });
-    this._print('');
-    this._printStringRow(this._metricNames);
-    this._printStringRow(this._metricNames.map((_) => ''), '-');
-  }
-
-  reportMeasureValues(measureValues: MeasureValues): Promise<any> {
-    const formattedValues = this._metricNames.map(metricName => {
-      const value = measureValues.values[metricName];
-      return formatNum(value);
-    });
-    this._printStringRow(formattedValues);
-    return Promise.resolve(null);
-  }
-
-  reportSample(completeSample: MeasureValues[], validSamples: MeasureValues[]): Promise<any> {
-    this._printStringRow(this._metricNames.map((_) => ''), '=');
-    this._printStringRow(
-        this._metricNames.map(metricName => formatStats(validSamples, metricName)));
-    return Promise.resolve(null);
-  }
-
-  private _printStringRow(parts: any[], fill = ' ') {
-    this._print(
-        parts.map(part => ConsoleReporter._lpad(part, this._columnWidth, fill)).join(' | '));
-  }
-}
--- a/modules/@angular/benchpress/src/reporter/json_file_reporter.ts
+++ b/modules/@angular/benchpress/src/reporter/json_file_reporter.ts
@ -1,52 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Inject, Injectable, OpaqueToken} from '@angular/core';
-
-import {Options} from '../common_options';
-import {MeasureValues} from '../measure_values';
-import {Reporter} from '../reporter';
-import {SampleDescription} from '../sample_description';
-
-import {formatStats, sortedProps} from './util';
-
-
-/**
- * A reporter that writes results into a json file.
- */
-@Injectable()
-export class JsonFileReporter extends Reporter {
-  static PATH = new OpaqueToken('JsonFileReporter.path');
-  static PROVIDERS = [JsonFileReporter, {provide: JsonFileReporter.PATH, useValue: '.'}];
-
-  constructor(
-      private _description: SampleDescription, @Inject(JsonFileReporter.PATH) private _path: string,
-      @Inject(Options.WRITE_FILE) private _writeFile: Function,
-      @Inject(Options.NOW) private _now: Function) {
-    super();
-  }
-
-  reportMeasureValues(measureValues: MeasureValues): Promise<any> { return Promise.resolve(null); }
-
-  reportSample(completeSample: MeasureValues[], validSample: MeasureValues[]): Promise<any> {
-    const stats: {[key: string]: string} = {};
-    sortedProps(this._description.metrics).forEach((metricName) => {
-      stats[metricName] = formatStats(validSample, metricName);
-    });
-    const content = JSON.stringify(
-        {
-          'description': this._description,
-          'stats': stats,
-          'completeSample': completeSample,
-          'validSample': validSample,
-        },
-        null, 2);
-    const filePath = `${this._path}/${this._description.id}_${this._now().getTime()}.json`;
-    return this._writeFile(filePath, content);
-  }
-}
--- a/modules/@angular/benchpress/src/reporter/multi_reporter.ts
+++ b/modules/@angular/benchpress/src/reporter/multi_reporter.ts
@ -1,42 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Injector, OpaqueToken} from '@angular/core';
-
-import {MeasureValues} from '../measure_values';
-import {Reporter} from '../reporter';
-
-export class MultiReporter extends Reporter {
-  static provideWith(childTokens: any[]): any[] {
-    return [
-      {
-        provide: _CHILDREN,
-        useFactory: (injector: Injector) => childTokens.map(token => injector.get(token)),
-        deps: [Injector],
-      },
-      {
-        provide: MultiReporter,
-        useFactory: (children: Reporter[]) => new MultiReporter(children),
-        deps: [_CHILDREN]
-      }
-    ];
-  }
-
-  constructor(private _reporters: Reporter[]) { super(); }
-
-  reportMeasureValues(values: MeasureValues): Promise<any[]> {
-    return Promise.all(this._reporters.map(reporter => reporter.reportMeasureValues(values)));
-  }
-
-  reportSample(completeSample: MeasureValues[], validSample: MeasureValues[]): Promise<any[]> {
-    return Promise.all(
-        this._reporters.map(reporter => reporter.reportSample(completeSample, validSample)));
-  }
-}
-
-const _CHILDREN = new OpaqueToken('MultiReporter.children');
--- a/modules/@angular/benchpress/src/reporter/util.ts
+++ b/modules/@angular/benchpress/src/reporter/util.ts
@ -1,28 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {MeasureValues} from '../measure_values';
-import {Statistic} from '../statistic';
-
-export function formatNum(n: number) {
-  return n.toFixed(2);
-}
-
-export function sortedProps(obj: {[key: string]: any}) {
-  return Object.keys(obj).sort();
-}
-
-export function formatStats(validSamples: MeasureValues[], metricName: string): string {
-  const samples = validSamples.map(measureValues => measureValues.values[metricName]);
-  const mean = Statistic.calculateMean(samples);
-  const cv = Statistic.calculateCoefficientOfVariation(samples, mean);
-  const formattedMean = formatNum(mean);
-  // Note: Don't use the unicode character for +- as it might cause
-  // hickups for consoles...
-  return isNaN(cv) ? formattedMean : `${formattedMean}+-${Math.floor(cv)}%`;
-}
--- a/modules/@angular/benchpress/src/runner.ts
+++ b/modules/@angular/benchpress/src/runner.ts
@ -1,110 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Provider, ReflectiveInjector} from '@angular/core';
-
-import {Options} from './common_options';
-import {isPresent} from './facade/lang';
-import {Metric} from './metric';
-import {MultiMetric} from './metric/multi_metric';
-import {PerflogMetric} from './metric/perflog_metric';
-import {UserMetric} from './metric/user_metric';
-import {Reporter} from './reporter';
-import {ConsoleReporter} from './reporter/console_reporter';
-import {MultiReporter} from './reporter/multi_reporter';
-import {SampleDescription} from './sample_description';
-import {SampleState, Sampler} from './sampler';
-import {Validator} from './validator';
-import {RegressionSlopeValidator} from './validator/regression_slope_validator';
-import {SizeValidator} from './validator/size_validator';
-import {WebDriverAdapter} from './web_driver_adapter';
-import {WebDriverExtension} from './web_driver_extension';
-import {ChromeDriverExtension} from './webdriver/chrome_driver_extension';
-import {FirefoxDriverExtension} from './webdriver/firefox_driver_extension';
-import {IOsDriverExtension} from './webdriver/ios_driver_extension';
-
-
-
-/**
- * The Runner is the main entry point for executing a sample run.
- * It provides defaults, creates the injector and calls the sampler.
- */
-export class Runner {
-  constructor(private _defaultProviders: Provider[] = []) {}
-
-  sample({id, execute, prepare, microMetrics, providers, userMetrics}: {
-    id: string,
-    execute?: Function,
-    prepare?: Function,
-    microMetrics?: {[key: string]: string},
-    providers?: Provider[],
-    userMetrics?: {[key: string]: string}
-  }): Promise<SampleState> {
-    const sampleProviders: Provider[] = [
-      _DEFAULT_PROVIDERS, this._defaultProviders, {provide: Options.SAMPLE_ID, useValue: id},
-      {provide: Options.EXECUTE, useValue: execute}
-    ];
-    if (isPresent(prepare)) {
-      sampleProviders.push({provide: Options.PREPARE, useValue: prepare});
-    }
-    if (isPresent(microMetrics)) {
-      sampleProviders.push({provide: Options.MICRO_METRICS, useValue: microMetrics});
-    }
-    if (isPresent(userMetrics)) {
-      sampleProviders.push({provide: Options.USER_METRICS, useValue: userMetrics});
-    }
-    if (isPresent(providers)) {
-      sampleProviders.push(providers);
-    }
-
-    const inj = ReflectiveInjector.resolveAndCreate(sampleProviders);
-    const adapter: WebDriverAdapter = inj.get(WebDriverAdapter);
-
-    return Promise
-        .all([adapter.capabilities(), adapter.executeScript('return window.navigator.userAgent;')])
-        .then((args) => {
-          const capabilities = args[0];
-          const userAgent = args[1];
-
-          // This might still create instances twice. We are creating a new injector with all the
-          // providers.
-          // Only WebDriverAdapter is reused.
-          // TODO vsavkin consider changing it when toAsyncFactory is added back or when child
-          // injectors are handled better.
-          const injector = ReflectiveInjector.resolveAndCreate([
-            sampleProviders, {provide: Options.CAPABILITIES, useValue: capabilities},
-            {provide: Options.USER_AGENT, useValue: userAgent},
-            {provide: WebDriverAdapter, useValue: adapter}
-          ]);
-
-          const sampler = injector.get(Sampler);
-          return sampler.sample();
-        });
-  }
-}
-
-const _DEFAULT_PROVIDERS = [
-  Options.DEFAULT_PROVIDERS,
-  Sampler.PROVIDERS,
-  ConsoleReporter.PROVIDERS,
-  RegressionSlopeValidator.PROVIDERS,
-  SizeValidator.PROVIDERS,
-  ChromeDriverExtension.PROVIDERS,
-  FirefoxDriverExtension.PROVIDERS,
-  IOsDriverExtension.PROVIDERS,
-  PerflogMetric.PROVIDERS,
-  UserMetric.PROVIDERS,
-  SampleDescription.PROVIDERS,
-  MultiReporter.provideWith([ConsoleReporter]),
-  MultiMetric.provideWith([PerflogMetric, UserMetric]),
-  {provide: Reporter, useExisting: MultiReporter},
-  {provide: Validator, useExisting: RegressionSlopeValidator},
-  WebDriverExtension.provideFirstSupported(
-      [ChromeDriverExtension, FirefoxDriverExtension, IOsDriverExtension]),
-  {provide: Metric, useExisting: MultiMetric},
-];
--- a/modules/@angular/benchpress/src/sample_description.ts
+++ b/modules/@angular/benchpress/src/sample_description.ts
@ -1,49 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {OpaqueToken} from '@angular/core';
-
-import {Options} from './common_options';
-import {Metric} from './metric';
-import {Validator} from './validator';
-
-
-/**
- * SampleDescription merges all available descriptions about a sample
- */
-export class SampleDescription {
-  static PROVIDERS = [{
-    provide: SampleDescription,
-    useFactory:
-        (metric: Metric, id: string, forceGc: boolean, userAgent: string, validator: Validator,
-         defaultDesc: {[key: string]: string}, userDesc: {[key: string]: string}) =>
-            new SampleDescription(
-                id,
-                [
-                  {'forceGc': forceGc, 'userAgent': userAgent}, validator.describe(), defaultDesc,
-                  userDesc
-                ],
-                metric.describe()),
-    deps: [
-      Metric, Options.SAMPLE_ID, Options.FORCE_GC, Options.USER_AGENT, Validator,
-      Options.DEFAULT_DESCRIPTION, Options.SAMPLE_DESCRIPTION
-    ]
-  }];
-  description: {[key: string]: any};
-
-  constructor(
-      public id: string, descriptions: Array<{[key: string]: any}>,
-      public metrics: {[key: string]: any}) {
-    this.description = {};
-    descriptions.forEach(description => {
-      Object.keys(description).forEach(prop => { this.description[prop] = description[prop]; });
-    });
-  }
-
-  toJson() { return {'id': this.id, 'description': this.description, 'metrics': this.metrics}; }
-}
--- a/modules/@angular/benchpress/src/sampler.ts
+++ b/modules/@angular/benchpress/src/sampler.ts
@ -1,81 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Inject, Injectable} from '@angular/core';
-
-import {Options} from './common_options';
-import {isPresent} from './facade/lang';
-import {MeasureValues} from './measure_values';
-import {Metric} from './metric';
-import {Reporter} from './reporter';
-import {Validator} from './validator';
-import {WebDriverAdapter} from './web_driver_adapter';
-
-
-/**
- * The Sampler owns the sample loop:
- * 1. calls the prepare/execute callbacks,
- * 2. gets data from the metric
- * 3. asks the validator for a valid sample
- * 4. reports the new data to the reporter
- * 5. loop until there is a valid sample
- */
-@Injectable()
-export class Sampler {
-  static PROVIDERS = [Sampler];
-
-  constructor(
-      private _driver: WebDriverAdapter, private _metric: Metric, private _reporter: Reporter,
-      private _validator: Validator, @Inject(Options.PREPARE) private _prepare: Function,
-      @Inject(Options.EXECUTE) private _execute: Function,
-      @Inject(Options.NOW) private _now: Function) {}
-
-  sample(): Promise<SampleState> {
-    const loop = (lastState: SampleState): Promise<SampleState> => {
-      return this._iterate(lastState).then((newState) => {
-        if (isPresent(newState.validSample)) {
-          return newState;
-        } else {
-          return loop(newState);
-        }
-      });
-    };
-    return loop(new SampleState([], null));
-  }
-
-  private _iterate(lastState: SampleState): Promise<SampleState> {
-    let resultPromise: Promise<SampleState>;
-    if (this._prepare !== Options.NO_PREPARE) {
-      resultPromise = this._driver.waitFor(this._prepare);
-    } else {
-      resultPromise = Promise.resolve(null);
-    }
-    if (this._prepare !== Options.NO_PREPARE || lastState.completeSample.length === 0) {
-      resultPromise = resultPromise.then((_) => this._metric.beginMeasure());
-    }
-    return resultPromise.then((_) => this._driver.waitFor(this._execute))
-        .then((_) => this._metric.endMeasure(this._prepare === Options.NO_PREPARE))
-        .then((measureValues) => this._report(lastState, measureValues));
-  }
-
-  private _report(state: SampleState, metricValues: {[key: string]: any}): Promise<SampleState> {
-    const measureValues = new MeasureValues(state.completeSample.length, this._now(), metricValues);
-    const completeSample = state.completeSample.concat([measureValues]);
-    const validSample = this._validator.validate(completeSample);
-    let resultPromise = this._reporter.reportMeasureValues(measureValues);
-    if (isPresent(validSample)) {
-      resultPromise =
-          resultPromise.then((_) => this._reporter.reportSample(completeSample, validSample));
-    }
-    return resultPromise.then((_) => new SampleState(completeSample, validSample));
-  }
-}
-
-export class SampleState {
-  constructor(public completeSample: MeasureValues[], public validSample: MeasureValues[]) {}
-}
--- a/modules/@angular/benchpress/src/statistic.ts
+++ b/modules/@angular/benchpress/src/statistic.ts
@ -1,41 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-export class Statistic {
-  static calculateCoefficientOfVariation(sample: number[], mean: number) {
-    return Statistic.calculateStandardDeviation(sample, mean) / mean * 100;
-  }
-
-  static calculateMean(samples: number[]) {
-    let total = 0;
-    // TODO: use reduce
-    samples.forEach(x => total += x);
-    return total / samples.length;
-  }
-
-  static calculateStandardDeviation(samples: number[], mean: number) {
-    let deviation = 0;
-    // TODO: use reduce
-    samples.forEach(x => deviation += Math.pow(x - mean, 2));
-    deviation = deviation / (samples.length);
-    deviation = Math.sqrt(deviation);
-    return deviation;
-  }
-
-  static calculateRegressionSlope(
-      xValues: number[], xMean: number, yValues: number[], yMean: number) {
-    // See http://en.wikipedia.org/wiki/Simple_linear_regression
-    let dividendSum = 0;
-    let divisorSum = 0;
-    for (let i = 0; i < xValues.length; i++) {
-      dividendSum += (xValues[i] - xMean) * (yValues[i] - yMean);
-      divisorSum += Math.pow(xValues[i] - xMean, 2);
-    }
-    return dividendSum / divisorSum;
-  }
-}
--- a/modules/@angular/benchpress/src/validator.ts
+++ b/modules/@angular/benchpress/src/validator.ts
@ -1,27 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {MeasureValues} from './measure_values';
-
-/**
- * A Validator calculates a valid sample out of the complete sample.
- * A valid sample is a sample that represents the population that should be observed
- * in the correct way.
- */
-export abstract class Validator {
-  /**
-   * Calculates a valid sample out of the complete sample
-   */
-  validate(completeSample: MeasureValues[]): MeasureValues[] { throw new Error('NYI'); }
-
-  /**
-   * Returns a Map that describes the properties of the validator
-   * (e.g. sample size, ...)
-   */
-  describe(): {[key: string]: any} { throw new Error('NYI'); }
-}
--- a/modules/@angular/benchpress/src/validator/regression_slope_validator.ts
+++ b/modules/@angular/benchpress/src/validator/regression_slope_validator.ts
@ -1,57 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Inject, Injectable, OpaqueToken} from '@angular/core';
-
-import {MeasureValues} from '../measure_values';
-import {Statistic} from '../statistic';
-import {Validator} from '../validator';
-
-/**
- * A validator that checks the regression slope of a specific metric.
- * Waits for the regression slope to be >=0.
- */
-@Injectable()
-export class RegressionSlopeValidator extends Validator {
-  static SAMPLE_SIZE = new OpaqueToken('RegressionSlopeValidator.sampleSize');
-  static METRIC = new OpaqueToken('RegressionSlopeValidator.metric');
-  static PROVIDERS = [
-    RegressionSlopeValidator, {provide: RegressionSlopeValidator.SAMPLE_SIZE, useValue: 10},
-    {provide: RegressionSlopeValidator.METRIC, useValue: 'scriptTime'}
-  ];
-
-  constructor(
-      @Inject(RegressionSlopeValidator.SAMPLE_SIZE) private _sampleSize: number,
-      @Inject(RegressionSlopeValidator.METRIC) private _metric: string) {
-    super();
-  }
-
-  describe(): {[key: string]: any} {
-    return {'sampleSize': this._sampleSize, 'regressionSlopeMetric': this._metric};
-  }
-
-  validate(completeSample: MeasureValues[]): MeasureValues[] {
-    if (completeSample.length >= this._sampleSize) {
-      const latestSample =
-          completeSample.slice(completeSample.length - this._sampleSize, completeSample.length);
-      const xValues: number[] = [];
-      const yValues: number[] = [];
-      for (let i = 0; i < latestSample.length; i++) {
-        // For now, we only use the array index as x value.
-        // TODO(tbosch): think about whether we should use time here instead
-        xValues.push(i);
-        yValues.push(latestSample[i].values[this._metric]);
-      }
-      const regressionSlope = Statistic.calculateRegressionSlope(
-          xValues, Statistic.calculateMean(xValues), yValues, Statistic.calculateMean(yValues));
-      return regressionSlope >= 0 ? latestSample : null;
-    } else {
-      return null;
-    }
-  }
-}
--- a/modules/@angular/benchpress/src/validator/size_validator.ts
+++ b/modules/@angular/benchpress/src/validator/size_validator.ts
@ -1,33 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Inject, Injectable, OpaqueToken} from '@angular/core';
-
-import {MeasureValues} from '../measure_values';
-import {Validator} from '../validator';
-
-/**
- * A validator that waits for the sample to have a certain size.
- */
-@Injectable()
-export class SizeValidator extends Validator {
-  static SAMPLE_SIZE = new OpaqueToken('SizeValidator.sampleSize');
-  static PROVIDERS = [SizeValidator, {provide: SizeValidator.SAMPLE_SIZE, useValue: 10}];
-
-  constructor(@Inject(SizeValidator.SAMPLE_SIZE) private _sampleSize: number) { super(); }
-
-  describe(): {[key: string]: any} { return {'sampleSize': this._sampleSize}; }
-
-  validate(completeSample: MeasureValues[]): MeasureValues[] {
-    if (completeSample.length >= this._sampleSize) {
-      return completeSample.slice(completeSample.length - this._sampleSize, completeSample.length);
-    } else {
-      return null;
-    }
-  }
-}
--- a/modules/@angular/benchpress/src/web_driver_adapter.ts
+++ b/modules/@angular/benchpress/src/web_driver_adapter.ts
@ -1,22 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-
-
-/**
- * A WebDriverAdapter bridges API differences between different WebDriver clients,
- * e.g. JS vs Dart Async vs Dart Sync webdriver.
- * Needs one implementation for every supported WebDriver client.
- */
-export abstract class WebDriverAdapter {
-  waitFor(callback: Function): Promise<any> { throw new Error('NYI'); }
-  executeScript(script: string): Promise<any> { throw new Error('NYI'); }
-  executeAsyncScript(script: string): Promise<any> { throw new Error('NYI'); }
-  capabilities(): Promise<{[key: string]: any}> { throw new Error('NYI'); }
-  logs(type: string): Promise<any[]> { throw new Error('NYI'); }
-}
--- a/modules/@angular/benchpress/src/web_driver_extension.ts
+++ b/modules/@angular/benchpress/src/web_driver_extension.ts
@ -1,104 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Injector, OpaqueToken} from '@angular/core';
-
-import {Options} from './common_options';
-
-export type PerfLogEvent = {
-  [key: string]: any
-} & {
-  ph?: 'X' | 'B' | 'E' | 'I',
-  ts?: number,
-  dur?: number,
-  name?: string,
-  pid?: string,
-  args?: {
-    encodedDataLength?: number,
-    usedHeapSize?: number,
-    majorGc?: boolean,
-    url?: string,
-    method?: string
-  }
-};
-
-/**
- * A WebDriverExtension implements extended commands of the webdriver protocol
- * for a given browser, independent of the WebDriverAdapter.
- * Needs one implementation for every supported Browser.
- */
-export abstract class WebDriverExtension {
-  static provideFirstSupported(childTokens: any[]): any[] {
-    const res = [
-      {
-        provide: _CHILDREN,
-        useFactory: (injector: Injector) => childTokens.map(token => injector.get(token)),
-        deps: [Injector]
-      },
-      {
-        provide: WebDriverExtension,
-        useFactory: (children: WebDriverExtension[], capabilities: {[key: string]: any}) => {
-          let delegate: WebDriverExtension;
-          children.forEach(extension => {
-            if (extension.supports(capabilities)) {
-              delegate = extension;
-            }
-          });
-          if (!delegate) {
-            throw new Error('Could not find a delegate for given capabilities!');
-          }
-          return delegate;
-        },
-        deps: [_CHILDREN, Options.CAPABILITIES]
-      }
-    ];
-    return res;
-  }
-
-  gc(): Promise<any> { throw new Error('NYI'); }
-
-  timeBegin(name: string): Promise<any> { throw new Error('NYI'); }
-
-  timeEnd(name: string, restartName: string): Promise<any> { throw new Error('NYI'); }
-
-  /**
-   * Format:
-   * - cat: category of the event
-   * - name: event name: 'script', 'gc', 'render', ...
-   * - ph: phase: 'B' (begin), 'E' (end), 'X' (Complete event), 'I' (Instant event)
-   * - ts: timestamp in ms, e.g. 12345
-   * - pid: process id
-   * - args: arguments, e.g. {heapSize: 1234}
-   *
-   * Based on [Chrome Trace Event
-   *Format](https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/edit)
-   **/
-  readPerfLog(): Promise<PerfLogEvent[]> { throw new Error('NYI'); }
-
-  perfLogFeatures(): PerfLogFeatures { throw new Error('NYI'); }
-
-  supports(capabilities: {[key: string]: any}): boolean { return true; }
-}
-
-export class PerfLogFeatures {
-  render: boolean;
-  gc: boolean;
-  frameCapture: boolean;
-  userTiming: boolean;
-
-  constructor(
-      {render = false, gc = false, frameCapture = false, userTiming = false}:
-          {render?: boolean, gc?: boolean, frameCapture?: boolean, userTiming?: boolean} = {}) {
-    this.render = render;
-    this.gc = gc;
-    this.frameCapture = frameCapture;
-    this.userTiming = userTiming;
-  }
-}
-
-const _CHILDREN = new OpaqueToken('WebDriverExtension.children');
--- a/modules/@angular/benchpress/src/webdriver/chrome_driver_extension.ts
+++ b/modules/@angular/benchpress/src/webdriver/chrome_driver_extension.ts
@ -1,208 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Inject, Injectable} from '@angular/core';
-
-import {Options} from '../common_options';
-import {WebDriverAdapter} from '../web_driver_adapter';
-import {PerfLogEvent, PerfLogFeatures, WebDriverExtension} from '../web_driver_extension';
-
-/**
- * Set the following 'traceCategories' to collect metrics in Chrome:
- * 'v8,blink.console,disabled-by-default-devtools.timeline,devtools.timeline,blink.user_timing'
- *
- * In order to collect the frame rate related metrics, add 'benchmark'
- * to the list above.
- */
-@Injectable()
-export class ChromeDriverExtension extends WebDriverExtension {
-  static PROVIDERS = [ChromeDriverExtension];
-
-  private _majorChromeVersion: number;
-
-  constructor(private _driver: WebDriverAdapter, @Inject(Options.USER_AGENT) userAgent: string) {
-    super();
-    this._majorChromeVersion = this._parseChromeVersion(userAgent);
-  }
-
-  private _parseChromeVersion(userAgent: string): number {
-    if (!userAgent) {
-      return -1;
-    }
-    let v = userAgent.split(/Chrom(e|ium)\//g)[2];
-    if (!v) {
-      return -1;
-    }
-    v = v.split('.')[0];
-    if (!v) {
-      return -1;
-    }
-    return parseInt(v, 10);
-  }
-
-  gc() { return this._driver.executeScript('window.gc()'); }
-
-  timeBegin(name: string): Promise<any> {
-    return this._driver.executeScript(`console.time('${name}');`);
-  }
-
-  timeEnd(name: string, restartName: string = null): Promise<any> {
-    let script = `console.timeEnd('${name}');`;
-    if (restartName) {
-      script += `console.time('${restartName}');`;
-    }
-    return this._driver.executeScript(script);
-  }
-
-  // See [Chrome Trace Event
-  // Format](https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/edit)
-  readPerfLog(): Promise<PerfLogEvent[]> {
-    // TODO(tbosch): Chromedriver bug https://code.google.com/p/chromedriver/issues/detail?id=1098
-    // Need to execute at least one command so that the browser logs can be read out!
-    return this._driver.executeScript('1+1')
-        .then((_) => this._driver.logs('performance'))
-        .then((entries) => {
-          const events: PerfLogEvent[] = [];
-          entries.forEach(entry => {
-            const message = JSON.parse(entry['message'])['message'];
-            if (message['method'] === 'Tracing.dataCollected') {
-              events.push(message['params']);
-            }
-            if (message['method'] === 'Tracing.bufferUsage') {
-              throw new Error('The DevTools trace buffer filled during the test!');
-            }
-          });
-          return this._convertPerfRecordsToEvents(events);
-        });
-  }
-
-  private _convertPerfRecordsToEvents(
-      chromeEvents: Array<{[key: string]: any}>, normalizedEvents: PerfLogEvent[] = null) {
-    if (!normalizedEvents) {
-      normalizedEvents = [];
-    }
-    chromeEvents.forEach((event) => {
-      const categories = this._parseCategories(event['cat']);
-      const normalizedEvent = this._convertEvent(event, categories);
-      if (normalizedEvent != null) normalizedEvents.push(normalizedEvent);
-    });
-    return normalizedEvents;
-  }
-
-  private _convertEvent(event: {[key: string]: any}, categories: string[]) {
-    const name = event['name'];
-    const args = event['args'];
-    if (this._isEvent(categories, name, ['blink.console'])) {
-      return normalizeEvent(event, {'name': name});
-    } else if (this._isEvent(
-                   categories, name, ['benchmark'],
-                   'BenchmarkInstrumentation::ImplThreadRenderingStats')) {
-      // TODO(goderbauer): Instead of BenchmarkInstrumentation::ImplThreadRenderingStats the
-      // following events should be used (if available) for more accurate measurments:
-      //   1st choice: vsync_before - ground truth on Android
-      //   2nd choice: BenchmarkInstrumentation::DisplayRenderingStats - available on systems with
-      //               new surfaces framework (not broadly enabled yet)
-      //   3rd choice: BenchmarkInstrumentation::ImplThreadRenderingStats - fallback event that is
-      //               always available if something is rendered
-      const frameCount = event['args']['data']['frame_count'];
-      if (frameCount > 1) {
-        throw new Error('multi-frame render stats not supported');
-      }
-      if (frameCount == 1) {
-        return normalizeEvent(event, {'name': 'frame'});
-      }
-    } else if (
-        this._isEvent(categories, name, ['disabled-by-default-devtools.timeline'], 'Rasterize') ||
-        this._isEvent(
-            categories, name, ['disabled-by-default-devtools.timeline'], 'CompositeLayers')) {
-      return normalizeEvent(event, {'name': 'render'});
-    } else if (this._isEvent(categories, name, ['devtools.timeline', 'v8'], 'MajorGC')) {
-      const normArgs = {
-        'majorGc': true,
-        'usedHeapSize': args['usedHeapSizeAfter'] !== undefined ? args['usedHeapSizeAfter'] :
-                                                                  args['usedHeapSizeBefore']
-      };
-      return normalizeEvent(event, {'name': 'gc', 'args': normArgs});
-    } else if (this._isEvent(categories, name, ['devtools.timeline', 'v8'], 'MinorGC')) {
-      const normArgs = {
-        'majorGc': false,
-        'usedHeapSize': args['usedHeapSizeAfter'] !== undefined ? args['usedHeapSizeAfter'] :
-                                                                  args['usedHeapSizeBefore']
-      };
-      return normalizeEvent(event, {'name': 'gc', 'args': normArgs});
-    } else if (
-        this._isEvent(categories, name, ['devtools.timeline'], 'FunctionCall') &&
-        (!args || !args['data'] ||
-         (args['data']['scriptName'] !== 'InjectedScript' && args['data']['scriptName'] !== ''))) {
-      return normalizeEvent(event, {'name': 'script'});
-    } else if (this._isEvent(categories, name, ['devtools.timeline'], 'EvaluateScript')) {
-      return normalizeEvent(event, {'name': 'script'});
-    } else if (this._isEvent(
-                   categories, name, ['devtools.timeline', 'blink'], 'UpdateLayoutTree')) {
-      return normalizeEvent(event, {'name': 'render'});
-    } else if (
-        this._isEvent(categories, name, ['devtools.timeline'], 'UpdateLayerTree') ||
-        this._isEvent(categories, name, ['devtools.timeline'], 'Layout') ||
-        this._isEvent(categories, name, ['devtools.timeline'], 'Paint')) {
-      return normalizeEvent(event, {'name': 'render'});
-    } else if (this._isEvent(categories, name, ['devtools.timeline'], 'ResourceReceivedData')) {
-      const normArgs = {'encodedDataLength': args['data']['encodedDataLength']};
-      return normalizeEvent(event, {'name': 'receivedData', 'args': normArgs});
-    } else if (this._isEvent(categories, name, ['devtools.timeline'], 'ResourceSendRequest')) {
-      const data = args['data'];
-      const normArgs = {'url': data['url'], 'method': data['requestMethod']};
-      return normalizeEvent(event, {'name': 'sendRequest', 'args': normArgs});
-    } else if (this._isEvent(categories, name, ['blink.user_timing'], 'navigationStart')) {
-      return normalizeEvent(event, {'name': 'navigationStart'});
-    }
-    return null;  // nothing useful in this event
-  }
-
-  private _parseCategories(categories: string): string[] { return categories.split(','); }
-
-  private _isEvent(
-      eventCategories: string[], eventName: string, expectedCategories: string[],
-      expectedName: string = null): boolean {
-    const hasCategories = expectedCategories.reduce(
-        (value, cat) => value && eventCategories.indexOf(cat) !== -1, true);
-    return !expectedName ? hasCategories : hasCategories && eventName === expectedName;
-  }
-
-  perfLogFeatures(): PerfLogFeatures {
-    return new PerfLogFeatures({render: true, gc: true, frameCapture: true, userTiming: true});
-  }
-
-  supports(capabilities: {[key: string]: any}): boolean {
-    return this._majorChromeVersion >= 44 && capabilities['browserName'].toLowerCase() === 'chrome';
-  }
-}
-
-function normalizeEvent(chromeEvent: {[key: string]: any}, data: PerfLogEvent): PerfLogEvent {
-  let ph = chromeEvent['ph'].toUpperCase();
-  if (ph === 'S') {
-    ph = 'B';
-  } else if (ph === 'F') {
-    ph = 'E';
-  } else if (ph === 'R') {
-    // mark events from navigation timing
-    ph = 'I';
-  }
-  const result: {[key: string]: any} =
-      {'pid': chromeEvent['pid'], 'ph': ph, 'cat': 'timeline', 'ts': chromeEvent['ts'] / 1000};
-  if (ph === 'X') {
-    let dur = chromeEvent['dur'];
-    if (dur === undefined) {
-      dur = chromeEvent['tdur'];
-    }
-    result['dur'] = !dur ? 0.0 : dur / 1000;
-  }
-  for (const prop in data) {
-    result[prop] = data[prop];
-  }
-  return result;
-}
--- a/modules/@angular/benchpress/src/webdriver/firefox_driver_extension.ts
+++ b/modules/@angular/benchpress/src/webdriver/firefox_driver_extension.ts
@ -1,53 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Injectable} from '@angular/core';
-
-import {isPresent} from '../facade/lang';
-import {WebDriverAdapter} from '../web_driver_adapter';
-import {PerfLogEvent, PerfLogFeatures, WebDriverExtension} from '../web_driver_extension';
-
-@Injectable()
-export class FirefoxDriverExtension extends WebDriverExtension {
-  static PROVIDERS = [FirefoxDriverExtension];
-
-  private _profilerStarted: boolean;
-
-  constructor(private _driver: WebDriverAdapter) {
-    super();
-    this._profilerStarted = false;
-  }
-
-  gc() { return this._driver.executeScript('window.forceGC()'); }
-
-  timeBegin(name: string): Promise<any> {
-    if (!this._profilerStarted) {
-      this._profilerStarted = true;
-      this._driver.executeScript('window.startProfiler();');
-    }
-    return this._driver.executeScript('window.markStart("' + name + '");');
-  }
-
-  timeEnd(name: string, restartName: string = null): Promise<any> {
-    let script = 'window.markEnd("' + name + '");';
-    if (isPresent(restartName)) {
-      script += 'window.markStart("' + restartName + '");';
-    }
-    return this._driver.executeScript(script);
-  }
-
-  readPerfLog(): Promise<PerfLogEvent> {
-    return this._driver.executeAsyncScript('var cb = arguments[0]; window.getProfile(cb);');
-  }
-
-  perfLogFeatures(): PerfLogFeatures { return new PerfLogFeatures({render: true, gc: true}); }
-
-  supports(capabilities: {[key: string]: any}): boolean {
-    return capabilities['browserName'].toLowerCase() === 'firefox';
-  }
-}
--- a/modules/@angular/benchpress/src/webdriver/ios_driver_extension.ts
+++ b/modules/@angular/benchpress/src/webdriver/ios_driver_extension.ts
@ -1,127 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Injectable} from '@angular/core';
-
-import {isBlank, isPresent} from '../facade/lang';
-import {WebDriverAdapter} from '../web_driver_adapter';
-import {PerfLogEvent, PerfLogFeatures, WebDriverExtension} from '../web_driver_extension';
-
-@Injectable()
-export class IOsDriverExtension extends WebDriverExtension {
-  static PROVIDERS = [IOsDriverExtension];
-
-  constructor(private _driver: WebDriverAdapter) { super(); }
-
-  gc(): Promise<any> { throw new Error('Force GC is not supported on iOS'); }
-
-  timeBegin(name: string): Promise<any> {
-    return this._driver.executeScript(`console.time('${name}');`);
-  }
-
-  timeEnd(name: string, restartName: string = null): Promise<any> {
-    let script = `console.timeEnd('${name}');`;
-    if (isPresent(restartName)) {
-      script += `console.time('${restartName}');`;
-    }
-    return this._driver.executeScript(script);
-  }
-
-  // See https://github.com/WebKit/webkit/tree/master/Source/WebInspectorUI/Versions
-  readPerfLog() {
-    // TODO(tbosch): Bug in IOsDriver: Need to execute at least one command
-    // so that the browser logs can be read out!
-    return this._driver.executeScript('1+1')
-        .then((_) => this._driver.logs('performance'))
-        .then((entries) => {
-          const records: any[] = [];
-          entries.forEach(entry => {
-            const message = JSON.parse(entry['message'])['message'];
-            if (message['method'] === 'Timeline.eventRecorded') {
-              records.push(message['params']['record']);
-            }
-          });
-          return this._convertPerfRecordsToEvents(records);
-        });
-  }
-
-  /** @internal */
-  private _convertPerfRecordsToEvents(records: any[], events: PerfLogEvent[] = null) {
-    if (!events) {
-      events = [];
-    }
-    records.forEach((record) => {
-      let endEvent: PerfLogEvent = null;
-      const type = record['type'];
-      const data = record['data'];
-      const startTime = record['startTime'];
-      const endTime = record['endTime'];
-
-      if (type === 'FunctionCall' && (data == null || data['scriptName'] !== 'InjectedScript')) {
-        events.push(createStartEvent('script', startTime));
-        endEvent = createEndEvent('script', endTime);
-      } else if (type === 'Time') {
-        events.push(createMarkStartEvent(data['message'], startTime));
-      } else if (type === 'TimeEnd') {
-        events.push(createMarkEndEvent(data['message'], startTime));
-      } else if (
-          type === 'RecalculateStyles' || type === 'Layout' || type === 'UpdateLayerTree' ||
-          type === 'Paint' || type === 'Rasterize' || type === 'CompositeLayers') {
-        events.push(createStartEvent('render', startTime));
-        endEvent = createEndEvent('render', endTime);
-      }
-      // Note: ios used to support GCEvent up until iOS 6 :-(
-      if (isPresent(record['children'])) {
-        this._convertPerfRecordsToEvents(record['children'], events);
-      }
-      if (isPresent(endEvent)) {
-        events.push(endEvent);
-      }
-    });
-    return events;
-  }
-
-  perfLogFeatures(): PerfLogFeatures { return new PerfLogFeatures({render: true}); }
-
-  supports(capabilities: {[key: string]: any}): boolean {
-    return capabilities['browserName'].toLowerCase() === 'safari';
-  }
-}
-
-function createEvent(
-    ph: 'X' | 'B' | 'E' | 'B' | 'E', name: string, time: number, args: any = null) {
-  const result: PerfLogEvent = {
-    'cat': 'timeline',
-    'name': name,
-    'ts': time,
-    'ph': ph,
-    // The ios protocol does not support the notions of multiple processes in
-    // the perflog...
-    'pid': 'pid0'
-  };
-  if (isPresent(args)) {
-    result['args'] = args;
-  }
-  return result;
-}
-
-function createStartEvent(name: string, time: number, args: any = null) {
-  return createEvent('B', name, time, args);
-}
-
-function createEndEvent(name: string, time: number, args: any = null) {
-  return createEvent('E', name, time, args);
-}
-
-function createMarkStartEvent(name: string, time: number) {
-  return createEvent('B', name, time);
-}
-
-function createMarkEndEvent(name: string, time: number) {
-  return createEvent('E', name, time);
-}
--- a/modules/@angular/benchpress/src/webdriver/selenium_webdriver_adapter.ts
+++ b/modules/@angular/benchpress/src/webdriver/selenium_webdriver_adapter.ts
@ -1,70 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {WebDriverAdapter} from '../web_driver_adapter';
-
-/**
- * Adapter for the selenium-webdriver.
- */
-export class SeleniumWebDriverAdapter extends WebDriverAdapter {
-  static PROTRACTOR_PROVIDERS = [{
-    provide: WebDriverAdapter,
-    useFactory: () => new SeleniumWebDriverAdapter((<any>global).browser)
-  }];
-
-  constructor(private _driver: any) { super(); }
-
-  waitFor(callback: () => any): Promise<any> { return this._driver.call(callback); }
-
-  executeScript(script: string): Promise<any> { return this._driver.executeScript(script); }
-
-  executeAsyncScript(script: string): Promise<any> {
-    return this._driver.executeAsyncScript(script);
-  }
-
-  capabilities(): Promise<{[key: string]: any}> {
-    return this._driver.getCapabilities().then((capsObject: any) => {
-      const localData: {[key: string]: any} = {};
-      capsObject.forEach((value: any, key: string) => { localData[key] = value; });
-      return localData;
-    });
-  }
-
-  logs(type: string): Promise<any> {
-    // Needed as selenium-webdriver does not forward
-    // performance logs in the correct way via manage().logs
-    return this._driver.schedule(
-        new Command('getLog').setParameter('type', type),
-        'WebDriver.manage().logs().get(' + type + ')');
-  }
-}
-
-/**
- * Copy of the `Command` class of webdriver as
- * it is not exposed via index.js in selenium-webdriver.
- */
-class Command {
-  private parameters_: {[key: string]: any} = {};
-  constructor(private name_: string) {}
-
-  getName() { return this.name_; }
-
-  setParameter(name: string, value: any) {
-    this.parameters_[name] = value;
-    return this;
-  }
-
-  setParameters(parameters: {[key: string]: any}) {
-    this.parameters_ = parameters;
-    return this;
-  }
-
-  getParameter(key: string) { return this.parameters_[key]; }
-
-  getParameters() { return this.parameters_; }
-}
--- a/modules/@angular/benchpress/test/firefox_extension/conf.ts
+++ b/modules/@angular/benchpress/test/firefox_extension/conf.ts
@ -1,21 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-require('core-js');
-require('reflect-metadata');
-const testHelper = require('../../src/firefox_extension/lib/test_helper.js');
-
-exports.config = {
-  specs: ['spec.js', 'sample_benchmark.js'],
-
-  framework: 'jasmine2',
-
-  jasmineNodeOpts: {showColors: true, defaultTimeoutInterval: 1200000},
-
-  getMultiCapabilities: function() { return testHelper.getFirefoxProfileWithExtension(); }
-};
--- a/modules/@angular/benchpress/test/firefox_extension/parser_util_spec.ts
+++ b/modules/@angular/benchpress/test/firefox_extension/parser_util_spec.ts
@ -1,100 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {convertPerfProfileToEvents} from '../../src/firefox_extension/lib/parser_util';
-
-function assertEventsEqual(actualEvents: any[], expectedEvents: any[]) {
-  expect(actualEvents.length == expectedEvents.length);
-  for (let i = 0; i < actualEvents.length; ++i) {
-    const actualEvent = actualEvents[i];
-    const expectedEvent = expectedEvents[i];
-    for (const key in actualEvent) {
-      expect(actualEvent[key]).toEqual(expectedEvent[key]);
-    }
-  }
-};
-
-export function main() {
-  describe('convertPerfProfileToEvents', function() {
-    it('should convert single instantaneous event', function() {
-      const profileData = {
-        threads: [
-          {samples: [{time: 1, frames: [{location: 'FirefoxDriver.prototype.executeScript'}]}]}
-        ]
-      };
-      const perfEvents = convertPerfProfileToEvents(profileData);
-      assertEventsEqual(perfEvents, [{ph: 'X', ts: 1, name: 'script'}]);
-    });
-
-    it('should convert single non-instantaneous event', function() {
-      const profileData = {
-        threads: [{
-          samples: [
-            {time: 1, frames: [{location: 'FirefoxDriver.prototype.executeScript'}]},
-            {time: 2, frames: [{location: 'FirefoxDriver.prototype.executeScript'}]},
-            {time: 100, frames: [{location: 'FirefoxDriver.prototype.executeScript'}]}
-          ]
-        }]
-      };
-      const perfEvents = convertPerfProfileToEvents(profileData);
-      assertEventsEqual(
-          perfEvents, [{ph: 'B', ts: 1, name: 'script'}, {ph: 'E', ts: 100, name: 'script'}]);
-    });
-
-    it('should convert multiple instantaneous events', function() {
-      const profileData = {
-        threads: [{
-          samples: [
-            {time: 1, frames: [{location: 'FirefoxDriver.prototype.executeScript'}]},
-            {time: 2, frames: [{location: 'PresShell::Paint'}]}
-          ]
-        }]
-      };
-      const perfEvents = convertPerfProfileToEvents(profileData);
-      assertEventsEqual(
-          perfEvents, [{ph: 'X', ts: 1, name: 'script'}, {ph: 'X', ts: 2, name: 'render'}]);
-    });
-
-    it('should convert multiple mixed events', function() {
-      const profileData = {
-        threads: [{
-          samples: [
-            {time: 1, frames: [{location: 'FirefoxDriver.prototype.executeScript'}]},
-            {time: 2, frames: [{location: 'PresShell::Paint'}]},
-            {time: 5, frames: [{location: 'FirefoxDriver.prototype.executeScript'}]},
-            {time: 10, frames: [{location: 'FirefoxDriver.prototype.executeScript'}]}
-          ]
-        }]
-      };
-      const perfEvents = convertPerfProfileToEvents(profileData);
-      assertEventsEqual(perfEvents, [
-        {ph: 'X', ts: 1, name: 'script'}, {ph: 'X', ts: 2, name: 'render'},
-        {ph: 'B', ts: 5, name: 'script'}, {ph: 'E', ts: 10, name: 'script'}
-      ]);
-    });
-
-    it('should add args to gc events', function() {
-      const profileData = {threads: [{samples: [{time: 1, frames: [{location: 'forceGC'}]}]}]};
-      const perfEvents = convertPerfProfileToEvents(profileData);
-      assertEventsEqual(perfEvents, [{ph: 'X', ts: 1, name: 'gc', args: {usedHeapSize: 0}}]);
-    });
-
-    it('should skip unknown events', function() {
-      const profileData = {
-        threads: [{
-          samples: [
-            {time: 1, frames: [{location: 'FirefoxDriver.prototype.executeScript'}]},
-            {time: 2, frames: [{location: 'foo'}]}
-          ]
-        }]
-      };
-      const perfEvents = convertPerfProfileToEvents(profileData);
-      assertEventsEqual(perfEvents, [{ph: 'X', ts: 1, name: 'script'}]);
-    });
-  });
-};
--- a/modules/@angular/benchpress/test/firefox_extension/sample_benchmark.ts
+++ b/modules/@angular/benchpress/test/firefox_extension/sample_benchmark.ts
@ -1,42 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {$, browser} from 'protractor';
-
-const benchpress = require('../../index.js');
-const runner = new benchpress.Runner([
-  // use protractor as Webdriver client
-  benchpress.SeleniumWebDriverAdapter.PROTRACTOR_PROVIDERS,
-  // use RegressionSlopeValidator to validate samples
-  benchpress.Validator.bindTo(benchpress.RegressionSlopeValidator),
-  // use 10 samples to calculate slope regression
-  benchpress.bind(benchpress.RegressionSlopeValidator.SAMPLE_SIZE).toValue(20),
-  // use the script metric to calculate slope regression
-  benchpress.bind(benchpress.RegressionSlopeValidator.METRIC).toValue('scriptTime'),
-  benchpress.bind(benchpress.Options.FORCE_GC).toValue(true)
-]);
-
-describe('deep tree baseline', function() {
-  it('should be fast!', function(done) {
-    browser.ignoreSynchronization = true;
-    browser.get('http://localhost:8001/playground/src/benchpress/');
-
-    /*
-     * Tell benchpress to click the buttons to destroy and re-create the tree for each sample.
-     * Benchpress will log the collected metrics after each sample is collected, and will stop
-     * sampling as soon as the calculated regression slope for last 20 samples is stable.
-     */
-    runner
-        .sample({
-          id: 'baseline',
-          execute: function() { $('button').click(); },
-          providers: [benchpress.bind(benchpress.Options.SAMPLE_DESCRIPTION).toValue({depth: 9})]
-        })
-        .then(done, done.fail);
-  });
-});
--- a/modules/@angular/benchpress/test/firefox_extension/spec.ts
+++ b/modules/@angular/benchpress/test/firefox_extension/spec.ts
@ -1,43 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {browser} from 'protractor';
-
-const assertEventsContainsName = function(events: any[], eventName: string) {
-  let found = false;
-  for (let i = 0; i < events.length; ++i) {
-    if (events[i].name == eventName) {
-      found = true;
-      break;
-    }
-  }
-  expect(found).toBeTruthy();
-};
-
-describe('firefox extension', function() {
-  const TEST_URL = 'http://localhost:8001/playground/src/hello_world/index.html';
-
-  it('should measure performance', function() {
-    browser.sleep(3000);  // wait for extension to load
-
-    browser.driver.get(TEST_URL);
-
-    browser.executeScript('window.startProfiler()').then(function() {
-      console.log('started measuring perf');
-    });
-
-    browser.executeAsyncScript('setTimeout(arguments[0], 1000);');
-    browser.executeScript('window.forceGC()');
-
-    browser.executeAsyncScript('var cb = arguments[0]; window.getProfile(cb);')
-        .then(function(profile: any) {
-          assertEventsContainsName(profile, 'gc');
-          assertEventsContainsName(profile, 'script');
-        });
-  });
-});
--- a/modules/@angular/benchpress/test/metric/multi_metric_spec.ts
+++ b/modules/@angular/benchpress/test/metric/multi_metric_spec.ts
@ -1,69 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {AsyncTestCompleter, describe, expect, inject, it} from '@angular/core/testing/testing_internal';
-import {Metric, MultiMetric, ReflectiveInjector} from '../../index';
-
-export function main() {
-  function createMetric(ids: any[]) {
-    const m = ReflectiveInjector
-                  .resolveAndCreate([
-                    ids.map(id => ({provide: id, useValue: new MockMetric(id)})),
-                    MultiMetric.provideWith(ids)
-                  ])
-                  .get(MultiMetric);
-    return Promise.resolve(m);
-  }
-
-  describe('multi metric', () => {
-    it('should merge descriptions', inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-         createMetric(['m1', 'm2']).then((m) => {
-           expect(m.describe()).toEqual({'m1': 'describe', 'm2': 'describe'});
-           async.done();
-         });
-       }));
-
-    it('should merge all beginMeasure calls',
-       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-         createMetric(['m1', 'm2']).then((m) => m.beginMeasure()).then((values) => {
-           expect(values).toEqual(['m1_beginMeasure', 'm2_beginMeasure']);
-           async.done();
-         });
-       }));
-
-    [false, true].forEach((restartFlag) => {
-      it(`should merge all endMeasure calls for restart=${restartFlag}`,
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           createMetric(['m1', 'm2']).then((m) => m.endMeasure(restartFlag)).then((values) => {
-             expect(values).toEqual(
-                 {'m1': {'restart': restartFlag}, 'm2': {'restart': restartFlag}});
-             async.done();
-           });
-         }));
-    });
-
-  });
-}
-
-class MockMetric extends Metric {
-  constructor(private _id: string) { super(); }
-
-  beginMeasure(): Promise<string> { return Promise.resolve(`${this._id}_beginMeasure`); }
-
-  endMeasure(restart: boolean): Promise<{[key: string]: any}> {
-    const result: {[key: string]: any} = {};
-    result[this._id] = {'restart': restart};
-    return Promise.resolve(result);
-  }
-
-  describe(): {[key: string]: string} {
-    const result: {[key: string]: string} = {};
-    result[this._id] = 'describe';
-    return result;
-  }
-}
--- a/modules/@angular/benchpress/test/metric/perflog_metric_spec.ts
+++ b/modules/@angular/benchpress/test/metric/perflog_metric_spec.ts
@ -1,700 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Provider} from '@angular/core';
-import {AsyncTestCompleter, beforeEach, describe, expect, inject, it} from '@angular/core/testing/testing_internal';
-
-import {Metric, Options, PerfLogEvent, PerfLogFeatures, PerflogMetric, ReflectiveInjector, WebDriverExtension} from '../../index';
-import {isPresent} from '../../src/facade/lang';
-import {TraceEventFactory} from '../trace_event_factory';
-
-export function main() {
-  let commandLog: any[];
-  const eventFactory = new TraceEventFactory('timeline', 'pid0');
-
-  function createMetric(
-      perfLogs: PerfLogEvent[], perfLogFeatures: PerfLogFeatures,
-      {microMetrics, forceGc, captureFrames, receivedData, requestCount}: {
-        microMetrics?: {[key: string]: string},
-        forceGc?: boolean,
-        captureFrames?: boolean,
-        receivedData?: boolean,
-        requestCount?: boolean
-      } = {}): Metric {
-    commandLog = [];
-    if (!perfLogFeatures) {
-      perfLogFeatures =
-          new PerfLogFeatures({render: true, gc: true, frameCapture: true, userTiming: true});
-    }
-    if (!microMetrics) {
-      microMetrics = {};
-    }
-    const providers: Provider[] = [
-      Options.DEFAULT_PROVIDERS, PerflogMetric.PROVIDERS,
-      {provide: Options.MICRO_METRICS, useValue: microMetrics}, {
-        provide: PerflogMetric.SET_TIMEOUT,
-        useValue: (fn: Function, millis: number) => {
-          commandLog.push(['setTimeout', millis]);
-          fn();
-        },
-      },
-      {
-        provide: WebDriverExtension,
-        useValue: new MockDriverExtension(perfLogs, commandLog, perfLogFeatures)
-      }
-    ];
-    if (isPresent(forceGc)) {
-      providers.push({provide: Options.FORCE_GC, useValue: forceGc});
-    }
-    if (isPresent(captureFrames)) {
-      providers.push({provide: Options.CAPTURE_FRAMES, useValue: captureFrames});
-    }
-    if (isPresent(receivedData)) {
-      providers.push({provide: Options.RECEIVED_DATA, useValue: receivedData});
-    }
-    if (isPresent(requestCount)) {
-      providers.push({provide: Options.REQUEST_COUNT, useValue: requestCount});
-    }
-    return ReflectiveInjector.resolveAndCreate(providers).get(PerflogMetric);
-  }
-
-  describe('perflog metric', () => {
-
-    function sortedKeys(stringMap: {[key: string]: any}) {
-      const res: string[] = [];
-      res.push(...Object.keys(stringMap));
-      res.sort();
-      return res;
-    }
-
-    it('should describe itself based on the perfLogFeatrues', () => {
-      expect(sortedKeys(createMetric([[]], new PerfLogFeatures()).describe())).toEqual([
-        'pureScriptTime', 'scriptTime'
-      ]);
-
-      expect(
-          sortedKeys(createMetric([[]], new PerfLogFeatures({render: true, gc: false})).describe()))
-          .toEqual(['pureScriptTime', 'renderTime', 'scriptTime']);
-
-      expect(sortedKeys(createMetric([[]], null).describe())).toEqual([
-        'gcAmount', 'gcTime', 'majorGcTime', 'pureScriptTime', 'renderTime', 'scriptTime'
-      ]);
-
-      expect(sortedKeys(createMetric([[]], new PerfLogFeatures({render: true, gc: true}), {
-                          forceGc: true
-                        }).describe()))
-          .toEqual([
-            'forcedGcAmount', 'forcedGcTime', 'gcAmount', 'gcTime', 'majorGcTime', 'pureScriptTime',
-            'renderTime', 'scriptTime'
-          ]);
-
-
-      expect(sortedKeys(createMetric([[]], new PerfLogFeatures({userTiming: true}), {
-                          receivedData: true,
-                          requestCount: true
-                        }).describe()))
-          .toEqual(['pureScriptTime', 'receivedData', 'requestCount', 'scriptTime']);
-    });
-
-    it('should describe itself based on micro metrics', () => {
-      const description =
-          createMetric([[]], null, {microMetrics: {'myMicroMetric': 'someDesc'}}).describe();
-      expect(description['myMicroMetric']).toEqual('someDesc');
-    });
-
-    it('should describe itself if frame capture is requested and available', () => {
-      const description = createMetric([[]], new PerfLogFeatures({frameCapture: true}), {
-                            captureFrames: true
-                          }).describe();
-      expect(description['frameTime.mean']).not.toContain('WARNING');
-      expect(description['frameTime.best']).not.toContain('WARNING');
-      expect(description['frameTime.worst']).not.toContain('WARNING');
-      expect(description['frameTime.smooth']).not.toContain('WARNING');
-    });
-
-    it('should describe itself if frame capture is requested and not available', () => {
-      const description = createMetric([[]], new PerfLogFeatures({frameCapture: false}), {
-                            captureFrames: true
-                          }).describe();
-      expect(description['frameTime.mean']).toContain('WARNING');
-      expect(description['frameTime.best']).toContain('WARNING');
-      expect(description['frameTime.worst']).toContain('WARNING');
-      expect(description['frameTime.smooth']).toContain('WARNING');
-    });
-
-    describe('beginMeasure', () => {
-
-      it('should not force gc and mark the timeline',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           const metric = createMetric([[]], null);
-           metric.beginMeasure().then((_) => {
-             expect(commandLog).toEqual([['timeBegin', 'benchpress0']]);
-
-             async.done();
-           });
-         }));
-
-      it('should force gc and mark the timeline',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           const metric = createMetric([[]], null, {forceGc: true});
-           metric.beginMeasure().then((_) => {
-             expect(commandLog).toEqual([['gc'], ['timeBegin', 'benchpress0']]);
-
-             async.done();
-           });
-         }));
-
-    });
-
-    describe('endMeasure', () => {
-
-      it('should mark and aggregate events in between the marks',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           const events = [[
-             eventFactory.markStart('benchpress0', 0), eventFactory.start('script', 4),
-             eventFactory.end('script', 6), eventFactory.markEnd('benchpress0', 10)
-           ]];
-           const metric = createMetric(events, null);
-           metric.beginMeasure().then((_) => metric.endMeasure(false)).then((data) => {
-             expect(commandLog).toEqual([
-               ['timeBegin', 'benchpress0'], ['timeEnd', 'benchpress0', null], 'readPerfLog'
-             ]);
-             expect(data['scriptTime']).toBe(2);
-
-             async.done();
-           });
-         }));
-
-      it('should mark and aggregate events since navigationStart',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           const events = [[
-             eventFactory.markStart('benchpress0', 0), eventFactory.start('script', 4),
-             eventFactory.end('script', 6), eventFactory.instant('navigationStart', 7),
-             eventFactory.start('script', 8), eventFactory.end('script', 9),
-             eventFactory.markEnd('benchpress0', 10)
-           ]];
-           const metric = createMetric(events, null);
-           metric.beginMeasure().then((_) => metric.endMeasure(false)).then((data) => {
-             expect(data['scriptTime']).toBe(1);
-
-             async.done();
-           });
-         }));
-
-      it('should restart timing', inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           const events = [
-             [
-               eventFactory.markStart('benchpress0', 0),
-               eventFactory.markEnd('benchpress0', 1),
-               eventFactory.markStart('benchpress1', 2),
-             ],
-             [eventFactory.markEnd('benchpress1', 3)]
-           ];
-           const metric = createMetric(events, null);
-           metric.beginMeasure()
-               .then((_) => metric.endMeasure(true))
-               .then((_) => metric.endMeasure(true))
-               .then((_) => {
-                 expect(commandLog).toEqual([
-                   ['timeBegin', 'benchpress0'], ['timeEnd', 'benchpress0', 'benchpress1'],
-                   'readPerfLog', ['timeEnd', 'benchpress1', 'benchpress2'], 'readPerfLog'
-                 ]);
-
-                 async.done();
-               });
-         }));
-
-      it('should loop and aggregate until the end mark is present',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           const events = [
-             [eventFactory.markStart('benchpress0', 0), eventFactory.start('script', 1)],
-             [eventFactory.end('script', 2)],
-             [
-               eventFactory.start('script', 3), eventFactory.end('script', 5),
-               eventFactory.markEnd('benchpress0', 10)
-             ]
-           ];
-           const metric = createMetric(events, null);
-           metric.beginMeasure().then((_) => metric.endMeasure(false)).then((data) => {
-             expect(commandLog).toEqual([
-               ['timeBegin', 'benchpress0'], ['timeEnd', 'benchpress0', null], 'readPerfLog',
-               ['setTimeout', 100], 'readPerfLog', ['setTimeout', 100], 'readPerfLog'
-             ]);
-             expect(data['scriptTime']).toBe(3);
-
-             async.done();
-           });
-         }));
-
-      it('should store events after the end mark for the next call',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           const events = [
-             [
-               eventFactory.markStart('benchpress0', 0), eventFactory.markEnd('benchpress0', 1),
-               eventFactory.markStart('benchpress1', 1), eventFactory.start('script', 1),
-               eventFactory.end('script', 2)
-             ],
-             [
-               eventFactory.start('script', 3), eventFactory.end('script', 5),
-               eventFactory.markEnd('benchpress1', 6)
-             ]
-           ];
-           const metric = createMetric(events, null);
-           metric.beginMeasure()
-               .then((_) => metric.endMeasure(true))
-               .then((data) => {
-                 expect(data['scriptTime']).toBe(0);
-                 return metric.endMeasure(true);
-               })
-               .then((data) => {
-                 expect(commandLog).toEqual([
-                   ['timeBegin', 'benchpress0'], ['timeEnd', 'benchpress0', 'benchpress1'],
-                   'readPerfLog', ['timeEnd', 'benchpress1', 'benchpress2'], 'readPerfLog'
-                 ]);
-                 expect(data['scriptTime']).toBe(3);
-
-                 async.done();
-               });
-         }));
-
-      describe('with forced gc', () => {
-        let events: PerfLogEvent[][];
-        beforeEach(() => {
-          events = [[
-            eventFactory.markStart('benchpress0', 0), eventFactory.start('script', 4),
-            eventFactory.end('script', 6), eventFactory.markEnd('benchpress0', 10),
-            eventFactory.markStart('benchpress1', 11),
-            eventFactory.start('gc', 12, {'usedHeapSize': 2500}),
-            eventFactory.end('gc', 15, {'usedHeapSize': 1000}),
-            eventFactory.markEnd('benchpress1', 20)
-          ]];
-        });
-
-        it('should measure forced gc', inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             const metric = createMetric(events, null, {forceGc: true});
-             metric.beginMeasure().then((_) => metric.endMeasure(false)).then((data) => {
-               expect(commandLog).toEqual([
-                 ['gc'], ['timeBegin', 'benchpress0'], ['timeEnd', 'benchpress0', 'benchpress1'],
-                 'readPerfLog', ['gc'], ['timeEnd', 'benchpress1', null], 'readPerfLog'
-               ]);
-               expect(data['forcedGcTime']).toBe(3);
-               expect(data['forcedGcAmount']).toBe(1.5);
-
-               async.done();
-             });
-           }));
-
-        it('should restart after the forced gc if needed',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             const metric = createMetric(events, null, {forceGc: true});
-             metric.beginMeasure().then((_) => metric.endMeasure(true)).then((data) => {
-               expect(commandLog[5]).toEqual(['timeEnd', 'benchpress1', 'benchpress2']);
-
-               async.done();
-             });
-           }));
-
-      });
-
-    });
-
-    describe('aggregation', () => {
-
-      function aggregate(events: any[], {microMetrics, captureFrames, receivedData, requestCount}: {
-        microMetrics?: {[key: string]: string},
-        captureFrames?: boolean,
-        receivedData?: boolean,
-        requestCount?: boolean
-      } = {}) {
-        events.unshift(eventFactory.markStart('benchpress0', 0));
-        events.push(eventFactory.markEnd('benchpress0', 10));
-        const metric = createMetric([events], null, {
-          microMetrics: microMetrics,
-          captureFrames: captureFrames,
-          receivedData: receivedData,
-          requestCount: requestCount
-        });
-        return metric.beginMeasure().then((_) => metric.endMeasure(false));
-      }
-
-      describe('frame metrics', () => {
-        it('should calculate mean frame time',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             aggregate(
-                 [
-                   eventFactory.markStart('frameCapture', 0), eventFactory.instant('frame', 1),
-                   eventFactory.instant('frame', 3), eventFactory.instant('frame', 4),
-                   eventFactory.markEnd('frameCapture', 5)
-                 ],
-                 {captureFrames: true})
-                 .then((data) => {
-                   expect(data['frameTime.mean']).toBe(((3 - 1) + (4 - 3)) / 2);
-                   async.done();
-                 });
-           }));
-
-        it('should throw if no start event',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-
-             aggregate(
-                 [eventFactory.instant('frame', 4), eventFactory.markEnd('frameCapture', 5)],
-                 {captureFrames: true})
-                 .catch((err): any => {
-                   expect(() => {
-                     throw err;
-                   }).toThrowError('missing start event for frame capture');
-                   async.done();
-                 });
-           }));
-
-        it('should throw if no end event',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-
-             aggregate(
-                 [eventFactory.markStart('frameCapture', 3), eventFactory.instant('frame', 4)],
-                 {captureFrames: true})
-                 .catch((err): any => {
-                   expect(() => { throw err; }).toThrowError('missing end event for frame capture');
-                   async.done();
-                 });
-           }));
-
-        it('should throw if trying to capture twice',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-
-             aggregate(
-                 [
-                   eventFactory.markStart('frameCapture', 3),
-                   eventFactory.markStart('frameCapture', 4)
-                 ],
-                 {captureFrames: true})
-                 .catch((err): any => {
-                   expect(() => {
-                     throw err;
-                   }).toThrowError('can capture frames only once per benchmark run');
-                   async.done();
-                 });
-           }));
-
-        it('should throw if trying to capture when frame capture is disabled',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             aggregate([eventFactory.markStart('frameCapture', 3)]).catch((err) => {
-               expect(() => { throw err; })
-                   .toThrowError(
-                       'found start event for frame capture, but frame capture was not requested in benchpress');
-               async.done();
-               return null;
-             });
-           }));
-
-        it('should throw if frame capture is enabled, but nothing is captured',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             aggregate([], {captureFrames: true}).catch((err): any => {
-               expect(() => { throw err; })
-                   .toThrowError(
-                       'frame capture requested in benchpress, but no start event was found');
-               async.done();
-             });
-           }));
-
-        it('should calculate best and worst frame time',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             aggregate(
-                 [
-                   eventFactory.markStart('frameCapture', 0), eventFactory.instant('frame', 1),
-                   eventFactory.instant('frame', 9), eventFactory.instant('frame', 15),
-                   eventFactory.instant('frame', 18), eventFactory.instant('frame', 28),
-                   eventFactory.instant('frame', 32), eventFactory.markEnd('frameCapture', 10)
-                 ],
-                 {captureFrames: true})
-                 .then((data) => {
-                   expect(data['frameTime.worst']).toBe(10);
-                   expect(data['frameTime.best']).toBe(3);
-                   async.done();
-                 });
-           }));
-
-        it('should calculate percentage of smoothness to be good',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             aggregate(
-                 [
-                   eventFactory.markStart('frameCapture', 0), eventFactory.instant('frame', 1),
-                   eventFactory.instant('frame', 2), eventFactory.instant('frame', 3),
-                   eventFactory.markEnd('frameCapture', 4)
-                 ],
-                 {captureFrames: true})
-                 .then((data) => {
-                   expect(data['frameTime.smooth']).toBe(1.0);
-                   async.done();
-                 });
-           }));
-
-        it('should calculate percentage of smoothness to be bad',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             aggregate(
-                 [
-                   eventFactory.markStart('frameCapture', 0), eventFactory.instant('frame', 1),
-                   eventFactory.instant('frame', 2), eventFactory.instant('frame', 22),
-                   eventFactory.instant('frame', 23), eventFactory.instant('frame', 24),
-                   eventFactory.markEnd('frameCapture', 4)
-                 ],
-                 {captureFrames: true})
-                 .then((data) => {
-                   expect(data['frameTime.smooth']).toBe(0.75);
-                   async.done();
-                 });
-           }));
-
-      });
-
-      it('should report a single interval',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           aggregate([
-             eventFactory.start('script', 0), eventFactory.end('script', 5)
-           ]).then((data) => {
-             expect(data['scriptTime']).toBe(5);
-             async.done();
-           });
-         }));
-
-      it('should sum up multiple intervals',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           aggregate([
-             eventFactory.start('script', 0), eventFactory.end('script', 5),
-             eventFactory.start('script', 10), eventFactory.end('script', 17)
-           ]).then((data) => {
-             expect(data['scriptTime']).toBe(12);
-             async.done();
-           });
-         }));
-
-      it('should ignore not started intervals',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           aggregate([eventFactory.end('script', 10)]).then((data) => {
-             expect(data['scriptTime']).toBe(0);
-             async.done();
-           });
-         }));
-
-      it('should ignore not ended intervals',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           aggregate([eventFactory.start('script', 10)]).then((data) => {
-             expect(data['scriptTime']).toBe(0);
-             async.done();
-           });
-         }));
-
-      it('should ignore nested intervals',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           aggregate([
-             eventFactory.start('script', 0), eventFactory.start('script', 5),
-             eventFactory.end('script', 10), eventFactory.end('script', 17)
-           ]).then((data) => {
-             expect(data['scriptTime']).toBe(17);
-             async.done();
-           });
-         }));
-
-      it('should ignore events from different processed as the start mark',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           const otherProcessEventFactory = new TraceEventFactory('timeline', 'pid1');
-           const metric = createMetric(
-               [[
-                 eventFactory.markStart('benchpress0', 0), eventFactory.start('script', 0, null),
-                 eventFactory.end('script', 5, null),
-                 otherProcessEventFactory.start('script', 10, null),
-                 otherProcessEventFactory.end('script', 17, null),
-                 eventFactory.markEnd('benchpress0', 20)
-               ]],
-               null);
-           metric.beginMeasure().then((_) => metric.endMeasure(false)).then((data) => {
-             expect(data['scriptTime']).toBe(5);
-             async.done();
-           });
-         }));
-
-      it('should support scriptTime metric',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           aggregate([
-             eventFactory.start('script', 0), eventFactory.end('script', 5)
-           ]).then((data) => {
-             expect(data['scriptTime']).toBe(5);
-             async.done();
-           });
-         }));
-
-      it('should support renderTime metric',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           aggregate([
-             eventFactory.start('render', 0), eventFactory.end('render', 5)
-           ]).then((data) => {
-             expect(data['renderTime']).toBe(5);
-             async.done();
-           });
-         }));
-
-      it('should support gcTime/gcAmount metric',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           aggregate([
-             eventFactory.start('gc', 0, {'usedHeapSize': 2500}),
-             eventFactory.end('gc', 5, {'usedHeapSize': 1000})
-           ]).then((data) => {
-             expect(data['gcTime']).toBe(5);
-             expect(data['gcAmount']).toBe(1.5);
-             expect(data['majorGcTime']).toBe(0);
-             async.done();
-           });
-         }));
-
-      it('should support majorGcTime metric',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           aggregate([
-             eventFactory.start('gc', 0, {'usedHeapSize': 2500}),
-             eventFactory.end('gc', 5, {'usedHeapSize': 1000, 'majorGc': true})
-           ]).then((data) => {
-             expect(data['gcTime']).toBe(5);
-             expect(data['majorGcTime']).toBe(5);
-             async.done();
-           });
-         }));
-
-      it('should support pureScriptTime = scriptTime-gcTime-renderTime',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           aggregate([
-             eventFactory.start('script', 0), eventFactory.start('gc', 1, {'usedHeapSize': 1000}),
-             eventFactory.end('gc', 4, {'usedHeapSize': 0}), eventFactory.start('render', 4),
-             eventFactory.end('render', 5), eventFactory.end('script', 6)
-           ]).then((data) => {
-             expect(data['scriptTime']).toBe(6);
-             expect(data['pureScriptTime']).toBe(2);
-             async.done();
-           });
-         }));
-
-      describe('receivedData', () => {
-        it('should report received data since last navigationStart',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             aggregate(
-                 [
-                   eventFactory.instant('receivedData', 0, {'encodedDataLength': 1}),
-                   eventFactory.instant('navigationStart', 1),
-                   eventFactory.instant('receivedData', 2, {'encodedDataLength': 2}),
-                   eventFactory.instant('navigationStart', 3),
-                   eventFactory.instant('receivedData', 4, {'encodedDataLength': 4}),
-                   eventFactory.instant('receivedData', 5, {'encodedDataLength': 8})
-                 ],
-                 {receivedData: true})
-                 .then((data) => {
-                   expect(data['receivedData']).toBe(12);
-                   async.done();
-                 });
-           }));
-      });
-
-      describe('requestCount', () => {
-        it('should report count of requests sent since last navigationStart',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             aggregate(
-                 [
-                   eventFactory.instant('sendRequest', 0),
-                   eventFactory.instant('navigationStart', 1),
-                   eventFactory.instant('sendRequest', 2),
-                   eventFactory.instant('navigationStart', 3),
-                   eventFactory.instant('sendRequest', 4), eventFactory.instant('sendRequest', 5)
-                 ],
-                 {requestCount: true})
-                 .then((data) => {
-                   expect(data['requestCount']).toBe(2);
-                   async.done();
-                 });
-           }));
-      });
-
-      describe('microMetrics', () => {
-
-        it('should report micro metrics',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             aggregate(
-                 [
-                   eventFactory.markStart('mm1', 0),
-                   eventFactory.markEnd('mm1', 5),
-                 ],
-                 {microMetrics: {'mm1': 'micro metric 1'}})
-                 .then((data) => {
-                   expect(data['mm1']).toBe(5.0);
-                   async.done();
-                 });
-           }));
-
-        it('should ignore micro metrics that were not specified',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             aggregate([
-               eventFactory.markStart('mm1', 0),
-               eventFactory.markEnd('mm1', 5),
-             ]).then((data) => {
-               expect(data['mm1']).toBeFalsy();
-               async.done();
-             });
-           }));
-
-        it('should report micro metric averages',
-           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-             aggregate(
-                 [
-                   eventFactory.markStart('mm1*20', 0),
-                   eventFactory.markEnd('mm1*20', 5),
-                 ],
-                 {microMetrics: {'mm1': 'micro metric 1'}})
-                 .then((data) => {
-                   expect(data['mm1']).toBe(5 / 20);
-                   async.done();
-                 });
-           }));
-
-      });
-
-    });
-
-  });
-}
-
-class MockDriverExtension extends WebDriverExtension {
-  constructor(
-      private _perfLogs: any[], private _commandLog: any[],
-      private _perfLogFeatures: PerfLogFeatures) {
-    super();
-  }
-
-  timeBegin(name: string): Promise<any> {
-    this._commandLog.push(['timeBegin', name]);
-    return Promise.resolve(null);
-  }
-
-  timeEnd(name: string, restartName: string): Promise<any> {
-    this._commandLog.push(['timeEnd', name, restartName]);
-    return Promise.resolve(null);
-  }
-
-  perfLogFeatures(): PerfLogFeatures { return this._perfLogFeatures; }
-
-  readPerfLog(): Promise<any> {
-    this._commandLog.push('readPerfLog');
-    if (this._perfLogs.length > 0) {
-      const next = this._perfLogs[0];
-      this._perfLogs.shift();
-      return Promise.resolve(next);
-    } else {
-      return Promise.resolve([]);
-    }
-  }
-
-  gc(): Promise<any> {
-    this._commandLog.push(['gc']);
-    return Promise.resolve(null);
-  }
-}
--- a/modules/@angular/benchpress/test/metric/user_metric_spec.ts
+++ b/modules/@angular/benchpress/test/metric/user_metric_spec.ts
@ -1,82 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Provider, ReflectiveInjector} from '@angular/core';
-import {AsyncTestCompleter, describe, expect, inject, it} from '@angular/core/testing/testing_internal';
-
-import {Options, PerfLogEvent, PerfLogFeatures, UserMetric, WebDriverAdapter} from '../../index';
-
-export function main() {
-  let wdAdapter: MockDriverAdapter;
-
-  function createMetric(
-      perfLogs: PerfLogEvent[], perfLogFeatures: PerfLogFeatures,
-      {userMetrics}: {userMetrics?: {[key: string]: string}} = {}): UserMetric {
-    if (!perfLogFeatures) {
-      perfLogFeatures =
-          new PerfLogFeatures({render: true, gc: true, frameCapture: true, userTiming: true});
-    }
-    if (!userMetrics) {
-      userMetrics = {};
-    }
-    wdAdapter = new MockDriverAdapter();
-    const providers: Provider[] = [
-      Options.DEFAULT_PROVIDERS, UserMetric.PROVIDERS,
-      {provide: Options.USER_METRICS, useValue: userMetrics},
-      {provide: WebDriverAdapter, useValue: wdAdapter}
-    ];
-    return ReflectiveInjector.resolveAndCreate(providers).get(UserMetric);
-  }
-
-  describe('user metric', () => {
-
-    it('should describe itself based on userMetrics', () => {
-      expect(createMetric([[]], new PerfLogFeatures(), {
-               userMetrics: {'loadTime': 'time to load'}
-             }).describe())
-          .toEqual({'loadTime': 'time to load'});
-    });
-
-    describe('endMeasure', () => {
-      it('should stop measuring when all properties have numeric values',
-         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-           const metric = createMetric(
-               [[]], new PerfLogFeatures(),
-               {userMetrics: {'loadTime': 'time to load', 'content': 'time to see content'}});
-           metric.beginMeasure()
-               .then((_) => metric.endMeasure(true))
-               .then((values: {[key: string]: string}) => {
-                 expect(values['loadTime']).toBe(25);
-                 expect(values['content']).toBe(250);
-                 async.done();
-               });
-
-           wdAdapter.data['loadTime'] = 25;
-           // Wait before setting 2nd property.
-           setTimeout(() => { wdAdapter.data['content'] = 250; }, 50);
-
-         }), 600);
-    });
-  });
-}
-
-class MockDriverAdapter extends WebDriverAdapter {
-  data: any = {};
-
-  executeScript(script: string): any {
-    // Just handles `return window.propName` ignores `delete window.propName`.
-    if (script.indexOf('return window.') == 0) {
-      const metricName = script.substring('return window.'.length);
-      return Promise.resolve(this.data[metricName]);
-    } else if (script.indexOf('delete window.') == 0) {
-      return Promise.resolve(null);
-    } else {
-      return Promise.reject(`Unexpected syntax: ${script}`);
-    }
-  }
-}
--- a/modules/@angular/benchpress/test/reporter/console_reporter_spec.ts
+++ b/modules/@angular/benchpress/test/reporter/console_reporter_spec.ts
@ -1,94 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Provider} from '@angular/core';
-import {describe, expect, it} from '@angular/core/testing/testing_internal';
-
-import {ConsoleReporter, MeasureValues, ReflectiveInjector, SampleDescription} from '../../index';
-import {isBlank, isPresent} from '../../src/facade/lang';
-
-export function main() {
-  describe('console reporter', () => {
-    let reporter: ConsoleReporter;
-    let log: string[];
-
-    function createReporter(
-        {columnWidth = null, sampleId = null, descriptions = null, metrics = null}: {
-          columnWidth?: number,
-          sampleId?: string,
-          descriptions?: {[key: string]: any}[],
-          metrics?: {[key: string]: any}
-        }) {
-      log = [];
-      if (!descriptions) {
-        descriptions = [];
-      }
-      if (sampleId == null) {
-        sampleId = 'null';
-      }
-      const providers: Provider[] = [
-        ConsoleReporter.PROVIDERS, {
-          provide: SampleDescription,
-          useValue: new SampleDescription(sampleId, descriptions, metrics)
-        },
-        {provide: ConsoleReporter.PRINT, useValue: (line: string) => log.push(line)}
-      ];
-      if (isPresent(columnWidth)) {
-        providers.push({provide: ConsoleReporter.COLUMN_WIDTH, useValue: columnWidth});
-      }
-      reporter = ReflectiveInjector.resolveAndCreate(providers).get(ConsoleReporter);
-    }
-
-    it('should print the sample id, description and table header', () => {
-      createReporter({
-        columnWidth: 8,
-        sampleId: 'someSample',
-        descriptions: [{'a': 1, 'b': 2}],
-        metrics: {'m1': 'some desc', 'm2': 'some other desc'}
-      });
-      expect(log).toEqual([
-        'BENCHMARK someSample',
-        'Description:',
-        '- a: 1',
-        '- b: 2',
-        'Metrics:',
-        '- m1: some desc',
-        '- m2: some other desc',
-        '',
-        '      m1 |       m2',
-        '-------- | --------',
-      ]);
-    });
-
-    it('should print a table row', () => {
-      createReporter({columnWidth: 8, metrics: {'a': '', 'b': ''}});
-      log = [];
-      reporter.reportMeasureValues(mv(0, 0, {'a': 1.23, 'b': 2}));
-      expect(log).toEqual(['    1.23 |     2.00']);
-    });
-
-    it('should print the table footer and stats when there is a valid sample', () => {
-      createReporter({columnWidth: 8, metrics: {'a': '', 'b': ''}});
-      log = [];
-      reporter.reportSample([], [mv(0, 0, {'a': 3, 'b': 6}), mv(1, 1, {'a': 5, 'b': 9})]);
-      expect(log).toEqual(['======== | ========', '4.00+-25% | 7.50+-20%']);
-    });
-
-    it('should print the coefficient of variation only when it is meaningful', () => {
-      createReporter({columnWidth: 8, metrics: {'a': '', 'b': ''}});
-      log = [];
-      reporter.reportSample([], [mv(0, 0, {'a': 3, 'b': 0}), mv(1, 1, {'a': 5, 'b': 0})]);
-      expect(log).toEqual(['======== | ========', '4.00+-25% |     0.00']);
-    });
-
-  });
-}
-
-function mv(runIndex: number, time: number, values: {[key: string]: number}) {
-  return new MeasureValues(runIndex, new Date(time), values);
-}
--- a/modules/@angular/benchpress/test/reporter/json_file_reporter_spec.ts
+++ b/modules/@angular/benchpress/test/reporter/json_file_reporter_spec.ts
@ -1,81 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {AsyncTestCompleter, describe, expect, inject, it} from '@angular/core/testing/testing_internal';
-
-import {JsonFileReporter, MeasureValues, Options, ReflectiveInjector, SampleDescription} from '../../index';
-import {isPresent} from '../../src/facade/lang';
-
-export function main() {
-  describe('file reporter', () => {
-    let loggedFile: any;
-
-    function createReporter({sampleId, descriptions, metrics, path}: {
-      sampleId: string,
-      descriptions: {[key: string]: any}[],
-      metrics: {[key: string]: string},
-      path: string
-    }) {
-      const providers = [
-        JsonFileReporter.PROVIDERS, {
-          provide: SampleDescription,
-          useValue: new SampleDescription(sampleId, descriptions, metrics)
-        },
-        {provide: JsonFileReporter.PATH, useValue: path},
-        {provide: Options.NOW, useValue: () => new Date(1234)}, {
-          provide: Options.WRITE_FILE,
-          useValue: (filename: string, content: string) => {
-            loggedFile = {'filename': filename, 'content': content};
-            return Promise.resolve(null);
-          }
-        }
-      ];
-      return ReflectiveInjector.resolveAndCreate(providers).get(JsonFileReporter);
-    }
-
-    it('should write all data into a file',
-       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-         createReporter({
-           sampleId: 'someId',
-           descriptions: [{'a': 2}],
-           path: 'somePath',
-           metrics: {'a': 'script time', 'b': 'render time'}
-         })
-             .reportSample(
-                 [mv(0, 0, {'a': 3, 'b': 6})],
-                 [mv(0, 0, {'a': 3, 'b': 6}), mv(1, 1, {'a': 5, 'b': 9})]);
-         const regExp = /somePath\/someId_\d+\.json/;
-         expect(isPresent(loggedFile['filename'].match(regExp))).toBe(true);
-         const parsedContent = JSON.parse(loggedFile['content']);
-         expect(parsedContent).toEqual({
-           'description': {
-             'id': 'someId',
-             'description': {'a': 2},
-             'metrics': {'a': 'script time', 'b': 'render time'}
-           },
-           'stats': {'a': '4.00+-25%', 'b': '7.50+-20%'},
-           'completeSample': [
-             {'timeStamp': '1970-01-01T00:00:00.000Z', 'runIndex': 0, 'values': {'a': 3, 'b': 6}}
-           ],
-           'validSample': [
-             {'timeStamp': '1970-01-01T00:00:00.000Z', 'runIndex': 0, 'values': {'a': 3, 'b': 6}}, {
-               'timeStamp': '1970-01-01T00:00:00.001Z',
-               'runIndex': 1,
-               'values': {'a': 5, 'b': 9}
-             }
-           ]
-         });
-         async.done();
-       }));
-
-  });
-}
-
-function mv(runIndex: number, time: number, values: {[key: string]: number}) {
-  return new MeasureValues(runIndex, new Date(time), values);
-}
--- a/modules/@angular/benchpress/test/reporter/multi_reporter_spec.ts
+++ b/modules/@angular/benchpress/test/reporter/multi_reporter_spec.ts
@ -1,68 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {AsyncTestCompleter, describe, expect, inject, it} from '@angular/core/testing/testing_internal';
-
-import {MeasureValues, MultiReporter, ReflectiveInjector, Reporter} from '../../index';
-
-export function main() {
-  function createReporters(ids: any[]) {
-    const r = ReflectiveInjector
-                  .resolveAndCreate([
-                    ids.map(id => ({provide: id, useValue: new MockReporter(id)})),
-                    MultiReporter.provideWith(ids)
-                  ])
-                  .get(MultiReporter);
-    return Promise.resolve(r);
-  }
-
-  describe('multi reporter', () => {
-
-    it('should reportMeasureValues to all',
-       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-         const mv = new MeasureValues(0, new Date(), {});
-         createReporters(['m1', 'm2']).then((r) => r.reportMeasureValues(mv)).then((values) => {
-
-           expect(values).toEqual([{'id': 'm1', 'values': mv}, {'id': 'm2', 'values': mv}]);
-           async.done();
-         });
-       }));
-
-    it('should reportSample to call', inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-         const completeSample =
-             [new MeasureValues(0, new Date(), {}), new MeasureValues(1, new Date(), {})];
-         const validSample = [completeSample[1]];
-
-         createReporters(['m1', 'm2'])
-             .then((r) => r.reportSample(completeSample, validSample))
-             .then((values) => {
-
-               expect(values).toEqual([
-                 {'id': 'm1', 'completeSample': completeSample, 'validSample': validSample},
-                 {'id': 'm2', 'completeSample': completeSample, 'validSample': validSample}
-               ]);
-               async.done();
-             });
-       }));
-
-  });
-}
-
-class MockReporter extends Reporter {
-  constructor(private _id: string) { super(); }
-
-  reportMeasureValues(values: MeasureValues): Promise<{[key: string]: any}> {
-    return Promise.resolve({'id': this._id, 'values': values});
-  }
-
-  reportSample(completeSample: MeasureValues[], validSample: MeasureValues[]):
-      Promise<{[key: string]: any}> {
-    return Promise.resolve(
-        {'id': this._id, 'completeSample': completeSample, 'validSample': validSample});
-  }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Naomi Black	7196243628	chore(changelog): update change log to alpha-45	2015-10-28 17:36:56 -07:00
Naomi Black	b34340e456	chore: bump version to 2.0.0-alpha.45	2015-10-28 17:32:43 -07:00
 @ -1 +1 @@
 .6.0
 .2.1