docs(changelog): update change log to beta.2

chore(release): bump version to beta.2
2016-01-28 11:34:11 -08:00 · 2016-01-28 11:27:47 -08:00
1710 changed files with 45575 additions and 63937 deletions
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@ -1,16 +0,0 @@
-**IMPORTANT**: This repository's issues are reserved for feature requests and bug reports. Do not submit support requests here, see https://github.com/angular/angular/blob/master/CONTRIBUTING.md#question. 
-
-
-**Steps to reproduce and a minimal demo of the problem**
-
-_Use https://plnkr.co or similar -- try this template as a starting point: http://plnkr.co/edit/tpl:AvJOMERrnz94ekVua0u5_
-
-_What steps should we try in your demo to see the problem?_
-
-**Current behavior**
-
-
-**Expected/desired behavior**
-
-
-**Other information**
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,24 +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-message-format
- [ ] 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?** (Bug fix, feature, docs update, ...)
-
-
-
-* **What is the current behavior?** (You can also link to an open issue here)
-
-
-
-* **What is the new behavior (if this is a feature change)?**
-
-
-
-* **Does this PR introduce a breaking change?** (What changes might users need to make in their application due to this PR?)
-
-
-
-* **Other information**:
-
--- a/.gitignore
+++ b/.gitignore
@ -21,13 +21,7 @@ tmp
 *.js.deps
 *.js.map

-# Files created by the template compiler
-**/*.ngfactory.ts
-**/*.css.ts
-**/*.css.shim.ts
-
 # Or type definitions we mirror from github
-# (NB: these lines are removed in publish-build-artifacts.sh)
 **/typings/**/*.d.ts
 **/typings/tsd.cached.json

@ -54,6 +48,3 @@ npm-debug.log

 # built dart payload tests
 /modules_dart/payload/**/build
-
-# rollup-test output
-/modules/rollup-test/dist/
--- a/.travis.yml
+++ b/.travis.yml
@ -1,16 +1,7 @@
 language: node_js
 sudo: false
 node_js:
-  - '5.4.1'
-
-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
+- '5.4.1'

 branches:
  except:
@ -18,175 +9,108 @@ branches:

 cache:
  directories:
-     - ./node_modules
-     - ./.chrome/chromium
-#    - $HOME/.pub-cache
-
-
-#before_cache:
-#  # Undo the pollution of the typescript_next build before the cache is primed for future use
-#  - if [[ "$MODE" == "typescript_next" ]]; then npm install typescript; fi
+    - node_modules
+    - $HOME/.pub-cache

 env:
  global:
-#    - KARMA_JS_BROWSERS=ChromeNoSandbox
-#    - E2E_BROWSERS=ChromeOnTravis
-#    - LOGS_DIR=/tmp/angular-build/logs
-#    - ARCH=linux-x64
-
+  - KARMA_BROWSERS=DartiumWithWebPlatform
+  - E2E_BROWSERS=Dartium
+  - LOGS_DIR=/tmp/angular-build/logs
+  - SAUCE_USERNAME=angular-ci
+  - SAUCE_ACCESS_KEY=9b988f434ff8-fbca-8aa4-4ae3-35442987
+  - BROWSER_STACK_USERNAME=angularteam1
+  - BROWSER_STACK_ACCESS_KEY=BWCd4SynLzdDcv8xtzsB
+  - 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=lint
-   - CI_MODE=e2e
-   - CI_MODE=saucelabs_required
-   - CI_MODE=browserstack_required
+    - MODE=dart DART_CHANNEL=stable DART_VERSION=$DART_STABLE_VERSION
+    - MODE=dart DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=saucelabs_required DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=browserstack_required DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=saucelabs_optional DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=browserstack_optional 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=build_only DART_CHANNEL=stable DART_VERSION=$DART_STABLE_VERSION
+    - MODE=lint DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=payload DART_CHANNEL=stable DART_VERSION=$DART_STABLE_VERSION

-#matrix:
-#  allow_failures:
-#    - env: "MODE=saucelabs_optional"
-#    - env: "MODE=browserstack_optional"
+matrix:
+  allow_failures:
+  - env: "MODE=saucelabs_optional DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION"
+  - env: "MODE=browserstack_optional DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION"
+  - env: "MODE=dart_experimental DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION"
+  # TODO(alxhub): remove when dartdoc #1039 is in dev channel
+  - env: "MODE=dart DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION"

+addons:
+  firefox: "38.0"
+
+before_install:
+- npm install -g npm@3.5.3
+- node tools/analytics/build-analytics start ci job
+- node tools/analytics/build-analytics start ci 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'
+- node tools/analytics/build-analytics success ci before_install

 install:
-  - ./scripts/ci-lite/install.sh
+  - node tools/analytics/build-analytics start ci install
+  # Check the size of caches
+  - du -sh ./node_modules || true
+  # Install npm dependecies
+  # check-node-modules will exit(1) if we don't need to install
+  # we need to manually kick off the postinstall script if check-node-modules exit(0)s
+  - node tools/npm/check-node-modules --purge && npm install || npm run postinstall
+  - node tools/analytics/build-analytics success ci install

 before_script:
-
+- node tools/analytics/build-analytics start ci before_script
+- mkdir -p $LOGS_DIR
+- ./scripts/ci/presubmit-queue-setup.sh
+- node tools/analytics/build-analytics success ci before_script

 script:
-  - ./scripts/ci-lite/build.sh && ./scripts/ci-lite/test.sh
+- node tools/analytics/build-analytics start ci script
+- ./scripts/ci/build_and_test.sh ${MODE}
+- node tools/analytics/build-analytics success ci script

 after_script:
-  - ./scripts/ci-lite/cleanup.sh
+- node tools/analytics/build-analytics start ci after_script
+- ./scripts/ci/print-logs.sh
+- ./scripts/ci/after-script.sh
+- ./scripts/publish/publish-build-artifacts.sh
+- node tools/analytics/build-analytics success ci after_script
+- if [[ $TRAVIS_TEST_RESULT -eq 0 ]]; then node tools/analytics/build-analytics success ci job; else node tools/analytics/build-analytics error ci job; fi

+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=

-#branches:
-#  except:
-#    - g3_v2_0
-#
-#cache:
-#  directories:
-#    - $HOME/.pub-cache
-#    - $HOME/.chrome/chromium
-#
-#before_cache:
-#  # Undo the pollution of the typescript_next build before the cache is primed for future use
-#  - if [[ "$MODE" == "typescript_next" ]]; then npm install typescript; fi
-#
-#env:
-#  global:
-#    # Use newer verison of GCC to that is required to compile native npm modules for Node v4+ on Ubuntu Precise
-#    # more info: https://docs.travis-ci.com/user/languages/javascript-with-nodejs#Node.js-v4-(or-io.js-v3)-compiler-requirements
-#    - CXX=g++-4.8
-#    - KARMA_DART_BROWSERS=DartiumWithWebPlatform
-#    # No sandbox mode is needed for Chromium in Travis, it crashes otherwise: https://sites.google.com/a/chromium.org/chromedriver/help/chrome-doesn-t-start
-#    - KARMA_JS_BROWSERS=ChromeNoSandbox
-#    - E2E_BROWSERS=ChromeOnTravis
-#    - LOGS_DIR=/tmp/angular-build/logs
-#    - SAUCE_USERNAME=angular-ci
-#    - SAUCE_ACCESS_KEY=9b988f434ff8-fbca-8aa4-4ae3-35442987
-#    - BROWSER_STACK_USERNAME=angularteam1
-#    - BROWSER_STACK_ACCESS_KEY=BWCd4SynLzdDcv8xtzsB
-#    - ARCH=linux-x64
-#    - DART_DEV_VERSION=latest
-#    - DART_STABLE_VERSION=latest
-#    - DART_CHANNEL=stable
-#    - DART_VERSION=$DART_STABLE_VERSION
-#    # 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.
-#    - MODE=dart
-#    - MODE=dart DART_CHANNEL=dev
-#    - MODE=saucelabs_required
-#    - MODE=browserstack_required
-#    - MODE=saucelabs_optional
-#    - MODE=browserstack_optional
-#    - MODE=dart_ddc
-#    - MODE=js
-#    - MODE=router
-#    - MODE=build_only
-#    - MODE=typescript_next
-#    - MODE=lint
-#
-#matrix:
-#  allow_failures:
-#    - env: "MODE=saucelabs_optional"
-#    - env: "MODE=browserstack_optional"
-#
-#addons:
-#  firefox: "38.0"
-#  apt:
-#    sources:
-#      - ubuntu-toolchain-r-test
-#    packages:
-#      - g++-4.8
-#
-#before_install:
-#  - node tools/analytics/build-analytics start ci job
-#  - node tools/analytics/build-analytics start ci before_install
-#  - echo ${TSDRC} > .tsdrc
-#  - export CHROME_BIN=$HOME/.chrome/chromium/chrome-linux/chrome
-#  - export DISPLAY=:99.0
-#  - export GIT_SHA=$(git rev-parse HEAD)
-#  - ./scripts/ci/init_android.sh
-#  - sh -e /etc/init.d/xvfb start
-#  # Use a separate SauseLabs account for upstream/master builds in order for Sauce to create a badge representing the status of just upstream/master
-#  - '[ "${TRAVIS_PULL_REQUEST}" = "false" ] && [ "${TRAVIS_BRANCH}" = "master" ] && SAUCE_USERNAME="angular2-ci" && SAUCE_ACCESS_KEY="693ebc16208a-0b5b-1614-8d66-a2662f4e" || true'
-#  - node tools/analytics/build-analytics success ci before_install
-#
-#install:
-#  - node tools/analytics/build-analytics start ci install
-#  # Install version of npm that we are locked against
-#  - npm install -g npm@3.5.3
-#  # Install version of Chromium that we are locked against
-#  - ./scripts/ci/install_chromium.sh
-#  # Install version of Dart based on the matrix build variables
-#  - ./scripts/ci/install_dart.sh ${DART_CHANNEL} ${DART_VERSION} ${ARCH}
-#  # Print the size of caches to ease debugging
-#  - du -sh ./node_modules || true
-#  # Install npm dependecies
-#  # check-node-modules will exit(1) if we don't need to install
-#  # we need to manually kick off the postinstall script if check-node-modules exit(0)s
-#  - node tools/npm/check-node-modules --purge && npm install || npm run postinstall
-#  - node tools/analytics/build-analytics success ci install
-#
-#before_script:
-#  - node tools/analytics/build-analytics start ci before_script
-#  - mkdir -p $LOGS_DIR
-#  - ./scripts/ci/presubmit-queue-setup.sh
-#  - node tools/analytics/build-analytics success ci before_script
-#
-#script:
-#  - node tools/analytics/build-analytics start ci script
-#  - ./scripts/ci/build_and_test.sh ${MODE}
-#  - node tools/analytics/build-analytics success ci script
-#
-#after_script:
-#  - node tools/analytics/build-analytics start ci after_script
-#  - ./scripts/ci/print-logs.sh
-#  - ./scripts/ci/after-script.sh
-#  - ./scripts/publish/publish-build-artifacts.sh
-#  - node tools/analytics/build-analytics success ci after_script
-#  - tools/analytics/build-analytics $TRAVIS_TEST_RESULT ci job
-#
-#notifications:
-#  webhooks:
-#    urls:
-#      - https://webhooks.gitter.im/e/1ef62e23078036f9cee4
-#      # trigger Buildtime Trend Service to parse Travis CI log
-#      - https://buildtimetrend.herokuapp.com/travis
-#      - http://104.197.9.155:8484/hubot/travis/activity
-#    on_success: always  # options: [always|never|change] default: always
-#    on_failure: always  # options: [always|never|change] default: always
-#    on_start: never     # default: never
-#  slack:
-#    secure: EP4MzZ8JMyNQJ4S3cd5LEPWSMjC7ZRdzt3veelDiOeorJ6GwZfCDHncR+4BahDzQAuqyE/yNpZqaLbwRWloDi15qIUsm09vgl/1IyNky1Sqc6lEknhzIXpWSalo4/T9ZP8w870EoDvM/UO+LCV99R3wS8Nm9o99eLoWVb2HIUu0=
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,644 +1,3 @@
-<a name="2.0.0-beta.17"></a>
-# 2.0.0-beta.17 (2016-04-28)
-
-
-### Bug Fixes
-
-* **changelog:** fix changelog script. ([c209836](https://github.com/angular/angular/commit/c209836))
-* **compiler:** Allow templates to access variables that are declared afterwards. ([1e8864c](https://github.com/angular/angular/commit/1e8864c)), closes [#8261](https://github.com/angular/angular/issues/8261)
-* **core:** properly evaluate expressions with conditional and boolean operators ([1ad2a02](https://github.com/angular/angular/commit/1ad2a02)), closes [#8235](https://github.com/angular/angular/issues/8235) [#8244](https://github.com/angular/angular/issues/8244) [#8282](https://github.com/angular/angular/issues/8282)
-* **metadata:** Do not attach module names to metadata. ([d964888](https://github.com/angular/angular/commit/d964888)), closes [#8225](https://github.com/angular/angular/issues/8225) [#8082](https://github.com/angular/angular/issues/8082) [#8256](https://github.com/angular/angular/issues/8256)
-* **testing:** allow test component builder to override directives from lists ([ff2ae7a](https://github.com/angular/angular/commit/ff2ae7a)), closes [#7397](https://github.com/angular/angular/issues/7397) [#8217](https://github.com/angular/angular/issues/8217)
-
-### Features
-
-* **compiler:** ElementSchema now has explicit DOM schema information ([d327ac4](https://github.com/angular/angular/commit/d327ac4)), closes [#8179](https://github.com/angular/angular/issues/8179)
-* **core:** separate refs from vars. ([d2efac1](https://github.com/angular/angular/commit/d2efac1)), closes [#7158](https://github.com/angular/angular/issues/7158) [#8264](https://github.com/angular/angular/issues/8264)
-
-
-### BREAKING CHANGES
-
-The reference `#...` now always means `ref-`.
-
-**Before:**
- Outside of `ngFor`, a `#...` meant a reference.
- Inside of `ngFor`, it meant a local variable. 
-
-This was pattern was confusing.
-
-**After:**
-
- `<template #abc>` now defines a reference to a TemplateRef, instead of an input variable used inside of the template.
- Inside of structural directives that declare local variables, such as `*ngFor`, usage of `#...` is deprecated. Use `let` instead.
-  - `<div *ngFor="#item of items">` now becomes `<div *ngFor="let item of items">`
- `var-...` is deprecated. 
-  - use `#` or a `ref-` outside of `*ngFor`
-  - for `ngFor`, use the syntax:  `<template ngFor let-... [ngForOf]="...">`
-
-
-<a name="2.0.0-beta.16"></a>
-# 2.0.0-beta.16 (2016-04-26)
-
-
-### Bug Fixes
-
-* **angular_1_router:** Removed arrow function from module template ([d094a85](https://github.com/angular/angular/commit/d094a85)), closes [#8076](https://github.com/angular/angular/issues/8076)
-* **build:** ignore Dart warnings for external code. ([4140405](https://github.com/angular/angular/commit/4140405))
-* **codegen:** add explicit any to class fields ([c8d00dc](https://github.com/angular/angular/commit/c8d00dc)), closes [#8204](https://github.com/angular/angular/issues/8204) [#8205](https://github.com/angular/angular/issues/8205)
-* **compiler:** only call pure pipes if their input changed. ([8db6215](https://github.com/angular/angular/commit/8db6215))
-* **compiler:** properly implement pure pipes and change pipe syntax ([152a117](https://github.com/angular/angular/commit/152a117))
-* **compiler:** support string tokens with `.` inside. ([cc86fee](https://github.com/angular/angular/commit/cc86fee))
-* **compiler:** use DI order for change detection order. ([67d05eb](https://github.com/angular/angular/commit/67d05eb)), closes [#8198](https://github.com/angular/angular/issues/8198)
-* **core:** various minor compiler fixes ([2f70457](https://github.com/angular/angular/commit/2f70457)), closes [#8162](https://github.com/angular/angular/issues/8162)
-* **forms:** ensure select model updates in firefox and ie ([c3daccd](https://github.com/angular/angular/commit/c3daccd)), closes [#6573](https://github.com/angular/angular/issues/6573) [#8148](https://github.com/angular/angular/issues/8148)
-* **forms:** improve error message when ngFormModel is missing a form ([12837e1](https://github.com/angular/angular/commit/12837e1)), closes [#8136](https://github.com/angular/angular/issues/8136) [#8143](https://github.com/angular/angular/issues/8143)
-* **forms:** number input should report null when blank ([e69cb40](https://github.com/angular/angular/commit/e69cb40)), closes [#6932](https://github.com/angular/angular/issues/6932) [#8141](https://github.com/angular/angular/issues/8141)
-* **metadata:** emit metadata rooted at 'angular2' ([9889c21](https://github.com/angular/angular/commit/9889c21)), closes [#8144](https://github.com/angular/angular/issues/8144) [#8147](https://github.com/angular/angular/issues/8147)
-* **release:** Fix the package.json zone.js requirement to 0.6.12 ([6103aa0](https://github.com/angular/angular/commit/6103aa0))
-* **tests:** remove payload size check ([22c05b0](https://github.com/angular/angular/commit/22c05b0))
-* **transformers:** support `query.read` ([386cc5d](https://github.com/angular/angular/commit/386cc5d)), closes [#8172](https://github.com/angular/angular/issues/8172)
-* **upgrade:** clean up scope when element is destroyed ([0fc9ec2](https://github.com/angular/angular/commit/0fc9ec2)), closes [#8102](https://github.com/angular/angular/issues/8102)
-
-### Features
-
-* **codegen:** produce `.ngfactory.dart/ts` files instead of `.template.dart/ts` files. ([c06b0a2](https://github.com/angular/angular/commit/c06b0a2))
-* **core:** add `Query.read` and remove `DynamicComponentLoader.loadIntoLocation`. ([efbd446](https://github.com/angular/angular/commit/efbd446))
-* **core:** introduce ComponentFactory. ([0c600cf](https://github.com/angular/angular/commit/0c600cf))
-* **core:** separate reflective injector from Injector interface ([0a7d10b](https://github.com/angular/angular/commit/0a7d10b))
-* **core:** support importUri in StaticReflector ([3e11422](https://github.com/angular/angular/commit/3e11422)), closes [#8195](https://github.com/angular/angular/issues/8195)
-* **core:** support non reflective bootstrap. ([9092ac7](https://github.com/angular/angular/commit/9092ac7))
-* **html_lexer:** support special forms used by i18n { exp, plural, =0 {} } ([7f29766](https://github.com/angular/angular/commit/7f29766))
-* **html_parser:** support special forms used by i18n { exp, plural, =0 {} } ([7c9717b](https://github.com/angular/angular/commit/7c9717b))
-* **i18n:** add custom placeholder names ([bb9fb21](https://github.com/angular/angular/commit/bb9fb21)), closes [#7799](https://github.com/angular/angular/issues/7799) [#8057](https://github.com/angular/angular/issues/8057)
-* **i18n:** add support for nested expansion forms ([c6244d1](https://github.com/angular/angular/commit/c6244d1)), closes [#7977](https://github.com/angular/angular/issues/7977)
-* **i18n:** support plural and gender special forms ([88b0a23](https://github.com/angular/angular/commit/88b0a23))
-* **Location:** out of router and into platform/common ([b602bd8](https://github.com/angular/angular/commit/b602bd8)), closes [#7962](https://github.com/angular/angular/issues/7962)
-* **NgTemplateOutlet:** add NgTemplateOutlet directive ([f4e6994](https://github.com/angular/angular/commit/f4e6994)), closes [#7615](https://github.com/angular/angular/issues/7615) [#8021](https://github.com/angular/angular/issues/8021)
-* **router:** add Router and RouterOutlet ([5a897cf](https://github.com/angular/angular/commit/5a897cf)), closes [#8173](https://github.com/angular/angular/issues/8173)
-* **router:** add router metadata ([ef67a0c](https://github.com/angular/angular/commit/ef67a0c))
-* **router:** add UrlSegment, RouteSegment, and Tree ([90a1f7d](https://github.com/angular/angular/commit/90a1f7d))
-* **router:** implement recognizer ([ef6163e](https://github.com/angular/angular/commit/ef6163e))
-* **router:** implement RouterUrlParser ([f698567](https://github.com/angular/angular/commit/f698567))
-* **test:** Implement fakeAsync using the FakeAsyncTestZoneSpec from zone.js. ([bab81a9](https://github.com/angular/angular/commit/bab81a9)), closes [#8142](https://github.com/angular/angular/issues/8142)
-* **tests:** manage asynchronous tests using zones ([8490921](https://github.com/angular/angular/commit/8490921)), closes [#7735](https://github.com/angular/angular/issues/7735)
-* **view_compiler:** codegen DI and Queries ([2b34c88](https://github.com/angular/angular/commit/2b34c88)), closes [#6301](https://github.com/angular/angular/issues/6301) [#6567](https://github.com/angular/angular/issues/6567)
-
-
-### BREAKING CHANGES
-
-* - pipes now take a variable number of arguments, and not an array that contains all arguments.
-
-* inject can no longer wrap fakeAsync while fakeAsync can wrap inject. So the order in existing tests with inject and fakeAsync has to be switched as follows:
-Before:
-```
-inject([...], fakeAsync((...) => {...}))
-```
-After:
-```
-fakeAsync(inject([...], (...) => {...}))
-```
-You will also need to add the dependency
-`'node_modules/zone.js/dist/fake-async-test.js'`
-as a served file in your Karma or other test configuration.
-
-* - Injector was renamed into `ReflectiveInjector`,
-  as `Injector` is only an abstract class with one method on it
- `Injector.getOptional()` was changed into `Injector.get(token, notFoundValue)`
-  to make implementing injectors simpler
- `ViewContainerRef.createComponent` now takes an `Injector`
-  instead of `ResolvedProviders`. If a reflective injector
-  should be used, create one before calling this method.
-  (e.g. via `ReflectiveInjector.resolveAndCreate(…)`.
-
-* - `DynamicComponentLoader.loadIntoLocation` has been removed. Use `@ViewChild(‘myVar’, read: ViewContainerRef)` to get hold of a `ViewContainerRef` at an element with variable `myVar`. Then call `DynamicComponentLoader.loadNextToLocation`.
- `DynamicComponentLoader.loadNextToLocation` now takes a `ViewContainerRef` instead of an `ElementRef`.
- `AppViewManager` is renamed into `ViewUtils` and is a mere private utility service.
-
-* - `Compiler` is renamed to `ComponentResolver`,
-  `Compiler.compileInHost` has been renamed to `ComponentResolver.resolveComponent`.
- `ComponentRef.dispose` is renamed to `ComponentRef.destroy`
- `ViewContainerRef.createHostView` is renamed to `ViewContainerRef.createComponent`
- `ComponentFixture_` has been removed, the class `ComponentFixture`
-  can now be created directly as it is no more using private APIs.
-
-* `Location` and other related providers have been moved out of `router` and into `platform/common`. `BrowserPlatformLocation` is not meant to be used directly however advanced configurations may use it via the following import change.
-Before:
-```
-import {
-  PlatformLocation,
-  Location,
-  LocationStrategy,
-  HashLocationStrategy,
-  PathLocationStrategy,
-  APP_BASE_HREF}
-from 'angular2/router';
-import {BrowserPlatformLocation} from 'angular2/src/router/location/browser_platform_location';
-```
-After:
-```
-import {
-  PlatformLocation,
-  Location,
-  LocationStrategy,
-  HashLocationStrategy,
-  PathLocationStrategy,
-  APP_BASE_HREF}
-from 'angular2/platform/common';
-import {BrowserPlatformLocation} from 'angular2/src/platform/browser/location/browser_platform_location';
-```
-
-* `injectAsync` is now deprecated. Instead, use the `async` function
-to wrap any asynchronous tests.
-
-You will also need to add the dependency
-`'node_modules/zone.js/dist/async-test.js'`
-as a served file in your Karma or other test configuration.
-
-Before:
-```
-it('should wait for returned promises', injectAsync([FancyService], (service) => {
-  return service.getAsyncValue().then((value) => { expect(value).toEqual('async value'); });
-}));
-it('should wait for returned promises', injectAsync([], () => {
-  return somePromise.then(() => { expect(true).toEqual(true); });
-}));
-```
-After:
-```
-it('should wait for returned promises', async(inject([FancyService], (service) => {
-  service.getAsyncValue().then((value) => { expect(value).toEqual('async value'); });
-})));
-// Note that if there is no injection, we no longer need `inject` OR `injectAsync`.
-it('should wait for returned promises', async(() => {
-  somePromise.then() => { expect(true).toEqual(true); });
-}));
-```
-
-* - Renderer:
-  * renderComponent method is removed form `Renderer`, only present on `RootRenderer`
-  * Renderer.setDebugInfo is removed. Renderer.createElement / createText / createTemplateAnchor
-    now take the DebugInfo directly.
- Query semantics:
-  * Queries don't work with dynamically loaded components.
-  * e.g. for router-outlet: loaded components can't be queries via @ViewQuery,
-    but router-outlet emits an event `activate` now that emits the activated component
- Exception classes and the context inside changed (renamed fields)
- DebugElement.attributes is an Object and not a Map in JS any more
- ChangeDetectorGenConfig was renamed into CompilerConfig
- AppViewManager.createEmbeddedViewInContainer / AppViewManager.createHostViewInContainer
-  are removed, use the methods in ViewContainerRef instead
- Change detection order changed:
-  * 1. dirty check component inputs
-  * 2. dirty check content children
-  * 3. update render nodes
-
-
-
-<a name="2.0.0-beta.15"></a>
-# 2.0.0-beta.15 (2016-04-13)
-
-
-### Bug Fixes
-
-* **7837:** MetadataCollector takes no parameters for the constructor. ([c17dc1c](https://github.com/angular/angular/commit/c17dc1c)), closes [#7838](https://github.com/angular/angular/issues/7838)
-* **7987:** Incremental build works with new trees ([08b2956](https://github.com/angular/angular/commit/08b2956)), closes [#7989](https://github.com/angular/angular/issues/7989)
-* **build:** ignore dart warnings `The name … is shown, but not used` ([01e6b8c](https://github.com/angular/angular/commit/01e6b8c)), closes [#8045](https://github.com/angular/angular/issues/8045)
-* **payload:** increase payload size limit temporarily ([28e657d](https://github.com/angular/angular/commit/28e657d))
-* **RouterLink:** ignore optional parameters when checking for active routes ([5e2bc5c](https://github.com/angular/angular/commit/5e2bc5c)), closes [#6459](https://github.com/angular/angular/issues/6459) [#7834](https://github.com/angular/angular/issues/7834)
-* **select:** set value individually from ngModel ([e1e44a9](https://github.com/angular/angular/commit/e1e44a9)), closes [#7975](https://github.com/angular/angular/issues/7975) [#7978](https://github.com/angular/angular/issues/7978)
-* **upgrade:** make upgradeAdapter upgrade angular 1 components correctly ([247964a](https://github.com/angular/angular/commit/247964a)), closes [#7951](https://github.com/angular/angular/issues/7951)
-
-### Features
-
-* **compiler:** Add an implementation for XHR that uses a template cache to load template files. ([a596b88](https://github.com/angular/angular/commit/a596b88)), closes [#7940](https://github.com/angular/angular/issues/7940)
-* **gestures:** allow override of Hammer default configuration ([6cbf990](https://github.com/angular/angular/commit/6cbf990)), closes [#7924](https://github.com/angular/angular/issues/7924)
-* **ngFor:** Support convenience  view local in ngFor ([ccff175](https://github.com/angular/angular/commit/ccff175)), closes [#8013](https://github.com/angular/angular/issues/8013)
-* **parser:** TemplateParser.tryParse() returns both the AST and errors ([226e662](https://github.com/angular/angular/commit/226e662)), closes [#7858](https://github.com/angular/angular/issues/7858)
-* **transformers:** changes transformers to collect information about providers and resolve identifi ([3b60503](https://github.com/angular/angular/commit/3b60503))
-* **transformers:** special case Profiler ([83b8f59](https://github.com/angular/angular/commit/83b8f59))
-* **typescript:** update to 1.9 nightly. ([3412aba](https://github.com/angular/angular/commit/3412aba)), closes [#8003](https://github.com/angular/angular/issues/8003)
-
-### BREAKING CHANGES
-
-* In Dart files, `import 'package:angular2/bootstrap.dart'` no longer works.
-  Instead, use `import 'package:angular2/platform/browser.dart'`.
-
-### Reverts
-
-* Revert "chore(format): update to latest formatter" ([60727c4](https://github.com/angular/angular/commit/60727c4))
-
-
-
-<a name="2.0.0-beta.14"></a>
-# 2.0.0-beta.14 (2016-04-07)
-
-
-### Bug Fixes
-
-* **forms:** support both value and ng-value ([8db97b0](https://github.com/angular/angular/commit/8db97b0))
-* **router:** allow forward slashes in query parameters ([4902244](https://github.com/angular/angular/commit/4902244)), closes [#7824](https://github.com/angular/angular/issues/7824)
-* **select:** support objects as select values ([74e2bd7](https://github.com/angular/angular/commit/74e2bd7)), closes [#4843](https://github.com/angular/angular/issues/4843) [#7842](https://github.com/angular/angular/issues/7842)
-* **select:** update name from ng-value to ngValue ([3ca6df8](https://github.com/angular/angular/commit/3ca6df8)), closes [#7939](https://github.com/angular/angular/issues/7939)
-* **upgrade:** leak when angular1 destroys element ([9be04f8](https://github.com/angular/angular/commit/9be04f8)), closes [#6401](https://github.com/angular/angular/issues/6401) [#7935](https://github.com/angular/angular/issues/7935)
-
-### Features
-
-* **dart/transform:** Avoid `print` in transformer code. ([e310bee](https://github.com/angular/angular/commit/e310bee)), closes [#7855](https://github.com/angular/angular/issues/7855)
-* **static-reflector:** Added StaticReflector ([0dbf959](https://github.com/angular/angular/commit/0dbf959))
-
-
-
-
-
-<a name="2.0.0-beta.13"></a>
-# 2.0.0-beta.13 (2016-03-31)
-
-
-### Bug Fixes
-
-* **build:** MetadataCollector correctly collects property metadata ([111afcd](https://github.com/angular/angular/commit/111afcd)), closes [#7772](https://github.com/angular/angular/issues/7772) [#7773](https://github.com/angular/angular/issues/7773)
-* **codegen:** stringify using an opaque ID when toString contains parens. ([90c87fa](https://github.com/angular/angular/commit/90c87fa)), closes [#7825](https://github.com/angular/angular/issues/7825)
-* **ngFor:** give more instructive error when binding to non-iterable ([49527ab](https://github.com/angular/angular/commit/49527ab))
-* **Router:** handling of special chars in dynamic segments ([0bcfcde](https://github.com/angular/angular/commit/0bcfcde)), closes [#7804](https://github.com/angular/angular/issues/7804)
-* **upgrade:** make ngUpgrade work with testability API ([430f367](https://github.com/angular/angular/commit/430f367)), closes [#7603](https://github.com/angular/angular/issues/7603)
-
-### Features
-
-* **build:** Persisting decorator metadata ([ae876d1](https://github.com/angular/angular/commit/ae876d1))
-* **compiler:** assert that Component.style is an array ([6de68e2](https://github.com/angular/angular/commit/6de68e2)), closes [#7559](https://github.com/angular/angular/issues/7559)
-* **compiler:** Resolvers now use DI to create reflector ([506f4ce](https://github.com/angular/angular/commit/506f4ce)), closes [#7762](https://github.com/angular/angular/issues/7762)
-* **Compiler:** Allow overriding the projection selector ([aa966f5](https://github.com/angular/angular/commit/aa966f5)), closes [#6303](https://github.com/angular/angular/issues/6303) [#7742](https://github.com/angular/angular/issues/7742)
-* **dart:** Add a dev-mode check for undeclared lifecycle interfaces ([1c20a62](https://github.com/angular/angular/commit/1c20a62)), closes [#6849](https://github.com/angular/angular/issues/6849)
-* **facade:** add ListWrapper.flatten ([a1880c3](https://github.com/angular/angular/commit/a1880c3))
-* **facade:** add RegExpWrapper.replaceAll to replace all matches using the provided function ([91999e0](https://github.com/angular/angular/commit/91999e0))
-* **html_parser:** change HtmlElementAst to store both the start and the end positions ([17c8ec8](https://github.com/angular/angular/commit/17c8ec8))
-* **i18n:** implement an i18n-aware html parser ([d272f96](https://github.com/angular/angular/commit/d272f96)), closes [#7738](https://github.com/angular/angular/issues/7738)
-* **i18n:** implement xmb deserialization ([d7e1175](https://github.com/angular/angular/commit/d7e1175))
-* **i18n:** reexport I18nHtmlParser through the i18n barrel ([d2ca7d8](https://github.com/angular/angular/commit/d2ca7d8))
-* **i18n:** update I18nHtmlParser to accept parsed messages ([756121a](https://github.com/angular/angular/commit/756121a))
-* **i18n:** update transformers to read a xmb file when provided and use I18nHtmlParser in t ([8430927](https://github.com/angular/angular/commit/8430927)), closes [#7790](https://github.com/angular/angular/issues/7790)
-
-
-### BREAKING CHANGES
-
-* For static content projection, elements with *-directives are now matched against the element itself vs the template before.
-
-`<p *ngIf="condition" foo></p>`
-
-Before:
-```html
-    // Use the implicit template for projection
-    <ng-content select="template"></ng-content>
-```
-
-After:
-```html
-    // Use the actual element for projection
-    <ng-content select="p[foo]"></ng-content>
-```
-
-<a name="2.0.0-beta.12"></a>
-# 2.0.0-beta.12 (2016-03-23)
-
-
-### Bug Fixes
-
-* **angular_1_router:** ng-link is generating wrong hrefs ([69c1405](https://github.com/angular/angular/commit/69c1405)), closes [#7423](https://github.com/angular/angular/issues/7423)
-* **angular1_router:** support link generation with custom hashPrefixes ([0f8efce](https://github.com/angular/angular/commit/0f8efce))
-* **package.json:** remove es6-promise from the peerDependency list ([8b67b07](https://github.com/angular/angular/commit/8b67b07))
-
-### Features
-
-* **dart/transform:** Use angular2/platform/browser as bootstrap lib ([b6507e3](https://github.com/angular/angular/commit/b6507e3)), closes [#7647](https://github.com/angular/angular/issues/7647)
-
-
-<a name="2.0.0-beta.11"></a>
-# 2.0.0-beta.11 (2016-03-18)
-
-
-### Bug Fixes
-
-* make sure that Zone does not show up in angular2.d.ts ([d4e9b55](https://github.com/angular/angular/commit/d4e9b55fb69d87f948d02905d34fc78221adb11a))
-* **common:** remove @internal annotation on SwitchView ([967ae3e](https://github.com/angular/angular/commit/967ae3e)), closes [#7657](https://github.com/angular/angular/issues/7657)
-* **router:** RouterOutlet loads component twice in a race condition ([2f581ff](https://github.com/angular/angular/commit/2f581ff)), closes [#7497](https://github.com/angular/angular/issues/7497) [#7545](https://github.com/angular/angular/issues/7545)
-
-### Features
-
-* **i18n:** add a simple dart script extracting all i18n messages from a package ([8326ab3](https://github.com/angular/angular/commit/8326ab3)), closes [#7620](https://github.com/angular/angular/issues/7620)
-* **i18n:** create i18n barrel ([a7fe983](https://github.com/angular/angular/commit/a7fe983))
-* **i18n:** implement xmb serializer ([e1f8e54](https://github.com/angular/angular/commit/e1f8e54))
-
-
-<a name="2.0.0-beta.10"></a>
-# 2.0.0-beta.10 (2016-03-17)
-
-
-### Bug Fixes
-
-* **change_detection:** fix a memory leak ([128acbb](https://github.com/angular/angular/commit/128acbb))
-* **closure:** don't throw from top-level ([5824866](https://github.com/angular/angular/commit/5824866))
-* **router:** handle URL that does not match a route ([8e3e450](https://github.com/angular/angular/commit/8e3e450)), closes [#7349](https://github.com/angular/angular/issues/7349) [#7203](https://github.com/angular/angular/issues/7203)
-* **router/instruction:** ensure toLinkUrl includes extra params ([0d58b13](https://github.com/angular/angular/commit/0d58b13)), closes [#7367](https://github.com/angular/angular/issues/7367)
-
-### Features
-
-* **compiler:** change html parser to preserve comments ([70d18b5](https://github.com/angular/angular/commit/70d18b5))
-* **core:** introduce a CSS lexer/parser ([b72bab4](https://github.com/angular/angular/commit/b72bab4))
-* **core:** introduce a CSS lexer/parser ([293fa55](https://github.com/angular/angular/commit/293fa55))
-* **facade:** add .values to StringMapWrapper ([f1796d6](https://github.com/angular/angular/commit/f1796d6))
-* **i18n:** add ngPlural directive ([df1f78e](https://github.com/angular/angular/commit/df1f78e))
-* **i18n:** implement a simple version of message extractor ([095db67](https://github.com/angular/angular/commit/095db67)), closes [#7454](https://github.com/angular/angular/issues/7454)
-* **shadow_css:** support `/deep/` and `>>>` ([cb38d72](https://github.com/angular/angular/commit/cb38d72)), closes [#7562](https://github.com/angular/angular/issues/7562) [#7563](https://github.com/angular/angular/issues/7563)
-* **TAG_DEFINITIONS:** include <meta> and <base> ([2c7c3e3](https://github.com/angular/angular/commit/2c7c3e3)), closes [#7455](https://github.com/angular/angular/issues/7455)
-
-### BREAKING CHANGES
-
-Removed deprecated API from NgZone
- `NgZone.overrideOnTurnStart`
- `NgZone.overrideOnTurnDone`
- `NgZone.overrideOnEventDone`
- `NgZone.overrideOnErrorHandler`
-
-Rename NgZone API
- `NgZone.onTurnStart` => `NgZone.onUnstable`
- `NgZone.onTurnDone` => `NgZone.onMicrotaskEmpty`
- `NgZone.onEventDone` => `NgZone.onStable`
-
-
-<a name="2.0.0-beta.9"></a>
-# 2.0.0-beta.9 (2016-03-09)
-
-
-### Bug Fixes
-
-* **angular_1_router:** Renamed require statements after TypeScript files are transpiled ([ae49085](https://github.com/angular/angular/commit/ae49085)), closes [#7049](https://github.com/angular/angular/issues/7049)
-* **angular1_router:** rename `router` component binding to `$router` ([2548ce8](https://github.com/angular/angular/commit/2548ce8))
-* **angular1_router:** rename `router` component binding to `$router` ([1174473](https://github.com/angular/angular/commit/1174473))
-* **angular1_router:** support templateUrl components ([5586c29](https://github.com/angular/angular/commit/5586c29))
-* **build:** Use fixed version of Chromium Canary that will be updated manually instead of au ([1d49b3e](https://github.com/angular/angular/commit/1d49b3e))
-* **router:** support outlets within dynamic components ([7d44b82](https://github.com/angular/angular/commit/7d44b82))
-
-### Features
-
-* **angular1_router:** Add ng-link-active class to active ng-link ([11e8aa2](https://github.com/angular/angular/commit/11e8aa2)), closes [#6882](https://github.com/angular/angular/issues/6882)
-* **compiler:** Added spans to HTML parser errors ([19a08f3](https://github.com/angular/angular/commit/19a08f3))
-* **dart:** Add a dev-mode check for undeclared lifecycle interfaces ([a3d7629](https://github.com/angular/angular/commit/a3d7629)), closes [#6849](https://github.com/angular/angular/issues/6849)
-* **dart/transform:** Create standalone transformers for phases ([15e1614](https://github.com/angular/angular/commit/15e1614))
-* **iterable_differ:** support immutable lists ([a10c02c](https://github.com/angular/angular/commit/a10c02c)), closes [#7127](https://github.com/angular/angular/issues/7127)
-* **router:** add regex matchers ([75343eb](https://github.com/angular/angular/commit/75343eb)), closes [#7325](https://github.com/angular/angular/issues/7325) [#7126](https://github.com/angular/angular/issues/7126)
-* **router:** Added method to get current instruction ([6dce4f4](https://github.com/angular/angular/commit/6dce4f4))
-* **transformers:** change 'Missing Identifier' to be an error ([45fd6f0](https://github.com/angular/angular/commit/45fd6f0)), closes [#7403](https://github.com/angular/angular/issues/7403)
-* **transformers:** collect provider information ([81beb1c](https://github.com/angular/angular/commit/81beb1c))
-
-
-### BREAKING CHANGES
-
-* The recently added binding of the current router to the current component
-has been renamed from `router` to `$router`.
-So now the recommended set up for your bindings in your routed component
-is:
-```js
-{
-  ...
-  bindings: {
-    $router: '<'
-  }
-}
-```
-
-* The recently added binding of the current router to the current component
-has been renamed from `router` to `$router`.
-So now the recommended set up for your bindings in your routed component
-is:
-```js
-{
-  ...
-  bindings: {
-    $router: '<'
-  }
-}
-```
-
-
-
-<a name="2.0.0-beta.8"></a>
-# 2.0.0-beta.8 (2016-03-02)
-
-
-### Bug Fixes
-
-* **angular1_router:** rename `$route` service to `$rootRouter` ([a1c3be2](https://github.com/angular/angular/commit/a1c3be2))
-* **angular1_router:** rename `router` component binding to `$router` ([edad8e3](https://github.com/angular/angular/commit/edad8e3))
-* **angular1_router:** support templateUrl components ([d4a4d81](https://github.com/angular/angular/commit/d4a4d81))
-* **change_detection:** allow to destroy `OnPush` components inside of a host event. ([280b86e](https://github.com/angular/angular/commit/280b86e))
-* **change_detection:** allow to destroy `OnPush` components inside of a host event. ([ebd438f](https://github.com/angular/angular/commit/ebd438f)), closes [#7192](https://github.com/angular/angular/issues/7192)
-* **core:** support `ngFor` that has an `ngIf` as last node ([1779caf](https://github.com/angular/angular/commit/1779caf)), closes [#6304](https://github.com/angular/angular/issues/6304) [#6878](https://github.com/angular/angular/issues/6878)
-* **dart/payload:** Fix runtime error in hello_world payload app ([eeb594c](https://github.com/angular/angular/commit/eeb594c)), closes [#7358](https://github.com/angular/angular/issues/7358)
-* **differ:** clean up stale identity change refs ([ab36ea0](https://github.com/angular/angular/commit/ab36ea0)), closes [#7193](https://github.com/angular/angular/issues/7193)
-* **DomRenderer:** correctly handle namespaced attributes ([c6afea6](https://github.com/angular/angular/commit/c6afea6))
-* **Router:** Query strings are copied for HashLocationStrategy ([b47f80e](https://github.com/angular/angular/commit/b47f80e)), closes [#7298](https://github.com/angular/angular/issues/7298)
-* **test:** fix a broken test ([9aedef2](https://github.com/angular/angular/commit/9aedef2))
-* **transformers:** record reflection info about abstract classes ([05c185a](https://github.com/angular/angular/commit/05c185a)), closes [#7347](https://github.com/angular/angular/issues/7347)
-* **transformers:** replace an error with a warning when cannot resolve a symbol ([ee3c580](https://github.com/angular/angular/commit/ee3c580))
-* **transformers:** special case types some built-in types, so they can be resolved ([331b9c1](https://github.com/angular/angular/commit/331b9c1))
-* **web_worker:** wait for bindings in kitchen sink spec ([4a93f58](https://github.com/angular/angular/commit/4a93f58))
-* **web_workers:** make waitForElementText function more stable ([f6a8d04](https://github.com/angular/angular/commit/f6a8d04))
-* **WebWorker:** Fix PostMessageBusSink and Source undefined error. ([01fe7f5](https://github.com/angular/angular/commit/01fe7f5)), closes [#7156](https://github.com/angular/angular/issues/7156)
-* **WebWorker:** Make MessageBus EventEmitter synchronous ([69c1694](https://github.com/angular/angular/commit/69c1694))
-
-### Features
-
-* **core:** Add `QueryList.forEach` to public api. ([e7470d5](https://github.com/angular/angular/commit/e7470d5))
-* **core:** Add `QueryList#forEach` ([b634a25](https://github.com/angular/angular/commit/b634a25))
-* **core:** add more debug APIs to inspect the application form a browser ([b5e6319](https://github.com/angular/angular/commit/b5e6319)), closes [#7045](https://github.com/angular/angular/issues/7045) [#7161](https://github.com/angular/angular/issues/7161)
-* **core:** drop `ChangeDetectionStrategy.OnPushObserve` ([f60fa14](https://github.com/angular/angular/commit/f60fa14))
-* **di:** drop support for injecting types with generics in Dart ([c9a3df9](https://github.com/angular/angular/commit/c9a3df9)), closes [#7262](https://github.com/angular/angular/issues/7262)
-* **forms/validators:** pattern validator ([38cb526](https://github.com/angular/angular/commit/38cb526)), closes [#5561](https://github.com/angular/angular/issues/5561)
-* **i18n:** added i18nPlural and i18nSelect pipes ([59629a0](https://github.com/angular/angular/commit/59629a0)), closes [#7268](https://github.com/angular/angular/issues/7268)
-* **pipes:** add ReplacePipe for string manipulation ([6ef2121](https://github.com/angular/angular/commit/6ef2121))
-* **test:** add withProviders for per test providers ([c1a0af5](https://github.com/angular/angular/commit/c1a0af5)), closes [#5128](https://github.com/angular/angular/issues/5128)
-* **transformers:** collect data needed for the template compiler ([ebe531b](https://github.com/angular/angular/commit/ebe531b)), closes [#7299](https://github.com/angular/angular/issues/7299)
-* **transformers:** collect information for CompileDiDependencyMetadata ([39b6e0e](https://github.com/angular/angular/commit/39b6e0e))
-* **transformers:** makes the map of resolved identifiers configurable ([0bb10d6](https://github.com/angular/angular/commit/0bb10d6)), closes [#7359](https://github.com/angular/angular/issues/7359)
-
-
-### BREAKING CHANGES
-
-* `OnPushObserve` was an experimental
-feature for Dart and had
-conceptual performance problems,
-as setting up observables is slow.
-Use `OnPush` instead.
-
-* In Dart we used to support injecting types with generics. As this feature is hard to implement with the upcoming codegen we are dropping it.
-Merge cl/115454020 in G3 with this change.
-
-* The `$router` injectable service has been renamed to `$rootRouter`
-
-* The recently added binding of the current router to the current component
-has been renamed from `router` to `$router`.
-So now the recommended set up for your bindings in your routed component
-is:
-```js
-{
-  ...
-  bindings: {
-    $router: '<'
-  }
-}
-```
-
-<a name="2.0.0-beta.7"></a>
-# 2.0.0-beta.7 (2016-02-18)
-
-
-### Bug Fixes
-
-* **angular_1_router:** Added DI string tokens ([3478d5d](https://github.com/angular/angular/commit/3478d5d)), closes [#4269](https://github.com/angular/angular/issues/4269) [#7031](https://github.com/angular/angular/issues/7031)
-* **typing:** Remove re-export of the Promise built-in type. ([265703b](https://github.com/angular/angular/commit/265703b)), closes [#6468](https://github.com/angular/angular/issues/6468)
-
-<a name="2.0.0-beta.6"></a>
-# 2.0.0-beta.6 (2016-02-11)
-
-
-### Bug Fixes
-
-* **angular1-router:** add missing wrapper methods ([55122cd](https://github.com/angular/angular/commit/55122cd)), closes [#6763](https://github.com/angular/angular/issues/6763) [#6861](https://github.com/angular/angular/issues/6861) [#6861](https://github.com/angular/angular/issues/6861)
-* **angular1-router:** add support for using the component helper ([d86be24](https://github.com/angular/angular/commit/d86be24)), closes [angular/angular.js#13860](https://github.com/angular/angular.js/issues/13860) [#6076](https://github.com/angular/angular/issues/6076) [#5278](https://github.com/angular/angular/issues/5278)
-* **async:** handle synchronous initial value in async pipe ([26e60d6](https://github.com/angular/angular/commit/26e60d6)), closes [#5996](https://github.com/angular/angular/issues/5996)
-* **build:** don't try to copy .d.ts files into the npm distro ([16b5217](https://github.com/angular/angular/commit/16b5217)), closes [#6921](https://github.com/angular/angular/issues/6921)
-* **compiler:** fix interpolation regexp ([9b0e10e](https://github.com/angular/angular/commit/9b0e10e)), closes [#6056](https://github.com/angular/angular/issues/6056)
-* **compiler:** use event names for matching directives ([231773e](https://github.com/angular/angular/commit/231773e)), closes [#6870](https://github.com/angular/angular/issues/6870)
-* **core:** add detail to dehydrated detector exception ([e7ad03c](https://github.com/angular/angular/commit/e7ad03c)), closes [#6939](https://github.com/angular/angular/issues/6939)
-* **core:** mute mode printing in console in prod mode ([74be3d3](https://github.com/angular/angular/commit/74be3d3)), closes [#6873](https://github.com/angular/angular/issues/6873)
-* **di:** throw if a token uses more than 20 dependencies. ([de77700](https://github.com/angular/angular/commit/de77700)), closes [#6690](https://github.com/angular/angular/issues/6690) [#6869](https://github.com/angular/angular/issues/6869)
-* **forms:** add RadioButtonValueAccessor to the list of default value accessors ([8f47aa3](https://github.com/angular/angular/commit/8f47aa3))
-* **forms:** add support for radio buttons ([e725542](https://github.com/angular/angular/commit/e725542)), closes [#6877](https://github.com/angular/angular/issues/6877)
-* **forms:** use strict runtimeType checks instead of instanceof ([50548fb](https://github.com/angular/angular/commit/50548fb)), closes [#6981](https://github.com/angular/angular/issues/6981)
-* **Headers:** serializable toJSON ([b55f176](https://github.com/angular/angular/commit/b55f176)), closes [#6073](https://github.com/angular/angular/issues/6073) [#6714](https://github.com/angular/angular/issues/6714)
-* **ngFor:** update view locals if identity changes ([0f10624](https://github.com/angular/angular/commit/0f10624)), closes [#6923](https://github.com/angular/angular/issues/6923)
-* **router:** Added route data to normalized async route ([df7885c](https://github.com/angular/angular/commit/df7885c)), closes [#6802](https://github.com/angular/angular/issues/6802)
-* **router:** don't prepend `/` unnecessarily to Location paths ([c603643](https://github.com/angular/angular/commit/c603643)), closes [#6729](https://github.com/angular/angular/issues/6729) [#5502](https://github.com/angular/angular/issues/5502)
-* **router:** fix incorrect url param value coercion of 1 to true ([995a9e0](https://github.com/angular/angular/commit/995a9e0)), closes [#5346](https://github.com/angular/angular/issues/5346) [#6286](https://github.com/angular/angular/issues/6286)
-* **router:** fix url path for star segment in path recognizer ([6f1ef33](https://github.com/angular/angular/commit/6f1ef33)), closes [#6976](https://github.com/angular/angular/issues/6976)
-* **router:** fixed the location wrapper for angular1 ([e73fee7](https://github.com/angular/angular/commit/e73fee7)), closes [#6943](https://github.com/angular/angular/issues/6943)
-* **typings:** Don't expose typing dependencies to users. ([2a70f4e](https://github.com/angular/angular/commit/2a70f4e)), closes [#5973](https://github.com/angular/angular/issues/5973) [#5807](https://github.com/angular/angular/issues/5807) [#6266](https://github.com/angular/angular/issues/6266) [#5242](https://github.com/angular/angular/issues/5242) [#6817](https://github.com/angular/angular/issues/6817) [#6267](https://github.com/angular/angular/issues/6267)
-* **upgrade:** fix infinite $rootScope.$digest() ([7e0f02f](https://github.com/angular/angular/commit/7e0f02f)), closes [#6385](https://github.com/angular/angular/issues/6385) [#6386](https://github.com/angular/angular/issues/6386)
-* **Validators:** fix Validators.required marking number zero as invalid ([c2ceb7f](https://github.com/angular/angular/commit/c2ceb7f)), closes [#6617](https://github.com/angular/angular/issues/6617)
-* **WebWorkers:** Fix flaky WebWorker test ([da1fcfd](https://github.com/angular/angular/commit/da1fcfd)), closes [#6851](https://github.com/angular/angular/issues/6851)
-
-### Features
-
-* **angular1_router:** allow component to bind to router ([0f22dce](https://github.com/angular/angular/commit/0f22dce))
-* **typings:** install es6-shim typings to a location users can reference. ([f1f5b45](https://github.com/angular/angular/commit/f1f5b45))
-
-### BREAKING CHANGES
-
-Transitive typings are no longer included in the distribution.
-
-If you use `--target=es5`, you will need to add a line somewhere in your
-application (for example, at the top of the `.ts` file where you call `bootstrap`):
-```
-///<reference path="node_modules/angular2/typings/browser.d.ts"/>
-```
-(Note that if your file is not in the same directory as `node_modules`, you'll
-need to add one or more `../` to the start of that path.)
-
-If you have unit tests, you need to install typings in your project using
-http://github.com/typings/typings
-And install typings such as `jasmine`, `angular-protractor`, or `selenium-webdriver`
-to satisfy the type-checker.
-
-If you rely on es6 APIs other than Promises and Collections, you will need to
-install the es6-shim typing instead of using the <reference> tag above.
-Angular previously exposed typings for the entire ES6 API.
-
-<a name="2.0.0-beta.5"></a>
-# 2.0.0-beta.5 (2016-02-10)
-
-This release was incorrect; replaced with beta.6.
-
-<a name="2.0.0-beta.4"></a>
-# 2.0.0-beta.4 (2016-02-10)
-
-This release was incorrect; replaced with beta.6.
-
-<a name="2.0.0-beta.3"></a>
-# 2.0.0-beta.3 (2016-02-03)
-
-
-### Bug Fixes
-
-* **bundle:** add angular2/platform/testing/browser to SystemJS testing bundle ([ae7d2ab](https://github.com/angular/angular/commit/ae7d2ab))
-* **circle:** pre-dependencies `npm install npm` ([36a0e04](https://github.com/angular/angular/commit/36a0e04)), closes [#6777](https://github.com/angular/angular/issues/6777)
-* **dart/transform:** Handle edge cases in ReflectionRemover ([3e9b532](https://github.com/angular/angular/commit/3e9b532)), closes [#6749](https://github.com/angular/angular/issues/6749)
-* **docs:** `rxjs/add/operators/map` -> `rxjs/add/operator/map` (no 's'). ([2a302aa](https://github.com/angular/angular/commit/2a302aa))
-* **karma:** fix running karma via gulp ([27daeaf](https://github.com/angular/angular/commit/27daeaf))
-* **query:** don’t cross component boundaries ([c6adbf6](https://github.com/angular/angular/commit/c6adbf6)), closes [#6759](https://github.com/angular/angular/issues/6759)
-* **query:** update view queries that query directives in embedded views ([1f7a41c](https://github.com/angular/angular/commit/1f7a41c)), closes [#6747](https://github.com/angular/angular/issues/6747)
-* **WebWorkers:** Add support for transitionend events. ([c2a38c0](https://github.com/angular/angular/commit/c2a38c0)), closes [#6649](https://github.com/angular/angular/issues/6649)
-* **zone:** correct incorrect calls to zone ([3211938](https://github.com/angular/angular/commit/3211938))
-
-### Features
-
-* **change_detection:** allow all legal programs in the dev mode ([42231f5](https://github.com/angular/angular/commit/42231f5))
-* **dart/transform:** Generate all code into <file>.template.dart ([8c36aa8](https://github.com/angular/angular/commit/8c36aa8))
-* **debug:** replace DebugElement with new Debug DOM ([e1bf3d3](https://github.com/angular/angular/commit/e1bf3d3))
-* **ngFor:** add custom trackBy function support ([cee2318](https://github.com/angular/angular/commit/cee2318)), closes [#6779](https://github.com/angular/angular/issues/6779)
-* **upgrade:** support bindToController with binding definitions ([99e6500](https://github.com/angular/angular/commit/99e6500)), closes [#4784](https://github.com/angular/angular/issues/4784)
-* **WebWorker:** Add Router Support for WebWorker Apps ([8bea667](https://github.com/angular/angular/commit/8bea667)), closes [#3563](https://github.com/angular/angular/issues/3563)
-
-### Performance Improvements
-
-* **dart/transform:** Only process deferred libs when necessary ([f56df65](https://github.com/angular/angular/commit/f56df65)), closes [#6745](https://github.com/angular/angular/issues/6745)
-
-### BREAKING CHANGES
-
-This is a breaking change for unit tests. The API for the DebugElement
-has changed. Now, there is a DebugElement or DebugNode for every node
-in the DOM, not only nodes with an ElementRef. `componentViewChildren` is
-removed, and `childNodes` is a list of ElementNodes corresponding to every
-child in the DOM. `query` no longer takes a scope parameter, since
-the entire rendered DOM is included in the `childNodes`.
-
-Before:
-
-```
-componentFixture.debugElement.componentViewChildren[0];
-```
-
-After
-```
-// Depending on the DOM structure of your component, the
-// index may have changed or the first component child
-// may be a sub-child.
-componentFixture.debugElement.children[0];
-```
-
-Before:
-
-```
-debugElement.query(By.css('div'), Scope.all());
-```
-
-After:
-
-```
-debugElement.query(By.css('div'));
-```
-
-Before:
-
-```
-componentFixture.debugElement.elementRef;
-```
-
-After:
-
-```
-componentFixture.elementRef;
-```
-
 <a name="2.0.0-beta.2"></a>
 # 2.0.0-beta.2 (2016-01-28)

@ -671,10 +30,13 @@ componentFixture.elementRef;

 ### BREAKING CHANGES

+* there's a chance of breakage as router's Instruction constructor
+  signature changed.
+
 * `Renderer.listen` now has to return a function that
  removes the event listener.

-* TemplateRef.elementRef is now read-only.
+* remove TemplateRef.elementRef setter

 * Tests are now required to use `setBaseTestProviders`
 to set up. Assuming your tests are run on a browser, setup would change
@ -697,6 +59,7 @@ setBaseTestProviders(TEST_BROWSER_PLATFORM_PROVIDERS,
                     TEST_BROWSER_APPLICATION_PROVIDERS);
 ```

+* This is very unlikely to be breaking, but I'm still marking just in case. The only change to the user should be that dev mode is driven by Dart's checked mode, like it was in the past.

 <a name="2.0.0-beta.1"></a>
 # 2.0.0-beta.1 catamorphic-involution (2016-01-08)
@ -743,7 +106,6 @@ setBaseTestProviders(TEST_BROWSER_PLATFORM_PROVIDERS,
  take a native element instead of an ElementRef
 * `Renderer` interface now operates on plain native nodes,
  instead of `RenderElementRef`s or `RenderViewRef`s
-
 <a name="2.0.0-beta.0"></a>
 # 2.0.0-beta.0 somnambulant-inauguration (2015-12-15)

@ -765,7 +127,10 @@ setBaseTestProviders(TEST_BROWSER_PLATFORM_PROVIDERS,

 ### BREAKING CHANGES

-* Previously, Angular would run in dev prod mode by default, and you could enable the dev mode by calling enableDevMode. Now, Angular runs in the dev mode by default, and you can enable the prod mode by calling enableProdMode.
+* Before
+Previously Angular would run in dev prod mode by default, and you could enable the dev mode by calling enableDevMode.
+After
+Now, Angular runs in the dev mode by default, and you can enable the prod mode by calling enableProdMode.



@ -842,11 +207,11 @@ bundle. `ngUpgrade` has a dedicated `upgrade.js` bundle now.

 * `Observable` are no more re-exported from `angular2/core`

-    Before
+    Before 
    ```
    import {Observable} from 'angular2/core'
    ```
-    After
+    After 
    ```
    import {Observable} from 'rxjs/Observable';
    ```
@ -1067,7 +432,7 @@ import * as core from 'angular2/core';
 * Operators and Observables from RxJS (e.g. .map(), .toArray(), .toPromise(), etc ) now need to be explicitly imported (once per operator in your app)
  ```
  import {Observable} from 'rxjs/Observable';
-  import 'rxjs/add/operator/map';
+  import 'rxjs/add/operators/map';
  import 'rxjs/add/observable/interval';

  Observable.interval(1000).subscribe(...);
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -180,8 +180,8 @@ Must be one of the following:
 * **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)
+* **build**: Changes that affect the build system, CI configuration or external dependencies (example scopes: gulp, broccoli, npm)
+* **ci**: Any changes to our CI configuration files and scripts (Travis, Circle CI, BrowserStack, SauceLabs)
 * **chore**: Other changes that don't modify `src` or `test` files

 ### Scope
--- a/DEVELOPER.md
+++ b/DEVELOPER.md
@ -9,7 +9,7 @@ JS and Dart versions. It also explains the basic mechanics of using `git`, `node
 * [Installing NPM Modules and Dart Packages](#installing-npm-modules-and-dart-packages)
 * [Build commands](#build-commands)
 * [Running Tests Locally](#running-tests-locally)
-* [Code Style](#code-style)
+* [Formatting](#clang-format)
 * [Project Information](#project-information)
 * [CI using Travis](#ci-using-travis)
 * [Transforming Dart code](#transforming-dart-code)
@ -227,9 +227,7 @@ Angular specific command line options when running protractor:
 Angular specific command line options when running protractor (e.g. force gc, ...):
 `$(npm bin)/protractor protractor-{js|dart2js}-conf.js --ng-help`

-## Code Style
-
-### Formatting with <a name="clang-format">clang-format</a>
+## 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
@ -275,14 +273,6 @@ to some whitespace difference.
 * `clang-format` integrations are also available for many popular editors (`vim`, `emacs`,
  `Sublime Text`, etc.).

-### Linting
-
-We use [tslint](https://github.com/palantir/tslint) for linting. See linting rules in [gulpfile](gulpfile.js). To lint, run
-
-```shell
-$ gulp lint
-```
-
 ## Generating the API documentation

 The following gulp task will generate the API docs in the `dist/angular.io/partials/api/angular2`:  
--- a/README.md
+++ b/README.md
@ -1,19 +1,18 @@
-[![Build Status](https://travis-ci.org/angular/angular.svg?branch=master)](https://travis-ci.org/angular/angular)
+[![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)](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)

-Angular
+Angular 
 =========

 Angular is a development platform for building mobile and desktop web applications. This is the
 repository for [Angular 2][ng2], both the JavaScript (JS) and [Dart][dart] versions.

-Angular 2 is currently in **Beta**.
+Angular 2 is currently in **Beta**. 

 ## Quickstart

--- a/TOOLS_JS.md
+++ b/TOOLS_JS.md
@ -117,7 +117,7 @@ speed things up is to use plain class fields in your expressions and avoid any
 kinds of computation. Example:

 ```typescript
-@Component({
+@View({
  template: '<button [enabled]="isEnabled">{{title}}</button>'
 })
 class FancyButton {
--- a/browser-providers.conf.js
+++ b/browser-providers.conf.js
@ -4,9 +4,8 @@
 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 should be required:true
-  // https://github.com/angular/angular/issues/7560
-  'FirefoxBeta':  { unitTest: {target: 'SL', required: false}, e2e: {target: null, required: false}},
+  'ChromeBeta':   { unitTest: {target: 'SL', required: true}, e2e: {target: null, required: true}},
+  'FirefoxBeta':  { unitTest: {target: 'SL', required: true}, e2e: {target: null, required: true}},
  '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}},
@ -38,7 +37,7 @@ var customLaunchers = {
  'SL_CHROME': {
    base: 'SauceLabs',
    browserName: 'chrome',
-    version: '50'
+    version: '46'
  },
  'SL_CHROMEBETA': {
    base: 'SauceLabs',
@ -53,7 +52,7 @@ var customLaunchers = {
  'SL_FIREFOX': {
    base: 'SauceLabs',
    browserName: 'firefox',
-    version: '45'
+    version: '42'
  },
  'SL_FIREFOXBETA': {
    base: 'SauceLabs',
@ -299,7 +298,12 @@ module.exports = {
  customLaunchers: customLaunchers,
  sauceAliases: sauceAliases,
  browserstackAliases: browserstackAliases
-};
+}
+
+if (process.env.TRAVIS) {
+  process.env.SAUCE_ACCESS_KEY = process.env.SAUCE_ACCESS_KEY.split('').reverse().join('');
+  process.env.BROWSER_STACK_ACCESS_KEY = process.env.BROWSER_STACK_ACCESS_KEY.split('').reverse().join('');
+}

 function buildConfiguration(type, target, required) {
  return Object.keys(CIconfiguration)
--- a/build.sh
+++ b/build.sh
@ -1,97 +0,0 @@
-#!/usr/bin/env bash
-
-set -e -o pipefail
-
-cd `dirname $0`
-
-
-TSCONFIG=./modules/tsconfig.json
-echo "====== (all)COMPILING: \$(npm bin)/ng2tc -p ${TSCONFIG} ====="
-rm -rf ./dist/all/
-mkdir ./dist/all/
-
-# prepare all files 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/es6-shim/es6-shim.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/lib/b64.js .
-ln -s ../../../../node_modules/reflect-metadata/Reflect.js .
-ln -s ../../../../node_modules/rxjs/bundles/Rx.js .
-ln -s ../../../../node_modules/angular/angular.js .
-cd -
-
-# compile ts code
-$(npm bin)/ng2tc -p ${TSCONFIG}
-
-
-rm -rf ./dist/packages-dist
-
-for PACKAGE in \
-  core \
-  compiler \
-  common \
-  platform-browser \
-  platform-browser-dynamic \
-  platform-server \
-  http \
-  router \
-  router-deprecated \
-  upgrade
-do
-  SRCDIR=./modules/@angular/${PACKAGE}
-  DESTDIR=./dist/packages-dist/${PACKAGE}
-  UMDES6PATH=${DESTDIR}/esm/${PACKAGE}.umd.js
-  UMDES5PATH=${DESTDIR}/${PACKAGE}.umd.js
-
-
-  echo "======      COMPILING: \$(npm bin)/ng2tc -p ${SRCDIR}/tsconfig-es5.json        ====="
-  $(npm bin)/ng2tc -p ${SRCDIR}/tsconfig-es5.json
-  cp ${SRCDIR}/package.json ${DESTDIR}/
-
-
-  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 [[ ${TRAVIS} ]]; 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/^( +)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/^( +)abstract ([[:alnum:]]+\:)/\1\2/g'
-  fi
-
-
-  echo "====== (esm)COMPILING: \$(npm bin)/ng2tc -p ${SRCDIR}/tsconfig-es2015.json ====="
-  $(npm bin)/ng2tc -p ${SRCDIR}/tsconfig-es2015.json
-
-
-  echo "======      BUNDLING: ${SRCDIR} ====="
-  (
-    cd  ${SRCDIR}
-    echo "..."  # here just to have grep match something and not exit with 1
-    ../../../node_modules/.bin/rollup -c rollup.config.js
-  ) 2>&1 | grep -v "as external dependency"
-
-  # workaround for https://github.com/rollup/rollup/issues/626
-  if [[ ${TRAVIS} ]]; then
-    sed -i    "s/ class exports\./ class /g" ${DESTDIR}/esm/${PACKAGE}.umd.js
-  else
-    sed -i '' "s/ class exports\./ class /g" ${DESTDIR}/esm/${PACKAGE}.umd.js
-  fi
-
-  $(npm bin)/tsc  \
-      --out ${UMDES5PATH} \
-      --target es5 \
-      --allowJs \
-      ${UMDES6PATH} \
-      modules/\@angular/manual_typings/globals.d.ts \
-      modules/\@angular/typings/es6-collections/es6-collections.d.ts \
-      modules/\@angular/typings/es6-promise/es6-promise.d.ts
-  rm ${UMDES6PATH}
-
-done
--- a/circle.yml
+++ b/circle.yml
@ -1,21 +1,6 @@
 machine:
  node:
    version: 5.4.1
-
-dependencies:
-  pre:
-    - npm install -g npm
-  override:
-    - npm install:
-        environment:
-          # Token for tsd to increase github rate limit
-          # See https://github.com/DefinitelyTyped/tsd#tsdrc
-          # This is not hidden using https://circleci.com/docs/fork-pr-builds#details
-          # 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)
-          TSD_GITHUB_TOKEN: ef474500309daea53d5991b3079159a29520a40b
-
 test:
  override:
    - npm run build
--- a/gulpfile.js
+++ b/gulpfile.js
@ -40,9 +40,9 @@ if (cliArgs.projects) {
  cliArgs.projects.split(',').sort().join(',');
 }

-// --projects=angular2 => {angular2: true}
+// --projects=angular2,angular2_material => {angular2: true, angular2_material: true}
 var allProjects =
-    'angular1_router,angular2,benchmarks,benchmarks_external,benchpress,playground,payload_tests,bundle_deps';
+    'angular1_router,angular2,angular2_material,benchmarks,benchmarks_external,benchpress,playground,payload_tests,bundle_deps';
 var cliArgsProjects = (cliArgs.projects || allProjects)
                          .split(',')
                          .reduce((map, projectName) => {
@ -57,7 +57,7 @@ function printModulesWarning() {
    console.warn(
        "Pro Tip: Did you know that you can speed up your build by specifying project name(s)?");
    console.warn("         It's like pressing the turbo button in the old days, but better!");
-    console.warn("         Examples: --project=angular2 or --project=angular2");
+    console.warn("         Examples: --project=angular2 or --project=angular2,angular2_material");
  }
 }

@ -132,8 +132,7 @@ var CONFIG = {
      dev: {es6: 'dist/js/dev/es6', es5: 'dist/js/dev/es5'},
      prod: {es6: 'dist/js/prod/es6', es5: 'dist/js/prod/es5'},
      cjs: 'dist/js/cjs',
-      dart2js: 'dist/js/dart2js',
-      dart_dev_compiler: 'dist/js/ddc'
+      dart2js: 'dist/js/dart2js'
    },
    dart: 'dist/dart',
    docs: 'dist/docs',
@ -155,10 +154,8 @@ var NG2_BUNDLE_CONTENT = ANGULAR2_BUNDLE_CONFIG.join(' + ') + ' - rxjs/*';
 var HTTP_BUNDLE_CONTENT = 'angular2/http - rxjs/* - ' + ANGULAR2_BUNDLE_CONFIG.join(' - ');
 var ROUTER_BUNDLE_CONTENT = 'angular2/router + angular2/router/router_link_dsl - rxjs/* - ' +
                            ANGULAR2_BUNDLE_CONFIG.join(' - ');
-var ALT_ROUTER_BUNDLE_CONTENT =
-    'angular2/alt_router - rxjs/* - ' + ANGULAR2_BUNDLE_CONFIG.join(' - ');
 var TESTING_BUNDLE_CONTENT =
-    'angular2/testing + angular2/http/testing + angular2/router/testing + angular2/platform/testing/browser - rxjs/* - ' +
+    'angular2/testing + angular2/http/testing + angular2/router/testing - rxjs/* - ' +
    ANGULAR2_BUNDLE_CONFIG.join(' - ');
 var UPGRADE_BUNDLE_CONTENT = 'angular2/upgrade - rxjs/* - ' + ANGULAR2_BUNDLE_CONFIG.join(' - ');

@ -179,8 +176,8 @@ var PAYLOAD_TESTS_CONFIG = {
      return path.join(__dirname, CONFIG.dest.js.prod.es5, 'payload_tests', caseName,
                       'ts/' + packaging);
    },
-    systemjs: {sizeLimits: {'uncompressed': 880 * 1024, 'gzip level=9': 170 * 1024}},
-    webpack: {sizeLimits: {'uncompressed': 560 * 1024, 'gzip level=9': 130 * 1024}}
+    systemjs: {sizeLimits: {'uncompressed': 850 * 1024, 'gzip level=9': 165 * 1024}},
+    webpack: {sizeLimits: {'uncompressed': 550 * 1024, 'gzip level=9': 120 * 1024}}
  }
 };

@ -300,14 +297,7 @@ function doCheckFormat() {
  var clangFormat = require('clang-format');
  var gulpFormat = require('gulp-clang-format');

-  return gulp.src([
-               'modules/**/*.ts',
-               'tools/**/*.ts',
-               '!**/typings/**/*.d.ts',
-               // workaround https://github.com/angular/clang-format/issues/28
-               '!tools/compiler_cli/src/main.ts',
-               'gulpfile.js'
-             ])
+  return gulp.src(['modules/**/*.ts', 'tools/**/*.ts', '!**/typings/**/*.d.ts', 'gulpfile.js'])
      .pipe(gulpFormat.checkFormat('file', clangFormat));
 }

@ -354,8 +344,9 @@ gulp.task('lint', ['build.tools'], function() {
 gulp.task('build/checkCircularDependencies', function(done) {
  var madge = require('madge');

-  var dependencyObject = madge([CONFIG.dest.js.dev.es5], {
+  var dependencyObject = madge(CONFIG.dest.js.dev.es5, {
    format: 'cjs',
+    paths: [CONFIG.dest.js.dev.es5],
    extensions: ['.js'],
    onParseFile: function(data) { data.src = data.src.replace(/\/\* circular \*\//g, "//"); }
  });
@ -379,10 +370,6 @@ function jsServeDartJs() {
  return jsserve(gulp, gulpPlugins, {path: CONFIG.dest.js.dart2js, port: 8002})();
 }

-function jsServeDartDevCompiler() {
-  return jsserve(gulp, gulpPlugins, {path: CONFIG.dest.js.dart_dev_compiler, port: 8003})();
-}
-
 function proxyServeDart() {
  return jsserve(gulp, gulpPlugins, {
    port: 8002,
@ -396,7 +383,7 @@ function proxyServeDart() {

 // ------------------
 // web servers
-gulp.task('serve.js.dev', ['build.js.dev', 'build.js.cjs'], function(neverDone) {
+gulp.task('serve.js.dev', ['build.js.dev'], function(neverDone) {
  var watch = require('./tools/build/watch');

  watch('modules/**', {ignoreInitial: true}, '!broccoli.js.dev');
@ -405,24 +392,24 @@ gulp.task('serve.js.dev', ['build.js.dev', 'build.js.cjs'], function(neverDone)

 gulp.task('serve.js.prod', jsServeProd);

-gulp.task('serve.e2e.dev', ['build.js.dev', 'build.js.cjs'], function(neverDone) {
-  var watch = require('./tools/build/watch');
+gulp.task('serve.e2e.dev', ['build.js.dev', 'build.js.cjs', 'build.css.material'],
+          function(neverDone) {
+            var watch = require('./tools/build/watch');

-  watch('modules/**', {ignoreInitial: true}, ['!broccoli.js.dev', '!build.js.cjs']);
-  jsServeDev();
-});
+            watch('modules/**', {ignoreInitial: true}, ['!broccoli.js.dev', '!build.js.cjs']);
+            jsServeDev();
+          });

-gulp.task('serve.e2e.prod', ['build.js.prod', 'build.js.cjs'], function(neverDone) {
-  var watch = require('./tools/build/watch');
+gulp.task('serve.e2e.prod', ['build.js.prod', 'build.js.cjs', 'build.css.material'],
+          function(neverDone) {
+            var watch = require('./tools/build/watch');

-  watch('modules/**', {ignoreInitial: true}, ['!broccoli.js.prod', '!build.js.cjs']);
-  jsServeProd();
-});
+            watch('modules/**', {ignoreInitial: true}, ['!broccoli.js.prod', '!build.js.cjs']);
+            jsServeProd();
+          });

 gulp.task('serve.js.dart2js', jsServeDartJs);

-gulp.task('serve.js.ddc', jsServeDartDevCompiler);
-
 gulp.task('!proxyServeDart', proxyServeDart);

 gulp.task('serve.dart', function(done) {
@ -454,52 +441,34 @@ gulp.task('serve.e2e.dart', ['build.js.cjs'], function(neverDone) {

  // Note: we are not using build.dart as the dart analyzer takes too long...
  watch('modules/**', {ignoreInitial: true}, ['!build/tree.dart', '!build.js.cjs']);
-  runSequence('build/packages.dart', 'build/pubspec.dart', 'serve.dart');
+  runSequence('build/packages.dart', 'build/pubspec.dart', 'build.dart.material.css', 'serve.dart');
 });


 // ------------------
 // CI tests suites

-function execProcess(name, args, done) {
+function runKarma(configFile, done) {
  var exec = require('child_process').exec;

-  var cmd = process.platform === 'win32' ? 'node_modules\\.bin\\' + name + ' ' :
-                                           'node node_modules/.bin/' + name + ' ';
-  cmd += args;
-  exec(cmd, done);
-}
-function runKarma(configFile, done) {
-  execProcess('karma', 'run ' + configFile, function(e, stdout) {
+  var cmd = process.platform === 'win32' ? 'node_modules\\.bin\\karma run ' :
+                                           'node node_modules/.bin/karma run ';
+  cmd += configFile;
+  exec(cmd, function(e, stdout) {
    // ignore errors, we don't want to fail the build in the interactive (non-ci) mode
    // karma server will print all test failures
    done();
  });
 }

-// Gulp-typescript doesn't work with typescript@next:
-// https://github.com/ivogabe/gulp-typescript/issues/331
-function runTsc(project, done) {
-  execProcess('tsc', '-p ' + project, function(e, stdout, stderr) {
-    if (e) {
-      console.log(stdout);
-      console.error(stderr);
-      done(e);
-    } else {
-      done();
-    }
-  });
-}
-
 gulp.task('test.js', function(done) {
-  runSequence('test.compiler_cli', 'test.unit.tools/ci', 'test.transpiler.unittest',
-              'test.unit.js/ci', 'test.unit.cjs/ci', 'test.typings', 'check-public-api',
-              sequenceComplete(done));
+  runSequence('test.unit.tools/ci', 'test.transpiler.unittest', 'test.unit.js/ci',
+              'test.unit.cjs/ci', 'test.typings', sequenceComplete(done));
 });

 gulp.task('test.dart', function(done) {
  runSequence('versions.dart', 'test.transpiler.unittest', 'test.unit.dart/ci',
-              sequenceComplete(done));
+              'test.dart.angular2_testing/ci', sequenceComplete(done));
 });

 gulp.task('versions.dart', function() { dartSdk.logVersion(DART_SDK); });
@ -658,16 +627,13 @@ gulp.task('!test.unit.router/karma-run', function(done) {
                   });
 });

-gulp.task('buildRouter.dev', function() {
-  var modulesSrcDir = __dirname + '/modules';
-  var distDir = __dirname + '/dist';
-  buildRouter(modulesSrcDir, distDir);
-});
+gulp.task('buildRouter.dev', function() { buildRouter(); });

 gulp.task('test.unit.dart', function(done) {
  printModulesWarning();
  runSequence('build/tree.dart', 'build/pure-packages.dart', '!build/pubget.angular2.dart',
-              '!build/remove-pub-symlinks', function(error) {
+              '!build/change_detect.dart', '!build/remove-pub-symlinks', 'build.dart.material.css',
+              '!test.unit.dart/karma-server', '!test.unit.dart/karma-run', function(error) {
                var watch = require('./tools/build/watch');

                // if initial build failed (likely due to build or formatting step) then exit
@ -676,10 +642,9 @@ gulp.task('test.unit.dart', function(done) {
                  done(error);
                  return;
                }
-                // treatTestErrorsAsFatal = false;

-                watch(['modules/angular2/**'],
-                      ['!build/tree.dart', '!test.unit.dart/run/angular2']);
+                watch(['modules/angular2/**'], {ignoreInitial: true},
+                      ['!build/tree.dart', '!test.unit.dart/karma-run']);
              });
 });

@ -738,7 +703,7 @@ gulp.task('!build.payload.js.webpack', function() {
        .then(function() {  // pad bundle with mandatory dependencies
          return new Promise(function(resolve, reject) {
            gulp.src([
-                  'node_modules/zone.js/dist/zone.js',
+                  'node_modules/zone.js/dist/zone-microtask.js',
                  'node_modules/zone.js/dist/long-stack-trace-zone.js',
                  'node_modules/reflect-metadata/Reflect.js',
                  CASE_PATH + '/app-bundle.js'
@ -795,7 +760,7 @@ gulp.task('!checkAndReport.payload.js', function() {
                      {
                        failConditions: PAYLOAD_TESTS_CONFIG.ts[packaging].sizeLimits,
                        prefix: caseName + '_' + packaging
-                      });
+                      })
  }

  return PAYLOAD_TESTS_CONFIG.ts.cases.reduce(function(sizeReportingStreams, caseName) {
@ -806,7 +771,8 @@ gulp.task('!checkAndReport.payload.js', function() {

 gulp.task('watch.dart.dev', function(done) {
  runSequence('build/tree.dart', 'build/pure-packages.dart', '!build/pubget.angular2.dart',
-              '!build/remove-pub-symlinks', function(error) {
+              '!build/change_detect.dart', '!build/remove-pub-symlinks', 'build.dart.material.css',
+              function(error) {
                var watch = require('./tools/build/watch');

                // if initial build failed (likely due to build or formatting step) then exit
@ -816,11 +782,24 @@ gulp.task('watch.dart.dev', function(done) {
                  return;
                }

-                watch(['modules/angular2/**', 'modules_dart/**'], {ignoreInitial: true},
-                      ['!build/tree.dart', 'build/pure-packages.dart']);
+                watch(['modules/angular2/**'], {ignoreInitial: true}, ['!build/tree.dart']);
              });
 });

+gulp.task('!test.unit.dart/karma-run', function(done) {
+  // run the run command in a new process to avoid duplicate logging by both server and runner from
+  // a single process
+  runKarma('karma-dart.conf.js', done);
+});
+
+
+gulp.task('!test.unit.dart/karma-server', function() {
+  var karma = require('karma');
+
+  new karma.Server({configFile: __dirname + '/karma-dart.conf.js', reporters: 'dots'}).start();
+});
+
+
 gulp.task('test.unit.router/ci', function(done) {
  var karma = require('karma');

@ -847,7 +826,7 @@ gulp.task('test.unit.js/ci', function(done) {
                 reporters: ['dots'],
                 browsers: browserConf.browsersToRun
               },
-               function(err) { done(); })
+               done)
      .start();
 });

@ -868,63 +847,25 @@ gulp.task('test.unit.js.browserstack/ci', function(done) {
 });

 gulp.task('test.unit.dart/ci', function(done) {
-  runSequence('test.dart.dartium_symlink', '!test.unit.dart/run/angular2',
-              '!test.unit.dart/run/angular2_testing', '!test.unit.dart/run/benchpress',
-              sequenceComplete(done));
+  var karma = require('karma');
+
+  var browserConf = getBrowsersFromCLI(null, true);
+  new karma.Server(
+               {
+                 configFile: __dirname + '/karma-dart.conf.js',
+                 singleRun: true,
+                 reporters: ['dots'],
+                 browsers: browserConf.browsersToRun
+               },
+               done)
+      .start();
 });

-// At the moment, dart test requires dartium to be an executable on the path.
-// Make a temporary directory and symlink dartium from there (just for this command)
-// so that it can run.
-// TODO(juliemr): this won't work with windows - remove the hack and make this platform agnostic.
-var dartiumTmpdir = path.join(os.tmpdir(), 'dartium' + new Date().getTime().toString());
-var dartiumPathPrefix = 'PATH=$PATH:' + dartiumTmpdir + ' ';
-gulp.task(
-    'test.dart.dartium_symlink',
-    shell.task(['mkdir ' + dartiumTmpdir, 'ln -s $DARTIUM_BIN ' + dartiumTmpdir + '/dartium']));
-
-gulp.task('!test.unit.dart/run/angular2', function() {
-  var pubtest = require('./tools/build/pubtest');
-  return pubtest({
-    dir: path.join(CONFIG.dest.dart, 'angular2'),
-    dartiumTmpdir: dartiumTmpdir,
-    command: DART_SDK.PUB,
-    files: '**/*_spec.dart',
-    bunchFiles: true,
-    useExclusiveTests: true
-  });
-});
-
-gulp.task('!test.unit.dart/run/angular2_testing', function() {
-  var pubtest = require('./tools/build/pubtest');
-
-  return pubtest({
-    dir: path.join(CONFIG.dest.dart, 'angular2_testing'),
-    dartiumTmpdir: dartiumTmpdir,
-    command: DART_SDK.PUB,
-    files: '**/*_test.dart',
-    useExclusiveTests: true
-  });
-});
-
-gulp.task('!test.unit.dart/run/benchpress', function() {
-  var pubtest = require('./tools/build/pubtest');
-
-  return pubtest({
-    dir: path.join(CONFIG.dest.dart, 'benchpress'),
-    dartiumTmpdir: dartiumTmpdir,
-    command: DART_SDK.PUB,
-    files: '**/*_spec.dart',
-    useExclusiveTests: true
-  });
-});

 gulp.task('test.unit.cjs/ci', function(done) {
  runJasmineTests(['dist/js/cjs/{angular2,benchpress}/test/**/*_spec.js'], done);
 });

-gulp.task('check-public-api', ['build.tools'],
-          function(done) { runJasmineTests(['dist/tools/public_api_guard/**/*_spec.js'], done); });

 gulp.task('test.unit.cjs', ['build/clean.js', 'build.tools'], function(neverDone) {
  var watch = require('./tools/build/watch');
@ -939,20 +880,21 @@ gulp.task('test.unit.cjs', ['build/clean.js', 'build.tools'], function(neverDone
 gulp.task('test.unit.dartvm', function(neverDone) {
  var watch = require('./tools/build/watch');

-  runSequence('build/tree.dart', 'build/pure-packages.dart', '!build/pubget.angular2.dart',
-              '!test.unit.dartvm/run', function(error) {
-                // Watch for changes made in the TS and Dart code under "modules" and
-                // run ts2dart and test change detector generator prior to rerunning the
-                // tests.
-                watch('modules/angular2/**', {ignoreInitial: true},
-                      ['!build/tree.dart', '!test.unit.dartvm/run']);
+  runSequence(
+      'build/tree.dart', 'build/pure-packages.dart', '!build/pubget.angular2.dart',
+      '!build/change_detect.dart', '!test.unit.dartvm/run', function(error) {
+        // Watch for changes made in the TS and Dart code under "modules" and
+        // run ts2dart and test change detector generator prior to rerunning the
+        // tests.
+        watch('modules/angular2/**', {ignoreInitial: true},
+              ['!build/tree.dart', '!build/change_detect.dart', '!test.unit.dartvm/run']);

-                // Watch for changes made in Dart code under "modules_dart", then copy it
-                // to dist and run test change detector generator prior to retunning the
-                // tests.
-                watch('modules_dart/**', {ignoreInitial: true},
-                      ['build/pure-packages.dart', '!test.unit.dartvm/run']);
-              });
+        // Watch for changes made in Dart code under "modules_dart", then copy it
+        // to dist and run test change detector generator prior to retunning the
+        // tests.
+        watch('modules_dart/**', {ignoreInitial: true},
+              ['build/pure-packages.dart', '!build/change_detect.dart', '!test.unit.dartvm/run']);
+      });
 });

 gulp.task('!test.unit.dartvm/run',
@ -983,6 +925,24 @@ gulp.task('test.server.dart', runServerDartTests(gulp, gulpPlugins, {dest: 'dist
 gulp.task('test.transpiler.unittest',
          function(done) { runJasmineTests(['tools/transpiler/unittest/**/*.js'], done); });

+// At the moment, dart test requires dartium to be an executable on the path.
+// Make a temporary directory and symlink dartium from there (just for this command)
+// so that it can run.
+var dartiumTmpdir = path.join(os.tmpdir(), 'dartium' + new Date().getTime().toString());
+gulp.task('test.dart.angular2_testing/ci', ['build/pubspec.dart'], function(done) {
+  runSequence('test.dart.angular2_testing_symlink', 'test.dart.angular2_testing',
+              sequenceComplete(done));
+});
+
+gulp.task(
+    'test.dart.angular2_testing_symlink',
+    shell.task(['mkdir ' + dartiumTmpdir, 'ln -s $DARTIUM_BIN ' + dartiumTmpdir + '/dartium']));
+
+gulp.task('test.dart.angular2_testing',
+          shell.task(['PATH=$PATH:' + dartiumTmpdir + ' pub run test -p dartium'],
+                     {'cwd': 'dist/dart/angular2_testing'}));
+
+
 // -----------------
 // Pre-test checks

@ -1008,40 +968,22 @@ gulp.task('static-checks', ['!build.tools'], function(done) {
 // distributed in our npm package, and loaded from node_modules by
 // the typescript compiler.

-// Make sure the typings tests are isolated, by running in a tempdir
+// Make sure the two typings tests are isolated, by running this one in a tempdir
 var tmpdir = path.join(os.tmpdir(), 'test.typings', new Date().getTime().toString());
-gulp.task('!pre.test.typings.layoutNodeModule', function() {
-  return gulp.src(['dist/js/cjs/angular2/**/*', 'node_modules/rxjs/**/*'], {base: 'dist/js/cjs'})
+gulp.task('!pre.test.typings.layoutNodeModule', ['build.js.cjs'], function() {
+  return gulp.src(['dist/js/cjs/angular2/**/*', 'node_modules/rxjs/**'], {base: 'dist/js/cjs'})
      .pipe(gulp.dest(path.join(tmpdir, 'node_modules')));
 });
-
-gulp.task('!pre.test.typings.copyDeps', function() {
-  return gulp.src(
-                 [
-                   'modules/angular2/typings/angular-protractor/*.ts',
-                   'modules/angular2/typings/jasmine/*.ts',
-                   'modules/angular2/typings/selenium-webdriver/*.ts',
-                 ],
-                 {base: 'modules/angular2/typings'})
-      .pipe(gulp.dest(tmpdir));
-});
-
 gulp.task('!pre.test.typings.copyTypingsSpec', function() {
-  return gulp.src(['modules/angular2/examples/**/*.ts']).pipe(gulp.dest(tmpdir));
+  return gulp.src(['typing_spec/*.ts'], {base: 'typing_spec'}).pipe(gulp.dest(path.join(tmpdir)));
 });
-
-gulp.task('!test.typings',
-          [
-            '!pre.test.typings.layoutNodeModule',
-            '!pre.test.typings.copyTypingsSpec',
-            '!pre.test.typings.copyDeps'
-          ],
-          function() {
+gulp.task('test.typings',
+          ['!pre.test.typings.layoutNodeModule', '!pre.test.typings.copyTypingsSpec'], function() {
            var tsc = require('gulp-typescript');

-            return gulp.src([tmpdir + '/**/*.ts', '!' + tmpdir + '/node_modules/**/*'])
+            return gulp.src([tmpdir + '/**'])
                .pipe(tsc({
-                  target: 'ES6',
+                  target: 'ES5',
                  module: 'commonjs',
                  experimentalDecorators: true,
                  noImplicitAny: true,
@ -1050,46 +992,6 @@ gulp.task('!test.typings',
                }));
          });

-gulp.task('test.typings', ['build.js.cjs'],
-          function(done) { runSequence('!test.typings', sequenceComplete(done)); });
-
-gulp.task('!build.compiler_cli', function(done) { runTsc('tools/compiler_cli/src', done); });
-
-gulp.task('!clean.compiler_cli', function(done) {
-  fse.remove(path.join('dist', 'tools', 'compiler_cli', 'test'),
-             fse.remove(path.join('tools', 'compiler_cli', 'test', 'src', '*.ngfactory.ts'),
-                        fse.remove(path.join('tools', 'compiler_cli', 'test', 'src', 'a',
-                                             '*.ngfactory.ts'),
-                                   done)));
-});
-
-gulp.task('!test.compiler_cli.codegen', function(done) {
-  try {
-    require('./dist/tools/compiler_cli/main')
-        .main("tools/compiler_cli/test")
-        .then(done)
-        .catch(function(rej) { done(new Error(rej)); });
-  } catch (err) {
-    done(err);
-  }
-});
-
-gulp.task('!test.compiler_cli.unit',
-          function(done) { runJasmineTests(['dist/tools/compiler_cli/**/*_spec.js'], done) });
-
-// This task overwrites our careful tsickle-lowered Decorators with normal .js emit.
-// So it should only be run after asserting on the .js file content.
-gulp.task('!test.compiler_cli.verify_codegen',
-          function(done) { runTsc('tools/compiler_cli/test', done); });
-
-// End-to-end test for compiler CLI.
-// Calls the compiler using its command-line interface, then compiles the app with the codegen.
-// TODO(alexeagle): wire up the playground tests with offline compilation, similar to dart.
-gulp.task('test.compiler_cli', ['!build.compiler_cli'], function(done) {
-  runSequence('!clean.compiler_cli', '!test.compiler_cli.codegen', '!test.compiler_cli.unit',
-              '!test.compiler_cli.verify_codegen', sequenceComplete(done));
-});
-
 // -----------------
 // orchestrated targets

@ -1109,7 +1011,6 @@ gulp.task('build/pure-packages.dart/standalone', function() {
               'modules_dart/**/*',
               '!modules_dart/**/*.proto',
               '!modules_dart/**/packages{,/**}',
-               '!modules_dart/**/.packages',
               '!modules_dart/payload{,/**}',
               '!modules_dart/transform{,/**}',
             ])
@ -1133,15 +1034,15 @@ gulp.task('build/pure-packages.dart/angular2', function() {

 // Builds all Dart packages, but does not compile them
 gulp.task('build/packages.dart', function(done) {
-  runSequence('lint_protos.dart', 'pubget.dart', 'build/tree.dart', 'build/pure-packages.dart',
+  runSequence('lint_protos.dart', 'build/tree.dart', 'build/pure-packages.dart',
              // Run after 'build/tree.dart' because broccoli clears the dist/dart folder
-              '!build/pubget.angular2.dart', sequenceComplete(done));
+              '!build/pubget.angular2.dart', '!build/change_detect.dart', sequenceComplete(done));
 });

 // Builds and compiles all Dart packages
 gulp.task('build.dart', function(done) {
  runSequence('build/packages.dart', 'build/pubspec.dart', 'build/analyze.dart',
-              'build/check.apidocs.dart', sequenceComplete(done));
+              'build/check.apidocs.dart', 'build.dart.material.css', sequenceComplete(done));
 });


@ -1155,31 +1056,30 @@ gulp.task('!build.tools', function() {
  var sourcemaps = require('gulp-sourcemaps');
  var tsc = require('gulp-typescript');

-  var stream = gulp.src(['tools/**/*.ts', '!tools/compiler_cli/**'])
+  var stream = gulp.src(['tools/**/*.ts'])
                   .pipe(sourcemaps.init())
                   .pipe(tsc({
                     target: 'ES5',
                     module: 'commonjs',
-                     declaration: true,
                     // Don't use the version of typescript that gulp-typescript depends on
                     // see https://github.com/ivogabe/gulp-typescript#typescript-version
                     typescript: require('typescript')
-                   }));
-  stream =
-      merge2([stream.js.pipe(gulp.dest('dist/tools')), stream.dts.pipe(gulp.dest('dist/tools'))])
-          .on('error',
-              function(error) {
-                // nodejs doesn't propagate errors from the src stream into the final
-                // stream so we are
-                // forwarding the error into the final stream
-                stream.emit('error', error);
-              })
-          .pipe(sourcemaps.write('.'))
-          .on('end', function() {
-            var AngularBuilder = require('./dist/tools/broccoli/angular_builder').AngularBuilder;
-            angularBuilder =
-                new AngularBuilder({outputPath: 'dist', dartSDK: DART_SDK, logs: logs});
-          });
+                   }))
+                   .on('error',
+                       function(error) {
+                         // nodejs doesn't propagate errors from the src stream into the final
+                         // stream so we are
+                         // forwarding the error into the final stream
+                         stream.emit('error', error);
+                       })
+                   .pipe(sourcemaps.write('.'))
+                   .pipe(gulp.dest('dist/tools'))
+                   .on('end', function() {
+                     var AngularBuilder =
+                         require('./dist/tools/broccoli/angular_builder').AngularBuilder;
+                     angularBuilder =
+                         new AngularBuilder({outputPath: 'dist', dartSDK: DART_SDK, logs: logs});
+                   });

  return stream;
 });
@ -1201,8 +1101,9 @@ gulp.task('!broccoli.js.prod', () => angularBuilder.rebuildBrowserProdTree({
  useBundles: cliArgs.useBundles
 }));

-gulp.task('build.js.dev', ['build/clean.js'],
-          function(done) { runSequence('broccoli.js.dev', sequenceComplete(done)); });
+gulp.task('build.js.dev', ['build/clean.js'], function(done) {
+  runSequence('broccoli.js.dev', 'build.css.material', sequenceComplete(done));
+});

 gulp.task('build.js.prod', ['build.tools'],
          function(done) { runSequence('!broccoli.js.prod', sequenceComplete(done)); });
@ -1261,8 +1162,6 @@ gulp.task('!bundle.js.prod', ['build.js.prod'], function() {
          bundler.bundle(bundleConfig, HTTP_BUNDLE_CONTENT, './dist/build/http.js', bundlerConfig),
          bundler.bundle(bundleConfig, ROUTER_BUNDLE_CONTENT, './dist/build/router.js',
                         bundlerConfig),
-          bundler.bundle(bundleConfig, ALT_ROUTER_BUNDLE_CONTENT, './dist/build/alt_router.js',
-                         bundlerConfig),
          bundler.bundle(bundleConfig, UPGRADE_BUNDLE_CONTENT, './dist/build/upgrade.js',
                         bundlerConfig)
        ]);
@ -1272,8 +1171,7 @@ gulp.task('!bundle.js.prod', ['build.js.prod'], function() {
 // minified production build
 gulp.task('!bundle.js.min', ['build.js.prod'], function() {
  var bundler = require('./tools/build/bundle');
-  var bundlerConfig =
-      {sourceMaps: true, minify: true, mangle: false, uglify: {compress: {keep_fnames: true}}};
+  var bundlerConfig = {sourceMaps: true, minify: true};

  return bundler.bundle(bundleConfig, NG2_BUNDLE_CONTENT, './dist/build/angular2.min.js',
                        bundlerConfig)
@ -1283,8 +1181,6 @@ gulp.task('!bundle.js.min', ['build.js.prod'], function() {
                         bundlerConfig),
          bundler.bundle(bundleConfig, ROUTER_BUNDLE_CONTENT, './dist/build/router.min.js',
                         bundlerConfig),
-          bundler.bundle(bundleConfig, ALT_ROUTER_BUNDLE_CONTENT, './dist/build/alt_router.min.js',
-                         bundlerConfig),
          bundler.bundle(bundleConfig, UPGRADE_BUNDLE_CONTENT, './dist/build/upgrade.min.js',
                         bundlerConfig)
        ]);
@ -1307,8 +1203,6 @@ gulp.task('!bundle.js.dev', ['build.js.dev'], function() {
                         bundlerConfig),
          bundler.bundle(devBundleConfig, ROUTER_BUNDLE_CONTENT, './dist/build/router.dev.js',
                         bundlerConfig),
-          bundler.bundle(devBundleConfig, ALT_ROUTER_BUNDLE_CONTENT,
-                         './dist/build/alt_router.dev.js', bundlerConfig),
          bundler.bundle(devBundleConfig, UPGRADE_BUNDLE_CONTENT, './dist/build/upgrade.dev.js',
                         bundlerConfig)
        ]);
@ -1429,7 +1323,6 @@ gulp.task('!bundle.js.prod.deps', ['!bundle.js.prod'], function() {
  return merge2(bundler.modify(['dist/build/angular2.js'], 'angular2.js'),
                bundler.modify(['dist/build/http.js'], 'http.js'),
                bundler.modify(['dist/build/router.js'], 'router.js'),
-                bundler.modify(['dist/build/alt_router.js'], 'alt_router.js'),
                bundler.modify(['dist/build/upgrade.js'], 'upgrade.js'))
      .pipe(gulp.dest('dist/js/bundle'));
 });
@ -1441,7 +1334,6 @@ gulp.task('!bundle.js.min.deps', ['!bundle.js.min'], function() {
  return merge2(bundler.modify(['dist/build/angular2.min.js'], 'angular2.min.js'),
                bundler.modify(['dist/build/http.min.js'], 'http.min.js'),
                bundler.modify(['dist/build/router.min.js'], 'router.min.js'),
-                bundler.modify(['dist/build/alt_router.min.js'], 'alt_router.min.js'),
                bundler.modify(['dist/build/upgrade.min.js'], 'upgrade.min.js'))
      .pipe(uglify())
      .pipe(gulp.dest('dist/js/bundle'));
@ -1452,7 +1344,7 @@ gulp.task('!bundle.ng.polyfills', ['clean'],

 var JS_DEV_DEPS = [
  licenseWrap('node_modules/zone.js/LICENSE', true),
-  'node_modules/zone.js/dist/zone.js',
+  'node_modules/zone.js/dist/zone-microtask.js',
  'node_modules/zone.js/dist/long-stack-trace-zone.js',
  licenseWrap('node_modules/reflect-metadata/LICENSE', true),
  'node_modules/reflect-metadata/Reflect.js'
@ -1473,7 +1365,6 @@ gulp.task('!bundle.js.dev.deps', ['!bundle.js.dev'], function() {
  return merge2(bundler.modify(['dist/build/angular2.dev.js'], 'angular2.dev.js'),
                bundler.modify(['dist/build/http.dev.js'], 'http.dev.js'),
                bundler.modify(['dist/build/router.dev.js'], 'router.dev.js'),
-                bundler.modify(['dist/build/alt_router.dev.js'], 'alt_router.dev.js'),
                bundler.modify(['dist/build/upgrade.dev.js'], 'upgrade.dev.js'))
      .pipe(gulp.dest('dist/js/bundle'));
 });
@ -1540,7 +1431,70 @@ gulp.task('gen_protos.dart', function(done) {
      done);
 });

+// change detection codegen
+gulp.task('build.change_detect.dart', function(done) {
+  return runSequence('build/packages.dart', '!build/pubget.angular2.dart',
+                     '!build/change_detect.dart', done);
+});
+
+gulp.task('!build/change_detect.dart', function(done) {
+  var fs = require('fs');
+  var spawn = require('child_process').spawn;
+
+  var changeDetectDir = path.join(CONFIG.dest.dart, 'angular2/test/core/change_detection/');
+  var srcDir = path.join(changeDetectDir, 'generator');
+  var destDir = path.join(changeDetectDir, 'generated');
+
+  var dartStream = fs.createWriteStream(path.join(destDir, 'change_detector_classes.dart'));
+  var genMain = path.join(srcDir, 'gen_change_detectors.dart');
+  var proc = spawn(DART_SDK.VM, [genMain], {stdio: ['ignore', 'pipe', 'inherit']});
+  proc.on('error', function(code) {
+    done(new Error('Failed while generating change detector classes. Please run manually: ' +
+                   DART_SDK.VM + ' ' + dartArgs.join(' ')));
+  });
+  proc.on('close', function() {
+    dartStream.close();
+    done();
+  });
+  proc.stdout.pipe(dartStream);
+});
+
 // ------------
+// angular material testing rules
+gulp.task('build.css.material', function() {
+  var autoprefixer = require('gulp-autoprefixer');
+  var sass = require('gulp-sass');
+
+  return gulp.src('modules/*/src/**/*.scss')
+      .pipe(sass())
+      .pipe(autoprefixer())
+      .pipe(gulp.dest(CONFIG.dest.js.prod.es5))
+      .pipe(gulp.dest(CONFIG.dest.js.dev.es5))
+      .pipe(gulp.dest(CONFIG.dest.js.dart2js + '/examples/packages'));
+});
+
+
+gulp.task('build.js.material', function(done) {
+  runSequence('build.js.dev', 'build.css.material', sequenceComplete(done));
+});
+
+gulp.task('build.dart2js.material', function(done) {
+  runSequence('build.dart', 'build.css.material', sequenceComplete(done));
+});
+
+gulp.task('build.dart.material.css', function() {
+  var autoprefixer = require('gulp-autoprefixer');
+  var sass = require('gulp-sass');
+
+  return gulp.src('dist/dart/angular2_material/src/**/*.scss')
+      .pipe(sass())
+      .pipe(autoprefixer())
+      .pipe(gulp.dest('dist/dart/angular2_material/lib/src'));
+});
+
+gulp.task('build.dart.material', ['build/packages.dart'], function(done) {
+  runSequence('build/packages.dart', 'build.dart.material.css', sequenceComplete(done));
+});

 gulp.task('cleanup.builder', function() { return angularBuilder.cleanup(); });

@ -1579,16 +1533,13 @@ process.on('beforeExit', function() {


 var firstTask = true;
-
-
-
 gulp.on('task_start', (e) => {
  if (firstTask) {
    firstTask = false;
    analytics.buildSuccess('gulp <startup>', process.uptime() * 1000);
  }

-  analytics.buildStart('gulp ' + e.task);
+  analytics.buildStart('gulp ' + e.task)
 });
-gulp.on('task_stop', (e) => { analytics.buildSuccess('gulp ' + e.task, e.duration * 1000); });
-gulp.on('task_err', (e) => { analytics.buildError('gulp ' + e.task, e.duration * 1000); });
+gulp.on('task_stop', (e) => {analytics.buildSuccess('gulp ' + e.task, e.duration * 1000)});
+gulp.on('task_err', (e) => {analytics.buildError('gulp ' + e.task, e.duration * 1000)});
--- 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 browserProvidersConf = require('./browser-providers.conf.js');
+
+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: browserProvidersConf.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
@ -11,37 +11,28 @@ 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/all/angular2/**/*.js', included: false, watched: true},
+      {pattern: 'dist/js/dev/es5/**', included: false, watched: false},

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

-      'node_modules/zone.js/dist/zone.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',
-      'node_modules/zone.js/dist/async-test.js',
-      'node_modules/zone.js/dist/fake-async-test.js',

      // Including systemjs because it defines `__eval`, which produces correct stack traces.
-      'shims_for_IE.js',
+      'modules/angular2/src/testing/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-dynamic/test/browser/static_assets/**', included: false, watched: false}
+      {pattern: 'modules/**/test/**/static_assets/**', included: false, watched: false}
    ],

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

    customLaunchers: browserProvidersConf.customLaunchers,

@ -62,7 +53,6 @@ module.exports = function(config) {
    reporters: ['internal-angular'],
    sauceLabs: {
      testName: 'Angular2',
-      retryLimit: 3,
      startConnect: false,
      recordVideo: false,
      recordScreenshots: false,
@ -77,23 +67,19 @@ module.exports = function(config) {
    browserStack: {
      project: 'Angular2',
      startTunnel: false,
-      retryLimit: 3,
+      retryLimit: 1,
      timeout: 600,
      pollingTimeout: 10000
    },

    browsers: ['Chrome'],

-    port: 9876,
-    captureTimeout: 60000,
-    browserDisconnectTimeout : 60000,
-    browserDisconnectTolerance : 3,
-    browserNoActivityTimeout : 60000,
+    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')) {
+    if (process.env.MODE.startsWith('saucelabs')) {
      config.sauceLabs.build = buildId;
      config.sauceLabs.tunnelIdentifier = process.env.TRAVIS_JOB_NUMBER;

@ -103,7 +89,7 @@ module.exports = function(config) {
      config.transports = ['polling'];
    }

-    if (process.env.CI_MODE.startsWith('browserstack')) {
+    if (process.env.MODE.startsWith('browserstack')) {
      config.browserStack.build = buildId;
      config.browserStack.tunnelIdentifier = process.env.TRAVIS_JOB_NUMBER;
    }
--- a/modules/@angular/common/common.dart
+++ b/modules/@angular/common/common.dart
@ -1 +0,0 @@
-export 'index.dart';
--- a/modules/@angular/common/index.ts
+++ b/modules/@angular/common/index.ts
@ -1,5 +0,0 @@
-export * from './src/pipes';
-export * from './src/directives';
-export * from './src/forms';
-export * from './src/common_directives';
-export * from './src/location';
--- a/modules/@angular/common/package.json
+++ b/modules/@angular/common/package.json
@ -1,13 +0,0 @@
-{
-  "name": "@angular/common",
-  "version": "$$ANGULAR_VERSION$$",
-  "description": "",
-  "main": "index.js",
-  "jsnext:main": "esm/index.js",
-  "typings": "index.d.ts",
-  "author": "angular",
-  "license": "MIT",
-  "peerDependencies": {
-    "@angular/core": "$$ANGULAR_VERSION$$"
-  }
-}
--- a/modules/@angular/common/rollup.config.js
+++ b/modules/@angular/common/rollup.config.js
@ -1,18 +0,0 @@
-
-export default {
-  entry: '../../../dist/packages-dist/common/esm/index.js',
-  dest: '../../../dist/packages-dist/common/esm/common.umd.js',
-  sourceMap: true,
-  format: 'umd',
-  moduleName: 'ng.common',
-  globals: {
-    '@angular/core': 'ng.core',
-    'rxjs/Subject': 'Rx',
-    'rxjs/observable/PromiseObservable': 'Rx', // this is wrong, but this stuff has changed in rxjs b.6 so we need to fix it when we update.
-    'rxjs/operator/toPromise': 'Rx.Observable.prototype',
-    'rxjs/Observable': 'Rx'
-  },
-  plugins: [
-//    nodeResolve({ jsnext: true, main: true }),
-  ]
-}
--- a/modules/@angular/common/src/directives/ng_plural.ts
+++ b/modules/@angular/common/src/directives/ng_plural.ts
@ -1,148 +0,0 @@
-import {
-  Directive,
-  ViewContainerRef,
-  TemplateRef,
-  ContentChildren,
-  QueryList,
-  Attribute,
-  AfterContentInit,
-  Input
-} from '@angular/core';
-import {isPresent, NumberWrapper} from '../../src/facade/lang';
-import {Map} from '../../src/facade/collection';
-
-import {SwitchView} from './ng_switch';
-
-const _CATEGORY_DEFAULT = 'other';
-
-export abstract class NgLocalization { abstract getPluralCategory(value: any): string; }
-
-/**
- * `ngPlural` is an i18n directive that displays DOM sub-trees that match the switch expression
- * value, or failing that, DOM sub-trees that match the switch expression's pluralization category.
- *
- * To use this directive, you must provide an extension of `NgLocalization` that maps values to
- * category names. You then define a container element that sets the `[ngPlural]` attribute to a
- * switch expression.
- *    - Inner elements defined with an `[ngPluralCase]` attribute will display based on their
- * expression.
- *    - If `[ngPluralCase]` is set to a value starting with `=`, it will only display if the value
- * matches the switch expression exactly.
- *    - Otherwise, the view will be treated as a "category match", and will only display if exact
- * value matches aren't found and the value maps to its category using the `getPluralCategory`
- * function provided.
- *
- * If no matching views are found for a switch expression, inner elements marked
- * `[ngPluralCase]="other"` will be displayed.
- *
- * ```typescript
- * class MyLocalization extends NgLocalization {
- *    getPluralCategory(value: any) {
- *       if(value < 5) {
- *          return 'few';
- *       }
- *    }
- * }
- *
- * @Component({
- *    selector: 'app',
- *    providers: [provide(NgLocalization, {useClass: MyLocalization})]
- * })
- * @View({
- *   template: `
- *     <p>Value = {{value}}</p>
- *     <button (click)="inc()">Increment</button>
- *
- *     <div [ngPlural]="value">
- *       <template ngPluralCase="=0">there is nothing</template>
- *       <template ngPluralCase="=1">there is one</template>
- *       <template ngPluralCase="few">there are a few</template>
- *       <template ngPluralCase="other">there is some number</template>
- *     </div>
- *   `,
- *   directives: [NgPlural, NgPluralCase]
- * })
- * export class App {
- *   value = 'init';
- *
- *   inc() {
- *     this.value = this.value === 'init' ? 0 : this.value + 1;
- *   }
- * }
- *
- * ```
- */
-
-@Directive({selector: '[ngPluralCase]'})
-export class NgPluralCase {
-  /** @internal */
-  _view: SwitchView;
-  constructor(@Attribute('ngPluralCase') public value: string, template: TemplateRef<Object>,
-              viewContainer: ViewContainerRef) {
-    this._view = new SwitchView(viewContainer, template);
-  }
-}
-
-
-@Directive({selector: '[ngPlural]'})
-export class NgPlural implements AfterContentInit {
-  private _switchValue: number;
-  private _activeView: SwitchView;
-  private _caseViews = new Map<any, SwitchView>();
-  @ContentChildren(NgPluralCase) cases: QueryList<NgPluralCase> = null;
-
-  constructor(private _localization: NgLocalization) {}
-
-  @Input()
-  set ngPlural(value: number) {
-    this._switchValue = value;
-    this._updateView();
-  }
-
-  ngAfterContentInit() {
-    this.cases.forEach((pluralCase: NgPluralCase): void => {
-      this._caseViews.set(this._formatValue(pluralCase), pluralCase._view);
-    });
-    this._updateView();
-  }
-
-  /** @internal */
-  _updateView(): void {
-    this._clearViews();
-
-    var view: SwitchView = this._caseViews.get(this._switchValue);
-    if (!isPresent(view)) view = this._getCategoryView(this._switchValue);
-
-    this._activateView(view);
-  }
-
-  /** @internal */
-  _clearViews() {
-    if (isPresent(this._activeView)) this._activeView.destroy();
-  }
-
-  /** @internal */
-  _activateView(view: SwitchView) {
-    if (!isPresent(view)) return;
-    this._activeView = view;
-    this._activeView.create();
-  }
-
-  /** @internal */
-  _getCategoryView(value: number): SwitchView {
-    var category: string = this._localization.getPluralCategory(value);
-    var categoryView: SwitchView = this._caseViews.get(category);
-    return isPresent(categoryView) ? categoryView : this._caseViews.get(_CATEGORY_DEFAULT);
-  }
-
-  /** @internal */
-  _isValueView(pluralCase: NgPluralCase): boolean { return pluralCase.value[0] === "="; }
-
-  /** @internal */
-  _formatValue(pluralCase: NgPluralCase): any {
-    return this._isValueView(pluralCase) ? this._stripValue(pluralCase.value) : pluralCase.value;
-  }
-
-  /** @internal */
-  _stripValue(value: string): number { return NumberWrapper.parseInt(value.substring(1), 10); }
-}
--- a/modules/@angular/common/src/directives/ng_template_outlet.ts
+++ b/modules/@angular/common/src/directives/ng_template_outlet.ts
@ -1,26 +0,0 @@
-import {Directive, Input, ViewContainerRef, ViewRef, TemplateRef} from '@angular/core';
-import {isPresent} from '../../src/facade/lang';
-
-/**
- * Creates and inserts an embedded view based on a prepared `TemplateRef`.
- *
- * ### Syntax
- * - `<template [ngTemplateOutlet]="templateRefExpression"></template>`
- */
-@Directive({selector: '[ngTemplateOutlet]'})
-export class NgTemplateOutlet {
-  private _insertedViewRef: ViewRef;
-
-  constructor(private _viewContainerRef: ViewContainerRef) {}
-
-  @Input()
-  set ngTemplateOutlet(templateRef: TemplateRef<Object>) {
-    if (isPresent(this._insertedViewRef)) {
-      this._viewContainerRef.remove(this._viewContainerRef.indexOf(this._insertedViewRef));
-    }
-
-    if (isPresent(templateRef)) {
-      this._insertedViewRef = this._viewContainerRef.createEmbeddedView(templateRef);
-    }
-  }
-}
--- a/modules/@angular/common/src/facade
+++ b/modules/@angular/common/src/facade
@ -1 +0,0 @@
-../../facade/src
--- a/modules/@angular/common/src/forms/directives/normalize_validator.ts
+++ b/modules/@angular/common/src/forms/directives/normalize_validator.ts
@ -1,18 +0,0 @@
-import {AbstractControl} from '../model';
-import {Validator, ValidatorFn, AsyncValidatorFn} from './validators';
-
-export function normalizeValidator(validator: ValidatorFn | Validator): ValidatorFn {
-  if ((<Validator>validator).validate !== undefined) {
-    return (c: AbstractControl) => (<Validator>validator).validate(c);
-  } else {
-    return <ValidatorFn>validator;
-  }
-}
-
-export function normalizeAsyncValidator(validator: AsyncValidatorFn | Validator): AsyncValidatorFn {
-  if ((<Validator>validator).validate !== undefined) {
-    return (c: AbstractControl) => Promise.resolve((<Validator>validator).validate(c));
-  } else {
-    return <AsyncValidatorFn>validator;
-  }
-}
--- a/modules/@angular/common/src/forms/directives/radio_control_value_accessor.ts
+++ b/modules/@angular/common/src/forms/directives/radio_control_value_accessor.ts
@ -1,126 +0,0 @@
-import {
-  Directive,
-  ElementRef,
-  Renderer,
-  forwardRef,
-  Provider,
-  Input,
-  OnInit,
-  OnDestroy,
-  Injector,
-  Injectable
-} from '@angular/core';
-import {isPresent} from '../../../src/facade/lang';
-import {ListWrapper} from '../../../src/facade/collection';
-import {NG_VALUE_ACCESSOR, ControlValueAccessor} from './control_value_accessor';
-import {NgControl} from './ng_control';
-
-export const RADIO_VALUE_ACCESSOR: any = /*@ts2dart_const*/ /*@ts2dart_Provider*/ {
-  provide: NG_VALUE_ACCESSOR,
-  useExisting: forwardRef(() => RadioControlValueAccessor),
-  multi: true
-};
-
-/**
- * Internal class used by Angular to uncheck radio buttons with the matching name.
- */
-@Injectable()
-export class RadioControlRegistry {
-  private _accessors: any[] = [];
-
-  add(control: NgControl, accessor: RadioControlValueAccessor) {
-    this._accessors.push([control, accessor]);
-  }
-
-  remove(accessor: RadioControlValueAccessor) {
-    var indexToRemove = -1;
-    for (var i = 0; i < this._accessors.length; ++i) {
-      if (this._accessors[i][1] === accessor) {
-        indexToRemove = i;
-      }
-    }
-    ListWrapper.removeAt(this._accessors, indexToRemove);
-  }
-
-  select(accessor: RadioControlValueAccessor) {
-    this._accessors.forEach((c) => {
-      if (c[0].control.root === accessor._control.control.root && c[1] !== accessor) {
-        c[1].fireUncheck();
-      }
-    });
-  }
-}
-
-/**
- * The value provided by the forms API for radio buttons.
- */
-export class RadioButtonState {
-  constructor(public checked: boolean, public value: string) {}
-}
-
-
-/**
- * The accessor for writing a radio control value and listening to changes that is used by the
- * {@link NgModel}, {@link NgFormControl}, and {@link NgControlName} directives.
- *
- *  ### Example
- *  ```
- *  @Component({
- *    template: `
- *      <input type="radio" name="food" [(ngModel)]="foodChicken">
- *      <input type="radio" name="food" [(ngModel)]="foodFish">
- *    `
- *  })
- *  class FoodCmp {
- *    foodChicken = new RadioButtonState(true, "chicken");
- *    foodFish = new RadioButtonState(false, "fish");
- *  }
- *  ```
- */
-@Directive({
-  selector:
-      'input[type=radio][ngControl],input[type=radio][ngFormControl],input[type=radio][ngModel]',
-  host: {'(change)': 'onChange()', '(blur)': 'onTouched()'},
-  providers: [RADIO_VALUE_ACCESSOR]
-})
-export class RadioControlValueAccessor implements ControlValueAccessor,
-    OnDestroy, OnInit {
-  /** @internal */
-  _state: RadioButtonState;
-  /** @internal */
-  _control: NgControl;
-  @Input() name: string;
-  /** @internal */
-  _fn: Function;
-  onChange = () => {};
-  onTouched = () => {};
-
-  constructor(private _renderer: Renderer, private _elementRef: ElementRef,
-              private _registry: RadioControlRegistry, private _injector: Injector) {}
-
-  ngOnInit(): void {
-    this._control = this._injector.get(NgControl);
-    this._registry.add(this._control, this);
-  }
-
-  ngOnDestroy(): void { this._registry.remove(this); }
-
-  writeValue(value: any): void {
-    this._state = value;
-    if (isPresent(value) && value.checked) {
-      this._renderer.setElementProperty(this._elementRef.nativeElement, 'checked', true);
-    }
-  }
-
-  registerOnChange(fn: (_: any) => {}): void {
-    this._fn = fn;
-    this.onChange = () => {
-      fn(new RadioButtonState(true, this._state.value));
-      this._registry.select(this);
-    };
-  }
-
-  fireUncheck(): void { this._fn(new RadioButtonState(false, this._state.value)); }
-
-  registerOnTouched(fn: () => {}): void { this.onTouched = fn; }
-}
--- a/modules/@angular/common/src/forms/directives/select_control_value_accessor.ts
+++ b/modules/@angular/common/src/forms/directives/select_control_value_accessor.ts
@ -1,139 +0,0 @@
-import {
-  Directive,
-  Renderer,
-  forwardRef,
-  Provider,
-  ElementRef,
-  Input,
-  Host,
-  OnDestroy,
-  Optional
-} from '@angular/core';
-import {
-  StringWrapper,
-  isPrimitive,
-  isPresent,
-  isBlank,
-  looseIdentical
-} from '../../../src/facade/lang';
-import {MapWrapper} from '../../../src/facade/collection';
-
-import {NG_VALUE_ACCESSOR, ControlValueAccessor} from './control_value_accessor';
-
-export const SELECT_VALUE_ACCESSOR: any = /*@ts2dart_const*/ /*@ts2dart_Provider*/ {
-  provide: NG_VALUE_ACCESSOR,
-  useExisting: forwardRef(() => SelectControlValueAccessor),
-  multi: true
-};
-
-function _buildValueString(id: string, value: any): string {
-  if (isBlank(id)) return `${value}`;
-  if (!isPrimitive(value)) value = "Object";
-  return StringWrapper.slice(`${id}: ${value}`, 0, 50);
-}
-
-function _extractId(valueString: string): string {
-  return valueString.split(":")[0];
-}
-
-/**
- * The accessor for writing a value and listening to changes on a select element.
- *
- * Note: We have to listen to the 'change' event because 'input' events aren't fired
- * for selects in Firefox and IE:
- * https://bugzilla.mozilla.org/show_bug.cgi?id=1024350
- * https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/4660045/
- *
- */
-@Directive({
-  selector: 'select[ngControl],select[ngFormControl],select[ngModel]',
-  host: {'(change)': 'onChange($event.target.value)', '(blur)': 'onTouched()'},
-  providers: [SELECT_VALUE_ACCESSOR]
-})
-export class SelectControlValueAccessor implements ControlValueAccessor {
-  value: any;
-  /** @internal */
-  _optionMap: Map<string, any> = new Map<string, any>();
-  /** @internal */
-  _idCounter: number = 0;
-
-  onChange = (_: any) => {};
-  onTouched = () => {};
-
-  constructor(private _renderer: Renderer, private _elementRef: ElementRef) {}
-
-  writeValue(value: any): void {
-    this.value = value;
-    var valueString = _buildValueString(this._getOptionId(value), value);
-    this._renderer.setElementProperty(this._elementRef.nativeElement, 'value', valueString);
-  }
-
-  registerOnChange(fn: (value: any) => any): void {
-    this.onChange = (valueString: string) => { fn(this._getOptionValue(valueString)); };
-  }
-  registerOnTouched(fn: () => any): void { this.onTouched = fn; }
-
-  /** @internal */
-  _registerOption(): string { return (this._idCounter++).toString(); }
-
-  /** @internal */
-  _getOptionId(value: any): string {
-    for (let id of MapWrapper.keys(this._optionMap)) {
-      if (looseIdentical(this._optionMap.get(id), value)) return id;
-    }
-    return null;
-  }
-
-  /** @internal */
-  _getOptionValue(valueString: string): any {
-    let value = this._optionMap.get(_extractId(valueString));
-    return isPresent(value) ? value : valueString;
-  }
-}
-
-/**
- * Marks `<option>` as dynamic, so Angular can be notified when options change.
- *
- * ### Example
- *
- * ```
- * <select ngControl="city">
- *   <option *ngFor="let c of cities" [value]="c"></option>
- * </select>
- * ```
- */
-@Directive({selector: 'option'})
-export class NgSelectOption implements OnDestroy {
-  id: string;
-
-  constructor(private _element: ElementRef, private _renderer: Renderer,
-              @Optional() @Host() private _select: SelectControlValueAccessor) {
-    if (isPresent(this._select)) this.id = this._select._registerOption();
-  }
-
-  @Input('ngValue')
-  set ngValue(value: any) {
-    if (this._select == null) return;
-    this._select._optionMap.set(this.id, value);
-    this._setElementValue(_buildValueString(this.id, value));
-    this._select.writeValue(this._select.value);
-  }
-
-  @Input('value')
-  set value(value: any) {
-    this._setElementValue(value);
-    if (isPresent(this._select)) this._select.writeValue(this._select.value);
-  }
-
-  /** @internal */
-  _setElementValue(value: string): void {
-    this._renderer.setElementProperty(this._element.nativeElement, 'value', value);
-  }
-
-  ngOnDestroy() {
-    if (isPresent(this._select)) {
-      this._select._optionMap.delete(this.id);
-      this._select.writeValue(this._select.value);
-    }
-  }
-}
--- a/modules/@angular/common/src/location.ts
+++ b/modules/@angular/common/src/location.ts
@ -1,5 +0,0 @@
-export * from './location/platform_location';
-export * from './location/location_strategy';
-export * from './location/hash_location_strategy';
-export * from './location/path_location_strategy';
-export * from './location/location';
--- a/modules/@angular/common/src/location/platform_location.ts
+++ b/modules/@angular/common/src/location/platform_location.ts
@ -1,48 +0,0 @@
-/**
- * This class should not be used directly by an application developer. Instead, use
- * {@link Location}.
- *
- * `PlatformLocation` encapsulates all calls to DOM apis, which allows the Router to be platform
- * agnostic.
- * This means that we can have different implementation of `PlatformLocation` for the different
- * platforms
- * that angular supports. For example, the default `PlatformLocation` is {@link
- * BrowserPlatformLocation},
- * however when you run your app in a WebWorker you use {@link WebWorkerPlatformLocation}.
- *
- * The `PlatformLocation` class is used directly by all implementations of {@link LocationStrategy}
- * when
- * they need to interact with the DOM apis like pushState, popState, etc...
- *
- * {@link LocationStrategy} in turn is used by the {@link Location} service which is used directly
- * by
- * the {@link Router} in order to navigate between routes. Since all interactions between {@link
- * Router} /
- * {@link Location} / {@link LocationStrategy} and DOM apis flow through the `PlatformLocation`
- * class
- * they are all platform independent.
- */
-export abstract class PlatformLocation {
-  abstract getBaseHrefFromDOM(): string;
-  abstract onPopState(fn: UrlChangeListener): void;
-  abstract onHashChange(fn: UrlChangeListener): void;
-
-  /* abstract */ get pathname(): string { return null; }
-  /* abstract */ get search(): string { return null; }
-  /* abstract */ get hash(): string { return null; }
-
-  abstract replaceState(state: any, title: string, url: string): void;
-
-  abstract pushState(state: any, title: string, url: string): void;
-
-  abstract forward(): void;
-
-  abstract back(): void;
-}
-
-/**
- * A serializable version of the event from onPopState or onHashChange
- */
-export interface UrlChangeEvent { type: string; }
-
-export interface UrlChangeListener { (e: UrlChangeEvent): any; }
--- a/modules/@angular/common/src/pipes.ts
+++ b/modules/@angular/common/src/pipes.ts
@ -1,17 +0,0 @@
-/**
- * @module
- * @description
- * This module provides a set of common Pipes.
- */
-
-export {AsyncPipe} from './pipes/async_pipe';
-export {DatePipe} from './pipes/date_pipe';
-export {JsonPipe} from './pipes/json_pipe';
-export {SlicePipe} from './pipes/slice_pipe';
-export {LowerCasePipe} from './pipes/lowercase_pipe';
-export {NumberPipe, DecimalPipe, PercentPipe, CurrencyPipe} from './pipes/number_pipe';
-export {UpperCasePipe} from './pipes/uppercase_pipe';
-export {ReplacePipe} from './pipes/replace_pipe';
-export {I18nPluralPipe} from './pipes/i18n_plural_pipe';
-export {I18nSelectPipe} from './pipes/i18n_select_pipe';
-export {COMMON_PIPES} from './pipes/common_pipes';
--- a/modules/@angular/common/src/pipes/i18n_plural_pipe.ts
+++ b/modules/@angular/common/src/pipes/i18n_plural_pipe.ts
@ -1,54 +0,0 @@
-import {Injectable, PipeTransform, Pipe} from '@angular/core';
-import {isStringMap, StringWrapper, isPresent, RegExpWrapper} from '../../src/facade/lang';
-import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
-
-var interpolationExp: RegExp = RegExpWrapper.create('#');
-
-/**
- *
- *  Maps a value to a string that pluralizes the value properly.
- *
- *  ## Usage
- *
- *  expression | i18nPlural:mapping
- *
- *  where `expression` is a number and `mapping` is an object that indicates the proper text for
- *  when the `expression` evaluates to 0, 1, or some other number.  You can interpolate the actual
- *  value into the text using the `#` sign.
- *
- *  ## Example
- *
- *  ```
- *  <div>
- *    {{ messages.length | i18nPlural: messageMapping }}
- *  </div>
- *
- *  class MyApp {
- *    messages: any[];
- *    messageMapping: any = {
- *      '=0': 'No messages.',
- *      '=1': 'One message.',
- *      'other': '# messages.'
- *    }
- *    ...
- *  }
- *  ```
- *
- */
-@Pipe({name: 'i18nPlural', pure: true})
-@Injectable()
-export class I18nPluralPipe implements PipeTransform {
-  transform(value: number, pluralMap: {[count: string]: string}): string {
-    var key: string;
-    var valueStr: string;
-
-    if (!isStringMap(pluralMap)) {
-      throw new InvalidPipeArgumentException(I18nPluralPipe, pluralMap);
-    }
-
-    key = value === 0 || value === 1 ? `=${value}` : 'other';
-    valueStr = isPresent(value) ? value.toString() : '';
-
-    return StringWrapper.replaceAll(pluralMap[key], interpolationExp, valueStr);
-  }
-}
--- a/modules/@angular/common/src/pipes/i18n_select_pipe.ts
+++ b/modules/@angular/common/src/pipes/i18n_select_pipe.ts
@ -1,45 +0,0 @@
-import {Injectable, PipeTransform, Pipe} from '@angular/core';
-import {isStringMap} from '../../src/facade/lang';
-import {StringMapWrapper} from '../../src/facade/collection';
-import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
-
-/**
- *
- *  Generic selector that displays the string that matches the current value.
- *
- *  ## Usage
- *
- *  expression | i18nSelect:mapping
- *
- *  where `mapping` is an object that indicates the text that should be displayed
- *  for different values of the provided `expression`.
- *
- *  ## Example
- *
- *  ```
- *  <div>
- *    {{ gender | i18nSelect: inviteMap }}
- *  </div>
- *
- *  class MyApp {
- *    gender: string = 'male';
- *    inviteMap: any = {
- *      'male': 'Invite her.',
- *      'female': 'Invite him.',
- *      'other': 'Invite them.'
- *    }
- *    ...
- *  }
- *  ```
- */
-@Pipe({name: 'i18nSelect', pure: true})
-@Injectable()
-export class I18nSelectPipe implements PipeTransform {
-  transform(value: string, mapping: {[key: string]: string}): string {
-    if (!isStringMap(mapping)) {
-      throw new InvalidPipeArgumentException(I18nSelectPipe, mapping);
-    }
-
-    return StringMapWrapper.contains(mapping, value) ? mapping[value] : mapping['other'];
-  }
-}
--- a/modules/@angular/common/src/pipes/replace_pipe.ts
+++ b/modules/@angular/common/src/pipes/replace_pipe.ts
@ -1,85 +0,0 @@
-import {Injectable, PipeTransform, Pipe} from '@angular/core';
-
-import {
-  isBlank,
-  isString,
-  isNumber,
-  isFunction,
-  RegExpWrapper,
-  StringWrapper
-} from '../../src/facade/lang';
-
-import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
-
-/**
- * Creates a new String with some or all of the matches of a pattern replaced by
- * a replacement.
- *
- * The pattern to be matched is specified by the 'pattern' parameter.
- *
- * The replacement to be set is specified by the 'replacement' parameter.
- *
- * An optional 'flags' parameter can be set.
- *
- * ### Usage
- *
- *     expression | replace:pattern:replacement
- *
- * All behavior is based on the expected behavior of the JavaScript API
- * String.prototype.replace() function.
- *
- * Where the input expression is a [String] or [Number] (to be treated as a string),
- * the `pattern` is a [String] or [RegExp],
- * the 'replacement' is a [String] or [Function].
- *
- * --Note--: The 'pattern' parameter will be converted to a RegExp instance. Make sure to escape the
- * string properly if you are matching for regular expression special characters like parenthesis,
- * brackets etc.
- */
-
-@Pipe({name: 'replace'})
-@Injectable()
-export class ReplacePipe implements PipeTransform {
-  transform(value: any, pattern: string | RegExp, replacement: Function | string): any {
-    if (isBlank(value)) {
-      return value;
-    }
-
-    if (!this._supportedInput(value)) {
-      throw new InvalidPipeArgumentException(ReplacePipe, value);
-    }
-
-    var input = value.toString();
-
-    if (!this._supportedPattern(pattern)) {
-      throw new InvalidPipeArgumentException(ReplacePipe, pattern);
-    }
-    if (!this._supportedReplacement(replacement)) {
-      throw new InvalidPipeArgumentException(ReplacePipe, replacement);
-    }
-    // template fails with literal RegExp e.g /pattern/igm
-    // var rgx = pattern instanceof RegExp ? pattern : RegExpWrapper.create(pattern);
-
-    if (isFunction(replacement)) {
-      var rgxPattern = isString(pattern) ? RegExpWrapper.create(<string>pattern) : <RegExp>pattern;
-
-      return StringWrapper.replaceAllMapped(input, rgxPattern, <Function>replacement);
-    }
-    if (pattern instanceof RegExp) {
-      // use the replaceAll variant
-      return StringWrapper.replaceAll(input, pattern, <string>replacement);
-    }
-
-    return StringWrapper.replace(input, <string>pattern, <string>replacement);
-  }
-
-  private _supportedInput(input: any): boolean { return isString(input) || isNumber(input); }
-
-  private _supportedPattern(pattern: any): boolean {
-    return isString(pattern) || pattern instanceof RegExp;
-  }
-
-  private _supportedReplacement(replacement: any): boolean {
-    return isString(replacement) || isFunction(replacement);
-  }
-}
--- a/modules/@angular/common/test/directives/ng_plural_spec.ts
+++ b/modules/@angular/common/test/directives/ng_plural_spec.ts
@ -1,135 +0,0 @@
-import {
-  beforeEachProviders,
-  beforeEach,
-  ddescribe,
-  describe,
-  expect,
-  iit,
-  inject,
-  it,
-  xit,
-} from '@angular/core/testing/testing_internal';
-import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
-import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
-
-import {Component, Injectable, provide} from '@angular/core';
-import {NgPlural, NgPluralCase, NgLocalization} from '@angular/common';
-
-export function main() {
-  describe('switch', () => {
-    beforeEachProviders(() => [provide(NgLocalization, {useClass: TestLocalizationMap})]);
-
-    it('should display the template according to the exact value',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         var template = '<div>' +
-                        '<ul [ngPlural]="switchValue">' +
-                        '<template ngPluralCase="=0"><li>you have no messages.</li></template>' +
-                        '<template ngPluralCase="=1"><li>you have one message.</li></template>' +
-                        '</ul></div>';
-
-         tcb.overrideTemplate(TestComponent, template)
-             .createAsync(TestComponent)
-             .then((fixture) => {
-               fixture.debugElement.componentInstance.switchValue = 0;
-               fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement).toHaveText('you have no messages.');
-
-               fixture.debugElement.componentInstance.switchValue = 1;
-               fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement).toHaveText('you have one message.');
-
-               async.done();
-             });
-       }));
-
-    it('should display the template according to the category',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         var template =
-             '<div>' +
-             '<ul [ngPlural]="switchValue">' +
-             '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
-             '<template ngPluralCase="many"><li>you have many messages.</li></template>' +
-             '</ul></div>';
-
-         tcb.overrideTemplate(TestComponent, template)
-             .createAsync(TestComponent)
-             .then((fixture) => {
-               fixture.debugElement.componentInstance.switchValue = 2;
-               fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement).toHaveText('you have a few messages.');
-
-               fixture.debugElement.componentInstance.switchValue = 8;
-               fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement).toHaveText('you have many messages.');
-
-               async.done();
-             });
-       }));
-
-    it('should default to other when no matches are found',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         var template =
-             '<div>' +
-             '<ul [ngPlural]="switchValue">' +
-             '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
-             '<template ngPluralCase="other"><li>default message.</li></template>' +
-             '</ul></div>';
-
-         tcb.overrideTemplate(TestComponent, template)
-             .createAsync(TestComponent)
-             .then((fixture) => {
-               fixture.debugElement.componentInstance.switchValue = 100;
-               fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement).toHaveText('default message.');
-
-               async.done();
-             });
-       }));
-
-    it('should prioritize value matches over category matches',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         var template =
-             '<div>' +
-             '<ul [ngPlural]="switchValue">' +
-             '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
-             '<template ngPluralCase="=2">you have two messages.</template>' +
-             '</ul></div>';
-
-         tcb.overrideTemplate(TestComponent, template)
-             .createAsync(TestComponent)
-             .then((fixture) => {
-               fixture.debugElement.componentInstance.switchValue = 2;
-               fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement).toHaveText('you have two messages.');
-
-               fixture.debugElement.componentInstance.switchValue = 3;
-               fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement).toHaveText('you have a few messages.');
-
-               async.done();
-             });
-       }));
-  });
-}
-
-
-@Injectable()
-export class TestLocalizationMap extends NgLocalization {
-  getPluralCategory(value: number): string {
-    if (value > 1 && value < 4) {
-      return 'few';
-    } else if (value >= 4 && value < 10) {
-      return 'many';
-    } else {
-      return 'other';
-    }
-  }
-}
-
-
-@Component({selector: 'test-cmp', directives: [NgPlural, NgPluralCase], template: ''})
-class TestComponent {
-  switchValue: number;
-
-  constructor() { this.switchValue = null; }
-}
--- a/modules/@angular/common/test/directives/ng_template_outlet_spec.ts
+++ b/modules/@angular/common/test/directives/ng_template_outlet_spec.ts
@ -1,110 +0,0 @@
-import {
-  beforeEach,
-  ddescribe,
-  describe,
-  expect,
-  iit,
-  inject,
-  it,
-  xit,
-} from '@angular/core/testing/testing_internal';
-import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
-import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
-import {Component, Directive, TemplateRef, ContentChildren, QueryList} from '@angular/core';
-import {NgTemplateOutlet} from '@angular/common';
-
-export function main() {
-  describe('insert', () => {
-    it('should do nothing if templateRef is null',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         var template = `<template [ngTemplateOutlet]="null"></template>`;
-         tcb.overrideTemplate(TestComponent, template)
-             .createAsync(TestComponent)
-             .then((fixture) => {
-
-               fixture.detectChanges();
-               expect(fixture.nativeElement).toHaveText('');
-
-               async.done();
-             });
-       }));
-
-    it('should insert content specified by TemplateRef',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         var template =
-             `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
-         tcb.overrideTemplate(TestComponent, template)
-             .createAsync(TestComponent)
-             .then((fixture) => {
-
-               fixture.detectChanges();
-               expect(fixture.nativeElement).toHaveText('');
-
-               var refs = fixture.debugElement.children[0].references['refs'];
-
-               fixture.componentInstance.currentTplRef = refs.tplRefs.first;
-               fixture.detectChanges();
-               expect(fixture.nativeElement).toHaveText('foo');
-
-               async.done();
-             });
-       }));
-
-    it('should clear content if TemplateRef becomes null',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         var template =
-             `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
-         tcb.overrideTemplate(TestComponent, template)
-             .createAsync(TestComponent)
-             .then((fixture) => {
-
-               fixture.detectChanges();
-               var refs = fixture.debugElement.children[0].references['refs'];
-
-               fixture.componentInstance.currentTplRef = refs.tplRefs.first;
-               fixture.detectChanges();
-               expect(fixture.nativeElement).toHaveText('foo');
-
-               fixture.componentInstance.currentTplRef = null;
-               fixture.detectChanges();
-               expect(fixture.nativeElement).toHaveText('');
-
-               async.done();
-             });
-       }));
-
-    it('should swap content if TemplateRef changes',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         var template = `<tpl-refs #refs="tplRefs"><template>foo</template><template>bar</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
-         tcb.overrideTemplate(TestComponent, template)
-             .createAsync(TestComponent)
-             .then((fixture) => {
-
-               fixture.detectChanges();
-               var refs = fixture.debugElement.children[0].references['refs'];
-
-               fixture.componentInstance.currentTplRef = refs.tplRefs.first;
-               fixture.detectChanges();
-               expect(fixture.nativeElement).toHaveText('foo');
-
-               fixture.componentInstance.currentTplRef = refs.tplRefs.last;
-               fixture.detectChanges();
-               expect(fixture.nativeElement).toHaveText('bar');
-
-               async.done();
-             });
-       }));
-
-  });
-}
-
-
-@Directive({selector: 'tpl-refs', exportAs: 'tplRefs'})
-class CaptureTplRefs {
-  @ContentChildren(TemplateRef) tplRefs: QueryList<TemplateRef<any>>;
-}
-
-@Component({selector: 'test-cmp', directives: [NgTemplateOutlet, CaptureTplRefs], template: ''})
-class TestComponent {
-  currentTplRef: TemplateRef<any>;
-}
--- a/modules/@angular/common/test/forms/integration_spec.ts
+++ b/modules/@angular/common/test/forms/integration_spec.ts
--- a/modules/@angular/common/test/pipes/date_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/date_pipe_spec.ts
@ -1,82 +0,0 @@
-import {
-  ddescribe,
-  describe,
-  it,
-  iit,
-  xit,
-  expect,
-  beforeEach,
-  afterEach
-} from '@angular/core/testing/testing_internal';
-import {browserDetection} from '@angular/platform-browser/testing';
-
-import {DatePipe} from '@angular/common';
-import {DateWrapper} from '../../src/facade/lang';
-import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
-
-export function main() {
-  describe("DatePipe", () => {
-    var date;
-    var pipe;
-
-    beforeEach(() => {
-      date = DateWrapper.create(2015, 6, 15, 21, 43, 11);
-      pipe = new DatePipe();
-    });
-
-    it('should be marked as pure',
-       () => { expect(new PipeResolver().resolve(DatePipe).pure).toEqual(true); });
-
-    describe("supports", () => {
-      it("should support date", () => { expect(pipe.supports(date)).toBe(true); });
-      it("should support int", () => { expect(pipe.supports(123456789)).toBe(true); });
-
-      it("should not support other objects", () => {
-        expect(pipe.supports(new Object())).toBe(false);
-        expect(pipe.supports(null)).toBe(false);
-      });
-    });
-
-    // TODO(mlaval): enable tests when Intl API is no longer used, see
-    // https://github.com/angular/angular/issues/3333
-    if (browserDetection.supportsIntlApi) {
-      describe("transform", () => {
-        it('should format each component correctly', () => {
-          expect(pipe.transform(date, 'y')).toEqual('2015');
-          expect(pipe.transform(date, 'yy')).toEqual('15');
-          expect(pipe.transform(date, 'M')).toEqual('6');
-          expect(pipe.transform(date, 'MM')).toEqual('06');
-          expect(pipe.transform(date, 'MMM')).toEqual('Jun');
-          expect(pipe.transform(date, 'MMMM')).toEqual('June');
-          expect(pipe.transform(date, 'd')).toEqual('15');
-          expect(pipe.transform(date, 'E')).toEqual('Mon');
-          expect(pipe.transform(date, 'EEEE')).toEqual('Monday');
-          expect(pipe.transform(date, 'H')).toEqual('21');
-          expect(pipe.transform(date, 'j')).toEqual('9 PM');
-          expect(pipe.transform(date, 'm')).toEqual('43');
-          expect(pipe.transform(date, 's')).toEqual('11');
-        });
-
-        it('should format common multi component patterns', () => {
-          expect(pipe.transform(date, 'yMEd')).toEqual('Mon, 6/15/2015');
-          expect(pipe.transform(date, 'MEd')).toEqual('Mon, 6/15');
-          expect(pipe.transform(date, 'MMMd')).toEqual('Jun 15');
-          expect(pipe.transform(date, 'yMMMMEEEEd')).toEqual('Monday, June 15, 2015');
-          expect(pipe.transform(date, 'jms')).toEqual('9:43:11 PM');
-          expect(pipe.transform(date, 'ms')).toEqual('43:11');
-        });
-
-        it('should format with pattern aliases', () => {
-          expect(pipe.transform(date, 'medium')).toEqual('Jun 15, 2015, 9:43:11 PM');
-          expect(pipe.transform(date, 'short')).toEqual('6/15/2015, 9:43 PM');
-          expect(pipe.transform(date, 'fullDate')).toEqual('Monday, June 15, 2015');
-          expect(pipe.transform(date, 'longDate')).toEqual('June 15, 2015');
-          expect(pipe.transform(date, 'mediumDate')).toEqual('Jun 15, 2015');
-          expect(pipe.transform(date, 'shortDate')).toEqual('6/15/2015');
-          expect(pipe.transform(date, 'mediumTime')).toEqual('9:43:11 PM');
-          expect(pipe.transform(date, 'shortTime')).toEqual('9:43 PM');
-        });
-      });
-    }
-  });
-}
--- a/modules/@angular/common/test/pipes/i18n_plural_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/i18n_plural_pipe_spec.ts
@ -1,59 +0,0 @@
-import {
-  ddescribe,
-  describe,
-  it,
-  iit,
-  xit,
-  expect,
-  beforeEach,
-  afterEach
-} from '@angular/core/testing/testing_internal';
-
-import {I18nPluralPipe} from '@angular/common';
-import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
-
-export function main() {
-  describe("I18nPluralPipe", () => {
-    var pipe;
-    var mapping = {'=0': 'No messages.', '=1': 'One message.', 'other': 'There are some messages.'};
-    var interpolatedMapping =
-        {'=0': 'No messages.', '=1': 'One message.', 'other': 'There are # messages, that is #.'};
-
-    beforeEach(() => { pipe = new I18nPluralPipe(); });
-
-    it('should be marked as pure',
-       () => { expect(new PipeResolver().resolve(I18nPluralPipe).pure).toEqual(true); });
-
-    describe("transform", () => {
-      it("should return 0 text if value is 0", () => {
-        var val = pipe.transform(0, mapping);
-        expect(val).toEqual('No messages.');
-      });
-
-      it("should return 1 text if value is 1", () => {
-        var val = pipe.transform(1, mapping);
-        expect(val).toEqual('One message.');
-      });
-
-      it("should return other text if value is anything other than 0 or 1", () => {
-        var val = pipe.transform(6, mapping);
-        expect(val).toEqual('There are some messages.');
-      });
-
-      it("should interpolate the value into the text where indicated", () => {
-        var val = pipe.transform(6, interpolatedMapping);
-        expect(val).toEqual('There are 6 messages, that is 6.');
-      });
-
-      it("should use 'other' if value is undefined", () => {
-        var messageLength;
-        var val = pipe.transform(messageLength, interpolatedMapping);
-        expect(val).toEqual('There are  messages, that is .');
-      });
-
-      it("should not support bad arguments",
-         () => { expect(() => pipe.transform(0, 'hey')).toThrowError(); });
-    });
-
-  });
-}
--- a/modules/@angular/common/test/pipes/i18n_select_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/i18n_select_pipe_spec.ts
@ -1,52 +0,0 @@
-import {
-  ddescribe,
-  describe,
-  it,
-  iit,
-  xit,
-  expect,
-  beforeEach,
-  afterEach
-} from '@angular/core/testing/testing_internal';
-
-import {I18nSelectPipe} from '@angular/common';
-import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
-
-export function main() {
-  describe("I18nSelectPipe", () => {
-    var pipe;
-    var mapping = {'male': 'Invite him.', 'female': 'Invite her.', 'other': 'Invite them.'};
-
-    beforeEach(() => { pipe = new I18nSelectPipe(); });
-
-    it('should be marked as pure',
-       () => { expect(new PipeResolver().resolve(I18nSelectPipe).pure).toEqual(true); });
-
-    describe("transform", () => {
-      it("should return male text if value is male", () => {
-        var val = pipe.transform('male', mapping);
-        expect(val).toEqual('Invite him.');
-      });
-
-      it("should return female text if value is female", () => {
-        var val = pipe.transform('female', mapping);
-        expect(val).toEqual('Invite her.');
-      });
-
-      it("should return other text if value is anything other than male or female", () => {
-        var val = pipe.transform('Anything else', mapping);
-        expect(val).toEqual('Invite them.');
-      });
-
-      it("should use 'other' if value is undefined", () => {
-        var gender;
-        var val = pipe.transform(gender, mapping);
-        expect(val).toEqual('Invite them.');
-      });
-
-      it("should not support bad arguments",
-         () => { expect(() => pipe.transform('male', 'hey')).toThrowError(); });
-    });
-
-  });
-}
--- a/modules/@angular/common/test/pipes/number_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/number_pipe_spec.ts
@ -1,74 +0,0 @@
-import {
-  ddescribe,
-  describe,
-  it,
-  iit,
-  xit,
-  expect,
-  beforeEach,
-  afterEach,
-} from '@angular/core/testing/testing_internal';
-import {browserDetection} from '@angular/platform-browser/testing';
-
-import {DecimalPipe, PercentPipe, CurrencyPipe} from '@angular/common';
-
-export function main() {
-  describe('Number pipes', () => {
-    // TODO(mlaval): enable tests when Intl API is no longer used, see
-    // https://github.com/angular/angular/issues/3333
-    if (browserDetection.supportsIntlApi) {
-      describe("DecimalPipe", () => {
-        var pipe;
-
-        beforeEach(() => { pipe = new DecimalPipe(); });
-
-        describe("transform", () => {
-          it('should return correct value for numbers', () => {
-            expect(pipe.transform(12345)).toEqual('12,345');
-            expect(pipe.transform(123, '.2')).toEqual('123.00');
-            expect(pipe.transform(1, '3.')).toEqual('001');
-            expect(pipe.transform(1.1, '3.4-5')).toEqual('001.1000');
-
-            expect(pipe.transform(1.123456, '3.4-5')).toEqual('001.12346');
-            expect(pipe.transform(1.1234)).toEqual('1.123');
-          });
-
-          it("should not support other objects",
-             () => { expect(() => pipe.transform(new Object())).toThrowError(); });
-        });
-      });
-
-      describe("PercentPipe", () => {
-        var pipe;
-
-        beforeEach(() => { pipe = new PercentPipe(); });
-
-        describe("transform", () => {
-          it('should return correct value for numbers', () => {
-            expect(pipe.transform(1.23)).toEqual('123%');
-            expect(pipe.transform(1.2, '.2')).toEqual('120.00%');
-          });
-
-          it("should not support other objects",
-             () => { expect(() => pipe.transform(new Object())).toThrowError(); });
-        });
-      });
-
-      describe("CurrencyPipe", () => {
-        var pipe;
-
-        beforeEach(() => { pipe = new CurrencyPipe(); });
-
-        describe("transform", () => {
-          it('should return correct value for numbers', () => {
-            expect(pipe.transform(123)).toEqual('USD123');
-            expect(pipe.transform(12, 'EUR', false, '.2')).toEqual('EUR12.00');
-          });
-
-          it("should not support other objects",
-             () => { expect(() => pipe.transform(new Object())).toThrowError(); });
-        });
-      });
-    }
-  });
-}
--- a/modules/@angular/common/test/pipes/replace_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/replace_pipe_spec.ts
@ -1,71 +0,0 @@
-import {
-  ddescribe,
-  describe,
-  it,
-  iit,
-  xit,
-  expect,
-  beforeEach,
-  afterEach,
-  inject,
-} from '@angular/core/testing/testing_internal';
-import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
-
-import {ReplacePipe} from '@angular/common';
-import {RegExpWrapper, StringJoiner} from '../../src/facade/lang';
-
-export function main() {
-  describe("ReplacePipe", () => {
-    var someNumber: number;
-    var str;
-    var pipe;
-
-    beforeEach(() => {
-      someNumber = 42;
-      str = 'Douglas Adams';
-      pipe = new ReplacePipe();
-    });
-
-    describe("transform", () => {
-
-      it("should not support input other than strings and numbers", () => {
-        expect(() => pipe.transform({}, "Douglas", "Hugh")).toThrow();
-        expect(() => pipe.transform([1, 2, 3], "Douglas", "Hugh")).toThrow();
-      });
-
-      it("should not support patterns other than strings and regular expressions", () => {
-        expect(() => pipe.transform(str, {}, "Hugh")).toThrow();
-        expect(() => pipe.transform(str, null, "Hugh")).toThrow();
-        expect(() => pipe.transform(str, 123, "Hugh")).toThrow();
-      });
-
-      it("should not support replacements other than strings and functions", () => {
-        expect(() => pipe.transform(str, "Douglas", {})).toThrow();
-        expect(() => pipe.transform(str, "Douglas", null)).toThrow();
-        expect(() => pipe.transform(str, "Douglas", 123)).toThrow();
-      });
-
-      it("should return a new string with the pattern replaced", () => {
-        var result1 = pipe.transform(str, "Douglas", "Hugh");
-
-        var result2 = pipe.transform(str, RegExpWrapper.create("a"), "_");
-
-        var result3 = pipe.transform(str, RegExpWrapper.create("a", "i"), "_");
-
-        var f = (x => { return "Adams!"; });
-
-        var result4 = pipe.transform(str, "Adams", f);
-
-        var result5 = pipe.transform(someNumber, "2", "4");
-
-        expect(result1).toEqual("Hugh Adams");
-        expect(result2).toEqual("Dougl_s Ad_ms");
-        expect(result3).toEqual("Dougl_s _d_ms");
-        expect(result4).toEqual("Douglas Adams!");
-        expect(result5).toEqual("44");
-      });
-
-    });
-
-  });
-}
--- a/modules/@angular/common/testing.ts
+++ b/modules/@angular/common/testing.ts
@ -1,2 +0,0 @@
-export {MockLocationStrategy} from './testing/mock_location_strategy';
-export {SpyLocation} from './testing/location_mock';
--- a/modules/@angular/common/tsconfig-es2015.json
+++ b/modules/@angular/common/tsconfig-es2015.json
@ -1,26 +0,0 @@
-{
-  "angularCompilerOptions": {
-    "skipTemplateCodegen": true
-  },
-  "compilerOptions": {
-    "baseUrl": ".",
-    "declaration": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "module": "es2015",
-    "moduleResolution": "node",
-    "outDir": "../../../dist/packages-dist/common/esm",
-    "paths": {
-      "@angular/core": ["../../../dist/packages-dist/core"]
-    },
-    "rootDir": ".",
-    "sourceMap": true,
-    "sourceRoot": ".",
-    "target": "es2015"
-  },
-  "files": [
-    "index.ts",
-    "testing.ts",
-    "../../../node_modules/zone.js/dist/zone.js.d.ts"
-  ]
-}
--- a/modules/@angular/common/tsconfig-es5.json
+++ b/modules/@angular/common/tsconfig-es5.json
@ -1,30 +0,0 @@
-{
-  "angularCompilerOptions": {
-    "skipTemplateCodegen": true
-  },
-  "compilerOptions": {
-    "baseUrl": ".",
-    "declaration": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "outDir": "../../../dist/packages-dist/common/",
-    "paths": {
-      "@angular/core": ["../../../dist/packages-dist/core/"]
-    },
-    "rootDir": ".",
-    "sourceMap": true,
-    "sourceRoot": ".",
-    "target": "es5"
-  },
-  "files": [
-    "index.ts",
-    "testing.ts",
-    "../typings/es6-collections/es6-collections.d.ts",
-    "../typings/es6-promise/es6-promise.d.ts",
-    "../manual_typings/globals.d.ts",
-    "../../../node_modules/zone.js/dist/zone.js.d.ts"
-
-  ]
-}
--- a/modules/@angular/compiler/compiler.ts
+++ b/modules/@angular/compiler/compiler.ts
@ -1,37 +0,0 @@
-/**
- * @module
- * @description
- * Starting point to import all compiler APIs.
- */
-export {ElementSchemaRegistry} from './src/schema/element_schema_registry';
-export {
-  COMPILER_PROVIDERS,
-  TEMPLATE_TRANSFORMS,
-  CompilerConfig,
-  RenderTypes,
-  UrlResolver,
-  DEFAULT_PACKAGE_URL_PROVIDER,
-  createOfflineCompileUrlResolver,
-  XHR,
-  ViewResolver,
-  DirectiveResolver,
-  PipeResolver,
-  SourceModule,
-  NormalizedComponentWithViewDirectives,
-  OfflineCompiler,
-  CompileMetadataWithIdentifier,
-  CompileMetadataWithType,
-  CompileIdentifierMetadata,
-  CompileDiDependencyMetadata,
-  CompileProviderMetadata,
-  CompileFactoryMetadata,
-  CompileTokenMetadata,
-  CompileTypeMetadata,
-  CompileQueryMetadata,
-  CompileTemplateMetadata,
-  CompileDirectiveMetadata,
-  CompilePipeMetadata
-} from './src/compiler';
-
-export * from './src/template_ast';
-export * from './private_export';
--- a/modules/@angular/compiler/core_private.dart
+++ b/modules/@angular/compiler/core_private.dart
@ -1 +0,0 @@
-export '../core/private_export.dart';
--- a/modules/@angular/compiler/core_private.ts
+++ b/modules/@angular/compiler/core_private.ts
@ -1,56 +0,0 @@
-import {__core_private__ as r, __core_private_types__ as t} from '@angular/core';
-
-export var isDefaultChangeDetectionStrategy: typeof t.isDefaultChangeDetectionStrategy =
-    r.isDefaultChangeDetectionStrategy;
-export type ChangeDetectorState = t.ChangeDetectorState;
-export var ChangeDetectorState: typeof t.ChangeDetectorState = r.ChangeDetectorState;
-export var CHANGE_DETECTION_STRATEGY_VALUES: typeof t.CHANGE_DETECTION_STRATEGY_VALUES =
-    r.CHANGE_DETECTION_STRATEGY_VALUES;
-export var constructDependencies: typeof t.constructDependencies = r.constructDependencies;
-export type LifecycleHooks = t.LifecycleHooks;
-export var LifecycleHooks: typeof t.LifecycleHooks = r.LifecycleHooks;
-export var LIFECYCLE_HOOKS_VALUES: typeof t.LIFECYCLE_HOOKS_VALUES = r.LIFECYCLE_HOOKS_VALUES;
-export type ReflectorReader = t.ReflectorReader;
-export var ReflectorReader: typeof t.ReflectorReader = r.ReflectorReader;
-export var ReflectorComponentResolver: typeof t.ReflectorComponentResolver =
-    r.ReflectorComponentResolver;
-export type AppElement = t.AppElement;
-export var AppElement: typeof t.AppElement = r.AppElement;
-export var AppView: typeof t.AppView = r.AppView;
-export type DebugAppView<T> = t.DebugAppView<T>;
-export var DebugAppView: typeof t.DebugAppView = r.DebugAppView;
-export type ViewType = t.ViewType;
-export var ViewType: typeof t.ViewType = r.ViewType;
-export var MAX_INTERPOLATION_VALUES: typeof t.MAX_INTERPOLATION_VALUES = r.MAX_INTERPOLATION_VALUES;
-export var checkBinding: typeof t.checkBinding = r.checkBinding;
-export var flattenNestedViewRenderNodes: typeof t.flattenNestedViewRenderNodes =
-    r.flattenNestedViewRenderNodes;
-export var interpolate: typeof t.interpolate = r.interpolate;
-export var ViewUtils: typeof t.ViewUtils = r.ViewUtils;
-export var VIEW_ENCAPSULATION_VALUES: typeof t.VIEW_ENCAPSULATION_VALUES =
-    r.VIEW_ENCAPSULATION_VALUES;
-export var DebugContext: typeof t.DebugContext = r.DebugContext;
-export var StaticNodeDebugInfo: typeof t.StaticNodeDebugInfo = r.StaticNodeDebugInfo;
-export var devModeEqual: typeof t.devModeEqual = r.devModeEqual;
-export var uninitialized: typeof t.uninitialized = r.uninitialized;
-export var ValueUnwrapper: typeof t.ValueUnwrapper = r.ValueUnwrapper;
-export var TemplateRef_: typeof t.TemplateRef_ = r.TemplateRef_;
-export type RenderDebugInfo = t.RenderDebugInfo;
-export var RenderDebugInfo: typeof t.RenderDebugInfo = r.RenderDebugInfo;
-export var createProvider: typeof t.createProvider = r.createProvider;
-export var isProviderLiteral: typeof t.isProviderLiteral = r.isProviderLiteral;
-export var EMPTY_ARRAY: typeof t.EMPTY_ARRAY = r.EMPTY_ARRAY;
-export var EMPTY_MAP: typeof t.EMPTY_MAP = r.EMPTY_MAP;
-export var pureProxy1: typeof t.pureProxy1 = r.pureProxy1;
-export var pureProxy2: typeof t.pureProxy2 = r.pureProxy2;
-export var pureProxy3: typeof t.pureProxy3 = r.pureProxy3;
-export var pureProxy4: typeof t.pureProxy4 = r.pureProxy4;
-export var pureProxy5: typeof t.pureProxy5 = r.pureProxy5;
-export var pureProxy6: typeof t.pureProxy6 = r.pureProxy6;
-export var pureProxy7: typeof t.pureProxy7 = r.pureProxy7;
-export var pureProxy8: typeof t.pureProxy8 = r.pureProxy8;
-export var pureProxy9: typeof t.pureProxy9 = r.pureProxy9;
-export var pureProxy10: typeof t.pureProxy10 = r.pureProxy10;
-export var castByValue: typeof t.castByValue = r.castByValue;
-export type Console = t.Console;
-export var Console: typeof t.Console = r.Console;
--- a/modules/@angular/compiler/index.ts
+++ b/modules/@angular/compiler/index.ts
@ -1 +0,0 @@
-export * from './compiler';
--- a/modules/@angular/compiler/package.json
+++ b/modules/@angular/compiler/package.json
@ -1,13 +0,0 @@
-{
-  "name": "@angular/compiler",
-  "version": "$$ANGULAR_VERSION$$",
-  "description": "",
-  "main": "index.js",
-  "jsnext:main": "esm/index.js",
-  "typings": "index.d.ts",
-  "author": "angular",
-  "license": "MIT",
-  "peerDependencies": {
-    "@angular/core": "$$ANGULAR_VERSION$$"
-  }
-}
--- a/modules/@angular/compiler/private_export.dart
+++ b/modules/@angular/compiler/private_export.dart
@ -1 +0,0 @@
-export './src/core/change_detection/constants.dart' show SelectorMatcher, CssSelector;
--- a/modules/@angular/compiler/private_export.ts
+++ b/modules/@angular/compiler/private_export.ts
@ -1,16 +0,0 @@
-import * as selector from './src/selector';
-import * as pathUtil from './src/output/path_util';
-
-export namespace __compiler_private__ {
-  export type SelectorMatcher = selector.SelectorMatcher;
-  export var SelectorMatcher = selector.SelectorMatcher;
-
-  export type CssSelector = selector.CssSelector;
-  export var CssSelector = selector.CssSelector;
-
-  export type AssetUrl = pathUtil.AssetUrl;
-  export var AssetUrl = pathUtil.AssetUrl;
-
-  export type ImportGenerator = pathUtil.ImportGenerator;
-  export var ImportGenerator = pathUtil.ImportGenerator;
-}
--- a/modules/@angular/compiler/rollup.config.js
+++ b/modules/@angular/compiler/rollup.config.js
@ -1,18 +0,0 @@
-
-export default {
-  entry: '../../../dist/packages-dist/compiler/esm/index.js',
-  dest: '../../../dist/packages-dist/compiler/esm/compiler.umd.js',
-  sourceMap: true,
-  format: 'umd',
-  moduleName: 'ng.compiler',
-  globals: {
-    '@angular/core': 'ng.core',
-    'rxjs/Subject': 'Rx',
-    'rxjs/observable/PromiseObservable': 'Rx', // this is wrong, but this stuff has changed in rxjs b.6 so we need to fix it when we update.
-    'rxjs/operator/toPromise': 'Rx.Observable.prototype',
-    'rxjs/Observable': 'Rx'
-  },
-  plugins: [
-//    nodeResolve({ jsnext: true, main: true }),
-  ]
-}
--- a/modules/@angular/compiler/src/assertions.dart
+++ b/modules/@angular/compiler/src/assertions.dart
@ -1,3 +0,0 @@
-library angular2.core.util.asserions;
-
-void assertArrayOfStrings(String identifier, Object value) {}
--- a/modules/@angular/compiler/src/assertions.ts
+++ b/modules/@angular/compiler/src/assertions.ts
@ -1,16 +0,0 @@
-import {isArray, isString, isBlank, assertionsEnabled} from '../src/facade/lang';
-import {BaseException} from '../src/facade/exceptions';
-
-export function assertArrayOfStrings(identifier: string, value: any) {
-  if (!assertionsEnabled() || isBlank(value)) {
-    return;
-  }
-  if (!isArray(value)) {
-    throw new BaseException(`Expected '${identifier}' to be an array of strings.`);
-  }
-  for (var i = 0; i < value.length; i += 1) {
-    if (!isString(value[i])) {
-      throw new BaseException(`Expected '${identifier}' to be an array of strings.`);
-    }
-  }
-}
--- a/modules/@angular/compiler/src/chars.ts
+++ b/modules/@angular/compiler/src/chars.ts
@ -1,64 +0,0 @@
-export const $EOF = /*@ts2dart_const*/ 0;
-export const $TAB = /*@ts2dart_const*/ 9;
-export const $LF = /*@ts2dart_const*/ 10;
-export const $VTAB = /*@ts2dart_const*/ 11;
-export const $FF = /*@ts2dart_const*/ 12;
-export const $CR = /*@ts2dart_const*/ 13;
-export const $SPACE = /*@ts2dart_const*/ 32;
-export const $BANG = /*@ts2dart_const*/ 33;
-export const $DQ = /*@ts2dart_const*/ 34;
-export const $HASH = /*@ts2dart_const*/ 35;
-export const $$ = /*@ts2dart_const*/ 36;
-export const $PERCENT = /*@ts2dart_const*/ 37;
-export const $AMPERSAND = /*@ts2dart_const*/ 38;
-export const $SQ = /*@ts2dart_const*/ 39;
-export const $LPAREN = /*@ts2dart_const*/ 40;
-export const $RPAREN = /*@ts2dart_const*/ 41;
-export const $STAR = /*@ts2dart_const*/ 42;
-export const $PLUS = /*@ts2dart_const*/ 43;
-export const $COMMA = /*@ts2dart_const*/ 44;
-export const $MINUS = /*@ts2dart_const*/ 45;
-export const $PERIOD = /*@ts2dart_const*/ 46;
-export const $SLASH = /*@ts2dart_const*/ 47;
-export const $COLON = /*@ts2dart_const*/ 58;
-export const $SEMICOLON = /*@ts2dart_const*/ 59;
-export const $LT = /*@ts2dart_const*/ 60;
-export const $EQ = /*@ts2dart_const*/ 61;
-export const $GT = /*@ts2dart_const*/ 62;
-export const $QUESTION = /*@ts2dart_const*/ 63;
-
-export const $0 = /*@ts2dart_const*/ 48;
-export const $9 = /*@ts2dart_const*/ 57;
-
-export const $A = /*@ts2dart_const*/ 65;
-export const $E = /*@ts2dart_const*/ 69;
-export const $Z = /*@ts2dart_const*/ 90;
-
-export const $LBRACKET = /*@ts2dart_const*/ 91;
-export const $BACKSLASH = /*@ts2dart_const*/ 92;
-export const $RBRACKET = /*@ts2dart_const*/ 93;
-export const $CARET = /*@ts2dart_const*/ 94;
-export const $_ = /*@ts2dart_const*/ 95;
-
-export const $a = /*@ts2dart_const*/ 97;
-export const $e = /*@ts2dart_const*/ 101;
-export const $f = /*@ts2dart_const*/ 102;
-export const $n = /*@ts2dart_const*/ 110;
-export const $r = /*@ts2dart_const*/ 114;
-export const $t = /*@ts2dart_const*/ 116;
-export const $u = /*@ts2dart_const*/ 117;
-export const $v = /*@ts2dart_const*/ 118;
-export const $z = /*@ts2dart_const*/ 122;
-
-export const $LBRACE = /*@ts2dart_const*/ 123;
-export const $BAR = /*@ts2dart_const*/ 124;
-export const $RBRACE = /*@ts2dart_const*/ 125;
-export const $NBSP = /*@ts2dart_const*/ 160;
-
-export const $PIPE = /*@ts2dart_const*/ 124;
-export const $TILDA = /*@ts2dart_const*/ 126;
-export const $AT = /*@ts2dart_const*/ 64;
-
-export function isWhitespace(code: number): boolean {
-  return (code >= $TAB && code <= $SPACE) || (code == $NBSP);
-}
--- a/modules/@angular/compiler/src/compile_metadata.ts
+++ b/modules/@angular/compiler/src/compile_metadata.ts
@ -1,793 +0,0 @@
-import {ChangeDetectionStrategy, ViewEncapsulation} from '@angular/core';
-import {
-  CHANGE_DETECTION_STRATEGY_VALUES,
-  VIEW_ENCAPSULATION_VALUES,
-  LifecycleHooks,
-  LIFECYCLE_HOOKS_VALUES
-} from '../core_private';
-
-import {
-  isPresent,
-  isBlank,
-  isNumber,
-  isBoolean,
-  normalizeBool,
-  normalizeBlank,
-  serializeEnum,
-  Type,
-  isString,
-  RegExpWrapper,
-  isArray
-} from '../src/facade/lang';
-import {unimplemented, BaseException} from '../src/facade/exceptions';
-import {
-  StringMapWrapper,
-} from '../src/facade/collection';
-import {CssSelector} from './selector';
-import {splitAtColon, sanitizeIdentifier} from './util';
-import {getUrlScheme} from './url_resolver';
-
-// group 1: "property" from "[property]"
-// group 2: "event" from "(event)"
-var HOST_REG_EXP = /^(?:(?:\[([^\]]+)\])|(?:\(([^\)]+)\)))$/g;
-
-export abstract class CompileMetadataWithIdentifier {
-  abstract toJson(): {[key: string]: any};
-
-  get identifier(): CompileIdentifierMetadata { return <CompileIdentifierMetadata>unimplemented(); }
-}
-
-export abstract class CompileMetadataWithType extends CompileMetadataWithIdentifier {
-  abstract toJson(): {[key: string]: any};
-
-  get type(): CompileTypeMetadata { return <CompileTypeMetadata>unimplemented(); }
-
-  get identifier(): CompileIdentifierMetadata { return <CompileIdentifierMetadata>unimplemented(); }
-}
-
-export function metadataFromJson(data: {[key: string]: any}): any {
-  return _COMPILE_METADATA_FROM_JSON[data['class']](data);
-}
-
-export class CompileIdentifierMetadata implements CompileMetadataWithIdentifier {
-  runtime: any;
-  name: string;
-  prefix: string;
-  moduleUrl: string;
-  value: any;
-
-  constructor(
-      {runtime, name, moduleUrl, prefix, value}:
-          {runtime?: any, name?: string, moduleUrl?: string, prefix?: string, value?: any} = {}) {
-    this.runtime = runtime;
-    this.name = name;
-    this.prefix = prefix;
-    this.moduleUrl = moduleUrl;
-    this.value = value;
-  }
-
-  static fromJson(data: {[key: string]: any}): CompileIdentifierMetadata {
-    let value = isArray(data['value']) ? _arrayFromJson(data['value'], metadataFromJson) :
-                                         _objFromJson(data['value'], metadataFromJson);
-    return new CompileIdentifierMetadata(
-        {name: data['name'], prefix: data['prefix'], moduleUrl: data['moduleUrl'], value: value});
-  }
-
-  toJson(): {[key: string]: any} {
-    let value = isArray(this.value) ? _arrayToJson(this.value) : _objToJson(this.value);
-    return {
-      // Note: Runtime type can't be serialized...
-      'class': 'Identifier',
-      'name': this.name,
-      'moduleUrl': this.moduleUrl,
-      'prefix': this.prefix,
-      'value': value
-    };
-  }
-
-  get identifier(): CompileIdentifierMetadata { return this; }
-}
-
-export class CompileDiDependencyMetadata {
-  isAttribute: boolean;
-  isSelf: boolean;
-  isHost: boolean;
-  isSkipSelf: boolean;
-  isOptional: boolean;
-  isValue: boolean;
-  query: CompileQueryMetadata;
-  viewQuery: CompileQueryMetadata;
-  token: CompileTokenMetadata;
-  value: any;
-
-  constructor({isAttribute, isSelf, isHost, isSkipSelf, isOptional, isValue, query, viewQuery,
-               token, value}: {
-    isAttribute?: boolean,
-    isSelf?: boolean,
-    isHost?: boolean,
-    isSkipSelf?: boolean,
-    isOptional?: boolean,
-    isValue?: boolean,
-    query?: CompileQueryMetadata,
-    viewQuery?: CompileQueryMetadata,
-    token?: CompileTokenMetadata,
-    value?: any
-  } = {}) {
-    this.isAttribute = normalizeBool(isAttribute);
-    this.isSelf = normalizeBool(isSelf);
-    this.isHost = normalizeBool(isHost);
-    this.isSkipSelf = normalizeBool(isSkipSelf);
-    this.isOptional = normalizeBool(isOptional);
-    this.isValue = normalizeBool(isValue);
-    this.query = query;
-    this.viewQuery = viewQuery;
-    this.token = token;
-    this.value = value;
-  }
-
-  static fromJson(data: {[key: string]: any}): CompileDiDependencyMetadata {
-    return new CompileDiDependencyMetadata({
-      token: _objFromJson(data['token'], CompileTokenMetadata.fromJson),
-      query: _objFromJson(data['query'], CompileQueryMetadata.fromJson),
-      viewQuery: _objFromJson(data['viewQuery'], CompileQueryMetadata.fromJson),
-      value: data['value'],
-      isAttribute: data['isAttribute'],
-      isSelf: data['isSelf'],
-      isHost: data['isHost'],
-      isSkipSelf: data['isSkipSelf'],
-      isOptional: data['isOptional'],
-      isValue: data['isValue']
-    });
-  }
-
-  toJson(): {[key: string]: any} {
-    return {
-      'token': _objToJson(this.token),
-      'query': _objToJson(this.query),
-      'viewQuery': _objToJson(this.viewQuery),
-      'value': this.value,
-      'isAttribute': this.isAttribute,
-      'isSelf': this.isSelf,
-      'isHost': this.isHost,
-      'isSkipSelf': this.isSkipSelf,
-      'isOptional': this.isOptional,
-      'isValue': this.isValue
-    };
-  }
-}
-
-export class CompileProviderMetadata {
-  token: CompileTokenMetadata;
-  useClass: CompileTypeMetadata;
-  useValue: any;
-  useExisting: CompileTokenMetadata;
-  useFactory: CompileFactoryMetadata;
-  deps: CompileDiDependencyMetadata[];
-  multi: boolean;
-
-  constructor({token, useClass, useValue, useExisting, useFactory, deps, multi}: {
-    token?: CompileTokenMetadata,
-    useClass?: CompileTypeMetadata,
-    useValue?: any,
-    useExisting?: CompileTokenMetadata,
-    useFactory?: CompileFactoryMetadata,
-    deps?: CompileDiDependencyMetadata[],
-    multi?: boolean
-  }) {
-    this.token = token;
-    this.useClass = useClass;
-    this.useValue = useValue;
-    this.useExisting = useExisting;
-    this.useFactory = useFactory;
-    this.deps = normalizeBlank(deps);
-    this.multi = normalizeBool(multi);
-  }
-
-  static fromJson(data: {[key: string]: any}): CompileProviderMetadata {
-    return new CompileProviderMetadata({
-      token: _objFromJson(data['token'], CompileTokenMetadata.fromJson),
-      useClass: _objFromJson(data['useClass'], CompileTypeMetadata.fromJson),
-      useExisting: _objFromJson(data['useExisting'], CompileTokenMetadata.fromJson),
-      useValue: _objFromJson(data['useValue'], CompileIdentifierMetadata.fromJson),
-      useFactory: _objFromJson(data['useFactory'], CompileFactoryMetadata.fromJson),
-      multi: data['multi'],
-      deps: _arrayFromJson(data['deps'], CompileDiDependencyMetadata.fromJson)
-    });
-  }
-
-  toJson(): {[key: string]: any} {
-    return {
-      // Note: Runtime type can't be serialized...
-      'class': 'Provider',
-      'token': _objToJson(this.token),
-      'useClass': _objToJson(this.useClass),
-      'useExisting': _objToJson(this.useExisting),
-      'useValue': _objToJson(this.useValue),
-      'useFactory': _objToJson(this.useFactory),
-      'multi': this.multi,
-      'deps': _arrayToJson(this.deps)
-    };
-  }
-}
-
-export class CompileFactoryMetadata implements CompileIdentifierMetadata,
-    CompileMetadataWithIdentifier {
-  runtime: Function;
-  name: string;
-  prefix: string;
-  moduleUrl: string;
-  value: any;
-  diDeps: CompileDiDependencyMetadata[];
-
-  constructor({runtime, name, moduleUrl, prefix, diDeps, value}: {
-    runtime?: Function,
-    name?: string,
-    prefix?: string,
-    moduleUrl?: string,
-    value?: boolean,
-    diDeps?: CompileDiDependencyMetadata[]
-  }) {
-    this.runtime = runtime;
-    this.name = name;
-    this.prefix = prefix;
-    this.moduleUrl = moduleUrl;
-    this.diDeps = _normalizeArray(diDeps);
-    this.value = value;
-  }
-
-  get identifier(): CompileIdentifierMetadata { return this; }
-
-  static fromJson(data: {[key: string]: any}): CompileFactoryMetadata {
-    return new CompileFactoryMetadata({
-      name: data['name'],
-      prefix: data['prefix'],
-      moduleUrl: data['moduleUrl'],
-      value: data['value'],
-      diDeps: _arrayFromJson(data['diDeps'], CompileDiDependencyMetadata.fromJson)
-    });
-  }
-
-  toJson(): {[key: string]: any} {
-    return {
-      'class': 'Factory',
-      'name': this.name,
-      'prefix': this.prefix,
-      'moduleUrl': this.moduleUrl,
-      'value': this.value,
-      'diDeps': _arrayToJson(this.diDeps)
-    };
-  }
-}
-
-export class CompileTokenMetadata implements CompileMetadataWithIdentifier {
-  value: any;
-  identifier: CompileIdentifierMetadata;
-  identifierIsInstance: boolean;
-
-  constructor({value, identifier, identifierIsInstance}: {
-    value?: any,
-    identifier?: CompileIdentifierMetadata,
-    identifierIsInstance?: boolean
-  }) {
-    this.value = value;
-    this.identifier = identifier;
-    this.identifierIsInstance = normalizeBool(identifierIsInstance);
-  }
-
-  static fromJson(data: {[key: string]: any}): CompileTokenMetadata {
-    return new CompileTokenMetadata({
-      value: data['value'],
-      identifier: _objFromJson(data['identifier'], CompileIdentifierMetadata.fromJson),
-      identifierIsInstance: data['identifierIsInstance']
-    });
-  }
-
-  toJson(): {[key: string]: any} {
-    return {
-      'value': this.value,
-      'identifier': _objToJson(this.identifier),
-      'identifierIsInstance': this.identifierIsInstance
-    };
-  }
-
-  get runtimeCacheKey(): any {
-    if (isPresent(this.identifier)) {
-      return this.identifier.runtime;
-    } else {
-      return this.value;
-    }
-  }
-
-  get assetCacheKey(): any {
-    if (isPresent(this.identifier)) {
-      return isPresent(this.identifier.moduleUrl) &&
-                     isPresent(getUrlScheme(this.identifier.moduleUrl)) ?
-                 `${this.identifier.name}|${this.identifier.moduleUrl}|${this.identifierIsInstance}` :
-                 null;
-    } else {
-      return this.value;
-    }
-  }
-
-  equalsTo(token2: CompileTokenMetadata): boolean {
-    var rk = this.runtimeCacheKey;
-    var ak = this.assetCacheKey;
-    return (isPresent(rk) && rk == token2.runtimeCacheKey) ||
-           (isPresent(ak) && ak == token2.assetCacheKey);
-  }
-
-  get name(): string {
-    return isPresent(this.value) ? sanitizeIdentifier(this.value) : this.identifier.name;
-  }
-}
-
-export class CompileTokenMap<VALUE> {
-  private _valueMap = new Map<any, VALUE>();
-  private _values: VALUE[] = [];
-
-  add(token: CompileTokenMetadata, value: VALUE) {
-    var existing = this.get(token);
-    if (isPresent(existing)) {
-      throw new BaseException(`Can only add to a TokenMap! Token: ${token.name}`);
-    }
-    this._values.push(value);
-    var rk = token.runtimeCacheKey;
-    if (isPresent(rk)) {
-      this._valueMap.set(rk, value);
-    }
-    var ak = token.assetCacheKey;
-    if (isPresent(ak)) {
-      this._valueMap.set(ak, value);
-    }
-  }
-  get(token: CompileTokenMetadata): VALUE {
-    var rk = token.runtimeCacheKey;
-    var ak = token.assetCacheKey;
-    var result;
-    if (isPresent(rk)) {
-      result = this._valueMap.get(rk);
-    }
-    if (isBlank(result) && isPresent(ak)) {
-      result = this._valueMap.get(ak);
-    }
-    return result;
-  }
-  values(): VALUE[] { return this._values; }
-  get size(): number { return this._values.length; }
-}
-
-/**
- * Metadata regarding compilation of a type.
- */
-export class CompileTypeMetadata implements CompileIdentifierMetadata, CompileMetadataWithType {
-  runtime: Type;
-  name: string;
-  prefix: string;
-  moduleUrl: string;
-  isHost: boolean;
-  value: any;
-  diDeps: CompileDiDependencyMetadata[];
-
-  constructor({runtime, name, moduleUrl, prefix, isHost, value, diDeps}: {
-    runtime?: Type,
-    name?: string,
-    moduleUrl?: string,
-    prefix?: string,
-    isHost?: boolean,
-    value?: any,
-    diDeps?: CompileDiDependencyMetadata[]
-  } = {}) {
-    this.runtime = runtime;
-    this.name = name;
-    this.moduleUrl = moduleUrl;
-    this.prefix = prefix;
-    this.isHost = normalizeBool(isHost);
-    this.value = value;
-    this.diDeps = _normalizeArray(diDeps);
-  }
-
-  static fromJson(data: {[key: string]: any}): CompileTypeMetadata {
-    return new CompileTypeMetadata({
-      name: data['name'],
-      moduleUrl: data['moduleUrl'],
-      prefix: data['prefix'],
-      isHost: data['isHost'],
-      value: data['value'],
-      diDeps: _arrayFromJson(data['diDeps'], CompileDiDependencyMetadata.fromJson)
-    });
-  }
-
-  get identifier(): CompileIdentifierMetadata { return this; }
-  get type(): CompileTypeMetadata { return this; }
-
-  toJson(): {[key: string]: any} {
-    return {
-      // Note: Runtime type can't be serialized...
-      'class': 'Type',
-      'name': this.name,
-      'moduleUrl': this.moduleUrl,
-      'prefix': this.prefix,
-      'isHost': this.isHost,
-      'value': this.value,
-      'diDeps': _arrayToJson(this.diDeps)
-    };
-  }
-}
-
-export class CompileQueryMetadata {
-  selectors: Array<CompileTokenMetadata>;
-  descendants: boolean;
-  first: boolean;
-  propertyName: string;
-  read: CompileTokenMetadata;
-
-  constructor({selectors, descendants, first, propertyName, read}: {
-    selectors?: Array<CompileTokenMetadata>,
-    descendants?: boolean,
-    first?: boolean,
-    propertyName?: string,
-    read?: CompileTokenMetadata
-  } = {}) {
-    this.selectors = selectors;
-    this.descendants = normalizeBool(descendants);
-    this.first = normalizeBool(first);
-    this.propertyName = propertyName;
-    this.read = read;
-  }
-
-  static fromJson(data: {[key: string]: any}): CompileQueryMetadata {
-    return new CompileQueryMetadata({
-      selectors: _arrayFromJson(data['selectors'], CompileTokenMetadata.fromJson),
-      descendants: data['descendants'],
-      first: data['first'],
-      propertyName: data['propertyName'],
-      read: _objFromJson(data['read'], CompileTokenMetadata.fromJson)
-    });
-  }
-
-  toJson(): {[key: string]: any} {
-    return {
-      'selectors': _arrayToJson(this.selectors),
-      'descendants': this.descendants,
-      'first': this.first,
-      'propertyName': this.propertyName,
-      'read': _objToJson(this.read)
-    };
-  }
-}
-
-/**
- * Metadata regarding compilation of a template.
- */
-export class CompileTemplateMetadata {
-  encapsulation: ViewEncapsulation;
-  template: string;
-  templateUrl: string;
-  styles: string[];
-  styleUrls: string[];
-  ngContentSelectors: string[];
-  constructor({encapsulation, template, templateUrl, styles, styleUrls, ngContentSelectors}: {
-    encapsulation?: ViewEncapsulation,
-    template?: string,
-    templateUrl?: string,
-    styles?: string[],
-    styleUrls?: string[],
-    ngContentSelectors?: string[]
-  } = {}) {
-    this.encapsulation = isPresent(encapsulation) ? encapsulation : ViewEncapsulation.Emulated;
-    this.template = template;
-    this.templateUrl = templateUrl;
-    this.styles = isPresent(styles) ? styles : [];
-    this.styleUrls = isPresent(styleUrls) ? styleUrls : [];
-    this.ngContentSelectors = isPresent(ngContentSelectors) ? ngContentSelectors : [];
-  }
-
-  static fromJson(data: {[key: string]: any}): CompileTemplateMetadata {
-    return new CompileTemplateMetadata({
-      encapsulation: isPresent(data['encapsulation']) ?
-                         VIEW_ENCAPSULATION_VALUES[data['encapsulation']] :
-                         data['encapsulation'],
-      template: data['template'],
-      templateUrl: data['templateUrl'],
-      styles: data['styles'],
-      styleUrls: data['styleUrls'],
-      ngContentSelectors: data['ngContentSelectors']
-    });
-  }
-
-  toJson(): {[key: string]: any} {
-    return {
-      'encapsulation':
-          isPresent(this.encapsulation) ? serializeEnum(this.encapsulation) : this.encapsulation,
-      'template': this.template,
-      'templateUrl': this.templateUrl,
-      'styles': this.styles,
-      'styleUrls': this.styleUrls,
-      'ngContentSelectors': this.ngContentSelectors
-    };
-  }
-}
-
-/**
- * Metadata regarding compilation of a directive.
- */
-export class CompileDirectiveMetadata implements CompileMetadataWithType {
-  static create({type, isComponent, selector, exportAs, changeDetection, inputs, outputs, host,
-                 lifecycleHooks, providers, viewProviders, queries, viewQueries, template}: {
-    type?: CompileTypeMetadata,
-    isComponent?: boolean,
-    selector?: string,
-    exportAs?: string,
-    changeDetection?: ChangeDetectionStrategy,
-    inputs?: string[],
-    outputs?: string[],
-    host?: {[key: string]: string},
-    lifecycleHooks?: LifecycleHooks[],
-    providers?:
-        Array<CompileProviderMetadata | CompileTypeMetadata | CompileIdentifierMetadata | any[]>,
-    viewProviders?:
-        Array<CompileProviderMetadata | CompileTypeMetadata | CompileIdentifierMetadata | any[]>,
-    queries?: CompileQueryMetadata[],
-    viewQueries?: CompileQueryMetadata[],
-    template?: CompileTemplateMetadata
-  } = {}): CompileDirectiveMetadata {
-    var hostListeners: {[key: string]: string} = {};
-    var hostProperties: {[key: string]: string} = {};
-    var hostAttributes: {[key: string]: string} = {};
-    if (isPresent(host)) {
-      StringMapWrapper.forEach(host, (value: string, key: string) => {
-        var matches = RegExpWrapper.firstMatch(HOST_REG_EXP, key);
-        if (isBlank(matches)) {
-          hostAttributes[key] = value;
-        } else if (isPresent(matches[1])) {
-          hostProperties[matches[1]] = value;
-        } else if (isPresent(matches[2])) {
-          hostListeners[matches[2]] = value;
-        }
-      });
-    }
-    var inputsMap: {[key: string]: string} = {};
-    if (isPresent(inputs)) {
-      inputs.forEach((bindConfig: string) => {
-        // canonical syntax: `dirProp: elProp`
-        // if there is no `:`, use dirProp = elProp
-        var parts = splitAtColon(bindConfig, [bindConfig, bindConfig]);
-        inputsMap[parts[0]] = parts[1];
-      });
-    }
-    var outputsMap: {[key: string]: string} = {};
-    if (isPresent(outputs)) {
-      outputs.forEach((bindConfig: string) => {
-        // canonical syntax: `dirProp: elProp`
-        // if there is no `:`, use dirProp = elProp
-        var parts = splitAtColon(bindConfig, [bindConfig, bindConfig]);
-        outputsMap[parts[0]] = parts[1];
-      });
-    }
-
-    return new CompileDirectiveMetadata({
-      type: type,
-      isComponent: normalizeBool(isComponent),
-      selector: selector,
-      exportAs: exportAs,
-      changeDetection: changeDetection,
-      inputs: inputsMap,
-      outputs: outputsMap,
-      hostListeners: hostListeners,
-      hostProperties: hostProperties,
-      hostAttributes: hostAttributes,
-      lifecycleHooks: isPresent(lifecycleHooks) ? lifecycleHooks : [],
-      providers: providers,
-      viewProviders: viewProviders,
-      queries: queries,
-      viewQueries: viewQueries,
-      template: template
-    });
-  }
-  type: CompileTypeMetadata;
-  isComponent: boolean;
-  selector: string;
-  exportAs: string;
-  changeDetection: ChangeDetectionStrategy;
-  inputs: {[key: string]: string};
-  outputs: {[key: string]: string};
-  hostListeners: {[key: string]: string};
-  hostProperties: {[key: string]: string};
-  hostAttributes: {[key: string]: string};
-  lifecycleHooks: LifecycleHooks[];
-  providers: CompileProviderMetadata[];
-  viewProviders: CompileProviderMetadata[];
-  queries: CompileQueryMetadata[];
-  viewQueries: CompileQueryMetadata[];
-
-  template: CompileTemplateMetadata;
-  constructor({type, isComponent, selector, exportAs, changeDetection, inputs, outputs,
-               hostListeners, hostProperties, hostAttributes, lifecycleHooks, providers,
-               viewProviders, queries, viewQueries, template}: {
-    type?: CompileTypeMetadata,
-    isComponent?: boolean,
-    selector?: string,
-    exportAs?: string,
-    changeDetection?: ChangeDetectionStrategy,
-    inputs?: {[key: string]: string},
-    outputs?: {[key: string]: string},
-    hostListeners?: {[key: string]: string},
-    hostProperties?: {[key: string]: string},
-    hostAttributes?: {[key: string]: string},
-    lifecycleHooks?: LifecycleHooks[],
-    providers?:
-        Array<CompileProviderMetadata | CompileTypeMetadata | CompileIdentifierMetadata | any[]>,
-    viewProviders?:
-        Array<CompileProviderMetadata | CompileTypeMetadata | CompileIdentifierMetadata | any[]>,
-    queries?: CompileQueryMetadata[],
-    viewQueries?: CompileQueryMetadata[],
-    template?: CompileTemplateMetadata
-  } = {}) {
-    this.type = type;
-    this.isComponent = isComponent;
-    this.selector = selector;
-    this.exportAs = exportAs;
-    this.changeDetection = changeDetection;
-    this.inputs = inputs;
-    this.outputs = outputs;
-    this.hostListeners = hostListeners;
-    this.hostProperties = hostProperties;
-    this.hostAttributes = hostAttributes;
-    this.lifecycleHooks = _normalizeArray(lifecycleHooks);
-    this.providers = _normalizeArray(providers);
-    this.viewProviders = _normalizeArray(viewProviders);
-    this.queries = _normalizeArray(queries);
-    this.viewQueries = _normalizeArray(viewQueries);
-    this.template = template;
-  }
-
-  get identifier(): CompileIdentifierMetadata { return this.type; }
-
-  static fromJson(data: {[key: string]: any}): CompileDirectiveMetadata {
-    return new CompileDirectiveMetadata({
-      isComponent: data['isComponent'],
-      selector: data['selector'],
-      exportAs: data['exportAs'],
-      type: isPresent(data['type']) ? CompileTypeMetadata.fromJson(data['type']) : data['type'],
-      changeDetection: isPresent(data['changeDetection']) ?
-                           CHANGE_DETECTION_STRATEGY_VALUES[data['changeDetection']] :
-                           data['changeDetection'],
-      inputs: data['inputs'],
-      outputs: data['outputs'],
-      hostListeners: data['hostListeners'],
-      hostProperties: data['hostProperties'],
-      hostAttributes: data['hostAttributes'],
-      lifecycleHooks:
-          (<any[]>data['lifecycleHooks']).map(hookValue => LIFECYCLE_HOOKS_VALUES[hookValue]),
-      template: isPresent(data['template']) ? CompileTemplateMetadata.fromJson(data['template']) :
-                                              data['template'],
-      providers: _arrayFromJson(data['providers'], metadataFromJson),
-      viewProviders: _arrayFromJson(data['viewProviders'], metadataFromJson),
-      queries: _arrayFromJson(data['queries'], CompileQueryMetadata.fromJson),
-      viewQueries: _arrayFromJson(data['viewQueries'], CompileQueryMetadata.fromJson)
-    });
-  }
-
-  toJson(): {[key: string]: any} {
-    return {
-      'class': 'Directive',
-      'isComponent': this.isComponent,
-      'selector': this.selector,
-      'exportAs': this.exportAs,
-      'type': isPresent(this.type) ? this.type.toJson() : this.type,
-      'changeDetection': isPresent(this.changeDetection) ? serializeEnum(this.changeDetection) :
-                                                           this.changeDetection,
-      'inputs': this.inputs,
-      'outputs': this.outputs,
-      'hostListeners': this.hostListeners,
-      'hostProperties': this.hostProperties,
-      'hostAttributes': this.hostAttributes,
-      'lifecycleHooks': this.lifecycleHooks.map(hook => serializeEnum(hook)),
-      'template': isPresent(this.template) ? this.template.toJson() : this.template,
-      'providers': _arrayToJson(this.providers),
-      'viewProviders': _arrayToJson(this.viewProviders),
-      'queries': _arrayToJson(this.queries),
-      'viewQueries': _arrayToJson(this.viewQueries)
-    };
-  }
-}
-
-/**
- * Construct {@link CompileDirectiveMetadata} from {@link ComponentTypeMetadata} and a selector.
- */
-export function createHostComponentMeta(componentType: CompileTypeMetadata,
-                                        componentSelector: string): CompileDirectiveMetadata {
-  var template = CssSelector.parse(componentSelector)[0].getMatchingElementTemplate();
-  return CompileDirectiveMetadata.create({
-    type: new CompileTypeMetadata({
-      runtime: Object,
-      name: `${componentType.name}_Host`,
-      moduleUrl: componentType.moduleUrl,
-      isHost: true
-    }),
-    template: new CompileTemplateMetadata(
-        {template: template, templateUrl: '', styles: [], styleUrls: [], ngContentSelectors: []}),
-    changeDetection: ChangeDetectionStrategy.Default,
-    inputs: [],
-    outputs: [],
-    host: {},
-    lifecycleHooks: [],
-    isComponent: true,
-    selector: '*',
-    providers: [],
-    viewProviders: [],
-    queries: [],
-    viewQueries: []
-  });
-}
-
-
-export class CompilePipeMetadata implements CompileMetadataWithType {
-  type: CompileTypeMetadata;
-  name: string;
-  pure: boolean;
-  lifecycleHooks: LifecycleHooks[];
-
-  constructor({type, name, pure, lifecycleHooks}: {
-    type?: CompileTypeMetadata,
-    name?: string,
-    pure?: boolean,
-    lifecycleHooks?: LifecycleHooks[]
-  } = {}) {
-    this.type = type;
-    this.name = name;
-    this.pure = normalizeBool(pure);
-    this.lifecycleHooks = _normalizeArray(lifecycleHooks);
-  }
-  get identifier(): CompileIdentifierMetadata { return this.type; }
-
-  static fromJson(data: {[key: string]: any}): CompilePipeMetadata {
-    return new CompilePipeMetadata({
-      type: isPresent(data['type']) ? CompileTypeMetadata.fromJson(data['type']) : data['type'],
-      name: data['name'],
-      pure: data['pure']
-    });
-  }
-
-  toJson(): {[key: string]: any} {
-    return {
-      'class': 'Pipe',
-      'type': isPresent(this.type) ? this.type.toJson() : null,
-      'name': this.name,
-      'pure': this.pure
-    };
-  }
-}
-
-var _COMPILE_METADATA_FROM_JSON = {
-  'Directive': CompileDirectiveMetadata.fromJson,
-  'Pipe': CompilePipeMetadata.fromJson,
-  'Type': CompileTypeMetadata.fromJson,
-  'Provider': CompileProviderMetadata.fromJson,
-  'Identifier': CompileIdentifierMetadata.fromJson,
-  'Factory': CompileFactoryMetadata.fromJson
-};
-
-function _arrayFromJson(obj: any[], fn: (a: {[key: string]: any}) => any): any {
-  return isBlank(obj) ? null : obj.map(o => _objFromJson(o, fn));
-}
-
-function _arrayToJson(obj: any[]): string | {[key: string]: any} {
-  return isBlank(obj) ? null : obj.map(_objToJson);
-}
-
-function _objFromJson(obj: any, fn: (a: {[key: string]: any}) => any): any {
-  if (isArray(obj)) return _arrayFromJson(obj, fn);
-  if (isString(obj) || isBlank(obj) || isBoolean(obj) || isNumber(obj)) return obj;
-  return fn(obj);
-}
-
-function _objToJson(obj: any): string | {[key: string]: any} {
-  if (isArray(obj)) return _arrayToJson(obj);
-  if (isString(obj) || isBlank(obj) || isBoolean(obj) || isNumber(obj)) return obj;
-  return obj.toJson();
-}
-
-function _normalizeArray(obj: any[]): any[] {
-  return isPresent(obj) ? obj : [];
-}
--- a/modules/@angular/compiler/src/compiler.ts
+++ b/modules/@angular/compiler/src/compiler.ts
@ -1,62 +0,0 @@
-import {ComponentResolver, Type} from '@angular/core';
-import {assertionsEnabled} from '../src/facade/lang';
-
-export * from './template_ast';
-export {TEMPLATE_TRANSFORMS} from './template_parser';
-export {CompilerConfig, RenderTypes} from './config';
-export * from './compile_metadata';
-export * from './offline_compiler';
-export {RuntimeCompiler} from './runtime_compiler';
-export * from './url_resolver';
-export * from './xhr';
-
-export {ViewResolver} from './view_resolver';
-export {DirectiveResolver} from './directive_resolver';
-export {PipeResolver} from './pipe_resolver';
-
-import {TemplateParser} from './template_parser';
-import {HtmlParser} from './html_parser';
-import {DirectiveNormalizer} from './directive_normalizer';
-import {CompileMetadataResolver} from './metadata_resolver';
-import {StyleCompiler} from './style_compiler';
-import {ViewCompiler} from './view_compiler/view_compiler';
-import {CompilerConfig} from './config';
-import {RuntimeCompiler} from './runtime_compiler';
-import {ElementSchemaRegistry} from './schema/element_schema_registry';
-import {DomElementSchemaRegistry} from './schema/dom_element_schema_registry';
-import {UrlResolver, DEFAULT_PACKAGE_URL_PROVIDER} from './url_resolver';
-import {Parser} from './expression_parser/parser';
-import {Lexer} from './expression_parser/lexer';
-import {ViewResolver} from './view_resolver';
-import {DirectiveResolver} from './directive_resolver';
-import {PipeResolver} from './pipe_resolver';
-
-function _createCompilerConfig() {
-  return new CompilerConfig(assertionsEnabled(), false, true);
-}
-
-/**
- * A set of providers that provide `RuntimeCompiler` and its dependencies to use for
- * template compilation.
- */
-export const COMPILER_PROVIDERS: Array<any | Type | {[k: string]: any} | any[]> =
-    /*@ts2dart_const*/[
-      Lexer,
-      Parser,
-      HtmlParser,
-      TemplateParser,
-      DirectiveNormalizer,
-      CompileMetadataResolver,
-      DEFAULT_PACKAGE_URL_PROVIDER,
-      StyleCompiler,
-      ViewCompiler,
-      /*@ts2dart_Provider*/ {provide: CompilerConfig, useFactory: _createCompilerConfig, deps: []},
-      RuntimeCompiler,
-      /*@ts2dart_Provider*/ {provide: ComponentResolver, useExisting: RuntimeCompiler},
-      DomElementSchemaRegistry,
-      /*@ts2dart_Provider*/ {provide: ElementSchemaRegistry, useExisting: DomElementSchemaRegistry},
-      UrlResolver,
-      ViewResolver,
-      DirectiveResolver,
-      PipeResolver
-    ];
--- a/modules/@angular/compiler/src/config.ts
+++ b/modules/@angular/compiler/src/config.ts
@ -1,38 +0,0 @@
-import {isBlank} from '../src/facade/lang';
-import {unimplemented} from '../src/facade/exceptions';
-import {Identifiers} from './identifiers';
-import {CompileIdentifierMetadata} from './compile_metadata';
-
-export class CompilerConfig {
-  public renderTypes: RenderTypes;
-  constructor(public genDebugInfo: boolean, public logBindingUpdate: boolean,
-              public useJit: boolean, renderTypes: RenderTypes = null) {
-    if (isBlank(renderTypes)) {
-      renderTypes = new DefaultRenderTypes();
-    }
-    this.renderTypes = renderTypes;
-  }
-}
-
-/**
- * Types used for the renderer.
- * Can be replaced to specialize the generated output to a specific renderer
- * to help tree shaking.
- */
-export abstract class RenderTypes {
-  get renderer(): CompileIdentifierMetadata { return unimplemented(); }
-  get renderText(): CompileIdentifierMetadata { return unimplemented(); }
-  get renderElement(): CompileIdentifierMetadata { return unimplemented(); }
-  get renderComment(): CompileIdentifierMetadata { return unimplemented(); }
-  get renderNode(): CompileIdentifierMetadata { return unimplemented(); }
-  get renderEvent(): CompileIdentifierMetadata { return unimplemented(); }
-}
-
-export class DefaultRenderTypes implements RenderTypes {
-  renderer = Identifiers.Renderer;
-  renderText = null;
-  renderElement = null;
-  renderComment = null;
-  renderNode = null;
-  renderEvent = null;
-}
--- a/modules/@angular/compiler/src/css/lexer.ts
+++ b/modules/@angular/compiler/src/css/lexer.ts
@ -1,756 +0,0 @@
-import {NumberWrapper, StringWrapper, isPresent, resolveEnumToken} from '../../src/facade/lang';
-import {BaseException} from '../../src/facade/exceptions';
-
-import {
-  isWhitespace,
-  $EOF,
-  $HASH,
-  $TILDA,
-  $CARET,
-  $PERCENT,
-  $$,
-  $_,
-  $COLON,
-  $SQ,
-  $DQ,
-  $EQ,
-  $SLASH,
-  $BACKSLASH,
-  $PERIOD,
-  $STAR,
-  $PLUS,
-  $LPAREN,
-  $RPAREN,
-  $LBRACE,
-  $RBRACE,
-  $LBRACKET,
-  $RBRACKET,
-  $PIPE,
-  $COMMA,
-  $SEMICOLON,
-  $MINUS,
-  $BANG,
-  $QUESTION,
-  $AT,
-  $AMPERSAND,
-  $GT,
-  $a,
-  $A,
-  $z,
-  $Z,
-  $0,
-  $9,
-  $FF,
-  $CR,
-  $LF,
-  $VTAB
-} from '@angular/compiler/src/chars';
-
-export {
-  $EOF,
-  $AT,
-  $RBRACE,
-  $LBRACE,
-  $LBRACKET,
-  $RBRACKET,
-  $LPAREN,
-  $RPAREN,
-  $COMMA,
-  $COLON,
-  $SEMICOLON,
-  isWhitespace
-} from '@angular/compiler/src/chars';
-
-export enum CssTokenType {
-  EOF,
-  String,
-  Comment,
-  Identifier,
-  Number,
-  IdentifierOrNumber,
-  AtKeyword,
-  Character,
-  Whitespace,
-  Invalid
-}
-
-export enum CssLexerMode {
-  ALL,
-  ALL_TRACK_WS,
-  SELECTOR,
-  PSEUDO_SELECTOR,
-  ATTRIBUTE_SELECTOR,
-  AT_RULE_QUERY,
-  MEDIA_QUERY,
-  BLOCK,
-  KEYFRAME_BLOCK,
-  STYLE_BLOCK,
-  STYLE_VALUE,
-  STYLE_VALUE_FUNCTION,
-  STYLE_CALC_FUNCTION
-}
-
-export class LexedCssResult {
-  constructor(public error: CssScannerError, public token: CssToken) {}
-}
-
-export function generateErrorMessage(input: string, message: string, errorValue: string,
-                                     index: number, row: number, column: number): string {
-  return `${message} at column ${row}:${column} in expression [` +
-         findProblemCode(input, errorValue, index, column) + ']';
-}
-
-export function findProblemCode(input: string, errorValue: string, index: number,
-                                column: number): string {
-  var endOfProblemLine = index;
-  var current = charCode(input, index);
-  while (current > 0 && !isNewline(current)) {
-    current = charCode(input, ++endOfProblemLine);
-  }
-  var choppedString = input.substring(0, endOfProblemLine);
-  var pointerPadding = "";
-  for (var i = 0; i < column; i++) {
-    pointerPadding += " ";
-  }
-  var pointerString = "";
-  for (var i = 0; i < errorValue.length; i++) {
-    pointerString += "^";
-  }
-  return choppedString + "\n" + pointerPadding + pointerString + "\n";
-}
-
-export class CssToken {
-  numValue: number;
-  constructor(public index: number, public column: number, public line: number,
-              public type: CssTokenType, public strValue: string) {
-    this.numValue = charCode(strValue, 0);
-  }
-}
-
-export class CssLexer {
-  scan(text: string, trackComments: boolean = false): CssScanner {
-    return new CssScanner(text, trackComments);
-  }
-}
-
-export class CssScannerError extends BaseException {
-  public rawMessage: string;
-  public message: string;
-
-  constructor(public token: CssToken, message) {
-    super('Css Parse Error: ' + message);
-    this.rawMessage = message;
-  }
-
-  toString(): string { return this.message; }
-}
-
-function _trackWhitespace(mode: CssLexerMode) {
-  switch (mode) {
-    case CssLexerMode.SELECTOR:
-    case CssLexerMode.ALL_TRACK_WS:
-    case CssLexerMode.STYLE_VALUE:
-      return true;
-
-    default:
-      return false;
-  }
-}
-
-export class CssScanner {
-  peek: number;
-  peekPeek: number;
-  length: number = 0;
-  index: number = -1;
-  column: number = -1;
-  line: number = 0;
-
-  /** @internal */
-  _currentMode: CssLexerMode = CssLexerMode.BLOCK;
-  /** @internal */
-  _currentError: CssScannerError = null;
-
-  constructor(public input: string, private _trackComments: boolean = false) {
-    this.length = this.input.length;
-    this.peekPeek = this.peekAt(0);
-    this.advance();
-  }
-
-  getMode(): CssLexerMode { return this._currentMode; }
-
-  setMode(mode: CssLexerMode) {
-    if (this._currentMode != mode) {
-      if (_trackWhitespace(this._currentMode)) {
-        this.consumeWhitespace();
-      }
-      this._currentMode = mode;
-    }
-  }
-
-  advance(): void {
-    if (isNewline(this.peek)) {
-      this.column = 0;
-      this.line++;
-    } else {
-      this.column++;
-    }
-
-    this.index++;
-    this.peek = this.peekPeek;
-    this.peekPeek = this.peekAt(this.index + 1);
-  }
-
-  peekAt(index: number): number {
-    return index >= this.length ? $EOF : StringWrapper.charCodeAt(this.input, index);
-  }
-
-  consumeEmptyStatements(): void {
-    this.consumeWhitespace();
-    while (this.peek == $SEMICOLON) {
-      this.advance();
-      this.consumeWhitespace();
-    }
-  }
-
-  consumeWhitespace(): void {
-    while (isWhitespace(this.peek) || isNewline(this.peek)) {
-      this.advance();
-      if (!this._trackComments && isCommentStart(this.peek, this.peekPeek)) {
-        this.advance();  // /
-        this.advance();  // *
-        while (!isCommentEnd(this.peek, this.peekPeek)) {
-          if (this.peek == $EOF) {
-            this.error('Unterminated comment');
-          }
-          this.advance();
-        }
-        this.advance();  // *
-        this.advance();  // /
-      }
-    }
-  }
-
-  consume(type: CssTokenType, value: string = null): LexedCssResult {
-    var mode = this._currentMode;
-    this.setMode(CssLexerMode.ALL);
-
-    var previousIndex = this.index;
-    var previousLine = this.line;
-    var previousColumn = this.column;
-
-    var output = this.scan();
-
-    // just incase the inner scan method returned an error
-    if (isPresent(output.error)) {
-      this.setMode(mode);
-      return output;
-    }
-
-    var next = output.token;
-    if (!isPresent(next)) {
-      next = new CssToken(0, 0, 0, CssTokenType.EOF, "end of file");
-    }
-
-    var isMatchingType;
-    if (type == CssTokenType.IdentifierOrNumber) {
-      // TODO (matsko): implement array traversal for lookup here
-      isMatchingType = next.type == CssTokenType.Number || next.type == CssTokenType.Identifier;
-    } else {
-      isMatchingType = next.type == type;
-    }
-
-    // before throwing the error we need to bring back the former
-    // mode so that the parser can recover...
-    this.setMode(mode);
-
-    var error = null;
-    if (!isMatchingType || (isPresent(value) && value != next.strValue)) {
-      var errorMessage = resolveEnumToken(CssTokenType, next.type) + " does not match expected " +
-                         resolveEnumToken(CssTokenType, type) + " value";
-
-      if (isPresent(value)) {
-        errorMessage += ' ("' + next.strValue + '" should match "' + value + '")';
-      }
-
-      error = new CssScannerError(
-          next, generateErrorMessage(this.input, errorMessage, next.strValue, previousIndex,
-                                     previousLine, previousColumn));
-    }
-
-    return new LexedCssResult(error, next);
-  }
-
-
-  scan(): LexedCssResult {
-    var trackWS = _trackWhitespace(this._currentMode);
-    if (this.index == 0 && !trackWS) {  // first scan
-      this.consumeWhitespace();
-    }
-
-    var token = this._scan();
-    if (token == null) return null;
-
-    var error = this._currentError;
-    this._currentError = null;
-
-    if (!trackWS) {
-      this.consumeWhitespace();
-    }
-    return new LexedCssResult(error, token);
-  }
-
-  /** @internal */
-  _scan(): CssToken {
-    var peek = this.peek;
-    var peekPeek = this.peekPeek;
-    if (peek == $EOF) return null;
-
-    if (isCommentStart(peek, peekPeek)) {
-      // even if comments are not tracked we still lex the
-      // comment so we can move the pointer forward
-      var commentToken = this.scanComment();
-      if (this._trackComments) {
-        return commentToken;
-      }
-    }
-
-    if (_trackWhitespace(this._currentMode) && (isWhitespace(peek) || isNewline(peek))) {
-      return this.scanWhitespace();
-    }
-
-    peek = this.peek;
-    peekPeek = this.peekPeek;
-    if (peek == $EOF) return null;
-
-    if (isStringStart(peek, peekPeek)) {
-      return this.scanString();
-    }
-
-    // something like url(cool)
-    if (this._currentMode == CssLexerMode.STYLE_VALUE_FUNCTION) {
-      return this.scanCssValueFunction();
-    }
-
-    var isModifier = peek == $PLUS || peek == $MINUS;
-    var digitA = isModifier ? false : isDigit(peek);
-    var digitB = isDigit(peekPeek);
-    if (digitA || (isModifier && (peekPeek == $PERIOD || digitB)) || (peek == $PERIOD && digitB)) {
-      return this.scanNumber();
-    }
-
-    if (peek == $AT) {
-      return this.scanAtExpression();
-    }
-
-    if (isIdentifierStart(peek, peekPeek)) {
-      return this.scanIdentifier();
-    }
-
-    if (isValidCssCharacter(peek, this._currentMode)) {
-      return this.scanCharacter();
-    }
-
-    return this.error(`Unexpected character [${StringWrapper.fromCharCode(peek)}]`);
-  }
-
-  scanComment(): CssToken {
-    if (this.assertCondition(isCommentStart(this.peek, this.peekPeek),
-                             "Expected comment start value")) {
-      return null;
-    }
-
-    var start = this.index;
-    var startingColumn = this.column;
-    var startingLine = this.line;
-
-    this.advance();  // /
-    this.advance();  // *
-
-    while (!isCommentEnd(this.peek, this.peekPeek)) {
-      if (this.peek == $EOF) {
-        this.error('Unterminated comment');
-      }
-      this.advance();
-    }
-
-    this.advance();  // *
-    this.advance();  // /
-
-    var str = this.input.substring(start, this.index);
-    return new CssToken(start, startingColumn, startingLine, CssTokenType.Comment, str);
-  }
-
-  scanWhitespace(): CssToken {
-    var start = this.index;
-    var startingColumn = this.column;
-    var startingLine = this.line;
-    while (isWhitespace(this.peek) && this.peek != $EOF) {
-      this.advance();
-    }
-    var str = this.input.substring(start, this.index);
-    return new CssToken(start, startingColumn, startingLine, CssTokenType.Whitespace, str);
-  }
-
-  scanString(): CssToken {
-    if (this.assertCondition(isStringStart(this.peek, this.peekPeek),
-                             "Unexpected non-string starting value")) {
-      return null;
-    }
-
-    var target = this.peek;
-    var start = this.index;
-    var startingColumn = this.column;
-    var startingLine = this.line;
-    var previous = target;
-    this.advance();
-
-    while (!isCharMatch(target, previous, this.peek)) {
-      if (this.peek == $EOF || isNewline(this.peek)) {
-        this.error('Unterminated quote');
-      }
-      previous = this.peek;
-      this.advance();
-    }
-
-    if (this.assertCondition(this.peek == target, "Unterminated quote")) {
-      return null;
-    }
-    this.advance();
-
-    var str = this.input.substring(start, this.index);
-    return new CssToken(start, startingColumn, startingLine, CssTokenType.String, str);
-  }
-
-  scanNumber(): CssToken {
-    var start = this.index;
-    var startingColumn = this.column;
-    if (this.peek == $PLUS || this.peek == $MINUS) {
-      this.advance();
-    }
-    var periodUsed = false;
-    while (isDigit(this.peek) || this.peek == $PERIOD) {
-      if (this.peek == $PERIOD) {
-        if (periodUsed) {
-          this.error('Unexpected use of a second period value');
-        }
-        periodUsed = true;
-      }
-      this.advance();
-    }
-    var strValue = this.input.substring(start, this.index);
-    return new CssToken(start, startingColumn, this.line, CssTokenType.Number, strValue);
-  }
-
-  scanIdentifier(): CssToken {
-    if (this.assertCondition(isIdentifierStart(this.peek, this.peekPeek),
-                             'Expected identifier starting value')) {
-      return null;
-    }
-
-    var start = this.index;
-    var startingColumn = this.column;
-    while (isIdentifierPart(this.peek)) {
-      this.advance();
-    }
-    var strValue = this.input.substring(start, this.index);
-    return new CssToken(start, startingColumn, this.line, CssTokenType.Identifier, strValue);
-  }
-
-  scanCssValueFunction(): CssToken {
-    var start = this.index;
-    var startingColumn = this.column;
-    while (this.peek != $EOF && this.peek != $RPAREN) {
-      this.advance();
-    }
-    var strValue = this.input.substring(start, this.index);
-    return new CssToken(start, startingColumn, this.line, CssTokenType.Identifier, strValue);
-  }
-
-  scanCharacter(): CssToken {
-    var start = this.index;
-    var startingColumn = this.column;
-    if (this.assertCondition(isValidCssCharacter(this.peek, this._currentMode),
-                             charStr(this.peek) + ' is not a valid CSS character')) {
-      return null;
-    }
-
-    var c = this.input.substring(start, start + 1);
-    this.advance();
-
-    return new CssToken(start, startingColumn, this.line, CssTokenType.Character, c);
-  }
-
-  scanAtExpression(): CssToken {
-    if (this.assertCondition(this.peek == $AT, 'Expected @ value')) {
-      return null;
-    }
-
-    var start = this.index;
-    var startingColumn = this.column;
-    this.advance();
-    if (isIdentifierStart(this.peek, this.peekPeek)) {
-      var ident = this.scanIdentifier();
-      var strValue = '@' + ident.strValue;
-      return new CssToken(start, startingColumn, this.line, CssTokenType.AtKeyword, strValue);
-    } else {
-      return this.scanCharacter();
-    }
-  }
-
-  assertCondition(status: boolean, errorMessage: string): boolean {
-    if (!status) {
-      this.error(errorMessage);
-      return true;
-    }
-    return false;
-  }
-
-  error(message: string, errorTokenValue: string = null, doNotAdvance: boolean = false): CssToken {
-    var index: number = this.index;
-    var column: number = this.column;
-    var line: number = this.line;
-    errorTokenValue =
-        isPresent(errorTokenValue) ? errorTokenValue : StringWrapper.fromCharCode(this.peek);
-    var invalidToken = new CssToken(index, column, line, CssTokenType.Invalid, errorTokenValue);
-    var errorMessage =
-        generateErrorMessage(this.input, message, errorTokenValue, index, line, column);
-    if (!doNotAdvance) {
-      this.advance();
-    }
-    this._currentError = new CssScannerError(invalidToken, errorMessage);
-    return invalidToken;
-  }
-}
-
-function isAtKeyword(current: CssToken, next: CssToken): boolean {
-  return current.numValue == $AT && next.type == CssTokenType.Identifier;
-}
-
-function isCharMatch(target: number, previous: number, code: number): boolean {
-  return code == target && previous != $BACKSLASH;
-}
-
-function isDigit(code: number): boolean {
-  return $0 <= code && code <= $9;
-}
-
-function isCommentStart(code: number, next: number): boolean {
-  return code == $SLASH && next == $STAR;
-}
-
-function isCommentEnd(code: number, next: number): boolean {
-  return code == $STAR && next == $SLASH;
-}
-
-function isStringStart(code: number, next: number): boolean {
-  var target = code;
-  if (target == $BACKSLASH) {
-    target = next;
-  }
-  return target == $DQ || target == $SQ;
-}
-
-function isIdentifierStart(code: number, next: number): boolean {
-  var target = code;
-  if (target == $MINUS) {
-    target = next;
-  }
-
-  return ($a <= target && target <= $z) || ($A <= target && target <= $Z) || target == $BACKSLASH ||
-         target == $MINUS || target == $_;
-}
-
-function isIdentifierPart(target: number): boolean {
-  return ($a <= target && target <= $z) || ($A <= target && target <= $Z) || target == $BACKSLASH ||
-         target == $MINUS || target == $_ || isDigit(target);
-}
-
-function isValidPseudoSelectorCharacter(code: number): boolean {
-  switch (code) {
-    case $LPAREN:
-    case $RPAREN:
-      return true;
-    default:
-      return false;
-  }
-}
-
-function isValidKeyframeBlockCharacter(code: number): boolean {
-  return code == $PERCENT;
-}
-
-function isValidAttributeSelectorCharacter(code: number): boolean {
-  // value^*|$~=something
-  switch (code) {
-    case $$:
-    case $PIPE:
-    case $CARET:
-    case $TILDA:
-    case $STAR:
-    case $EQ:
-      return true;
-    default:
-      return false;
-  }
-}
-
-function isValidSelectorCharacter(code: number): boolean {
-  // selector [ key   = value ]
-  // IDENT    C IDENT C IDENT C
-  // #id, .class, *+~>
-  // tag:PSEUDO
-  switch (code) {
-    case $HASH:
-    case $PERIOD:
-    case $TILDA:
-    case $STAR:
-    case $PLUS:
-    case $GT:
-    case $COLON:
-    case $PIPE:
-    case $COMMA:
-      return true;
-    default:
-      return false;
-  }
-}
-
-function isValidStyleBlockCharacter(code: number): boolean {
-  // key:value;
-  // key:calc(something ... )
-  switch (code) {
-    case $HASH:
-    case $SEMICOLON:
-    case $COLON:
-    case $PERCENT:
-    case $SLASH:
-    case $BACKSLASH:
-    case $BANG:
-    case $PERIOD:
-    case $LPAREN:
-    case $RPAREN:
-      return true;
-    default:
-      return false;
-  }
-}
-
-function isValidMediaQueryRuleCharacter(code: number): boolean {
-  // (min-width: 7.5em) and (orientation: landscape)
-  switch (code) {
-    case $LPAREN:
-    case $RPAREN:
-    case $COLON:
-    case $PERCENT:
-    case $PERIOD:
-      return true;
-    default:
-      return false;
-  }
-}
-
-function isValidAtRuleCharacter(code: number): boolean {
-  // @document url(http://www.w3.org/page?something=on#hash),
-  switch (code) {
-    case $LPAREN:
-    case $RPAREN:
-    case $COLON:
-    case $PERCENT:
-    case $PERIOD:
-    case $SLASH:
-    case $BACKSLASH:
-    case $HASH:
-    case $EQ:
-    case $QUESTION:
-    case $AMPERSAND:
-    case $STAR:
-    case $COMMA:
-    case $MINUS:
-    case $PLUS:
-      return true;
-    default:
-      return false;
-  }
-}
-
-function isValidStyleFunctionCharacter(code: number): boolean {
-  switch (code) {
-    case $PERIOD:
-    case $MINUS:
-    case $PLUS:
-    case $STAR:
-    case $SLASH:
-    case $LPAREN:
-    case $RPAREN:
-    case $COMMA:
-      return true;
-    default:
-      return false;
-  }
-}
-
-function isValidBlockCharacter(code: number): boolean {
-  // @something { }
-  // IDENT
-  return code == $AT;
-}
-
-function isValidCssCharacter(code: number, mode: CssLexerMode): boolean {
-  switch (mode) {
-    case CssLexerMode.ALL:
-    case CssLexerMode.ALL_TRACK_WS:
-      return true;
-
-    case CssLexerMode.SELECTOR:
-      return isValidSelectorCharacter(code);
-
-    case CssLexerMode.PSEUDO_SELECTOR:
-      return isValidPseudoSelectorCharacter(code);
-
-    case CssLexerMode.ATTRIBUTE_SELECTOR:
-      return isValidAttributeSelectorCharacter(code);
-
-    case CssLexerMode.MEDIA_QUERY:
-      return isValidMediaQueryRuleCharacter(code);
-
-    case CssLexerMode.AT_RULE_QUERY:
-      return isValidAtRuleCharacter(code);
-
-    case CssLexerMode.KEYFRAME_BLOCK:
-      return isValidKeyframeBlockCharacter(code);
-
-    case CssLexerMode.STYLE_BLOCK:
-    case CssLexerMode.STYLE_VALUE:
-      return isValidStyleBlockCharacter(code);
-
-    case CssLexerMode.STYLE_CALC_FUNCTION:
-      return isValidStyleFunctionCharacter(code);
-
-    case CssLexerMode.BLOCK:
-      return isValidBlockCharacter(code);
-
-    default:
-      return false;
-  }
-}
-
-function charCode(input, index): number {
-  return index >= input.length ? $EOF : StringWrapper.charCodeAt(input, index);
-}
-
-function charStr(code: number): string {
-  return StringWrapper.fromCharCode(code);
-}
-
-export function isNewline(code): boolean {
-  switch (code) {
-    case $FF:
-    case $CR:
-    case $LF:
-    case $VTAB:
-      return true;
-
-    default:
-      return false;
-  }
-}
--- a/modules/@angular/compiler/src/css/parser.ts
+++ b/modules/@angular/compiler/src/css/parser.ts
@ -1,740 +0,0 @@
-import {
-  ParseSourceSpan,
-  ParseSourceFile,
-  ParseLocation,
-  ParseError
-} from '@angular/compiler/src/parse_util';
-
-import {
-  bitWiseOr,
-  bitWiseAnd,
-  NumberWrapper,
-  StringWrapper,
-  isPresent
-} from '../../src/facade/lang';
-
-import {
-  CssLexerMode,
-  CssToken,
-  CssTokenType,
-  CssScanner,
-  CssScannerError,
-  generateErrorMessage,
-  $AT,
-  $EOF,
-  $RBRACE,
-  $LBRACE,
-  $LBRACKET,
-  $RBRACKET,
-  $LPAREN,
-  $RPAREN,
-  $COMMA,
-  $COLON,
-  $SEMICOLON,
-  isNewline
-} from '@angular/compiler/src/css/lexer';
-
-export {CssToken} from '@angular/compiler/src/css/lexer';
-
-export enum BlockType {
-  Import,
-  Charset,
-  Namespace,
-  Supports,
-  Keyframes,
-  MediaQuery,
-  Selector,
-  FontFace,
-  Page,
-  Document,
-  Viewport,
-  Unsupported
-}
-
-const EOF_DELIM = 1;
-const RBRACE_DELIM = 2;
-const LBRACE_DELIM = 4;
-const COMMA_DELIM = 8;
-const COLON_DELIM = 16;
-const SEMICOLON_DELIM = 32;
-const NEWLINE_DELIM = 64;
-const RPAREN_DELIM = 128;
-
-function mergeTokens(tokens: CssToken[], separator: string = ""): CssToken {
-  var mainToken = tokens[0];
-  var str = mainToken.strValue;
-  for (var i = 1; i < tokens.length; i++) {
-    str += separator + tokens[i].strValue;
-  }
-
-  return new CssToken(mainToken.index, mainToken.column, mainToken.line, mainToken.type, str);
-}
-
-function getDelimFromToken(token: CssToken): number {
-  return getDelimFromCharacter(token.numValue);
-}
-
-function getDelimFromCharacter(code: number): number {
-  switch (code) {
-    case $EOF:
-      return EOF_DELIM;
-    case $COMMA:
-      return COMMA_DELIM;
-    case $COLON:
-      return COLON_DELIM;
-    case $SEMICOLON:
-      return SEMICOLON_DELIM;
-    case $RBRACE:
-      return RBRACE_DELIM;
-    case $LBRACE:
-      return LBRACE_DELIM;
-    case $RPAREN:
-      return RPAREN_DELIM;
-    default:
-      return isNewline(code) ? NEWLINE_DELIM : 0;
-  }
-}
-
-function characterContainsDelimiter(code: number, delimiters: number): boolean {
-  return bitWiseAnd([getDelimFromCharacter(code), delimiters]) > 0;
-}
-
-export class CssAST {
-  visit(visitor: CssASTVisitor, context?: any): void {}
-}
-
-export interface CssASTVisitor {
-  visitCssValue(ast: CssStyleValueAST, context?: any): void;
-  visitInlineCssRule(ast: CssInlineRuleAST, context?: any): void;
-  visitCssKeyframeRule(ast: CssKeyframeRuleAST, context?: any): void;
-  visitCssKeyframeDefinition(ast: CssKeyframeDefinitionAST, context?: any): void;
-  visitCssMediaQueryRule(ast: CssMediaQueryRuleAST, context?: any): void;
-  visitCssSelectorRule(ast: CssSelectorRuleAST, context?: any): void;
-  visitCssSelector(ast: CssSelectorAST, context?: any): void;
-  visitCssDefinition(ast: CssDefinitionAST, context?: any): void;
-  visitCssBlock(ast: CssBlockAST, context?: any): void;
-  visitCssStyleSheet(ast: CssStyleSheetAST, context?: any): void;
-  visitUnkownRule(ast: CssUnknownTokenListAST, context?: any): void;
-}
-
-export class ParsedCssResult {
-  constructor(public errors: CssParseError[], public ast: CssStyleSheetAST) {}
-}
-
-export class CssParser {
-  private _errors: CssParseError[] = [];
-  private _file: ParseSourceFile;
-
-  constructor(private _scanner: CssScanner, private _fileName: string) {
-    this._file = new ParseSourceFile(this._scanner.input, _fileName);
-  }
-
-  /** @internal */
-  _resolveBlockType(token: CssToken): BlockType {
-    switch (token.strValue) {
-      case '@-o-keyframes':
-      case '@-moz-keyframes':
-      case '@-webkit-keyframes':
-      case '@keyframes':
-        return BlockType.Keyframes;
-
-      case '@charset':
-        return BlockType.Charset;
-
-      case '@import':
-        return BlockType.Import;
-
-      case '@namespace':
-        return BlockType.Namespace;
-
-      case '@page':
-        return BlockType.Page;
-
-      case '@document':
-        return BlockType.Document;
-
-      case '@media':
-        return BlockType.MediaQuery;
-
-      case '@font-face':
-        return BlockType.FontFace;
-
-      case '@viewport':
-        return BlockType.Viewport;
-
-      case '@supports':
-        return BlockType.Supports;
-
-      default:
-        return BlockType.Unsupported;
-    }
-  }
-
-  parse(): ParsedCssResult {
-    var delimiters: number = EOF_DELIM;
-    var ast = this._parseStyleSheet(delimiters);
-
-    var errors = this._errors;
-    this._errors = [];
-
-    return new ParsedCssResult(errors, ast);
-  }
-
-  /** @internal */
-  _parseStyleSheet(delimiters): CssStyleSheetAST {
-    var results = [];
-    this._scanner.consumeEmptyStatements();
-    while (this._scanner.peek != $EOF) {
-      this._scanner.setMode(CssLexerMode.BLOCK);
-      results.push(this._parseRule(delimiters));
-    }
-    return new CssStyleSheetAST(results);
-  }
-
-  /** @internal */
-  _parseRule(delimiters: number): CssRuleAST {
-    if (this._scanner.peek == $AT) {
-      return this._parseAtRule(delimiters);
-    }
-    return this._parseSelectorRule(delimiters);
-  }
-
-  /** @internal */
-  _parseAtRule(delimiters: number): CssRuleAST {
-    this._scanner.setMode(CssLexerMode.BLOCK);
-
-    var token = this._scan();
-
-    this._assertCondition(token.type == CssTokenType.AtKeyword,
-                          `The CSS Rule ${token.strValue} is not a valid [@] rule.`, token);
-
-    var block, type = this._resolveBlockType(token);
-    switch (type) {
-      case BlockType.Charset:
-      case BlockType.Namespace:
-      case BlockType.Import:
-        var value = this._parseValue(delimiters);
-        this._scanner.setMode(CssLexerMode.BLOCK);
-        this._scanner.consumeEmptyStatements();
-        return new CssInlineRuleAST(type, value);
-
-      case BlockType.Viewport:
-      case BlockType.FontFace:
-        block = this._parseStyleBlock(delimiters);
-        return new CssBlockRuleAST(type, block);
-
-      case BlockType.Keyframes:
-        var tokens = this._collectUntilDelim(bitWiseOr([delimiters, RBRACE_DELIM, LBRACE_DELIM]));
-        // keyframes only have one identifier name
-        var name = tokens[0];
-        return new CssKeyframeRuleAST(name, this._parseKeyframeBlock(delimiters));
-
-      case BlockType.MediaQuery:
-        this._scanner.setMode(CssLexerMode.MEDIA_QUERY);
-        var tokens = this._collectUntilDelim(bitWiseOr([delimiters, RBRACE_DELIM, LBRACE_DELIM]));
-        return new CssMediaQueryRuleAST(tokens, this._parseBlock(delimiters));
-
-      case BlockType.Document:
-      case BlockType.Supports:
-      case BlockType.Page:
-        this._scanner.setMode(CssLexerMode.AT_RULE_QUERY);
-        var tokens = this._collectUntilDelim(bitWiseOr([delimiters, RBRACE_DELIM, LBRACE_DELIM]));
-        return new CssBlockDefinitionRuleAST(type, tokens, this._parseBlock(delimiters));
-
-      // if a custom @rule { ... } is used it should still tokenize the insides
-      default:
-        var listOfTokens = [];
-        this._scanner.setMode(CssLexerMode.ALL);
-        this._error(generateErrorMessage(
-                        this._scanner.input,
-                        `The CSS "at" rule "${token.strValue}" is not allowed to used here`,
-                        token.strValue, token.index, token.line, token.column),
-                    token);
-
-        this._collectUntilDelim(bitWiseOr([delimiters, LBRACE_DELIM, SEMICOLON_DELIM]))
-            .forEach((token) => { listOfTokens.push(token); });
-        if (this._scanner.peek == $LBRACE) {
-          this._consume(CssTokenType.Character, '{');
-          this._collectUntilDelim(bitWiseOr([delimiters, RBRACE_DELIM, LBRACE_DELIM]))
-              .forEach((token) => { listOfTokens.push(token); });
-          this._consume(CssTokenType.Character, '}');
-        }
-        return new CssUnknownTokenListAST(token, listOfTokens);
-    }
-  }
-
-  /** @internal */
-  _parseSelectorRule(delimiters: number): CssSelectorRuleAST {
-    var selectors = this._parseSelectors(delimiters);
-    var block = this._parseStyleBlock(delimiters);
-    this._scanner.setMode(CssLexerMode.BLOCK);
-    this._scanner.consumeEmptyStatements();
-    return new CssSelectorRuleAST(selectors, block);
-  }
-
-  /** @internal */
-  _parseSelectors(delimiters: number): CssSelectorAST[] {
-    delimiters = bitWiseOr([delimiters, LBRACE_DELIM]);
-
-    var selectors = [];
-    var isParsingSelectors = true;
-    while (isParsingSelectors) {
-      selectors.push(this._parseSelector(delimiters));
-
-      isParsingSelectors = !characterContainsDelimiter(this._scanner.peek, delimiters);
-
-      if (isParsingSelectors) {
-        this._consume(CssTokenType.Character, ',');
-        isParsingSelectors = !characterContainsDelimiter(this._scanner.peek, delimiters);
-      }
-    }
-
-    return selectors;
-  }
-
-  /** @internal */
-  _scan(): CssToken {
-    var output = this._scanner.scan();
-    var token = output.token;
-    var error = output.error;
-    if (isPresent(error)) {
-      this._error(error.rawMessage, token);
-    }
-    return token;
-  }
-
-  /** @internal */
-  _consume(type: CssTokenType, value: string = null): CssToken {
-    var output = this._scanner.consume(type, value);
-    var token = output.token;
-    var error = output.error;
-    if (isPresent(error)) {
-      this._error(error.rawMessage, token);
-    }
-    return token;
-  }
-
-  /** @internal */
-  _parseKeyframeBlock(delimiters: number): CssBlockAST {
-    delimiters = bitWiseOr([delimiters, RBRACE_DELIM]);
-    this._scanner.setMode(CssLexerMode.KEYFRAME_BLOCK);
-
-    this._consume(CssTokenType.Character, '{');
-
-    var definitions = [];
-    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
-      definitions.push(this._parseKeyframeDefinition(delimiters));
-    }
-
-    this._consume(CssTokenType.Character, '}');
-
-    return new CssBlockAST(definitions);
-  }
-
-  /** @internal */
-  _parseKeyframeDefinition(delimiters: number): CssKeyframeDefinitionAST {
-    var stepTokens = [];
-    delimiters = bitWiseOr([delimiters, LBRACE_DELIM]);
-    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
-      stepTokens.push(this._parseKeyframeLabel(bitWiseOr([delimiters, COMMA_DELIM])));
-      if (this._scanner.peek != $LBRACE) {
-        this._consume(CssTokenType.Character, ',');
-      }
-    }
-    var styles = this._parseStyleBlock(bitWiseOr([delimiters, RBRACE_DELIM]));
-    this._scanner.setMode(CssLexerMode.BLOCK);
-    return new CssKeyframeDefinitionAST(stepTokens, styles);
-  }
-
-  /** @internal */
-  _parseKeyframeLabel(delimiters: number): CssToken {
-    this._scanner.setMode(CssLexerMode.KEYFRAME_BLOCK);
-    return mergeTokens(this._collectUntilDelim(delimiters));
-  }
-
-  /** @internal */
-  _parseSelector(delimiters: number): CssSelectorAST {
-    delimiters = bitWiseOr([delimiters, COMMA_DELIM, LBRACE_DELIM]);
-    this._scanner.setMode(CssLexerMode.SELECTOR);
-
-    var selectorCssTokens = [];
-    var isComplex = false;
-    var wsCssToken;
-
-    var previousToken;
-    var parenCount = 0;
-    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
-      var code = this._scanner.peek;
-      switch (code) {
-        case $LPAREN:
-          parenCount++;
-          break;
-
-        case $RPAREN:
-          parenCount--;
-          break;
-
-        case $COLON:
-          this._scanner.setMode(CssLexerMode.PSEUDO_SELECTOR);
-          previousToken = this._consume(CssTokenType.Character, ':');
-          selectorCssTokens.push(previousToken);
-          continue;
-
-        case $LBRACKET:
-          // if we are already inside an attribute selector then we can't
-          // jump into the mode again. Therefore this error will get picked
-          // up when the scan method is called below.
-          if (this._scanner.getMode() != CssLexerMode.ATTRIBUTE_SELECTOR) {
-            selectorCssTokens.push(this._consume(CssTokenType.Character, '['));
-            this._scanner.setMode(CssLexerMode.ATTRIBUTE_SELECTOR);
-            continue;
-          }
-          break;
-
-        case $RBRACKET:
-          selectorCssTokens.push(this._consume(CssTokenType.Character, ']'));
-          this._scanner.setMode(CssLexerMode.SELECTOR);
-          continue;
-      }
-
-      var token = this._scan();
-
-      // special case for the ":not(" selector since it
-      // contains an inner selector that needs to be parsed
-      // in isolation
-      if (this._scanner.getMode() == CssLexerMode.PSEUDO_SELECTOR && isPresent(previousToken) &&
-          previousToken.numValue == $COLON && token.strValue == "not" &&
-          this._scanner.peek == $LPAREN) {
-        selectorCssTokens.push(token);
-        selectorCssTokens.push(this._consume(CssTokenType.Character, '('));
-
-        // the inner selector inside of :not(...) can only be one
-        // CSS selector (no commas allowed) therefore we parse only
-        // one selector by calling the method below
-        this._parseSelector(bitWiseOr([delimiters, RPAREN_DELIM]))
-            .tokens.forEach(
-                (innerSelectorToken) => { selectorCssTokens.push(innerSelectorToken); });
-
-        selectorCssTokens.push(this._consume(CssTokenType.Character, ')'));
-
-        continue;
-      }
-
-      previousToken = token;
-
-      if (token.type == CssTokenType.Whitespace) {
-        wsCssToken = token;
-      } else {
-        if (isPresent(wsCssToken)) {
-          selectorCssTokens.push(wsCssToken);
-          wsCssToken = null;
-          isComplex = true;
-        }
-        selectorCssTokens.push(token);
-      }
-    }
-
-    if (this._scanner.getMode() == CssLexerMode.ATTRIBUTE_SELECTOR) {
-      this._error(
-          `Unbalanced CSS attribute selector at column ${previousToken.line}:${previousToken.column}`,
-          previousToken);
-    } else if (parenCount > 0) {
-      this._error(
-          `Unbalanced pseudo selector function value at column ${previousToken.line}:${previousToken.column}`,
-          previousToken);
-    }
-
-    return new CssSelectorAST(selectorCssTokens, isComplex);
-  }
-
-  /** @internal */
-  _parseValue(delimiters: number): CssStyleValueAST {
-    delimiters = bitWiseOr([delimiters, RBRACE_DELIM, SEMICOLON_DELIM, NEWLINE_DELIM]);
-
-    this._scanner.setMode(CssLexerMode.STYLE_VALUE);
-
-    var strValue = "";
-    var tokens = [];
-    var previous: CssToken;
-    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
-      var token;
-      if (isPresent(previous) && previous.type == CssTokenType.Identifier &&
-          this._scanner.peek == $LPAREN) {
-        token = this._consume(CssTokenType.Character, '(');
-        tokens.push(token);
-        strValue += token.strValue;
-
-        this._scanner.setMode(CssLexerMode.STYLE_VALUE_FUNCTION);
-
-        token = this._scan();
-        tokens.push(token);
-        strValue += token.strValue;
-
-        this._scanner.setMode(CssLexerMode.STYLE_VALUE);
-
-        token = this._consume(CssTokenType.Character, ')');
-        tokens.push(token);
-        strValue += token.strValue;
-      } else {
-        token = this._scan();
-        if (token.type != CssTokenType.Whitespace) {
-          tokens.push(token);
-        }
-        strValue += token.strValue;
-      }
-
-      previous = token;
-    }
-
-    this._scanner.consumeWhitespace();
-
-    var code = this._scanner.peek;
-    if (code == $SEMICOLON) {
-      this._consume(CssTokenType.Character, ';');
-    } else if (code != $RBRACE) {
-      this._error(
-          generateErrorMessage(this._scanner.input,
-                               `The CSS key/value definition did not end with a semicolon`,
-                               previous.strValue, previous.index, previous.line, previous.column),
-          previous);
-    }
-
-    return new CssStyleValueAST(tokens, strValue);
-  }
-
-  /** @internal */
-  _collectUntilDelim(delimiters: number, assertType: CssTokenType = null): CssToken[] {
-    var tokens = [];
-    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
-      var val = isPresent(assertType) ? this._consume(assertType) : this._scan();
-      tokens.push(val);
-    }
-    return tokens;
-  }
-
-  /** @internal */
-  _parseBlock(delimiters: number): CssBlockAST {
-    delimiters = bitWiseOr([delimiters, RBRACE_DELIM]);
-
-    this._scanner.setMode(CssLexerMode.BLOCK);
-
-    this._consume(CssTokenType.Character, '{');
-    this._scanner.consumeEmptyStatements();
-
-    var results = [];
-    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
-      results.push(this._parseRule(delimiters));
-    }
-
-    this._consume(CssTokenType.Character, '}');
-
-    this._scanner.setMode(CssLexerMode.BLOCK);
-    this._scanner.consumeEmptyStatements();
-
-    return new CssBlockAST(results);
-  }
-
-  /** @internal */
-  _parseStyleBlock(delimiters: number): CssBlockAST {
-    delimiters = bitWiseOr([delimiters, RBRACE_DELIM, LBRACE_DELIM]);
-
-    this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
-
-    this._consume(CssTokenType.Character, '{');
-    this._scanner.consumeEmptyStatements();
-
-    var definitions = [];
-    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
-      definitions.push(this._parseDefinition(delimiters));
-      this._scanner.consumeEmptyStatements();
-    }
-
-    this._consume(CssTokenType.Character, '}');
-
-    this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
-    this._scanner.consumeEmptyStatements();
-
-    return new CssBlockAST(definitions);
-  }
-
-  /** @internal */
-  _parseDefinition(delimiters: number): CssDefinitionAST {
-    this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
-
-    var prop = this._consume(CssTokenType.Identifier);
-    var parseValue, value = null;
-
-    // the colon value separates the prop from the style.
-    // there are a few cases as to what could happen if it
-    // is missing
-    switch (this._scanner.peek) {
-      case $COLON:
-        this._consume(CssTokenType.Character, ':');
-        parseValue = true;
-        break;
-
-      case $SEMICOLON:
-      case $RBRACE:
-      case $EOF:
-        parseValue = false;
-        break;
-
-      default:
-        var propStr = [prop.strValue];
-        if (this._scanner.peek != $COLON) {
-          // this will throw the error
-          var nextValue = this._consume(CssTokenType.Character, ':');
-          propStr.push(nextValue.strValue);
-
-          var remainingTokens = this._collectUntilDelim(
-              bitWiseOr([delimiters, COLON_DELIM, SEMICOLON_DELIM]), CssTokenType.Identifier);
-          if (remainingTokens.length > 0) {
-            remainingTokens.forEach((token) => { propStr.push(token.strValue); });
-          }
-
-          prop = new CssToken(prop.index, prop.column, prop.line, prop.type, propStr.join(" "));
-        }
-
-        // this means we've reached the end of the definition and/or block
-        if (this._scanner.peek == $COLON) {
-          this._consume(CssTokenType.Character, ':');
-          parseValue = true;
-        } else {
-          parseValue = false;
-        }
-        break;
-    }
-
-    if (parseValue) {
-      value = this._parseValue(delimiters);
-    } else {
-      this._error(generateErrorMessage(this._scanner.input,
-                                       `The CSS property was not paired with a style value`,
-                                       prop.strValue, prop.index, prop.line, prop.column),
-                  prop);
-    }
-
-    return new CssDefinitionAST(prop, value);
-  }
-
-  /** @internal */
-  _assertCondition(status: boolean, errorMessage: string, problemToken: CssToken): boolean {
-    if (!status) {
-      this._error(errorMessage, problemToken);
-      return true;
-    }
-    return false;
-  }
-
-  /** @internal */
-  _error(message: string, problemToken: CssToken) {
-    var length = problemToken.strValue.length;
-    var error = CssParseError.create(this._file, 0, problemToken.line, problemToken.column, length,
-                                     message);
-    this._errors.push(error);
-  }
-}
-
-export class CssStyleValueAST extends CssAST {
-  constructor(public tokens: CssToken[], public strValue: string) { super(); }
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitCssValue(this); }
-}
-
-export class CssRuleAST extends CssAST {}
-
-export class CssBlockRuleAST extends CssRuleAST {
-  constructor(public type: BlockType, public block: CssBlockAST, public name: CssToken = null) {
-    super();
-  }
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitCssBlock(this.block, context); }
-}
-
-export class CssKeyframeRuleAST extends CssBlockRuleAST {
-  constructor(name: CssToken, block: CssBlockAST) { super(BlockType.Keyframes, block, name); }
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitCssKeyframeRule(this, context); }
-}
-
-export class CssKeyframeDefinitionAST extends CssBlockRuleAST {
-  public steps;
-  constructor(_steps: CssToken[], block: CssBlockAST) {
-    super(BlockType.Keyframes, block, mergeTokens(_steps, ","));
-    this.steps = _steps;
-  }
-  visit(visitor: CssASTVisitor, context?: any) {
-    visitor.visitCssKeyframeDefinition(this, context);
-  }
-}
-
-export class CssBlockDefinitionRuleAST extends CssBlockRuleAST {
-  public strValue: string;
-  constructor(type: BlockType, public query: CssToken[], block: CssBlockAST) {
-    super(type, block);
-    this.strValue = query.map(token => token.strValue).join("");
-    var firstCssToken: CssToken = query[0];
-    this.name = new CssToken(firstCssToken.index, firstCssToken.column, firstCssToken.line,
-                             CssTokenType.Identifier, this.strValue);
-  }
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitCssBlock(this.block, context); }
-}
-
-export class CssMediaQueryRuleAST extends CssBlockDefinitionRuleAST {
-  constructor(query: CssToken[], block: CssBlockAST) { super(BlockType.MediaQuery, query, block); }
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitCssMediaQueryRule(this, context); }
-}
-
-export class CssInlineRuleAST extends CssRuleAST {
-  constructor(public type: BlockType, public value: CssStyleValueAST) { super(); }
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitInlineCssRule(this, context); }
-}
-
-export class CssSelectorRuleAST extends CssBlockRuleAST {
-  public strValue: string;
-
-  constructor(public selectors: CssSelectorAST[], block: CssBlockAST) {
-    super(BlockType.Selector, block);
-    this.strValue = selectors.map(selector => selector.strValue).join(",");
-  }
-
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitCssSelectorRule(this, context); }
-}
-
-export class CssDefinitionAST extends CssAST {
-  constructor(public property: CssToken, public value: CssStyleValueAST) { super(); }
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitCssDefinition(this, context); }
-}
-
-export class CssSelectorAST extends CssAST {
-  public strValue;
-  constructor(public tokens: CssToken[], public isComplex: boolean = false) {
-    super();
-    this.strValue = tokens.map(token => token.strValue).join("");
-  }
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitCssSelector(this, context); }
-}
-
-export class CssBlockAST extends CssAST {
-  constructor(public entries: CssAST[]) { super(); }
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitCssBlock(this, context); }
-}
-
-export class CssStyleSheetAST extends CssAST {
-  constructor(public rules: CssAST[]) { super(); }
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitCssStyleSheet(this, context); }
-}
-
-export class CssParseError extends ParseError {
-  static create(file: ParseSourceFile, offset: number, line: number, col: number, length: number,
-                errMsg: string): CssParseError {
-    var start = new ParseLocation(file, offset, line, col);
-    var end = new ParseLocation(file, offset, line, col + length);
-    var span = new ParseSourceSpan(start, end);
-    return new CssParseError(span, "CSS Parse Error: " + errMsg);
-  }
-
-  constructor(span: ParseSourceSpan, message: string) { super(span, message); }
-}
-
-export class CssUnknownTokenListAST extends CssRuleAST {
-  constructor(public name, public tokens: CssToken[]) { super(); }
-  visit(visitor: CssASTVisitor, context?: any) { visitor.visitUnkownRule(this, context); }
-}
--- a/modules/@angular/compiler/src/expression_parser/ast.ts
+++ b/modules/@angular/compiler/src/expression_parser/ast.ts
@ -1,348 +0,0 @@
-import {ListWrapper} from '../../src/facade/collection';
-
-export class AST {
-  visit(visitor: AstVisitor, context: any = null): any { return null; }
-  toString(): string { return "AST"; }
-}
-
-/**
- * Represents a quoted expression of the form:
- *
- * quote = prefix `:` uninterpretedExpression
- * prefix = identifier
- * uninterpretedExpression = arbitrary string
- *
- * A quoted expression is meant to be pre-processed by an AST transformer that
- * converts it into another AST that no longer contains quoted expressions.
- * It is meant to allow third-party developers to extend Angular template
- * expression language. The `uninterpretedExpression` part of the quote is
- * therefore not interpreted by the Angular's own expression parser.
- */
-export class Quote extends AST {
-  constructor(public prefix: string, public uninterpretedExpression: string, public location: any) {
-    super();
-  }
-  visit(visitor: AstVisitor, context: any = null): any { return visitor.visitQuote(this, context); }
-  toString(): string { return "Quote"; }
-}
-
-export class EmptyExpr extends AST {
-  visit(visitor: AstVisitor, context: any = null) {
-    // do nothing
-  }
-}
-
-export class ImplicitReceiver extends AST {
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitImplicitReceiver(this, context);
-  }
-}
-
-/**
- * Multiple expressions separated by a semicolon.
- */
-export class Chain extends AST {
-  constructor(public expressions: any[]) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any { return visitor.visitChain(this, context); }
-}
-
-export class Conditional extends AST {
-  constructor(public condition: AST, public trueExp: AST, public falseExp: AST) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitConditional(this, context);
-  }
-}
-
-export class PropertyRead extends AST {
-  constructor(public receiver: AST, public name: string) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitPropertyRead(this, context);
-  }
-}
-
-export class PropertyWrite extends AST {
-  constructor(public receiver: AST, public name: string, public value: AST) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitPropertyWrite(this, context);
-  }
-}
-
-export class SafePropertyRead extends AST {
-  constructor(public receiver: AST, public name: string) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitSafePropertyRead(this, context);
-  }
-}
-
-export class KeyedRead extends AST {
-  constructor(public obj: AST, public key: AST) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitKeyedRead(this, context);
-  }
-}
-
-export class KeyedWrite extends AST {
-  constructor(public obj: AST, public key: AST, public value: AST) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitKeyedWrite(this, context);
-  }
-}
-
-export class BindingPipe extends AST {
-  constructor(public exp: AST, public name: string, public args: any[]) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any { return visitor.visitPipe(this, context); }
-}
-
-export class LiteralPrimitive extends AST {
-  constructor(public value) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitLiteralPrimitive(this, context);
-  }
-}
-
-export class LiteralArray extends AST {
-  constructor(public expressions: any[]) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitLiteralArray(this, context);
-  }
-}
-
-export class LiteralMap extends AST {
-  constructor(public keys: any[], public values: any[]) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitLiteralMap(this, context);
-  }
-}
-
-export class Interpolation extends AST {
-  constructor(public strings: any[], public expressions: any[]) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitInterpolation(this, context);
-  }
-}
-
-export class Binary extends AST {
-  constructor(public operation: string, public left: AST, public right: AST) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitBinary(this, context);
-  }
-}
-
-export class PrefixNot extends AST {
-  constructor(public expression: AST) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitPrefixNot(this, context);
-  }
-}
-
-export class MethodCall extends AST {
-  constructor(public receiver: AST, public name: string, public args: any[]) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitMethodCall(this, context);
-  }
-}
-
-export class SafeMethodCall extends AST {
-  constructor(public receiver: AST, public name: string, public args: any[]) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitSafeMethodCall(this, context);
-  }
-}
-
-export class FunctionCall extends AST {
-  constructor(public target: AST, public args: any[]) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any {
-    return visitor.visitFunctionCall(this, context);
-  }
-}
-
-export class ASTWithSource extends AST {
-  constructor(public ast: AST, public source: string, public location: string) { super(); }
-  visit(visitor: AstVisitor, context: any = null): any { return this.ast.visit(visitor, context); }
-  toString(): string { return `${this.source} in ${this.location}`; }
-}
-
-export class TemplateBinding {
-  constructor(public key: string, public keyIsVar: boolean, public name: string,
-              public expression: ASTWithSource) {}
-}
-
-export interface AstVisitor {
-  visitBinary(ast: Binary, context: any): any;
-  visitChain(ast: Chain, context: any): any;
-  visitConditional(ast: Conditional, context: any): any;
-  visitFunctionCall(ast: FunctionCall, context: any): any;
-  visitImplicitReceiver(ast: ImplicitReceiver, context: any): any;
-  visitInterpolation(ast: Interpolation, context: any): any;
-  visitKeyedRead(ast: KeyedRead, context: any): any;
-  visitKeyedWrite(ast: KeyedWrite, context: any): any;
-  visitLiteralArray(ast: LiteralArray, context: any): any;
-  visitLiteralMap(ast: LiteralMap, context: any): any;
-  visitLiteralPrimitive(ast: LiteralPrimitive, context: any): any;
-  visitMethodCall(ast: MethodCall, context: any): any;
-  visitPipe(ast: BindingPipe, context: any): any;
-  visitPrefixNot(ast: PrefixNot, context: any): any;
-  visitPropertyRead(ast: PropertyRead, context: any): any;
-  visitPropertyWrite(ast: PropertyWrite, context: any): any;
-  visitQuote(ast: Quote, context: any): any;
-  visitSafeMethodCall(ast: SafeMethodCall, context: any): any;
-  visitSafePropertyRead(ast: SafePropertyRead, context: any): any;
-}
-
-export class RecursiveAstVisitor implements AstVisitor {
-  visitBinary(ast: Binary, context: any): any {
-    ast.left.visit(this);
-    ast.right.visit(this);
-    return null;
-  }
-  visitChain(ast: Chain, context: any): any { return this.visitAll(ast.expressions, context); }
-  visitConditional(ast: Conditional, context: any): any {
-    ast.condition.visit(this);
-    ast.trueExp.visit(this);
-    ast.falseExp.visit(this);
-    return null;
-  }
-  visitPipe(ast: BindingPipe, context: any): any {
-    ast.exp.visit(this);
-    this.visitAll(ast.args, context);
-    return null;
-  }
-  visitFunctionCall(ast: FunctionCall, context: any): any {
-    ast.target.visit(this);
-    this.visitAll(ast.args, context);
-    return null;
-  }
-  visitImplicitReceiver(ast: ImplicitReceiver, context: any): any { return null; }
-  visitInterpolation(ast: Interpolation, context: any): any {
-    return this.visitAll(ast.expressions, context);
-  }
-  visitKeyedRead(ast: KeyedRead, context: any): any {
-    ast.obj.visit(this);
-    ast.key.visit(this);
-    return null;
-  }
-  visitKeyedWrite(ast: KeyedWrite, context: any): any {
-    ast.obj.visit(this);
-    ast.key.visit(this);
-    ast.value.visit(this);
-    return null;
-  }
-  visitLiteralArray(ast: LiteralArray, context: any): any {
-    return this.visitAll(ast.expressions, context);
-  }
-  visitLiteralMap(ast: LiteralMap, context: any): any { return this.visitAll(ast.values, context); }
-  visitLiteralPrimitive(ast: LiteralPrimitive, context: any): any { return null; }
-  visitMethodCall(ast: MethodCall, context: any): any {
-    ast.receiver.visit(this);
-    return this.visitAll(ast.args, context);
-  }
-  visitPrefixNot(ast: PrefixNot, context: any): any {
-    ast.expression.visit(this);
-    return null;
-  }
-  visitPropertyRead(ast: PropertyRead, context: any): any {
-    ast.receiver.visit(this);
-    return null;
-  }
-  visitPropertyWrite(ast: PropertyWrite, context: any): any {
-    ast.receiver.visit(this);
-    ast.value.visit(this);
-    return null;
-  }
-  visitSafePropertyRead(ast: SafePropertyRead, context: any): any {
-    ast.receiver.visit(this);
-    return null;
-  }
-  visitSafeMethodCall(ast: SafeMethodCall, context: any): any {
-    ast.receiver.visit(this);
-    return this.visitAll(ast.args, context);
-  }
-  visitAll(asts: AST[], context: any): any {
-    asts.forEach(ast => ast.visit(this, context));
-    return null;
-  }
-  visitQuote(ast: Quote, context: any): any { return null; }
-}
-
-export class AstTransformer implements AstVisitor {
-  visitImplicitReceiver(ast: ImplicitReceiver, context: any): AST { return ast; }
-
-  visitInterpolation(ast: Interpolation, context: any): AST {
-    return new Interpolation(ast.strings, this.visitAll(ast.expressions));
-  }
-
-  visitLiteralPrimitive(ast: LiteralPrimitive, context: any): AST {
-    return new LiteralPrimitive(ast.value);
-  }
-
-  visitPropertyRead(ast: PropertyRead, context: any): AST {
-    return new PropertyRead(ast.receiver.visit(this), ast.name);
-  }
-
-  visitPropertyWrite(ast: PropertyWrite, context: any): AST {
-    return new PropertyWrite(ast.receiver.visit(this), ast.name, ast.value);
-  }
-
-  visitSafePropertyRead(ast: SafePropertyRead, context: any): AST {
-    return new SafePropertyRead(ast.receiver.visit(this), ast.name);
-  }
-
-  visitMethodCall(ast: MethodCall, context: any): AST {
-    return new MethodCall(ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
-  }
-
-  visitSafeMethodCall(ast: SafeMethodCall, context: any): AST {
-    return new SafeMethodCall(ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
-  }
-
-  visitFunctionCall(ast: FunctionCall, context: any): AST {
-    return new FunctionCall(ast.target.visit(this), this.visitAll(ast.args));
-  }
-
-  visitLiteralArray(ast: LiteralArray, context: any): AST {
-    return new LiteralArray(this.visitAll(ast.expressions));
-  }
-
-  visitLiteralMap(ast: LiteralMap, context: any): AST {
-    return new LiteralMap(ast.keys, this.visitAll(ast.values));
-  }
-
-  visitBinary(ast: Binary, context: any): AST {
-    return new Binary(ast.operation, ast.left.visit(this), ast.right.visit(this));
-  }
-
-  visitPrefixNot(ast: PrefixNot, context: any): AST {
-    return new PrefixNot(ast.expression.visit(this));
-  }
-
-  visitConditional(ast: Conditional, context: any): AST {
-    return new Conditional(ast.condition.visit(this), ast.trueExp.visit(this),
-                           ast.falseExp.visit(this));
-  }
-
-  visitPipe(ast: BindingPipe, context: any): AST {
-    return new BindingPipe(ast.exp.visit(this), ast.name, this.visitAll(ast.args));
-  }
-
-  visitKeyedRead(ast: KeyedRead, context: any): AST {
-    return new KeyedRead(ast.obj.visit(this), ast.key.visit(this));
-  }
-
-  visitKeyedWrite(ast: KeyedWrite, context: any): AST {
-    return new KeyedWrite(ast.obj.visit(this), ast.key.visit(this), ast.value.visit(this));
-  }
-
-  visitAll(asts: any[]): any[] {
-    var res = ListWrapper.createFixedSize(asts.length);
-    for (var i = 0; i < asts.length; ++i) {
-      res[i] = asts[i].visit(this);
-    }
-    return res;
-  }
-
-  visitChain(ast: Chain, context: any): AST { return new Chain(this.visitAll(ast.expressions)); }
-
-  visitQuote(ast: Quote, context: any): AST {
-    return new Quote(ast.prefix, ast.uninterpretedExpression, ast.location);
-  }
-}
--- a/modules/@angular/compiler/src/facade
+++ b/modules/@angular/compiler/src/facade
@ -1 +0,0 @@
-../../facade/src
--- a/modules/@angular/compiler/src/html_ast.ts
+++ b/modules/@angular/compiler/src/html_ast.ts
@ -1,68 +0,0 @@
-import {isPresent} from '../src/facade/lang';
-
-import {ParseSourceSpan} from './parse_util';
-
-export interface HtmlAst {
-  sourceSpan: ParseSourceSpan;
-  visit(visitor: HtmlAstVisitor, context: any): any;
-}
-
-export class HtmlTextAst implements HtmlAst {
-  constructor(public value: string, public sourceSpan: ParseSourceSpan) {}
-  visit(visitor: HtmlAstVisitor, context: any): any { return visitor.visitText(this, context); }
-}
-
-export class HtmlExpansionAst implements HtmlAst {
-  constructor(public switchValue: string, public type: string, public cases: HtmlExpansionCaseAst[],
-              public sourceSpan: ParseSourceSpan, public switchValueSourceSpan: ParseSourceSpan) {}
-  visit(visitor: HtmlAstVisitor, context: any): any {
-    return visitor.visitExpansion(this, context);
-  }
-}
-
-export class HtmlExpansionCaseAst implements HtmlAst {
-  constructor(public value: string, public expression: HtmlAst[],
-              public sourceSpan: ParseSourceSpan, public valueSourceSpan: ParseSourceSpan,
-              public expSourceSpan: ParseSourceSpan) {}
-
-  visit(visitor: HtmlAstVisitor, context: any): any {
-    return visitor.visitExpansionCase(this, context);
-  }
-}
-
-export class HtmlAttrAst implements HtmlAst {
-  constructor(public name: string, public value: string, public sourceSpan: ParseSourceSpan) {}
-  visit(visitor: HtmlAstVisitor, context: any): any { return visitor.visitAttr(this, context); }
-}
-
-export class HtmlElementAst implements HtmlAst {
-  constructor(public name: string, public attrs: HtmlAttrAst[], public children: HtmlAst[],
-              public sourceSpan: ParseSourceSpan, public startSourceSpan: ParseSourceSpan,
-              public endSourceSpan: ParseSourceSpan) {}
-  visit(visitor: HtmlAstVisitor, context: any): any { return visitor.visitElement(this, context); }
-}
-
-export class HtmlCommentAst implements HtmlAst {
-  constructor(public value: string, public sourceSpan: ParseSourceSpan) {}
-  visit(visitor: HtmlAstVisitor, context: any): any { return visitor.visitComment(this, context); }
-}
-
-export interface HtmlAstVisitor {
-  visitElement(ast: HtmlElementAst, context: any): any;
-  visitAttr(ast: HtmlAttrAst, context: any): any;
-  visitText(ast: HtmlTextAst, context: any): any;
-  visitComment(ast: HtmlCommentAst, context: any): any;
-  visitExpansion(ast: HtmlExpansionAst, context: any): any;
-  visitExpansionCase(ast: HtmlExpansionCaseAst, context: any): any;
-}
-
-export function htmlVisitAll(visitor: HtmlAstVisitor, asts: HtmlAst[], context: any = null): any[] {
-  var result = [];
-  asts.forEach(ast => {
-    var astResult = ast.visit(visitor, context);
-    if (isPresent(astResult)) {
-      result.push(astResult);
-    }
-  });
-  return result;
-}
--- a/modules/@angular/compiler/src/i18n/expander.ts
+++ b/modules/@angular/compiler/src/i18n/expander.ts
@ -1,116 +0,0 @@
-import {
-  HtmlAst,
-  HtmlAstVisitor,
-  HtmlElementAst,
-  HtmlAttrAst,
-  HtmlTextAst,
-  HtmlCommentAst,
-  HtmlExpansionAst,
-  HtmlExpansionCaseAst,
-  htmlVisitAll
-} from '../html_ast';
-
-import {BaseException} from '../../src/facade/exceptions';
-
-
-/**
- * Expands special forms into elements.
- *
- * For example,
- *
- * ```
- * { messages.length, plural,
- *   =0 {zero}
- *   =1 {one}
- *   =other {more than one}
- * }
- * ```
- *
- * will be expanded into
- *
- * ```
- * <ul [ngPlural]="messages.length">
- *   <template [ngPluralCase]="0"><li i18n="plural_0">zero</li></template>
- *   <template [ngPluralCase]="1"><li i18n="plural_1">one</li></template>
- *   <template [ngPluralCase]="other"><li i18n="plural_other">more than one</li></template>
- * </ul>
- * ```
- */
-export function expandNodes(nodes: HtmlAst[]): ExpansionResult {
-  let e = new _Expander();
-  let n = htmlVisitAll(e, nodes);
-  return new ExpansionResult(n, e.expanded);
-}
-
-export class ExpansionResult {
-  constructor(public nodes: HtmlAst[], public expanded: boolean) {}
-}
-
-class _Expander implements HtmlAstVisitor {
-  expanded: boolean = false;
-  constructor() {}
-
-  visitElement(ast: HtmlElementAst, context: any): any {
-    return new HtmlElementAst(ast.name, ast.attrs, htmlVisitAll(this, ast.children), ast.sourceSpan,
-                              ast.startSourceSpan, ast.endSourceSpan);
-  }
-
-  visitAttr(ast: HtmlAttrAst, context: any): any { return ast; }
-
-  visitText(ast: HtmlTextAst, context: any): any { return ast; }
-
-  visitComment(ast: HtmlCommentAst, context: any): any { return ast; }
-
-  visitExpansion(ast: HtmlExpansionAst, context: any): any {
-    this.expanded = true;
-    return ast.type == "plural" ? _expandPluralForm(ast) : _expandDefaultForm(ast);
-  }
-
-  visitExpansionCase(ast: HtmlExpansionCaseAst, context: any): any {
-    throw new BaseException("Should not be reached");
-  }
-}
-
-function _expandPluralForm(ast: HtmlExpansionAst): HtmlElementAst {
-  let children = ast.cases.map(c => {
-    let expansionResult = expandNodes(c.expression);
-    let i18nAttrs = expansionResult.expanded ?
-                        [] :
-                        [new HtmlAttrAst("i18n", `${ast.type}_${c.value}`, c.valueSourceSpan)];
-
-    return new HtmlElementAst(`template`,
-                              [
-                                new HtmlAttrAst("ngPluralCase", c.value, c.valueSourceSpan),
-                              ],
-                              [
-                                new HtmlElementAst(`li`, i18nAttrs, expansionResult.nodes,
-                                                   c.sourceSpan, c.sourceSpan, c.sourceSpan)
-                              ],
-                              c.sourceSpan, c.sourceSpan, c.sourceSpan);
-  });
-  let switchAttr = new HtmlAttrAst("[ngPlural]", ast.switchValue, ast.switchValueSourceSpan);
-  return new HtmlElementAst("ul", [switchAttr], children, ast.sourceSpan, ast.sourceSpan,
-                            ast.sourceSpan);
-}
-
-function _expandDefaultForm(ast: HtmlExpansionAst): HtmlElementAst {
-  let children = ast.cases.map(c => {
-    let expansionResult = expandNodes(c.expression);
-    let i18nAttrs = expansionResult.expanded ?
-                        [] :
-                        [new HtmlAttrAst("i18n", `${ast.type}_${c.value}`, c.valueSourceSpan)];
-
-    return new HtmlElementAst(`template`,
-                              [
-                                new HtmlAttrAst("ngSwitchWhen", c.value, c.valueSourceSpan),
-                              ],
-                              [
-                                new HtmlElementAst(`li`, i18nAttrs, expansionResult.nodes,
-                                                   c.sourceSpan, c.sourceSpan, c.sourceSpan)
-                              ],
-                              c.sourceSpan, c.sourceSpan, c.sourceSpan);
-  });
-  let switchAttr = new HtmlAttrAst("[ngSwitch]", ast.switchValue, ast.switchValueSourceSpan);
-  return new HtmlElementAst("ul", [switchAttr], children, ast.sourceSpan, ast.sourceSpan,
-                            ast.sourceSpan);
-}
--- a/modules/@angular/compiler/src/i18n/i18n_html_parser.ts
+++ b/modules/@angular/compiler/src/i18n/i18n_html_parser.ts
@ -1,377 +0,0 @@
-import {HtmlParser, HtmlParseTreeResult} from '../html_parser';
-import {ParseSourceSpan, ParseError} from '../parse_util';
-import {
-  HtmlAst,
-  HtmlAstVisitor,
-  HtmlElementAst,
-  HtmlAttrAst,
-  HtmlTextAst,
-  HtmlCommentAst,
-  HtmlExpansionAst,
-  HtmlExpansionCaseAst,
-  htmlVisitAll
-} from '../html_ast';
-import {ListWrapper, StringMapWrapper} from '../../src/facade/collection';
-import {RegExpWrapper, NumberWrapper, isPresent} from '../../src/facade/lang';
-import {BaseException} from '../../src/facade/exceptions';
-import {Parser} from '../expression_parser/parser';
-import {id} from './message';
-import {expandNodes} from './expander';
-import {
-  messageFromAttribute,
-  I18nError,
-  I18N_ATTR_PREFIX,
-  I18N_ATTR,
-  partition,
-  Part,
-  stringifyNodes,
-  meaning,
-  getPhNameFromBinding,
-  dedupePhName
-} from './shared';
-
-const _I18N_ATTR = "i18n";
-const _PLACEHOLDER_ELEMENT = "ph";
-const _NAME_ATTR = "name";
-const _I18N_ATTR_PREFIX = "i18n-";
-let _PLACEHOLDER_EXPANDED_REGEXP = RegExpWrapper.create(`\\<ph(\\s)+name=("(\\w)+")\\>\\<\\/ph\\>`);
-
-/**
- * Creates an i18n-ed version of the parsed template.
- *
- * Algorithm:
- *
- * To understand the algorithm, you need to know how partitioning works.
- * Partitioning is required as we can use two i18n comments to group node siblings together.
- * That is why we cannot just use nodes.
- *
- * Partitioning transforms an array of HtmlAst into an array of Part.
- * A part can optionally contain a root element or a root text node. And it can also contain
- * children.
- * A part can contain i18n property, in which case it needs to be transalted.
- *
- * Example:
- *
- * The following array of nodes will be split into four parts:
- *
- * ```
- * <a>A</a>
- * <b i18n>B</b>
- * <!-- i18n -->
- * <c>C</c>
- * D
- * <!-- /i18n -->
- * E
- * ```
- *
- * Part 1 containing the a tag. It should not be translated.
- * Part 2 containing the b tag. It should be translated.
- * Part 3 containing the c tag and the D text node. It should be translated.
- * Part 4 containing the E text node. It should not be translated.
- *
- *
- * It is also important to understand how we stringify nodes to create a message.
- *
- * We walk the tree and replace every element node with a placeholder. We also replace
- * all expressions in interpolation with placeholders. We also insert a placeholder element
- * to wrap a text node containing interpolation.
- *
- * Example:
- *
- * The following tree:
- *
- * ```
- * <a>A{{I}}</a><b>B</b>
- * ```
- *
- * will be stringified into:
- * ```
- * <ph name="e0"><ph name="t1">A<ph name="0"/></ph></ph><ph name="e2">B</ph>
- * ```
- *
- * This is what the algorithm does:
- *
- * 1. Use the provided html parser to get the html AST of the template.
- * 2. Partition the root nodes, and process each part separately.
- * 3. If a part does not have the i18n attribute, recurse to process children and attributes.
- * 4. If a part has the i18n attribute, merge the translated i18n part with the original tree.
- *
- * This is how the merging works:
- *
- * 1. Use the stringify function to get the message id. Look up the message in the map.
- * 2. Get the translated message. At this point we have two trees: the original tree
- * and the translated tree, where all the elements are replaced with placeholders.
- * 3. Use the original tree to create a mapping Index:number -> HtmlAst.
- * 4. Walk the translated tree.
- * 5. If we encounter a placeholder element, get is name property.
- * 6. Get the type and the index of the node using the name property.
- * 7. If the type is 'e', which means element, then:
- *     - translate the attributes of the original element
- *     - recurse to merge the children
- *     - create a new element using the original element name, original position,
- *     and translated children and attributes
- * 8. If the type if 't', which means text, then:
- *     - get the list of expressions from the original node.
- *     - get the string version of the interpolation subtree
- *     - find all the placeholders in the translated message, and replace them with the
- *     corresponding original expressions
- */
-export class I18nHtmlParser implements HtmlParser {
-  errors: ParseError[];
-
-  constructor(private _htmlParser: HtmlParser, private _parser: Parser,
-              private _messagesContent: string, private _messages: {[key: string]: HtmlAst[]}) {}
-
-  parse(sourceContent: string, sourceUrl: string,
-        parseExpansionForms: boolean = false): HtmlParseTreeResult {
-    this.errors = [];
-
-    let res = this._htmlParser.parse(sourceContent, sourceUrl, true);
-    if (res.errors.length > 0) {
-      return res;
-    } else {
-      let nodes = this._recurse(expandNodes(res.rootNodes).nodes);
-      return this.errors.length > 0 ? new HtmlParseTreeResult([], this.errors) :
-                                      new HtmlParseTreeResult(nodes, []);
-    }
-  }
-
-  private _processI18nPart(p: Part): HtmlAst[] {
-    try {
-      return p.hasI18n ? this._mergeI18Part(p) : this._recurseIntoI18nPart(p);
-    } catch (e) {
-      if (e instanceof I18nError) {
-        this.errors.push(e);
-        return [];
-      } else {
-        throw e;
-      }
-    }
-  }
-
-  private _mergeI18Part(p: Part): HtmlAst[] {
-    let message = p.createMessage(this._parser);
-    let messageId = id(message);
-    if (!StringMapWrapper.contains(this._messages, messageId)) {
-      throw new I18nError(
-          p.sourceSpan, `Cannot find message for id '${messageId}', content '${message.content}'.`);
-    }
-
-    let parsedMessage = this._messages[messageId];
-    return this._mergeTrees(p, parsedMessage, p.children);
-  }
-
-  private _recurseIntoI18nPart(p: Part): HtmlAst[] {
-    // we found an element without an i18n attribute
-    // we need to recurse in cause its children may have i18n set
-    // we also need to translate its attributes
-    if (isPresent(p.rootElement)) {
-      let root = p.rootElement;
-      let children = this._recurse(p.children);
-      let attrs = this._i18nAttributes(root);
-      return [
-        new HtmlElementAst(root.name, attrs, children, root.sourceSpan, root.startSourceSpan,
-                           root.endSourceSpan)
-      ];
-
-      // a text node without i18n or interpolation, nothing to do
-    } else if (isPresent(p.rootTextNode)) {
-      return [p.rootTextNode];
-
-    } else {
-      return this._recurse(p.children);
-    }
-  }
-
-  private _recurse(nodes: HtmlAst[]): HtmlAst[] {
-    let ps = partition(nodes, this.errors);
-    return ListWrapper.flatten(ps.map(p => this._processI18nPart(p)));
-  }
-
-  private _mergeTrees(p: Part, translated: HtmlAst[], original: HtmlAst[]): HtmlAst[] {
-    let l = new _CreateNodeMapping();
-    htmlVisitAll(l, original);
-
-    // merge the translated tree with the original tree.
-    // we do it by preserving the source code position of the original tree
-    let merged = this._mergeTreesHelper(translated, l.mapping);
-
-    // if the root element is present, we need to create a new root element with its attributes
-    // translated
-    if (isPresent(p.rootElement)) {
-      let root = p.rootElement;
-      let attrs = this._i18nAttributes(root);
-      return [
-        new HtmlElementAst(root.name, attrs, merged, root.sourceSpan, root.startSourceSpan,
-                           root.endSourceSpan)
-      ];
-
-      // this should never happen with a part. Parts that have root text node should not be merged.
-    } else if (isPresent(p.rootTextNode)) {
-      throw new BaseException("should not be reached");
-
-    } else {
-      return merged;
-    }
-  }
-
-  private _mergeTreesHelper(translated: HtmlAst[], mapping: HtmlAst[]): HtmlAst[] {
-    return translated.map(t => {
-      if (t instanceof HtmlElementAst) {
-        return this._mergeElementOrInterpolation(t, translated, mapping);
-
-      } else if (t instanceof HtmlTextAst) {
-        return t;
-
-      } else {
-        throw new BaseException("should not be reached");
-      }
-    });
-  }
-
-  private _mergeElementOrInterpolation(t: HtmlElementAst, translated: HtmlAst[],
-                                       mapping: HtmlAst[]): HtmlAst {
-    let name = this._getName(t);
-    let type = name[0];
-    let index = NumberWrapper.parseInt(name.substring(1), 10);
-    let originalNode = mapping[index];
-
-    if (type == "t") {
-      return this._mergeTextInterpolation(t, <HtmlTextAst>originalNode);
-    } else if (type == "e") {
-      return this._mergeElement(t, <HtmlElementAst>originalNode, mapping);
-    } else {
-      throw new BaseException("should not be reached");
-    }
-  }
-
-  private _getName(t: HtmlElementAst): string {
-    if (t.name != _PLACEHOLDER_ELEMENT) {
-      throw new I18nError(
-          t.sourceSpan,
-          `Unexpected tag "${t.name}". Only "${_PLACEHOLDER_ELEMENT}" tags are allowed.`);
-    }
-    let names = t.attrs.filter(a => a.name == _NAME_ATTR);
-    if (names.length == 0) {
-      throw new I18nError(t.sourceSpan, `Missing "${_NAME_ATTR}" attribute.`);
-    }
-    return names[0].value;
-  }
-
-  private _mergeTextInterpolation(t: HtmlElementAst, originalNode: HtmlTextAst): HtmlTextAst {
-    let split =
-        this._parser.splitInterpolation(originalNode.value, originalNode.sourceSpan.toString());
-    let exps = isPresent(split) ? split.expressions : [];
-
-    let messageSubstring =
-        this._messagesContent.substring(t.startSourceSpan.end.offset, t.endSourceSpan.start.offset);
-    let translated =
-        this._replacePlaceholdersWithExpressions(messageSubstring, exps, originalNode.sourceSpan);
-
-    return new HtmlTextAst(translated, originalNode.sourceSpan);
-  }
-
-  private _mergeElement(t: HtmlElementAst, originalNode: HtmlElementAst,
-                        mapping: HtmlAst[]): HtmlElementAst {
-    let children = this._mergeTreesHelper(t.children, mapping);
-    return new HtmlElementAst(originalNode.name, this._i18nAttributes(originalNode), children,
-                              originalNode.sourceSpan, originalNode.startSourceSpan,
-                              originalNode.endSourceSpan);
-  }
-
-  private _i18nAttributes(el: HtmlElementAst): HtmlAttrAst[] {
-    let res = [];
-    el.attrs.forEach(attr => {
-      if (attr.name.startsWith(I18N_ATTR_PREFIX) || attr.name == I18N_ATTR) return;
-
-      let i18ns = el.attrs.filter(a => a.name == `i18n-${attr.name}`);
-      if (i18ns.length == 0) {
-        res.push(attr);
-        return;
-      }
-
-      let i18n = i18ns[0];
-      let message = messageFromAttribute(this._parser, el, i18n);
-      let messageId = id(message);
-
-      if (StringMapWrapper.contains(this._messages, messageId)) {
-        let updatedMessage = this._replaceInterpolationInAttr(attr, this._messages[messageId]);
-        res.push(new HtmlAttrAst(attr.name, updatedMessage, attr.sourceSpan));
-
-      } else {
-        throw new I18nError(
-            attr.sourceSpan,
-            `Cannot find message for id '${messageId}', content '${message.content}'.`);
-      }
-    });
-    return res;
-  }
-
-  private _replaceInterpolationInAttr(attr: HtmlAttrAst, msg: HtmlAst[]): string {
-    let split = this._parser.splitInterpolation(attr.value, attr.sourceSpan.toString());
-    let exps = isPresent(split) ? split.expressions : [];
-
-    let first = msg[0];
-    let last = msg[msg.length - 1];
-
-    let start = first.sourceSpan.start.offset;
-    let end =
-        last instanceof HtmlElementAst ? last.endSourceSpan.end.offset : last.sourceSpan.end.offset;
-    let messageSubstring = this._messagesContent.substring(start, end);
-
-    return this._replacePlaceholdersWithExpressions(messageSubstring, exps, attr.sourceSpan);
-  };
-
-  private _replacePlaceholdersWithExpressions(message: string, exps: string[],
-                                              sourceSpan: ParseSourceSpan): string {
-    let expMap = this._buildExprMap(exps);
-    return RegExpWrapper.replaceAll(_PLACEHOLDER_EXPANDED_REGEXP, message, (match) => {
-      let nameWithQuotes = match[2];
-      let name = nameWithQuotes.substring(1, nameWithQuotes.length - 1);
-      return this._convertIntoExpression(name, expMap, sourceSpan);
-    });
-  }
-
-  private _buildExprMap(exps: string[]): Map<string, string> {
-    let expMap = new Map<string, string>();
-    let usedNames = new Map<string, number>();
-
-    for (var i = 0; i < exps.length; i++) {
-      let phName = getPhNameFromBinding(exps[i], i);
-      expMap.set(dedupePhName(usedNames, phName), exps[i]);
-    }
-    return expMap;
-  }
-
-  private _convertIntoExpression(name: string, expMap: Map<string, string>,
-                                 sourceSpan: ParseSourceSpan) {
-    if (expMap.has(name)) {
-      return `{{${expMap.get(name)}}}`;
-    } else {
-      throw new I18nError(sourceSpan, `Invalid interpolation name '${name}'`);
-    }
-  }
-}
-
-class _CreateNodeMapping implements HtmlAstVisitor {
-  mapping: HtmlAst[] = [];
-
-  visitElement(ast: HtmlElementAst, context: any): any {
-    this.mapping.push(ast);
-    htmlVisitAll(this, ast.children);
-    return null;
-  }
-
-  visitAttr(ast: HtmlAttrAst, context: any): any { return null; }
-
-  visitText(ast: HtmlTextAst, context: any): any {
-    this.mapping.push(ast);
-    return null;
-  }
-
-  visitExpansion(ast: HtmlExpansionAst, context: any): any { return null; }
-
-  visitExpansionCase(ast: HtmlExpansionCaseAst, context: any): any { return null; }
-
-  visitComment(ast: HtmlCommentAst, context: any): any { return ""; }
-}
--- a/modules/@angular/compiler/src/i18n/message.ts
+++ b/modules/@angular/compiler/src/i18n/message.ts
@ -1,21 +0,0 @@
-import {isPresent, escape} from '../../src/facade/lang';
-
-/**
- * A message extracted from a template.
- *
- * The identity of a message is comprised of `content` and `meaning`.
- *
- * `description` is additional information provided to the translator.
- */
-export class Message {
-  constructor(public content: string, public meaning: string, public description: string = null) {}
-}
-
-/**
- * Computes the id of a message
- */
-export function id(m: Message): string {
-  let meaning = isPresent(m.meaning) ? m.meaning : "";
-  let content = isPresent(m.content) ? m.content : "";
-  return escape(`$ng|${meaning}|${content}`);
-}
--- a/modules/@angular/compiler/src/i18n/message_extractor.ts
+++ b/modules/@angular/compiler/src/i18n/message_extractor.ts
@ -1,178 +0,0 @@
-import {HtmlParser} from '../html_parser';
-import {ParseSourceSpan, ParseError} from '../parse_util';
-import {
-  HtmlAst,
-  HtmlAstVisitor,
-  HtmlElementAst,
-  HtmlAttrAst,
-  HtmlTextAst,
-  HtmlCommentAst,
-  htmlVisitAll
-} from '../html_ast';
-import {isPresent} from '../../src/facade/lang';
-import {StringMapWrapper} from '../../src/facade/collection';
-import {Parser} from '../expression_parser/parser';
-import {Message, id} from './message';
-import {expandNodes} from './expander';
-import {
-  I18nError,
-  Part,
-  I18N_ATTR_PREFIX,
-  partition,
-  meaning,
-  description,
-  stringifyNodes,
-  messageFromAttribute
-} from './shared';
-
-/**
- * All messages extracted from a template.
- */
-export class ExtractionResult {
-  constructor(public messages: Message[], public errors: ParseError[]) {}
-}
-
-/**
- * Removes duplicate messages.
- *
- * E.g.
- *
- * ```
- *  var m = [new Message("message", "meaning", "desc1"), new Message("message", "meaning",
- * "desc2")];
- *  expect(removeDuplicates(m)).toEqual([new Message("message", "meaning", "desc1")]);
- * ```
- */
-export function removeDuplicates(messages: Message[]): Message[] {
-  let uniq: {[key: string]: Message} = {};
-  messages.forEach(m => {
-    if (!StringMapWrapper.contains(uniq, id(m))) {
-      uniq[id(m)] = m;
-    }
-  });
-  return StringMapWrapper.values(uniq);
-}
-
-/**
- * Extracts all messages from a template.
- *
- * Algorithm:
- *
- * To understand the algorithm, you need to know how partitioning works.
- * Partitioning is required as we can use two i18n comments to group node siblings together.
- * That is why we cannot just use nodes.
- *
- * Partitioning transforms an array of HtmlAst into an array of Part.
- * A part can optionally contain a root element or a root text node. And it can also contain
- * children.
- * A part can contain i18n property, in which case it needs to be extracted.
- *
- * Example:
- *
- * The following array of nodes will be split into four parts:
- *
- * ```
- * <a>A</a>
- * <b i18n>B</b>
- * <!-- i18n -->
- * <c>C</c>
- * D
- * <!-- /i18n -->
- * E
- * ```
- *
- * Part 1 containing the a tag. It should not be translated.
- * Part 2 containing the b tag. It should be translated.
- * Part 3 containing the c tag and the D text node. It should be translated.
- * Part 4 containing the E text node. It should not be translated..
- *
- * It is also important to understand how we stringify nodes to create a message.
- *
- * We walk the tree and replace every element node with a placeholder. We also replace
- * all expressions in interpolation with placeholders. We also insert a placeholder element
- * to wrap a text node containing interpolation.
- *
- * Example:
- *
- * The following tree:
- *
- * ```
- * <a>A{{I}}</a><b>B</b>
- * ```
- *
- * will be stringified into:
- * ```
- * <ph name="e0"><ph name="t1">A<ph name="0"/></ph></ph><ph name="e2">B</ph>
- * ```
- *
- * This is what the algorithm does:
- *
- * 1. Use the provided html parser to get the html AST of the template.
- * 2. Partition the root nodes, and process each part separately.
- * 3. If a part does not have the i18n attribute, recurse to process children and attributes.
- * 4. If a part has the i18n attribute, stringify the nodes to create a Message.
- */
-export class MessageExtractor {
-  messages: Message[];
-  errors: ParseError[];
-
-  constructor(private _htmlParser: HtmlParser, private _parser: Parser) {}
-
-  extract(template: string, sourceUrl: string): ExtractionResult {
-    this.messages = [];
-    this.errors = [];
-
-    let res = this._htmlParser.parse(template, sourceUrl, true);
-    if (res.errors.length > 0) {
-      return new ExtractionResult([], res.errors);
-    } else {
-      this._recurse(expandNodes(res.rootNodes).nodes);
-      return new ExtractionResult(this.messages, this.errors);
-    }
-  }
-
-  private _extractMessagesFromPart(p: Part): void {
-    if (p.hasI18n) {
-      this.messages.push(p.createMessage(this._parser));
-      this._recurseToExtractMessagesFromAttributes(p.children);
-    } else {
-      this._recurse(p.children);
-    }
-
-    if (isPresent(p.rootElement)) {
-      this._extractMessagesFromAttributes(p.rootElement);
-    }
-  }
-
-  private _recurse(nodes: HtmlAst[]): void {
-    if (isPresent(nodes)) {
-      let ps = partition(nodes, this.errors);
-      ps.forEach(p => this._extractMessagesFromPart(p));
-    }
-  }
-
-  private _recurseToExtractMessagesFromAttributes(nodes: HtmlAst[]): void {
-    nodes.forEach(n => {
-      if (n instanceof HtmlElementAst) {
-        this._extractMessagesFromAttributes(n);
-        this._recurseToExtractMessagesFromAttributes(n.children);
-      }
-    });
-  }
-
-  private _extractMessagesFromAttributes(p: HtmlElementAst): void {
-    p.attrs.forEach(attr => {
-      if (attr.name.startsWith(I18N_ATTR_PREFIX)) {
-        try {
-          this.messages.push(messageFromAttribute(this._parser, p, attr));
-        } catch (e) {
-          if (e instanceof I18nError) {
-            this.errors.push(e);
-          } else {
-            throw e;
-          }
-        }
-      }
-    });
-  }
-}
--- a/modules/@angular/compiler/src/i18n/shared.ts
+++ b/modules/@angular/compiler/src/i18n/shared.ts
@ -1,191 +0,0 @@
-import {ParseSourceSpan, ParseError} from '../parse_util';
-import {
-  HtmlAst,
-  HtmlAstVisitor,
-  HtmlElementAst,
-  HtmlAttrAst,
-  HtmlTextAst,
-  HtmlCommentAst,
-  HtmlExpansionAst,
-  HtmlExpansionCaseAst,
-  htmlVisitAll
-} from '../html_ast';
-import {isPresent, isBlank, StringWrapper} from '../../src/facade/lang';
-import {Message} from './message';
-import {Parser} from '../expression_parser/parser';
-
-export const I18N_ATTR = "i18n";
-export const I18N_ATTR_PREFIX = "i18n-";
-var CUSTOM_PH_EXP = /\/\/[\s\S]*i18n[\s\S]*\([\s\S]*ph[\s\S]*=[\s\S]*"([\s\S]*?)"[\s\S]*\)/g;
-
-/**
- * An i18n error.
- */
-export class I18nError extends ParseError {
-  constructor(span: ParseSourceSpan, msg: string) { super(span, msg); }
-}
-
-
-// Man, this is so ugly!
-export function partition(nodes: HtmlAst[], errors: ParseError[]): Part[] {
-  let res = [];
-
-  for (let i = 0; i < nodes.length; ++i) {
-    let n = nodes[i];
-    let temp = [];
-    if (_isOpeningComment(n)) {
-      let i18n = (<HtmlCommentAst>n).value.substring(5).trim();
-      i++;
-      while (!_isClosingComment(nodes[i])) {
-        temp.push(nodes[i++]);
-        if (i === nodes.length) {
-          errors.push(new I18nError(n.sourceSpan, "Missing closing 'i18n' comment."));
-          break;
-        }
-      }
-      res.push(new Part(null, null, temp, i18n, true));
-
-    } else if (n instanceof HtmlElementAst) {
-      let i18n = _findI18nAttr(n);
-      res.push(new Part(n, null, n.children, isPresent(i18n) ? i18n.value : null, isPresent(i18n)));
-    } else if (n instanceof HtmlTextAst) {
-      res.push(new Part(null, n, null, null, false));
-    }
-  }
-
-  return res;
-}
-
-export class Part {
-  constructor(public rootElement: HtmlElementAst, public rootTextNode: HtmlTextAst,
-              public children: HtmlAst[], public i18n: string, public hasI18n: boolean) {}
-
-  get sourceSpan(): ParseSourceSpan {
-    if (isPresent(this.rootElement))
-      return this.rootElement.sourceSpan;
-    else if (isPresent(this.rootTextNode))
-      return this.rootTextNode.sourceSpan;
-    else
-      return this.children[0].sourceSpan;
-  }
-
-  createMessage(parser: Parser): Message {
-    return new Message(stringifyNodes(this.children, parser), meaning(this.i18n),
-                       description(this.i18n));
-  }
-}
-
-function _isOpeningComment(n: HtmlAst): boolean {
-  return n instanceof HtmlCommentAst && isPresent(n.value) && n.value.startsWith("i18n:");
-}
-
-function _isClosingComment(n: HtmlAst): boolean {
-  return n instanceof HtmlCommentAst && isPresent(n.value) && n.value == "/i18n";
-}
-
-function _findI18nAttr(p: HtmlElementAst): HtmlAttrAst {
-  let i18n = p.attrs.filter(a => a.name == I18N_ATTR);
-  return i18n.length == 0 ? null : i18n[0];
-}
-
-export function meaning(i18n: string): string {
-  if (isBlank(i18n) || i18n == "") return null;
-  return i18n.split("|")[0];
-}
-
-export function description(i18n: string): string {
-  if (isBlank(i18n) || i18n == "") return null;
-  let parts = i18n.split("|");
-  return parts.length > 1 ? parts[1] : null;
-}
-
-export function messageFromAttribute(parser: Parser, p: HtmlElementAst,
-                                     attr: HtmlAttrAst): Message {
-  let expectedName = attr.name.substring(5);
-  let matching = p.attrs.filter(a => a.name == expectedName);
-
-  if (matching.length > 0) {
-    let value = removeInterpolation(matching[0].value, matching[0].sourceSpan, parser);
-    return new Message(value, meaning(attr.value), description(attr.value));
-  } else {
-    throw new I18nError(p.sourceSpan, `Missing attribute '${expectedName}'.`);
-  }
-}
-
-export function removeInterpolation(value: string, source: ParseSourceSpan,
-                                    parser: Parser): string {
-  try {
-    let parsed = parser.splitInterpolation(value, source.toString());
-    let usedNames = new Map<string, number>();
-    if (isPresent(parsed)) {
-      let res = "";
-      for (let i = 0; i < parsed.strings.length; ++i) {
-        res += parsed.strings[i];
-        if (i != parsed.strings.length - 1) {
-          let customPhName = getPhNameFromBinding(parsed.expressions[i], i);
-          customPhName = dedupePhName(usedNames, customPhName);
-          res += `<ph name="${customPhName}"/>`;
-        }
-      }
-      return res;
-    } else {
-      return value;
-    }
-  } catch (e) {
-    return value;
-  }
-}
-
-export function getPhNameFromBinding(input: string, index: number): string {
-  let customPhMatch = StringWrapper.split(input, CUSTOM_PH_EXP);
-  return customPhMatch.length > 1 ? customPhMatch[1] : `${index}`;
-}
-
-export function dedupePhName(usedNames: Map<string, number>, name: string): string {
-  let duplicateNameCount = usedNames.get(name);
-  if (isPresent(duplicateNameCount)) {
-    usedNames.set(name, duplicateNameCount + 1);
-    return `${name}_${duplicateNameCount}`;
-  } else {
-    usedNames.set(name, 1);
-    return name;
-  }
-}
-
-export function stringifyNodes(nodes: HtmlAst[], parser: Parser): string {
-  let visitor = new _StringifyVisitor(parser);
-  return htmlVisitAll(visitor, nodes).join("");
-}
-
-class _StringifyVisitor implements HtmlAstVisitor {
-  private _index: number = 0;
-  constructor(private _parser: Parser) {}
-
-  visitElement(ast: HtmlElementAst, context: any): any {
-    let name = this._index++;
-    let children = this._join(htmlVisitAll(this, ast.children), "");
-    return `<ph name="e${name}">${children}</ph>`;
-  }
-
-  visitAttr(ast: HtmlAttrAst, context: any): any { return null; }
-
-  visitText(ast: HtmlTextAst, context: any): any {
-    let index = this._index++;
-    let noInterpolation = removeInterpolation(ast.value, ast.sourceSpan, this._parser);
-    if (noInterpolation != ast.value) {
-      return `<ph name="t${index}">${noInterpolation}</ph>`;
-    } else {
-      return ast.value;
-    }
-  }
-
-  visitComment(ast: HtmlCommentAst, context: any): any { return ""; }
-
-  visitExpansion(ast: HtmlExpansionAst, context: any): any { return null; }
-
-  visitExpansionCase(ast: HtmlExpansionCaseAst, context: any): any { return null; }
-
-  private _join(strs: string[], str: string): string {
-    return strs.filter(s => s.length > 0).join(str);
-  }
-}
--- a/modules/@angular/compiler/src/i18n/xmb_serializer.ts
+++ b/modules/@angular/compiler/src/i18n/xmb_serializer.ts
@ -1,95 +0,0 @@
-import {isPresent, isBlank, RegExpWrapper} from '../../src/facade/lang';
-import {HtmlAst, HtmlElementAst} from '../html_ast';
-import {Message, id} from './message';
-import {HtmlParser} from '../html_parser';
-import {ParseSourceSpan, ParseError} from '../parse_util';
-
-let _PLACEHOLDER_REGEXP = RegExpWrapper.create(`\\<ph(\\s)+name=("(\\w)+")\\/\\>`);
-const _ID_ATTR = "id";
-const _MSG_ELEMENT = "msg";
-const _BUNDLE_ELEMENT = "message-bundle";
-
-export function serializeXmb(messages: Message[]): string {
-  let ms = messages.map((m) => _serializeMessage(m)).join("");
-  return `<message-bundle>${ms}</message-bundle>`;
-}
-
-export class XmbDeserializationResult {
-  constructor(public content: string, public messages: {[key: string]: HtmlAst[]},
-              public errors: ParseError[]) {}
-}
-
-export class XmbDeserializationError extends ParseError {
-  constructor(span: ParseSourceSpan, msg: string) { super(span, msg); }
-}
-
-export function deserializeXmb(content: string, url: string): XmbDeserializationResult {
-  let parser = new HtmlParser();
-  let normalizedContent = _expandPlaceholder(content.trim());
-  let parsed = parser.parse(normalizedContent, url);
-
-  if (parsed.errors.length > 0) {
-    return new XmbDeserializationResult(null, {}, parsed.errors);
-  }
-
-  if (_checkRootElement(parsed.rootNodes)) {
-    return new XmbDeserializationResult(
-        null, {}, [new XmbDeserializationError(null, `Missing element "${_BUNDLE_ELEMENT}"`)]);
-  }
-
-  let bundleEl = <HtmlElementAst>parsed.rootNodes[0];  // test this
-  let errors = [];
-  let messages: {[key: string]: HtmlAst[]} = {};
-
-  _createMessages(bundleEl.children, messages, errors);
-
-  return (errors.length == 0) ?
-             new XmbDeserializationResult(normalizedContent, messages, []) :
-             new XmbDeserializationResult(null, <{[key: string]: HtmlAst[]}>{}, errors);
-}
-
-function _checkRootElement(nodes: HtmlAst[]): boolean {
-  return nodes.length < 1 || !(nodes[0] instanceof HtmlElementAst) ||
-         (<HtmlElementAst>nodes[0]).name != _BUNDLE_ELEMENT;
-}
-
-function _createMessages(nodes: HtmlAst[], messages: {[key: string]: HtmlAst[]},
-                         errors: ParseError[]): void {
-  nodes.forEach((item) => {
-    if (item instanceof HtmlElementAst) {
-      let msg = <HtmlElementAst>item;
-
-      if (msg.name != _MSG_ELEMENT) {
-        errors.push(
-            new XmbDeserializationError(item.sourceSpan, `Unexpected element "${msg.name}"`));
-        return;
-      }
-
-      let id = _id(msg);
-      if (isBlank(id)) {
-        errors.push(
-            new XmbDeserializationError(item.sourceSpan, `"${_ID_ATTR}" attribute is missing`));
-        return;
-      }
-
-      messages[id] = msg.children;
-    }
-  });
-}
-
-function _id(el: HtmlElementAst): string {
-  let ids = el.attrs.filter(a => a.name == _ID_ATTR);
-  return ids.length > 0 ? ids[0].value : null;
-}
-
-function _serializeMessage(m: Message): string {
-  let desc = isPresent(m.description) ? ` desc='${m.description}'` : "";
-  return `<msg id='${id(m)}'${desc}>${m.content}</msg>`;
-}
-
-function _expandPlaceholder(input: string): string {
-  return RegExpWrapper.replaceAll(_PLACEHOLDER_REGEXP, input, (match) => {
-    let nameWithQuotes = match[2];
-    return `<ph name=${nameWithQuotes}></ph>`;
-  });
-}
--- a/modules/@angular/compiler/src/identifiers.ts
+++ b/modules/@angular/compiler/src/identifiers.ts
@ -1,206 +0,0 @@
-import {
-  SimpleChange,
-  ChangeDetectorRef,
-  ChangeDetectionStrategy,
-  ElementRef,
-  ViewContainerRef,
-  Renderer,
-  RenderComponentType,
-  Injector,
-  QueryList,
-  ViewEncapsulation,
-  TemplateRef
-} from '@angular/core';
-import {
-  AppElement,
-  AppView,
-  DebugAppView,
-  ChangeDetectorState,
-  checkBinding,
-  DebugContext,
-  devModeEqual,
-  flattenNestedViewRenderNodes,
-  interpolate,
-  RenderDebugInfo,
-  StaticNodeDebugInfo,
-  TemplateRef_,
-  uninitialized,
-  ValueUnwrapper,
-  ViewType,
-  ViewUtils,
-  castByValue,
-  EMPTY_ARRAY,
-  EMPTY_MAP,
-  pureProxy1,
-  pureProxy2,
-  pureProxy3,
-  pureProxy4,
-  pureProxy5,
-  pureProxy6,
-  pureProxy7,
-  pureProxy8,
-  pureProxy9,
-  pureProxy10
-} from '../core_private';
-
-import {CompileIdentifierMetadata, CompileTokenMetadata} from './compile_metadata';
-import {assetUrl} from './util';
-
-var APP_VIEW_MODULE_URL = assetUrl('core', 'linker/view');
-var VIEW_UTILS_MODULE_URL = assetUrl('core', 'linker/view_utils');
-var CD_MODULE_URL = assetUrl('core', 'change_detection/change_detection');
-
-// Reassign the imports to different variables so we can
-// define static variables with the name of the import.
-// (only needed for Dart).
-var impViewUtils = ViewUtils;
-var impAppView = AppView;
-var impDebugAppView = DebugAppView;
-var impDebugContext = DebugContext;
-var impAppElement = AppElement;
-var impElementRef = ElementRef;
-var impViewContainerRef = ViewContainerRef;
-var impChangeDetectorRef = ChangeDetectorRef;
-var impRenderComponentType = RenderComponentType;
-var impQueryList = QueryList;
-var impTemplateRef = TemplateRef;
-var impTemplateRef_ = TemplateRef_;
-var impValueUnwrapper = ValueUnwrapper;
-var impInjector = Injector;
-var impViewEncapsulation = ViewEncapsulation;
-var impViewType = ViewType;
-var impChangeDetectionStrategy = ChangeDetectionStrategy;
-var impStaticNodeDebugInfo = StaticNodeDebugInfo;
-var impRenderer = Renderer;
-var impSimpleChange = SimpleChange;
-var impUninitialized = uninitialized;
-var impChangeDetectorState = ChangeDetectorState;
-var impFlattenNestedViewRenderNodes = flattenNestedViewRenderNodes;
-var impDevModeEqual = devModeEqual;
-var impInterpolate = interpolate;
-var impCheckBinding = checkBinding;
-var impCastByValue = castByValue;
-var impEMPTY_ARRAY = EMPTY_ARRAY;
-var impEMPTY_MAP = EMPTY_MAP;
-
-export class Identifiers {
-  static ViewUtils = new CompileIdentifierMetadata(
-      {name: 'ViewUtils', moduleUrl: assetUrl('core', 'linker/view_utils'), runtime: impViewUtils});
-  static AppView = new CompileIdentifierMetadata(
-      {name: 'AppView', moduleUrl: APP_VIEW_MODULE_URL, runtime: impAppView});
-  static DebugAppView = new CompileIdentifierMetadata(
-      {name: 'DebugAppView', moduleUrl: APP_VIEW_MODULE_URL, runtime: impDebugAppView});
-  static AppElement = new CompileIdentifierMetadata(
-      {name: 'AppElement', moduleUrl: assetUrl('core', 'linker/element'), runtime: impAppElement});
-  static ElementRef = new CompileIdentifierMetadata({
-    name: 'ElementRef',
-    moduleUrl: assetUrl('core', 'linker/element_ref'),
-    runtime: impElementRef
-  });
-  static ViewContainerRef = new CompileIdentifierMetadata({
-    name: 'ViewContainerRef',
-    moduleUrl: assetUrl('core', 'linker/view_container_ref'),
-    runtime: impViewContainerRef
-  });
-  static ChangeDetectorRef = new CompileIdentifierMetadata({
-    name: 'ChangeDetectorRef',
-    moduleUrl: assetUrl('core', 'change_detection/change_detector_ref'),
-    runtime: impChangeDetectorRef
-  });
-  static RenderComponentType = new CompileIdentifierMetadata({
-    name: 'RenderComponentType',
-    moduleUrl: assetUrl('core', 'render/api'),
-    runtime: impRenderComponentType
-  });
-  static QueryList = new CompileIdentifierMetadata(
-      {name: 'QueryList', moduleUrl: assetUrl('core', 'linker/query_list'), runtime: impQueryList});
-  static TemplateRef = new CompileIdentifierMetadata({
-    name: 'TemplateRef',
-    moduleUrl: assetUrl('core', 'linker/template_ref'),
-    runtime: impTemplateRef
-  });
-  static TemplateRef_ = new CompileIdentifierMetadata({
-    name: 'TemplateRef_',
-    moduleUrl: assetUrl('core', 'linker/template_ref'),
-    runtime: impTemplateRef_
-  });
-  static ValueUnwrapper = new CompileIdentifierMetadata(
-      {name: 'ValueUnwrapper', moduleUrl: CD_MODULE_URL, runtime: impValueUnwrapper});
-  static Injector = new CompileIdentifierMetadata(
-      {name: 'Injector', moduleUrl: assetUrl('core', 'di/injector'), runtime: impInjector});
-  static ViewEncapsulation = new CompileIdentifierMetadata({
-    name: 'ViewEncapsulation',
-    moduleUrl: assetUrl('core', 'metadata/view'),
-    runtime: impViewEncapsulation
-  });
-  static ViewType = new CompileIdentifierMetadata(
-      {name: 'ViewType', moduleUrl: assetUrl('core', 'linker/view_type'), runtime: impViewType});
-  static ChangeDetectionStrategy = new CompileIdentifierMetadata({
-    name: 'ChangeDetectionStrategy',
-    moduleUrl: CD_MODULE_URL,
-    runtime: impChangeDetectionStrategy
-  });
-  static StaticNodeDebugInfo = new CompileIdentifierMetadata({
-    name: 'StaticNodeDebugInfo',
-    moduleUrl: assetUrl('core', 'linker/debug_context'),
-    runtime: impStaticNodeDebugInfo
-  });
-  static DebugContext = new CompileIdentifierMetadata({
-    name: 'DebugContext',
-    moduleUrl: assetUrl('core', 'linker/debug_context'),
-    runtime: impDebugContext
-  });
-  static Renderer = new CompileIdentifierMetadata(
-      {name: 'Renderer', moduleUrl: assetUrl('core', 'render/api'), runtime: impRenderer});
-  static SimpleChange = new CompileIdentifierMetadata(
-      {name: 'SimpleChange', moduleUrl: CD_MODULE_URL, runtime: impSimpleChange});
-  static uninitialized = new CompileIdentifierMetadata(
-      {name: 'uninitialized', moduleUrl: CD_MODULE_URL, runtime: impUninitialized});
-  static ChangeDetectorState = new CompileIdentifierMetadata(
-      {name: 'ChangeDetectorState', moduleUrl: CD_MODULE_URL, runtime: impChangeDetectorState});
-  static checkBinding = new CompileIdentifierMetadata(
-      {name: 'checkBinding', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: impCheckBinding});
-  static flattenNestedViewRenderNodes = new CompileIdentifierMetadata({
-    name: 'flattenNestedViewRenderNodes',
-    moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: impFlattenNestedViewRenderNodes
-  });
-  static devModeEqual = new CompileIdentifierMetadata(
-      {name: 'devModeEqual', moduleUrl: CD_MODULE_URL, runtime: impDevModeEqual});
-  static interpolate = new CompileIdentifierMetadata(
-      {name: 'interpolate', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: impInterpolate});
-  static castByValue = new CompileIdentifierMetadata(
-      {name: 'castByValue', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: impCastByValue});
-  static EMPTY_ARRAY = new CompileIdentifierMetadata(
-      {name: 'EMPTY_ARRAY', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: impEMPTY_ARRAY});
-  static EMPTY_MAP = new CompileIdentifierMetadata(
-      {name: 'EMPTY_MAP', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: impEMPTY_MAP});
-
-  static pureProxies = [
-    null,
-    new CompileIdentifierMetadata(
-        {name: 'pureProxy1', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy1}),
-    new CompileIdentifierMetadata(
-        {name: 'pureProxy2', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy2}),
-    new CompileIdentifierMetadata(
-        {name: 'pureProxy3', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy3}),
-    new CompileIdentifierMetadata(
-        {name: 'pureProxy4', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy4}),
-    new CompileIdentifierMetadata(
-        {name: 'pureProxy5', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy5}),
-    new CompileIdentifierMetadata(
-        {name: 'pureProxy6', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy6}),
-    new CompileIdentifierMetadata(
-        {name: 'pureProxy7', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy7}),
-    new CompileIdentifierMetadata(
-        {name: 'pureProxy8', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy8}),
-    new CompileIdentifierMetadata(
-        {name: 'pureProxy9', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy9}),
-    new CompileIdentifierMetadata(
-        {name: 'pureProxy10', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy10}),
-  ];
-}
-
-export function identifierToken(identifier: CompileIdentifierMetadata): CompileTokenMetadata {
-  return new CompileTokenMetadata({identifier: identifier});
-}
--- a/modules/@angular/compiler/src/metadata_resolver.ts
+++ b/modules/@angular/compiler/src/metadata_resolver.ts
@ -1,438 +0,0 @@
-import {
-  AttributeMetadata,
-  ReflectiveDependency,
-  OptionalMetadata,
-  ComponentMetadata,
-  SelfMetadata,
-  HostMetadata,
-  SkipSelfMetadata,
-  Provider,
-  PLATFORM_DIRECTIVES,
-  PLATFORM_PIPES,
-  reflector,
-  Injectable,
-  Inject,
-  Optional,
-  ViewMetadata,
-  NoAnnotationError,
-  QueryMetadata,
-  resolveForwardRef,
-  InjectMetadata,
-  ViewQueryMetadata
-} from '@angular/core';
-import {constructDependencies, LIFECYCLE_HOOKS_VALUES, ReflectorReader} from '../core_private';
-import {
-  Type,
-  isBlank,
-  isPresent,
-  isArray,
-  stringify,
-  isString,
-  isStringMap
-} from '../src/facade/lang';
-import {StringMapWrapper} from '../src/facade/collection';
-import {BaseException} from '../src/facade/exceptions';
-import * as cpl from './compile_metadata';
-import {DirectiveResolver} from './directive_resolver';
-import {PipeResolver} from './pipe_resolver';
-import {ViewResolver} from './view_resolver';
-import {hasLifecycleHook} from './directive_lifecycle_reflector';
-import {MODULE_SUFFIX, sanitizeIdentifier, ValueTransformer, visitValue} from './util';
-import {assertArrayOfStrings} from './assertions';
-import {getUrlScheme} from './url_resolver';
-import {createProvider, isProviderLiteral} from "../core_private";
-
-
-@Injectable()
-export class CompileMetadataResolver {
-  private _directiveCache = new Map<Type, cpl.CompileDirectiveMetadata>();
-  private _pipeCache = new Map<Type, cpl.CompilePipeMetadata>();
-  private _anonymousTypes = new Map<Object, number>();
-  private _anonymousTypeIndex = 0;
-  private _reflector: ReflectorReader;
-
-  constructor(private _directiveResolver: DirectiveResolver, private _pipeResolver: PipeResolver,
-              private _viewResolver: ViewResolver,
-              @Optional() @Inject(PLATFORM_DIRECTIVES) private _platformDirectives: Type[],
-              @Optional() @Inject(PLATFORM_PIPES) private _platformPipes: Type[],
-              _reflector?: ReflectorReader) {
-    if (isPresent(_reflector)) {
-      this._reflector = _reflector;
-    } else {
-      this._reflector = reflector;
-    }
-  }
-
-  private sanitizeTokenName(token: any): string {
-    let identifier = stringify(token);
-    if (identifier.indexOf('(') >= 0) {
-      // case: anonymous functions!
-      let found = this._anonymousTypes.get(token);
-      if (isBlank(found)) {
-        this._anonymousTypes.set(token, this._anonymousTypeIndex++);
-        found = this._anonymousTypes.get(token);
-      }
-      identifier = `anonymous_token_${found}_`;
-    }
-    return sanitizeIdentifier(identifier);
-  }
-
-  getDirectiveMetadata(directiveType: Type): cpl.CompileDirectiveMetadata {
-    var meta = this._directiveCache.get(directiveType);
-    if (isBlank(meta)) {
-      var dirMeta = this._directiveResolver.resolve(directiveType);
-      var templateMeta = null;
-      var changeDetectionStrategy = null;
-      var viewProviders = [];
-
-      if (dirMeta instanceof ComponentMetadata) {
-        assertArrayOfStrings('styles', dirMeta.styles);
-        var cmpMeta = <ComponentMetadata>dirMeta;
-        var viewMeta = this._viewResolver.resolve(directiveType);
-        assertArrayOfStrings('styles', viewMeta.styles);
-        templateMeta = new cpl.CompileTemplateMetadata({
-          encapsulation: viewMeta.encapsulation,
-          template: viewMeta.template,
-          templateUrl: viewMeta.templateUrl,
-          styles: viewMeta.styles,
-          styleUrls: viewMeta.styleUrls
-        });
-        changeDetectionStrategy = cmpMeta.changeDetection;
-        if (isPresent(dirMeta.viewProviders)) {
-          viewProviders = this.getProvidersMetadata(dirMeta.viewProviders);
-        }
-      }
-
-      var providers = [];
-      if (isPresent(dirMeta.providers)) {
-        providers = this.getProvidersMetadata(dirMeta.providers);
-      }
-      var queries = [];
-      var viewQueries = [];
-      if (isPresent(dirMeta.queries)) {
-        queries = this.getQueriesMetadata(dirMeta.queries, false);
-        viewQueries = this.getQueriesMetadata(dirMeta.queries, true);
-      }
-      meta = cpl.CompileDirectiveMetadata.create({
-        selector: dirMeta.selector,
-        exportAs: dirMeta.exportAs,
-        isComponent: isPresent(templateMeta),
-        type: this.getTypeMetadata(directiveType,
-                                   isPresent(cmpMeta) ?
-                                       componentModuleUrl(this._reflector, directiveType, cmpMeta) :
-                                       staticTypeModuleUrl(dirMeta)),
-        template: templateMeta,
-        changeDetection: changeDetectionStrategy,
-        inputs: dirMeta.inputs,
-        outputs: dirMeta.outputs,
-        host: dirMeta.host,
-        lifecycleHooks:
-            LIFECYCLE_HOOKS_VALUES.filter(hook => hasLifecycleHook(hook, directiveType)),
-        providers: providers,
-        viewProviders: viewProviders,
-        queries: queries,
-        viewQueries: viewQueries
-      });
-      this._directiveCache.set(directiveType, meta);
-    }
-    return meta;
-  }
-
-  /**
-   * @param someType a symbol which may or may not be a directive type
-   * @returns {cpl.CompileDirectiveMetadata} if possible, otherwise null.
-   */
-  maybeGetDirectiveMetadata(someType: Type): cpl.CompileDirectiveMetadata {
-    try {
-      return this.getDirectiveMetadata(someType);
-    } catch (e) {
-      if (e.message.indexOf('No Directive annotation') !== -1) {
-        return null;
-      }
-      throw e;
-    }
-  }
-
-  getTypeMetadata(type: Type, moduleUrl: string): cpl.CompileTypeMetadata {
-    return new cpl.CompileTypeMetadata({
-      name: this.sanitizeTokenName(type),
-      moduleUrl: moduleUrl,
-      runtime: type,
-      diDeps: this.getDependenciesMetadata(type, null)
-    });
-  }
-
-  getFactoryMetadata(factory: Function, moduleUrl: string): cpl.CompileFactoryMetadata {
-    return new cpl.CompileFactoryMetadata({
-      name: this.sanitizeTokenName(factory),
-      moduleUrl: moduleUrl,
-      runtime: factory,
-      diDeps: this.getDependenciesMetadata(factory, null)
-    });
-  }
-
-  getPipeMetadata(pipeType: Type): cpl.CompilePipeMetadata {
-    var meta = this._pipeCache.get(pipeType);
-    if (isBlank(meta)) {
-      var pipeMeta = this._pipeResolver.resolve(pipeType);
-      meta = new cpl.CompilePipeMetadata({
-        type: this.getTypeMetadata(pipeType, staticTypeModuleUrl(pipeType)),
-        name: pipeMeta.name,
-        pure: pipeMeta.pure,
-        lifecycleHooks: LIFECYCLE_HOOKS_VALUES.filter(hook => hasLifecycleHook(hook, pipeType)),
-      });
-      this._pipeCache.set(pipeType, meta);
-    }
-    return meta;
-  }
-
-  getViewDirectivesMetadata(component: Type): cpl.CompileDirectiveMetadata[] {
-    var view = this._viewResolver.resolve(component);
-    var directives = flattenDirectives(view, this._platformDirectives);
-    for (var i = 0; i < directives.length; i++) {
-      if (!isValidType(directives[i])) {
-        throw new BaseException(
-            `Unexpected directive value '${stringify(directives[i])}' on the View of component '${stringify(component)}'`);
-      }
-    }
-    return directives.map(type => this.getDirectiveMetadata(type));
-  }
-
-  getViewPipesMetadata(component: Type): cpl.CompilePipeMetadata[] {
-    var view = this._viewResolver.resolve(component);
-    var pipes = flattenPipes(view, this._platformPipes);
-    for (var i = 0; i < pipes.length; i++) {
-      if (!isValidType(pipes[i])) {
-        throw new BaseException(
-            `Unexpected piped value '${stringify(pipes[i])}' on the View of component '${stringify(component)}'`);
-      }
-    }
-    return pipes.map(type => this.getPipeMetadata(type));
-  }
-
-  getDependenciesMetadata(typeOrFunc: Type | Function,
-                          dependencies: any[]): cpl.CompileDiDependencyMetadata[] {
-    let params = isPresent(dependencies) ? dependencies : this._reflector.parameters(typeOrFunc);
-    if (isBlank(params)) {
-      params = [];
-    }
-    return params.map((param) => {
-      if (isBlank(param)) {
-        return null;
-      }
-      let isAttribute = false;
-      let isHost = false;
-      let isSelf = false;
-      let isSkipSelf = false;
-      let isOptional = false;
-      let query: QueryMetadata = null;
-      let viewQuery: ViewQueryMetadata = null;
-      var token = null;
-      if (isArray(param)) {
-        (<any[]>param)
-            .forEach((paramEntry) => {
-              if (paramEntry instanceof HostMetadata) {
-                isHost = true;
-              } else if (paramEntry instanceof SelfMetadata) {
-                isSelf = true;
-              } else if (paramEntry instanceof SkipSelfMetadata) {
-                isSkipSelf = true;
-              } else if (paramEntry instanceof OptionalMetadata) {
-                isOptional = true;
-              } else if (paramEntry instanceof AttributeMetadata) {
-                isAttribute = true;
-                token = paramEntry.attributeName;
-              } else if (paramEntry instanceof QueryMetadata) {
-                if (paramEntry.isViewQuery) {
-                  viewQuery = paramEntry;
-                } else {
-                  query = paramEntry;
-                }
-              } else if (paramEntry instanceof InjectMetadata) {
-                token = paramEntry.token;
-              } else if (isValidType(paramEntry) && isBlank(token)) {
-                token = paramEntry;
-              }
-            });
-      } else {
-        token = param;
-      }
-      if (isBlank(token)) {
-        return null;
-      }
-      return new cpl.CompileDiDependencyMetadata({
-        isAttribute: isAttribute,
-        isHost: isHost,
-        isSelf: isSelf,
-        isSkipSelf: isSkipSelf,
-        isOptional: isOptional,
-        query: isPresent(query) ? this.getQueryMetadata(query, null) : null,
-        viewQuery: isPresent(viewQuery) ? this.getQueryMetadata(viewQuery, null) : null,
-        token: this.getTokenMetadata(token)
-      });
-
-    });
-  }
-
-  getTokenMetadata(token: any): cpl.CompileTokenMetadata {
-    token = resolveForwardRef(token);
-    var compileToken;
-    if (isString(token)) {
-      compileToken = new cpl.CompileTokenMetadata({value: token});
-    } else {
-      compileToken = new cpl.CompileTokenMetadata({
-        identifier: new cpl.CompileIdentifierMetadata({
-          runtime: token,
-          name: this.sanitizeTokenName(token),
-          moduleUrl: staticTypeModuleUrl(token)
-        })
-      });
-    }
-    return compileToken;
-  }
-
-  getProvidersMetadata(providers: any[]):
-      Array<cpl.CompileProviderMetadata | cpl.CompileTypeMetadata | any[]> {
-    return providers.map((provider) => {
-      provider = resolveForwardRef(provider);
-      if (isArray(provider)) {
-        return this.getProvidersMetadata(provider);
-      } else if (provider instanceof Provider) {
-        return this.getProviderMetadata(provider);
-      } else if (isProviderLiteral(provider)) {
-        return this.getProviderMetadata(createProvider(provider));
-      } else {
-        return this.getTypeMetadata(provider, staticTypeModuleUrl(provider));
-      }
-    });
-  }
-
-  getProviderMetadata(provider: Provider): cpl.CompileProviderMetadata {
-    var compileDeps;
-    if (isPresent(provider.useClass)) {
-      compileDeps = this.getDependenciesMetadata(provider.useClass, provider.dependencies);
-    } else if (isPresent(provider.useFactory)) {
-      compileDeps = this.getDependenciesMetadata(provider.useFactory, provider.dependencies);
-    }
-    return new cpl.CompileProviderMetadata({
-      token: this.getTokenMetadata(provider.token),
-      useClass:
-          isPresent(provider.useClass) ?
-              this.getTypeMetadata(provider.useClass, staticTypeModuleUrl(provider.useClass)) :
-              null,
-      useValue: convertToCompileValue(provider.useValue),
-      useFactory: isPresent(provider.useFactory) ?
-                      this.getFactoryMetadata(provider.useFactory,
-                                              staticTypeModuleUrl(provider.useFactory)) :
-                      null,
-      useExisting: isPresent(provider.useExisting) ? this.getTokenMetadata(provider.useExisting) :
-                                                     null,
-      deps: compileDeps,
-      multi: provider.multi
-    });
-  }
-
-  getQueriesMetadata(queries: {[key: string]: QueryMetadata},
-                     isViewQuery: boolean): cpl.CompileQueryMetadata[] {
-    var compileQueries = [];
-    StringMapWrapper.forEach(queries, (query, propertyName) => {
-      if (query.isViewQuery === isViewQuery) {
-        compileQueries.push(this.getQueryMetadata(query, propertyName));
-      }
-    });
-    return compileQueries;
-  }
-
-  getQueryMetadata(q: QueryMetadata, propertyName: string): cpl.CompileQueryMetadata {
-    var selectors;
-    if (q.isVarBindingQuery) {
-      selectors = q.varBindings.map(varName => this.getTokenMetadata(varName));
-    } else {
-      selectors = [this.getTokenMetadata(q.selector)];
-    }
-    return new cpl.CompileQueryMetadata({
-      selectors: selectors,
-      first: q.first,
-      descendants: q.descendants,
-      propertyName: propertyName,
-      read: isPresent(q.read) ? this.getTokenMetadata(q.read) : null
-    });
-  }
-}
-
-function flattenDirectives(view: ViewMetadata, platformDirectives: any[]): Type[] {
-  let directives = [];
-  if (isPresent(platformDirectives)) {
-    flattenArray(platformDirectives, directives);
-  }
-  if (isPresent(view.directives)) {
-    flattenArray(view.directives, directives);
-  }
-  return directives;
-}
-
-function flattenPipes(view: ViewMetadata, platformPipes: any[]): Type[] {
-  let pipes = [];
-  if (isPresent(platformPipes)) {
-    flattenArray(platformPipes, pipes);
-  }
-  if (isPresent(view.pipes)) {
-    flattenArray(view.pipes, pipes);
-  }
-  return pipes;
-}
-
-function flattenArray(tree: any[], out: Array<Type | any[]>): void {
-  for (var i = 0; i < tree.length; i++) {
-    var item = resolveForwardRef(tree[i]);
-    if (isArray(item)) {
-      flattenArray(item, out);
-    } else {
-      out.push(item);
-    }
-  }
-}
-
-function isStaticType(value: any): boolean {
-  return isStringMap(value) && isPresent(value['name']) && isPresent(value['filePath']);
-}
-
-function isValidType(value: any): boolean {
-  return isStaticType(value) || (value instanceof Type);
-}
-
-function staticTypeModuleUrl(value: any): string {
-  return isStaticType(value) ? value['filePath'] : null;
-}
-
-function componentModuleUrl(reflector: ReflectorReader, type: any,
-                            cmpMetadata: ComponentMetadata): string {
-  if (isStaticType(type)) {
-    return staticTypeModuleUrl(type);
-  }
-
-  if (isPresent(cmpMetadata.moduleId)) {
-    var moduleId = cmpMetadata.moduleId;
-    var scheme = getUrlScheme(moduleId);
-    return isPresent(scheme) && scheme.length > 0 ? moduleId :
-                                                    `package:${moduleId}${MODULE_SUFFIX}`;
-  }
-
-  return reflector.importUri(type);
-}
-
-// Only fill CompileIdentifierMetadata.runtime if needed...
-function convertToCompileValue(value: any): any {
-  return visitValue(value, new _CompileValueConverter(), null);
-}
-
-class _CompileValueConverter extends ValueTransformer {
-  visitOther(value: any, context: any): any {
-    if (isStaticType(value)) {
-      return new cpl.CompileIdentifierMetadata(
-          {name: value['name'], moduleUrl: staticTypeModuleUrl(value)});
-    } else {
-      return new cpl.CompileIdentifierMetadata({runtime: value});
-    }
-  }
-}
--- a/modules/@angular/compiler/src/offline_compiler.ts
+++ b/modules/@angular/compiler/src/offline_compiler.ts
@ -1,171 +0,0 @@
-import {ComponentFactory} from '@angular/core';
-
-import {
-  CompileDirectiveMetadata,
-  CompileIdentifierMetadata,
-  CompilePipeMetadata,
-  createHostComponentMeta
-} from './compile_metadata';
-
-import {BaseException} from '../src/facade/exceptions';
-import {ListWrapper} from '../src/facade/collection';
-import {StyleCompiler, StylesCompileResult} from './style_compiler';
-import {ViewCompiler, ViewCompileResult} from './view_compiler/view_compiler';
-import {TemplateParser} from './template_parser';
-import {DirectiveNormalizer} from './directive_normalizer';
-import {OutputEmitter} from './output/abstract_emitter';
-import * as o from './output/output_ast';
-import {XHR} from './xhr';
-
-import {
-  MODULE_SUFFIX,
-  assetUrl,
-} from './util';
-
-var _COMPONENT_FACTORY_IDENTIFIER = new CompileIdentifierMetadata({
-  name: 'ComponentFactory',
-  runtime: ComponentFactory,
-  moduleUrl: assetUrl('core', 'linker/component_factory')
-});
-
-export class SourceModule {
-  constructor(public moduleUrl: string, public source: string) {}
-}
-
-export class StyleSheetSourceWithImports {
-  constructor(public source: SourceModule, public importedUrls: string[]) {}
-}
-
-export class NormalizedComponentWithViewDirectives {
-  constructor(public component: CompileDirectiveMetadata,
-              public directives: CompileDirectiveMetadata[], public pipes: CompilePipeMetadata[]) {}
-}
-
-export class OfflineCompiler {
-  constructor(private _directiveNormalizer: DirectiveNormalizer,
-              private _templateParser: TemplateParser, private _styleCompiler: StyleCompiler,
-              private _viewCompiler: ViewCompiler, private _outputEmitter: OutputEmitter,
-              private _xhr: XHR) {}
-
-  normalizeDirectiveMetadata(directive: CompileDirectiveMetadata):
-      Promise<CompileDirectiveMetadata> {
-    return this._directiveNormalizer.normalizeDirective(directive);
-  }
-
-  compileTemplates(components: NormalizedComponentWithViewDirectives[]): SourceModule {
-    if (components.length === 0) {
-      throw new BaseException('No components given');
-    }
-    var statements = [];
-    var exportedVars = [];
-    var moduleUrl = _templateModuleUrl(components[0].component);
-    components.forEach(componentWithDirs => {
-      var compMeta = <CompileDirectiveMetadata>componentWithDirs.component;
-      _assertComponent(compMeta);
-      var compViewFactoryVar = this._compileComponent(compMeta, componentWithDirs.directives,
-                                                      componentWithDirs.pipes, statements);
-      exportedVars.push(compViewFactoryVar);
-
-      var hostMeta = createHostComponentMeta(compMeta.type, compMeta.selector);
-      var hostViewFactoryVar = this._compileComponent(hostMeta, [compMeta], [], statements);
-      var compFactoryVar = `${compMeta.type.name}NgFactory`;
-      statements.push(
-          o.variable(compFactoryVar)
-              .set(o.importExpr(_COMPONENT_FACTORY_IDENTIFIER, [o.importType(compMeta.type)])
-                       .instantiate(
-                           [
-                             o.literal(compMeta.selector),
-                             o.variable(hostViewFactoryVar),
-                             o.importExpr(compMeta.type)
-                           ],
-                           o.importType(_COMPONENT_FACTORY_IDENTIFIER,
-                                        [o.importType(compMeta.type)], [o.TypeModifier.Const])))
-              .toDeclStmt(null, [o.StmtModifier.Final]));
-      exportedVars.push(compFactoryVar);
-    });
-    return this._codegenSourceModule(moduleUrl, statements, exportedVars);
-  }
-
-  loadAndCompileStylesheet(stylesheetUrl: string, shim: boolean,
-                           suffix: string): Promise<StyleSheetSourceWithImports> {
-    return this._xhr.get(stylesheetUrl)
-        .then((cssText) => {
-          var compileResult = this._styleCompiler.compileStylesheet(stylesheetUrl, cssText, shim);
-          var importedUrls = [];
-          compileResult.dependencies.forEach((dep) => {
-            importedUrls.push(dep.moduleUrl);
-            dep.valuePlaceholder.moduleUrl = _stylesModuleUrl(dep.moduleUrl, dep.isShimmed, suffix);
-          });
-          return new StyleSheetSourceWithImports(
-              this._codgenStyles(stylesheetUrl, shim, suffix, compileResult), importedUrls);
-        });
-  }
-
-  private _compileComponent(compMeta: CompileDirectiveMetadata,
-                            directives: CompileDirectiveMetadata[], pipes: CompilePipeMetadata[],
-                            targetStatements: o.Statement[]): string {
-    var styleResult = this._styleCompiler.compileComponent(compMeta);
-    var parsedTemplate = this._templateParser.parse(compMeta, compMeta.template.template,
-                                                    directives, pipes, compMeta.type.name);
-    var viewResult = this._viewCompiler.compileComponent(compMeta, parsedTemplate,
-                                                         o.variable(styleResult.stylesVar), pipes);
-    ListWrapper.addAll(targetStatements,
-                       _resolveStyleStatements(compMeta.type.moduleUrl, styleResult));
-    ListWrapper.addAll(targetStatements, _resolveViewStatements(viewResult));
-    return viewResult.viewFactoryVar;
-  }
-
-  private _codgenStyles(inputUrl: string, shim: boolean, suffix: string,
-                        stylesCompileResult: StylesCompileResult): SourceModule {
-    return this._codegenSourceModule(_stylesModuleUrl(inputUrl, shim, suffix),
-                                     stylesCompileResult.statements,
-                                     [stylesCompileResult.stylesVar]);
-  }
-
-  private _codegenSourceModule(moduleUrl: string, statements: o.Statement[],
-                               exportedVars: string[]): SourceModule {
-    return new SourceModule(
-        moduleUrl, this._outputEmitter.emitStatements(moduleUrl, statements, exportedVars));
-  }
-}
-
-function _resolveViewStatements(compileResult: ViewCompileResult): o.Statement[] {
-  compileResult.dependencies.forEach(
-      (dep) => { dep.factoryPlaceholder.moduleUrl = _templateModuleUrl(dep.comp); });
-  return compileResult.statements;
-}
-
-
-function _resolveStyleStatements(containingModuleUrl: string,
-                                 compileResult: StylesCompileResult): o.Statement[] {
-  var containingSuffix = _splitSuffix(containingModuleUrl)[1];
-  compileResult.dependencies.forEach((dep) => {
-    dep.valuePlaceholder.moduleUrl =
-        _stylesModuleUrl(dep.moduleUrl, dep.isShimmed, containingSuffix);
-  });
-  return compileResult.statements;
-}
-
-function _templateModuleUrl(comp: CompileDirectiveMetadata): string {
-  var urlWithSuffix = _splitSuffix(comp.type.moduleUrl);
-  return `${urlWithSuffix[0]}.ngfactory${urlWithSuffix[1]}`;
-}
-
-function _stylesModuleUrl(stylesheetUrl: string, shim: boolean, suffix: string): string {
-  return shim ? `${stylesheetUrl}.shim${suffix}` : `${stylesheetUrl}${suffix}`;
-}
-
-function _assertComponent(meta: CompileDirectiveMetadata) {
-  if (!meta.isComponent) {
-    throw new BaseException(`Could not compile '${meta.type.name}' because it is not a component.`);
-  }
-}
-
-function _splitSuffix(path: string): string[] {
-  let lastDot = path.lastIndexOf('.');
-  if (lastDot !== -1) {
-    return [path.substring(0, lastDot), path.substring(lastDot)];
-  } else {
-    return [path, ''];
-  }
-}
--- a/modules/@angular/compiler/src/output/abstract_emitter.ts
+++ b/modules/@angular/compiler/src/output/abstract_emitter.ts
@ -1,418 +0,0 @@
-import {isPresent, isBlank, isString, StringWrapper} from '../../src/facade/lang';
-import {BaseException} from '../../src/facade/exceptions';
-import * as o from './output_ast';
-
-var _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\|\n|\r|\$/g;
-export var CATCH_ERROR_VAR = o.variable('error');
-export var CATCH_STACK_VAR = o.variable('stack');
-
-export abstract class OutputEmitter {
-  abstract emitStatements(moduleUrl: string, stmts: o.Statement[], exportedVars: string[]): string;
-}
-
-class _EmittedLine {
-  parts: string[] = [];
-  constructor(public indent: number) {}
-}
-
-export class EmitterVisitorContext {
-  static createRoot(exportedVars: string[]): EmitterVisitorContext {
-    return new EmitterVisitorContext(exportedVars, 0);
-  }
-
-  private _lines: _EmittedLine[];
-  private _classes: o.ClassStmt[] = [];
-
-  constructor(private _exportedVars: string[], private _indent: number) {
-    this._lines = [new _EmittedLine(_indent)];
-  }
-
-  private get _currentLine(): _EmittedLine { return this._lines[this._lines.length - 1]; }
-
-  isExportedVar(varName: string): boolean { return this._exportedVars.indexOf(varName) !== -1; }
-
-  println(lastPart: string = ''): void { this.print(lastPart, true); }
-
-  lineIsEmpty(): boolean { return this._currentLine.parts.length === 0; }
-
-  print(part: string, newLine: boolean = false) {
-    if (part.length > 0) {
-      this._currentLine.parts.push(part);
-    }
-    if (newLine) {
-      this._lines.push(new _EmittedLine(this._indent));
-    }
-  }
-
-  removeEmptyLastLine() {
-    if (this.lineIsEmpty()) {
-      this._lines.pop();
-    }
-  }
-
-  incIndent() {
-    this._indent++;
-    this._currentLine.indent = this._indent;
-  }
-
-  decIndent() {
-    this._indent--;
-    this._currentLine.indent = this._indent;
-  }
-
-  pushClass(clazz: o.ClassStmt) { this._classes.push(clazz); }
-
-  popClass(): o.ClassStmt { return this._classes.pop(); }
-
-  get currentClass(): o.ClassStmt {
-    return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null;
-  }
-
-  toSource(): any {
-    var lines = this._lines;
-    if (lines[lines.length - 1].parts.length === 0) {
-      lines = lines.slice(0, lines.length - 1);
-    }
-    return lines.map((line) => {
-                  if (line.parts.length > 0) {
-                    return _createIndent(line.indent) + line.parts.join('');
-                  } else {
-                    return '';
-                  }
-                })
-        .join('\n');
-  }
-}
-
-export abstract class AbstractEmitterVisitor implements o.StatementVisitor, o.ExpressionVisitor {
-  constructor(private _escapeDollarInStrings: boolean) {}
-
-  visitExpressionStmt(stmt: o.ExpressionStatement, ctx: EmitterVisitorContext): any {
-    stmt.expr.visitExpression(this, ctx);
-    ctx.println(';');
-    return null;
-  }
-
-  visitReturnStmt(stmt: o.ReturnStatement, ctx: EmitterVisitorContext): any {
-    ctx.print(`return `);
-    stmt.value.visitExpression(this, ctx);
-    ctx.println(';');
-    return null;
-  }
-
-  abstract visitCastExpr(ast: o.CastExpr, context: any): any;
-
-  abstract visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any;
-
-  visitIfStmt(stmt: o.IfStmt, ctx: EmitterVisitorContext): any {
-    ctx.print(`if (`);
-    stmt.condition.visitExpression(this, ctx);
-    ctx.print(`) {`);
-    var hasElseCase = isPresent(stmt.falseCase) && stmt.falseCase.length > 0;
-    if (stmt.trueCase.length <= 1 && !hasElseCase) {
-      ctx.print(` `);
-      this.visitAllStatements(stmt.trueCase, ctx);
-      ctx.removeEmptyLastLine();
-      ctx.print(` `);
-    } else {
-      ctx.println();
-      ctx.incIndent();
-      this.visitAllStatements(stmt.trueCase, ctx);
-      ctx.decIndent();
-      if (hasElseCase) {
-        ctx.println(`} else {`);
-        ctx.incIndent();
-        this.visitAllStatements(stmt.falseCase, ctx);
-        ctx.decIndent();
-      }
-    }
-    ctx.println(`}`);
-    return null;
-  }
-
-  abstract visitTryCatchStmt(stmt: o.TryCatchStmt, ctx: EmitterVisitorContext): any;
-
-  visitThrowStmt(stmt: o.ThrowStmt, ctx: EmitterVisitorContext): any {
-    ctx.print(`throw `);
-    stmt.error.visitExpression(this, ctx);
-    ctx.println(`;`);
-    return null;
-  }
-  visitCommentStmt(stmt: o.CommentStmt, ctx: EmitterVisitorContext): any {
-    var lines = stmt.comment.split('\n');
-    lines.forEach((line) => { ctx.println(`// ${line}`); });
-    return null;
-  }
-  abstract visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any;
-  visitWriteVarExpr(expr: o.WriteVarExpr, ctx: EmitterVisitorContext): any {
-    var lineWasEmpty = ctx.lineIsEmpty();
-    if (!lineWasEmpty) {
-      ctx.print('(');
-    }
-    ctx.print(`${expr.name} = `);
-    expr.value.visitExpression(this, ctx);
-    if (!lineWasEmpty) {
-      ctx.print(')');
-    }
-    return null;
-  }
-  visitWriteKeyExpr(expr: o.WriteKeyExpr, ctx: EmitterVisitorContext): any {
-    var lineWasEmpty = ctx.lineIsEmpty();
-    if (!lineWasEmpty) {
-      ctx.print('(');
-    }
-    expr.receiver.visitExpression(this, ctx);
-    ctx.print(`[`);
-    expr.index.visitExpression(this, ctx);
-    ctx.print(`] = `);
-    expr.value.visitExpression(this, ctx);
-    if (!lineWasEmpty) {
-      ctx.print(')');
-    }
-    return null;
-  }
-  visitWritePropExpr(expr: o.WritePropExpr, ctx: EmitterVisitorContext): any {
-    var lineWasEmpty = ctx.lineIsEmpty();
-    if (!lineWasEmpty) {
-      ctx.print('(');
-    }
-    expr.receiver.visitExpression(this, ctx);
-    ctx.print(`.${expr.name} = `);
-    expr.value.visitExpression(this, ctx);
-    if (!lineWasEmpty) {
-      ctx.print(')');
-    }
-    return null;
-  }
-  visitInvokeMethodExpr(expr: o.InvokeMethodExpr, ctx: EmitterVisitorContext): any {
-    expr.receiver.visitExpression(this, ctx);
-    var name = expr.name;
-    if (isPresent(expr.builtin)) {
-      name = this.getBuiltinMethodName(expr.builtin);
-      if (isBlank(name)) {
-        // some builtins just mean to skip the call.
-        // e.g. `bind` in Dart.
-        return null;
-      }
-    }
-    ctx.print(`.${name}(`);
-    this.visitAllExpressions(expr.args, ctx, `,`);
-    ctx.print(`)`);
-    return null;
-  }
-
-  abstract getBuiltinMethodName(method: o.BuiltinMethod): string;
-
-  visitInvokeFunctionExpr(expr: o.InvokeFunctionExpr, ctx: EmitterVisitorContext): any {
-    expr.fn.visitExpression(this, ctx);
-    ctx.print(`(`);
-    this.visitAllExpressions(expr.args, ctx, ',');
-    ctx.print(`)`);
-    return null;
-  }
-  visitReadVarExpr(ast: o.ReadVarExpr, ctx: EmitterVisitorContext): any {
-    var varName = ast.name;
-    if (isPresent(ast.builtin)) {
-      switch (ast.builtin) {
-        case o.BuiltinVar.Super:
-          varName = 'super';
-          break;
-        case o.BuiltinVar.This:
-          varName = 'this';
-          break;
-        case o.BuiltinVar.CatchError:
-          varName = CATCH_ERROR_VAR.name;
-          break;
-        case o.BuiltinVar.CatchStack:
-          varName = CATCH_STACK_VAR.name;
-          break;
-        default:
-          throw new BaseException(`Unknown builtin variable ${ast.builtin}`);
-      }
-    }
-    ctx.print(varName);
-    return null;
-  }
-  visitInstantiateExpr(ast: o.InstantiateExpr, ctx: EmitterVisitorContext): any {
-    ctx.print(`new `);
-    ast.classExpr.visitExpression(this, ctx);
-    ctx.print(`(`);
-    this.visitAllExpressions(ast.args, ctx, ',');
-    ctx.print(`)`);
-    return null;
-  }
-  visitLiteralExpr(ast: o.LiteralExpr, ctx: EmitterVisitorContext): any {
-    var value = ast.value;
-    if (isString(value)) {
-      ctx.print(escapeSingleQuoteString(value, this._escapeDollarInStrings));
-    } else if (isBlank(value)) {
-      ctx.print('null');
-    } else {
-      ctx.print(`${value}`);
-    }
-    return null;
-  }
-
-  abstract visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any;
-
-  visitConditionalExpr(ast: o.ConditionalExpr, ctx: EmitterVisitorContext): any {
-    ctx.print(`(`);
-    ast.condition.visitExpression(this, ctx);
-    ctx.print('? ');
-    ast.trueCase.visitExpression(this, ctx);
-    ctx.print(': ');
-    ast.falseCase.visitExpression(this, ctx);
-    ctx.print(`)`);
-    return null;
-  }
-  visitNotExpr(ast: o.NotExpr, ctx: EmitterVisitorContext): any {
-    ctx.print('!');
-    ast.condition.visitExpression(this, ctx);
-    return null;
-  }
-  abstract visitFunctionExpr(ast: o.FunctionExpr, ctx: EmitterVisitorContext): any;
-  abstract visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, context: any): any;
-
-  visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, ctx: EmitterVisitorContext): any {
-    var opStr;
-    switch (ast.operator) {
-      case o.BinaryOperator.Equals:
-        opStr = '==';
-        break;
-      case o.BinaryOperator.Identical:
-        opStr = '===';
-        break;
-      case o.BinaryOperator.NotEquals:
-        opStr = '!=';
-        break;
-      case o.BinaryOperator.NotIdentical:
-        opStr = '!==';
-        break;
-      case o.BinaryOperator.And:
-        opStr = '&&';
-        break;
-      case o.BinaryOperator.Or:
-        opStr = '||';
-        break;
-      case o.BinaryOperator.Plus:
-        opStr = '+';
-        break;
-      case o.BinaryOperator.Minus:
-        opStr = '-';
-        break;
-      case o.BinaryOperator.Divide:
-        opStr = '/';
-        break;
-      case o.BinaryOperator.Multiply:
-        opStr = '*';
-        break;
-      case o.BinaryOperator.Modulo:
-        opStr = '%';
-        break;
-      case o.BinaryOperator.Lower:
-        opStr = '<';
-        break;
-      case o.BinaryOperator.LowerEquals:
-        opStr = '<=';
-        break;
-      case o.BinaryOperator.Bigger:
-        opStr = '>';
-        break;
-      case o.BinaryOperator.BiggerEquals:
-        opStr = '>=';
-        break;
-      default:
-        throw new BaseException(`Unknown operator ${ast.operator}`);
-    }
-    ctx.print(`(`);
-    ast.lhs.visitExpression(this, ctx);
-    ctx.print(` ${opStr} `);
-    ast.rhs.visitExpression(this, ctx);
-    ctx.print(`)`);
-    return null;
-  }
-
-  visitReadPropExpr(ast: o.ReadPropExpr, ctx: EmitterVisitorContext): any {
-    ast.receiver.visitExpression(this, ctx);
-    ctx.print(`.`);
-    ctx.print(ast.name);
-    return null;
-  }
-  visitReadKeyExpr(ast: o.ReadKeyExpr, ctx: EmitterVisitorContext): any {
-    ast.receiver.visitExpression(this, ctx);
-    ctx.print(`[`);
-    ast.index.visitExpression(this, ctx);
-    ctx.print(`]`);
-    return null;
-  }
-  visitLiteralArrayExpr(ast: o.LiteralArrayExpr, ctx: EmitterVisitorContext): any {
-    var useNewLine = ast.entries.length > 1;
-    ctx.print(`[`, useNewLine);
-    ctx.incIndent();
-    this.visitAllExpressions(ast.entries, ctx, ',', useNewLine);
-    ctx.decIndent();
-    ctx.print(`]`, useNewLine);
-    return null;
-  }
-  visitLiteralMapExpr(ast: o.LiteralMapExpr, ctx: EmitterVisitorContext): any {
-    var useNewLine = ast.entries.length > 1;
-    ctx.print(`{`, useNewLine);
-    ctx.incIndent();
-    this.visitAllObjects((entry) => {
-      ctx.print(`${escapeSingleQuoteString(entry[0], this._escapeDollarInStrings)}: `);
-      entry[1].visitExpression(this, ctx);
-    }, ast.entries, ctx, ',', useNewLine);
-    ctx.decIndent();
-    ctx.print(`}`, useNewLine);
-    return null;
-  }
-
-  visitAllExpressions(expressions: o.Expression[], ctx: EmitterVisitorContext, separator: string,
-                      newLine: boolean = false): void {
-    this.visitAllObjects((expr) => expr.visitExpression(this, ctx), expressions, ctx, separator,
-                         newLine);
-  }
-
-  visitAllObjects(handler: Function, expressions: any, ctx: EmitterVisitorContext,
-                  separator: string, newLine: boolean = false): void {
-    for (var i = 0; i < expressions.length; i++) {
-      if (i > 0) {
-        ctx.print(separator, newLine);
-      }
-      handler(expressions[i]);
-    }
-    if (newLine) {
-      ctx.println();
-    }
-  }
-
-  visitAllStatements(statements: o.Statement[], ctx: EmitterVisitorContext): void {
-    statements.forEach((stmt) => { return stmt.visitStatement(this, ctx); });
-  }
-}
-
-export function escapeSingleQuoteString(input: string, escapeDollar: boolean): any {
-  if (isBlank(input)) {
-    return null;
-  }
-  var body = StringWrapper.replaceAllMapped(input, _SINGLE_QUOTE_ESCAPE_STRING_RE, (match) => {
-    if (match[0] == '$') {
-      return escapeDollar ? '\\$' : '$';
-    } else if (match[0] == '\n') {
-      return '\\n';
-    } else if (match[0] == '\r') {
-      return '\\r';
-    } else {
-      return `\\${match[0]}`;
-    }
-  });
-  return `'${body}'`;
-}
-
-function _createIndent(count: number): string {
-  var res = '';
-  for (var i = 0; i < count; i++) {
-    res += '  ';
-  }
-  return res;
-}
--- a/modules/@angular/compiler/src/output/abstract_js_emitter.ts
+++ b/modules/@angular/compiler/src/output/abstract_js_emitter.ts
@ -1,164 +0,0 @@
-import {isPresent} from '../../src/facade/lang';
-import {BaseException} from '../../src/facade/exceptions';
-import * as o from './output_ast';
-import {
-  EmitterVisitorContext,
-  AbstractEmitterVisitor,
-  CATCH_ERROR_VAR,
-  CATCH_STACK_VAR
-} from './abstract_emitter';
-
-export abstract class AbstractJsEmitterVisitor extends AbstractEmitterVisitor {
-  constructor() { super(false); }
-  visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {
-    ctx.pushClass(stmt);
-    this._visitClassConstructor(stmt, ctx);
-
-    if (isPresent(stmt.parent)) {
-      ctx.print(`${stmt.name}.prototype = Object.create(`);
-      stmt.parent.visitExpression(this, ctx);
-      ctx.println(`.prototype);`);
-    }
-    stmt.getters.forEach((getter) => this._visitClassGetter(stmt, getter, ctx));
-    stmt.methods.forEach((method) => this._visitClassMethod(stmt, method, ctx));
-    ctx.popClass();
-    return null;
-  }
-
-  private _visitClassConstructor(stmt: o.ClassStmt, ctx: EmitterVisitorContext) {
-    ctx.print(`function ${stmt.name}(`);
-    if (isPresent(stmt.constructorMethod)) {
-      this._visitParams(stmt.constructorMethod.params, ctx);
-    }
-    ctx.println(`) {`);
-    ctx.incIndent();
-    if (isPresent(stmt.constructorMethod)) {
-      if (stmt.constructorMethod.body.length > 0) {
-        ctx.println(`var self = this;`);
-        this.visitAllStatements(stmt.constructorMethod.body, ctx);
-      }
-    }
-    ctx.decIndent();
-    ctx.println(`}`);
-  }
-
-  private _visitClassGetter(stmt: o.ClassStmt, getter: o.ClassGetter, ctx: EmitterVisitorContext) {
-    ctx.println(
-        `Object.defineProperty(${stmt.name}.prototype, '${getter.name}', { get: function() {`);
-    ctx.incIndent();
-    if (getter.body.length > 0) {
-      ctx.println(`var self = this;`);
-      this.visitAllStatements(getter.body, ctx);
-    }
-    ctx.decIndent();
-    ctx.println(`}});`);
-  }
-
-  private _visitClassMethod(stmt: o.ClassStmt, method: o.ClassMethod, ctx: EmitterVisitorContext) {
-    ctx.print(`${stmt.name}.prototype.${method.name} = function(`);
-    this._visitParams(method.params, ctx);
-    ctx.println(`) {`);
-    ctx.incIndent();
-    if (method.body.length > 0) {
-      ctx.println(`var self = this;`);
-      this.visitAllStatements(method.body, ctx);
-    }
-    ctx.decIndent();
-    ctx.println(`};`);
-  }
-
-  visitReadVarExpr(ast: o.ReadVarExpr, ctx: EmitterVisitorContext): string {
-    if (ast.builtin === o.BuiltinVar.This) {
-      ctx.print('self');
-    } else if (ast.builtin === o.BuiltinVar.Super) {
-      throw new BaseException(
-          `'super' needs to be handled at a parent ast node, not at the variable level!`);
-    } else {
-      super.visitReadVarExpr(ast, ctx);
-    }
-    return null;
-  }
-  visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any {
-    ctx.print(`var ${stmt.name} = `);
-    stmt.value.visitExpression(this, ctx);
-    ctx.println(`;`);
-    return null;
-  }
-  visitCastExpr(ast: o.CastExpr, ctx: EmitterVisitorContext): any {
-    ast.value.visitExpression(this, ctx);
-    return null;
-  }
-  visitInvokeFunctionExpr(expr: o.InvokeFunctionExpr, ctx: EmitterVisitorContext): string {
-    var fnExpr = expr.fn;
-    if (fnExpr instanceof o.ReadVarExpr && fnExpr.builtin === o.BuiltinVar.Super) {
-      ctx.currentClass.parent.visitExpression(this, ctx);
-      ctx.print(`.call(this`);
-      if (expr.args.length > 0) {
-        ctx.print(`, `);
-        this.visitAllExpressions(expr.args, ctx, ',');
-      }
-      ctx.print(`)`);
-    } else {
-      super.visitInvokeFunctionExpr(expr, ctx);
-    }
-    return null;
-  }
-  visitFunctionExpr(ast: o.FunctionExpr, ctx: EmitterVisitorContext): any {
-    ctx.print(`function(`);
-    this._visitParams(ast.params, ctx);
-    ctx.println(`) {`);
-    ctx.incIndent();
-    this.visitAllStatements(ast.statements, ctx);
-    ctx.decIndent();
-    ctx.print(`}`);
-    return null;
-  }
-  visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: EmitterVisitorContext): any {
-    ctx.print(`function ${stmt.name}(`);
-    this._visitParams(stmt.params, ctx);
-    ctx.println(`) {`);
-    ctx.incIndent();
-    this.visitAllStatements(stmt.statements, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-    return null;
-  }
-  visitTryCatchStmt(stmt: o.TryCatchStmt, ctx: EmitterVisitorContext): any {
-    ctx.println(`try {`);
-    ctx.incIndent();
-    this.visitAllStatements(stmt.bodyStmts, ctx);
-    ctx.decIndent();
-    ctx.println(`} catch (${CATCH_ERROR_VAR.name}) {`);
-    ctx.incIndent();
-    var catchStmts = [
-      <o.Statement>CATCH_STACK_VAR.set(CATCH_ERROR_VAR.prop('stack'))
-          .toDeclStmt(null, [o.StmtModifier.Final])
-    ].concat(stmt.catchStmts);
-    this.visitAllStatements(catchStmts, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-    return null;
-  }
-
-  private _visitParams(params: o.FnParam[], ctx: EmitterVisitorContext): void {
-    this.visitAllObjects((param) => ctx.print(param.name), params, ctx, ',');
-  }
-
-  getBuiltinMethodName(method: o.BuiltinMethod): string {
-    var name;
-    switch (method) {
-      case o.BuiltinMethod.ConcatArray:
-        name = 'concat';
-        break;
-      case o.BuiltinMethod.SubscribeObservable:
-        name = 'subscribe';
-        break;
-      case o.BuiltinMethod.bind:
-        name = 'bind';
-        break;
-      default:
-        throw new BaseException(`Unknown builtin method: ${method}`);
-    }
-    return name;
-  }
-}
--- a/modules/@angular/compiler/src/output/dart_emitter.ts
+++ b/modules/@angular/compiler/src/output/dart_emitter.ts
@ -1,374 +0,0 @@
-import {isPresent, isBlank, isArray} from '../../src/facade/lang';
-import {BaseException} from '../../src/facade/exceptions';
-import {CompileIdentifierMetadata} from '../compile_metadata';
-import * as o from './output_ast';
-import {
-  OutputEmitter,
-  EmitterVisitorContext,
-  AbstractEmitterVisitor,
-  CATCH_ERROR_VAR,
-  CATCH_STACK_VAR,
-} from './abstract_emitter';
-import {ImportGenerator} from './path_util';
-
-var _debugModuleUrl = 'asset://debug/lib';
-
-export function debugOutputAstAsDart(ast: o.Statement | o.Expression | o.Type | any[]): string {
-  var converter = new _DartEmitterVisitor(_debugModuleUrl);
-  var ctx = EmitterVisitorContext.createRoot([]);
-  var asts: any[];
-  if (isArray(ast)) {
-    asts = <any[]>ast;
-  } else {
-    asts = [ast];
-  }
-  asts.forEach((ast) => {
-    if (ast instanceof o.Statement) {
-      ast.visitStatement(converter, ctx);
-    } else if (ast instanceof o.Expression) {
-      ast.visitExpression(converter, ctx);
-    } else if (ast instanceof o.Type) {
-      ast.visitType(converter, ctx);
-    } else {
-      throw new BaseException(`Don't know how to print debug info for ${ast}`);
-    }
-  });
-  return ctx.toSource();
-}
-
-export class DartEmitter implements OutputEmitter {
-  constructor(private _importGenerator: ImportGenerator) {}
-  emitStatements(moduleUrl: string, stmts: o.Statement[], exportedVars: string[]): string {
-    var srcParts = [];
-    // Note: We are not creating a library here as Dart does not need it.
-    // Dart analzyer might complain about it though.
-
-    var converter = new _DartEmitterVisitor(moduleUrl);
-    var ctx = EmitterVisitorContext.createRoot(exportedVars);
-    converter.visitAllStatements(stmts, ctx);
-
-    converter.importsWithPrefixes.forEach((prefix, importedModuleUrl) => {
-      srcParts.push(
-          `import '${this._importGenerator.getImportPath(moduleUrl, importedModuleUrl)}' as ${prefix};`);
-    });
-    srcParts.push(ctx.toSource());
-    return srcParts.join('\n');
-  }
-}
-
-class _DartEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor {
-  importsWithPrefixes = new Map<string, string>();
-
-  constructor(private _moduleUrl: string) { super(true); }
-
-  visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any {
-    this._visitIdentifier(ast.value, ast.typeParams, ctx);
-    return null;
-  }
-  visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any {
-    if (stmt.hasModifier(o.StmtModifier.Final)) {
-      if (isConstType(stmt.type)) {
-        ctx.print(`const `);
-      } else {
-        ctx.print(`final `);
-      }
-    } else if (isBlank(stmt.type)) {
-      ctx.print(`var `);
-    }
-    if (isPresent(stmt.type)) {
-      stmt.type.visitType(this, ctx);
-      ctx.print(` `);
-    }
-    ctx.print(`${stmt.name} = `);
-    stmt.value.visitExpression(this, ctx);
-    ctx.println(`;`);
-    return null;
-  }
-  visitCastExpr(ast: o.CastExpr, ctx: EmitterVisitorContext): any {
-    ctx.print(`(`);
-    ast.value.visitExpression(this, ctx);
-    ctx.print(` as `);
-    ast.type.visitType(this, ctx);
-    ctx.print(`)`);
-    return null;
-  }
-  visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {
-    ctx.pushClass(stmt);
-    ctx.print(`class ${stmt.name}`);
-    if (isPresent(stmt.parent)) {
-      ctx.print(` extends `);
-      stmt.parent.visitExpression(this, ctx);
-    }
-    ctx.println(` {`);
-    ctx.incIndent();
-    stmt.fields.forEach((field) => this._visitClassField(field, ctx));
-    if (isPresent(stmt.constructorMethod)) {
-      this._visitClassConstructor(stmt, ctx);
-    }
-    stmt.getters.forEach((getter) => this._visitClassGetter(getter, ctx));
-    stmt.methods.forEach((method) => this._visitClassMethod(method, ctx));
-    ctx.decIndent();
-    ctx.println(`}`);
-    ctx.popClass();
-    return null;
-  }
-  private _visitClassField(field: o.ClassField, ctx: EmitterVisitorContext) {
-    if (field.hasModifier(o.StmtModifier.Final)) {
-      ctx.print(`final `);
-    } else if (isBlank(field.type)) {
-      ctx.print(`var `);
-    }
-    if (isPresent(field.type)) {
-      field.type.visitType(this, ctx);
-      ctx.print(` `);
-    }
-    ctx.println(`${field.name};`);
-  }
-  private _visitClassGetter(getter: o.ClassGetter, ctx: EmitterVisitorContext) {
-    if (isPresent(getter.type)) {
-      getter.type.visitType(this, ctx);
-      ctx.print(` `);
-    }
-    ctx.println(`get ${getter.name} {`);
-    ctx.incIndent();
-    this.visitAllStatements(getter.body, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-  }
-  private _visitClassConstructor(stmt: o.ClassStmt, ctx: EmitterVisitorContext) {
-    ctx.print(`${stmt.name}(`);
-    this._visitParams(stmt.constructorMethod.params, ctx);
-    ctx.print(`)`);
-
-    var ctorStmts = stmt.constructorMethod.body;
-    var superCtorExpr = ctorStmts.length > 0 ? getSuperConstructorCallExpr(ctorStmts[0]) : null;
-    if (isPresent(superCtorExpr)) {
-      ctx.print(`: `);
-      superCtorExpr.visitExpression(this, ctx);
-      ctorStmts = ctorStmts.slice(1);
-    }
-    ctx.println(` {`);
-    ctx.incIndent();
-    this.visitAllStatements(ctorStmts, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-  }
-  private _visitClassMethod(method: o.ClassMethod, ctx: EmitterVisitorContext) {
-    if (isPresent(method.type)) {
-      method.type.visitType(this, ctx);
-    } else {
-      ctx.print(`void`);
-    }
-    ctx.print(` ${method.name}(`);
-    this._visitParams(method.params, ctx);
-    ctx.println(`) {`);
-    ctx.incIndent();
-    this.visitAllStatements(method.body, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-  }
-
-  visitFunctionExpr(ast: o.FunctionExpr, ctx: EmitterVisitorContext): any {
-    ctx.print(`(`);
-    this._visitParams(ast.params, ctx);
-    ctx.println(`) {`);
-    ctx.incIndent();
-    this.visitAllStatements(ast.statements, ctx);
-    ctx.decIndent();
-    ctx.print(`}`);
-    return null;
-  }
-  visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: EmitterVisitorContext): any {
-    if (isPresent(stmt.type)) {
-      stmt.type.visitType(this, ctx);
-    } else {
-      ctx.print(`void`);
-    }
-    ctx.print(` ${stmt.name}(`);
-    this._visitParams(stmt.params, ctx);
-    ctx.println(`) {`);
-    ctx.incIndent();
-    this.visitAllStatements(stmt.statements, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-    return null;
-  }
-
-  getBuiltinMethodName(method: o.BuiltinMethod): string {
-    var name;
-    switch (method) {
-      case o.BuiltinMethod.ConcatArray:
-        name = '.addAll';
-        break;
-      case o.BuiltinMethod.SubscribeObservable:
-        name = 'listen';
-        break;
-      case o.BuiltinMethod.bind:
-        name = null;
-        break;
-      default:
-        throw new BaseException(`Unknown builtin method: ${method}`);
-    }
-    return name;
-  }
-  visitTryCatchStmt(stmt: o.TryCatchStmt, ctx: EmitterVisitorContext): any {
-    ctx.println(`try {`);
-    ctx.incIndent();
-    this.visitAllStatements(stmt.bodyStmts, ctx);
-    ctx.decIndent();
-    ctx.println(`} catch (${CATCH_ERROR_VAR.name}, ${CATCH_STACK_VAR.name}) {`);
-    ctx.incIndent();
-    this.visitAllStatements(stmt.catchStmts, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-    return null;
-  }
-  visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, ctx: EmitterVisitorContext): any {
-    switch (ast.operator) {
-      case o.BinaryOperator.Identical:
-        ctx.print(`identical(`);
-        ast.lhs.visitExpression(this, ctx);
-        ctx.print(`, `);
-        ast.rhs.visitExpression(this, ctx);
-        ctx.print(`)`);
-        break;
-      case o.BinaryOperator.NotIdentical:
-        ctx.print(`!identical(`);
-        ast.lhs.visitExpression(this, ctx);
-        ctx.print(`, `);
-        ast.rhs.visitExpression(this, ctx);
-        ctx.print(`)`);
-        break;
-      default:
-        super.visitBinaryOperatorExpr(ast, ctx);
-    }
-    return null;
-  }
-  visitLiteralArrayExpr(ast: o.LiteralArrayExpr, ctx: EmitterVisitorContext): any {
-    if (isConstType(ast.type)) {
-      ctx.print(`const `);
-    }
-    return super.visitLiteralArrayExpr(ast, ctx);
-  }
-  visitLiteralMapExpr(ast: o.LiteralMapExpr, ctx: EmitterVisitorContext): any {
-    if (isConstType(ast.type)) {
-      ctx.print(`const `);
-    }
-    if (isPresent(ast.valueType)) {
-      ctx.print(`<String, `);
-      ast.valueType.visitType(this, ctx);
-      ctx.print(`>`);
-    }
-    return super.visitLiteralMapExpr(ast, ctx);
-  }
-  visitInstantiateExpr(ast: o.InstantiateExpr, ctx: EmitterVisitorContext): any {
-    ctx.print(isConstType(ast.type) ? `const` : `new`);
-    ctx.print(' ');
-    ast.classExpr.visitExpression(this, ctx);
-    ctx.print(`(`);
-    this.visitAllExpressions(ast.args, ctx, `,`);
-    ctx.print(`)`);
-    return null;
-  }
-  visitBuiltintType(type: o.BuiltinType, ctx: EmitterVisitorContext): any {
-    var typeStr;
-    switch (type.name) {
-      case o.BuiltinTypeName.Bool:
-        typeStr = 'bool';
-        break;
-      case o.BuiltinTypeName.Dynamic:
-        typeStr = 'dynamic';
-        break;
-      case o.BuiltinTypeName.Function:
-        typeStr = 'Function';
-        break;
-      case o.BuiltinTypeName.Number:
-        typeStr = 'num';
-        break;
-      case o.BuiltinTypeName.Int:
-        typeStr = 'int';
-        break;
-      case o.BuiltinTypeName.String:
-        typeStr = 'String';
-        break;
-      default:
-        throw new BaseException(`Unsupported builtin type ${type.name}`);
-    }
-    ctx.print(typeStr);
-    return null;
-  }
-  visitExternalType(ast: o.ExternalType, ctx: EmitterVisitorContext): any {
-    this._visitIdentifier(ast.value, ast.typeParams, ctx);
-    return null;
-  }
-  visitArrayType(type: o.ArrayType, ctx: EmitterVisitorContext): any {
-    ctx.print(`List<`);
-    if (isPresent(type.of)) {
-      type.of.visitType(this, ctx);
-    } else {
-      ctx.print(`dynamic`);
-    }
-    ctx.print(`>`);
-    return null;
-  }
-  visitMapType(type: o.MapType, ctx: EmitterVisitorContext): any {
-    ctx.print(`Map<String, `);
-    if (isPresent(type.valueType)) {
-      type.valueType.visitType(this, ctx);
-    } else {
-      ctx.print(`dynamic`);
-    }
-    ctx.print(`>`);
-    return null;
-  }
-
-  private _visitParams(params: o.FnParam[], ctx: EmitterVisitorContext): void {
-    this.visitAllObjects((param) => {
-      if (isPresent(param.type)) {
-        param.type.visitType(this, ctx);
-        ctx.print(' ');
-      }
-      ctx.print(param.name);
-    }, params, ctx, ',');
-  }
-
-  private _visitIdentifier(value: CompileIdentifierMetadata, typeParams: o.Type[],
-                           ctx: EmitterVisitorContext): void {
-    if (isBlank(value.name)) {
-      throw new BaseException(`Internal error: unknown identifier ${value}`);
-    }
-    if (isPresent(value.moduleUrl) && value.moduleUrl != this._moduleUrl) {
-      var prefix = this.importsWithPrefixes.get(value.moduleUrl);
-      if (isBlank(prefix)) {
-        prefix = `import${this.importsWithPrefixes.size}`;
-        this.importsWithPrefixes.set(value.moduleUrl, prefix);
-      }
-      ctx.print(`${prefix}.`);
-    }
-    ctx.print(value.name);
-    if (isPresent(typeParams) && typeParams.length > 0) {
-      ctx.print(`<`);
-      this.visitAllObjects((type) => type.visitType(this, ctx), typeParams, ctx, ',');
-      ctx.print(`>`);
-    }
-  }
-}
-
-function getSuperConstructorCallExpr(stmt: o.Statement): o.Expression {
-  if (stmt instanceof o.ExpressionStatement) {
-    var expr = stmt.expr;
-    if (expr instanceof o.InvokeFunctionExpr) {
-      var fn = expr.fn;
-      if (fn instanceof o.ReadVarExpr) {
-        if (fn.builtin === o.BuiltinVar.Super) {
-          return expr;
-        }
-      }
-    }
-  }
-  return null;
-}
-
-function isConstType(type: o.Type): boolean {
-  return isPresent(type) && type.hasModifier(o.TypeModifier.Const);
-}
--- a/modules/@angular/compiler/src/output/dart_imports.ts
+++ b/modules/@angular/compiler/src/output/dart_imports.ts
@ -1,52 +0,0 @@
-import {BaseException} from '../../src/facade/exceptions';
-import {isPresent, isBlank, RegExpWrapper, Math} from '../../src/facade/lang';
-import {Injectable} from '@angular/core';
-
-import {AssetUrl, ImportGenerator} from './path_util';
-
-var _PATH_SEP = '/';
-var _PATH_SEP_RE = /\//g;
-
-@Injectable()
-export class DartImportGenerator implements ImportGenerator {
-  getImportPath(moduleUrlStr: string, importedUrlStr: string): string {
-    var moduleUrl = AssetUrl.parse(moduleUrlStr, false);
-    var importedUrl = AssetUrl.parse(importedUrlStr, true);
-    if (isBlank(importedUrl)) {
-      return importedUrlStr;
-    }
-    // Try to create a relative path first
-    if (moduleUrl.firstLevelDir == importedUrl.firstLevelDir &&
-        moduleUrl.packageName == importedUrl.packageName) {
-      return getRelativePath(moduleUrl.modulePath, importedUrl.modulePath);
-    } else if (importedUrl.firstLevelDir == 'lib') {
-      return `package:${importedUrl.packageName}/${importedUrl.modulePath}`;
-    }
-    throw new BaseException(`Can't import url ${importedUrlStr} from ${moduleUrlStr}`);
-  }
-}
-
-export function getRelativePath(modulePath: string, importedPath: string): string {
-  var moduleParts = modulePath.split(_PATH_SEP_RE);
-  var importedParts = importedPath.split(_PATH_SEP_RE);
-  var longestPrefix = getLongestPathSegmentPrefix(moduleParts, importedParts);
-
-  var resultParts = [];
-  var goParentCount = moduleParts.length - 1 - longestPrefix;
-  for (var i = 0; i < goParentCount; i++) {
-    resultParts.push('..');
-  }
-  for (var i = longestPrefix; i < importedParts.length; i++) {
-    resultParts.push(importedParts[i]);
-  }
-  return resultParts.join(_PATH_SEP);
-}
-
-export function getLongestPathSegmentPrefix(arr1: string[], arr2: string[]): number {
-  var prefixSize = 0;
-  var minLen = Math.min(arr1.length, arr2.length);
-  while (prefixSize < minLen && arr1[prefixSize] == arr2[prefixSize]) {
-    prefixSize++;
-  }
-  return prefixSize;
-}
--- a/modules/@angular/compiler/src/output/interpretive_view.ts
+++ b/modules/@angular/compiler/src/output/interpretive_view.ts
@ -1,68 +0,0 @@
-import {AppElement, AppView, DebugAppView} from '../../core_private';
-
-import {isPresent} from '../../src/facade/lang';
-import {BaseException} from '../../src/facade/exceptions';
-import {InstanceFactory, DynamicInstance} from './output_interpreter';
-
-export class InterpretiveAppViewInstanceFactory implements InstanceFactory {
-  createInstance(superClass: any, clazz: any, args: any[], props: Map<string, any>,
-                 getters: Map<string, Function>, methods: Map<string, Function>): any {
-    if (superClass === AppView) {
-      // We are always using DebugAppView as parent.
-      // However, in prod mode we generate a constructor call that does
-      // not have the argument for the debugNodeInfos.
-      args = args.concat([null]);
-      return new _InterpretiveAppView(args, props, getters, methods);
-    } else if (superClass === DebugAppView) {
-      return new _InterpretiveAppView(args, props, getters, methods);
-    }
-    throw new BaseException(`Can't instantiate class ${superClass} in interpretative mode`);
-  }
-}
-
-class _InterpretiveAppView extends DebugAppView<any> implements DynamicInstance {
-  constructor(args: any[], public props: Map<string, any>, public getters: Map<string, Function>,
-              public methods: Map<string, Function>) {
-    super(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
-  }
-  createInternal(rootSelector: string | any): AppElement {
-    var m = this.methods.get('createInternal');
-    if (isPresent(m)) {
-      return m(rootSelector);
-    } else {
-      return super.createInternal(rootSelector);
-    }
-  }
-  injectorGetInternal(token: any, nodeIndex: number, notFoundResult: any): any {
-    var m = this.methods.get('injectorGetInternal');
-    if (isPresent(m)) {
-      return m(token, nodeIndex, notFoundResult);
-    } else {
-      return super.injectorGet(token, nodeIndex, notFoundResult);
-    }
-  }
-  destroyInternal(): void {
-    var m = this.methods.get('destroyInternal');
-    if (isPresent(m)) {
-      return m();
-    } else {
-      return super.destroyInternal();
-    }
-  }
-  dirtyParentQueriesInternal(): void {
-    var m = this.methods.get('dirtyParentQueriesInternal');
-    if (isPresent(m)) {
-      return m();
-    } else {
-      return super.dirtyParentQueriesInternal();
-    }
-  }
-  detectChangesInternal(throwOnChange: boolean): void {
-    var m = this.methods.get('detectChangesInternal');
-    if (isPresent(m)) {
-      return m(throwOnChange);
-    } else {
-      return super.detectChangesInternal(throwOnChange);
-    }
-  }
-}
--- a/modules/@angular/compiler/src/output/js_emitter.ts
+++ b/modules/@angular/compiler/src/output/js_emitter.ts
@ -1,78 +0,0 @@
-import * as o from './output_ast';
-import {
-  isPresent,
-  isBlank,
-  isString,
-  evalExpression,
-  RegExpWrapper,
-  StringWrapper
-} from '../facade/lang';
-import {BaseException} from '@angular/core';
-import {OutputEmitter, EmitterVisitorContext} from './abstract_emitter';
-import {AbstractJsEmitterVisitor} from './abstract_js_emitter';
-import {ImportGenerator} from './path_util';
-
-export class JavaScriptEmitter implements OutputEmitter {
-  constructor(private _importGenerator: ImportGenerator) {}
-  emitStatements(moduleUrl: string, stmts: o.Statement[], exportedVars: string[]): string {
-    var converter = new JsEmitterVisitor(moduleUrl);
-    var ctx = EmitterVisitorContext.createRoot(exportedVars);
-    converter.visitAllStatements(stmts, ctx);
-    var srcParts = [];
-    converter.importsWithPrefixes.forEach((prefix, importedModuleUrl) => {
-      // Note: can't write the real word for import as it screws up system.js auto detection...
-      srcParts.push(
-          `var ${prefix} = req` +
-          `uire('${this._importGenerator.getImportPath(moduleUrl, importedModuleUrl)}');`);
-    });
-    srcParts.push(ctx.toSource());
-    return srcParts.join('\n');
-  }
-}
-
-class JsEmitterVisitor extends AbstractJsEmitterVisitor {
-  importsWithPrefixes = new Map<string, string>();
-
-  constructor(private _moduleUrl: string) { super(); }
-
-  visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any {
-    if (isBlank(ast.value.name)) {
-      throw new BaseException(`Internal error: unknown identifier ${ast.value}`);
-    }
-    if (isPresent(ast.value.moduleUrl) && ast.value.moduleUrl != this._moduleUrl) {
-      var prefix = this.importsWithPrefixes.get(ast.value.moduleUrl);
-      if (isBlank(prefix)) {
-        prefix = `import${this.importsWithPrefixes.size}`;
-        this.importsWithPrefixes.set(ast.value.moduleUrl, prefix);
-      }
-      ctx.print(`${prefix}.`);
-    }
-    ctx.print(ast.value.name);
-    return null;
-  }
-  visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any {
-    super.visitDeclareVarStmt(stmt, ctx);
-    if (ctx.isExportedVar(stmt.name)) {
-      ctx.println(exportVar(stmt.name));
-    }
-    return null;
-  }
-  visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: EmitterVisitorContext): any {
-    super.visitDeclareFunctionStmt(stmt, ctx);
-    if (ctx.isExportedVar(stmt.name)) {
-      ctx.println(exportVar(stmt.name));
-    }
-    return null;
-  }
-  visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {
-    super.visitDeclareClassStmt(stmt, ctx);
-    if (ctx.isExportedVar(stmt.name)) {
-      ctx.println(exportVar(stmt.name));
-    }
-    return null;
-  }
-}
-
-function exportVar(varName: string): string {
-  return `Object.defineProperty(exports, '${varName}', { get: function() { return ${varName}; }});`;
-}
--- a/modules/@angular/compiler/src/output/output_ast.ts
+++ b/modules/@angular/compiler/src/output/output_ast.ts
@ -1,869 +0,0 @@
-import {isString, isPresent, isBlank} from '../../src/facade/lang';
-import {CompileIdentifierMetadata} from '../compile_metadata';
-
-//// Types
-export enum TypeModifier {
-  Const
-}
-
-export abstract class Type {
-  constructor(public modifiers: TypeModifier[] = null) {
-    if (isBlank(modifiers)) {
-      this.modifiers = [];
-    }
-  }
-  abstract visitType(visitor: TypeVisitor, context: any): any;
-
-  hasModifier(modifier: TypeModifier): boolean { return this.modifiers.indexOf(modifier) !== -1; }
-}
-
-export enum BuiltinTypeName {
-  Dynamic,
-  Bool,
-  String,
-  Int,
-  Number,
-  Function
-}
-
-export class BuiltinType extends Type {
-  constructor(public name: BuiltinTypeName, modifiers: TypeModifier[] = null) { super(modifiers); }
-  visitType(visitor: TypeVisitor, context: any): any {
-    return visitor.visitBuiltintType(this, context);
-  }
-}
-
-export class ExternalType extends Type {
-  constructor(public value: CompileIdentifierMetadata, public typeParams: Type[] = null,
-              modifiers: TypeModifier[] = null) {
-    super(modifiers);
-  }
-  visitType(visitor: TypeVisitor, context: any): any {
-    return visitor.visitExternalType(this, context);
-  }
-}
-
-
-export class ArrayType extends Type {
-  constructor(public of: Type, modifiers: TypeModifier[] = null) { super(modifiers); }
-  visitType(visitor: TypeVisitor, context: any): any {
-    return visitor.visitArrayType(this, context);
-  }
-}
-
-
-export class MapType extends Type {
-  constructor(public valueType: Type, modifiers: TypeModifier[] = null) { super(modifiers); }
-  visitType(visitor: TypeVisitor, context: any): any { return visitor.visitMapType(this, context); }
-}
-
-export var DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);
-export var BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);
-export var INT_TYPE = new BuiltinType(BuiltinTypeName.Int);
-export var NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);
-export var STRING_TYPE = new BuiltinType(BuiltinTypeName.String);
-export var FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);
-
-
-export interface TypeVisitor {
-  visitBuiltintType(type: BuiltinType, context: any): any;
-  visitExternalType(type: ExternalType, context: any): any;
-  visitArrayType(type: ArrayType, context: any): any;
-  visitMapType(type: MapType, context: any): any;
-}
-
-///// Expressions
-
-export enum BinaryOperator {
-  Equals,
-  NotEquals,
-  Identical,
-  NotIdentical,
-  Minus,
-  Plus,
-  Divide,
-  Multiply,
-  Modulo,
-  And,
-  Or,
-  Lower,
-  LowerEquals,
-  Bigger,
-  BiggerEquals
-}
-
-
-export abstract class Expression {
-  constructor(public type: Type) {}
-
-  abstract visitExpression(visitor: ExpressionVisitor, context: any): any;
-
-  prop(name: string): ReadPropExpr { return new ReadPropExpr(this, name); }
-
-  key(index: Expression, type: Type = null): ReadKeyExpr {
-    return new ReadKeyExpr(this, index, type);
-  }
-
-  callMethod(name: string | BuiltinMethod, params: Expression[]): InvokeMethodExpr {
-    return new InvokeMethodExpr(this, name, params);
-  }
-
-  callFn(params: Expression[]): InvokeFunctionExpr { return new InvokeFunctionExpr(this, params); }
-
-  instantiate(params: Expression[], type: Type = null): InstantiateExpr {
-    return new InstantiateExpr(this, params, type);
-  }
-
-  conditional(trueCase: Expression, falseCase: Expression = null): ConditionalExpr {
-    return new ConditionalExpr(this, trueCase, falseCase);
-  }
-
-  equals(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.Equals, this, rhs);
-  }
-  notEquals(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.NotEquals, this, rhs);
-  }
-  identical(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.Identical, this, rhs);
-  }
-  notIdentical(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.NotIdentical, this, rhs);
-  }
-  minus(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.Minus, this, rhs);
-  }
-  plus(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.Plus, this, rhs);
-  }
-  divide(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.Divide, this, rhs);
-  }
-  multiply(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.Multiply, this, rhs);
-  }
-  modulo(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.Modulo, this, rhs);
-  }
-  and(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.And, this, rhs);
-  }
-  or(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs);
-  }
-  lower(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.Lower, this, rhs);
-  }
-  lowerEquals(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.LowerEquals, this, rhs);
-  }
-  bigger(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.Bigger, this, rhs);
-  }
-  biggerEquals(rhs: Expression): BinaryOperatorExpr {
-    return new BinaryOperatorExpr(BinaryOperator.BiggerEquals, this, rhs);
-  }
-  isBlank(): Expression {
-    // Note: We use equals by purpose here to compare to null and undefined in JS.
-    return this.equals(NULL_EXPR);
-  }
-  cast(type: Type): Expression { return new CastExpr(this, type); }
-  toStmt(): Statement { return new ExpressionStatement(this); }
-}
-
-export enum BuiltinVar {
-  This,
-  Super,
-  CatchError,
-  CatchStack
-}
-
-export class ReadVarExpr extends Expression {
-  public name;
-  public builtin: BuiltinVar;
-
-  constructor(name: string | BuiltinVar, type: Type = null) {
-    super(type);
-    if (isString(name)) {
-      this.name = <string>name;
-      this.builtin = null;
-    } else {
-      this.name = null;
-      this.builtin = <BuiltinVar>name;
-    }
-  }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitReadVarExpr(this, context);
-  }
-
-  set(value: Expression): WriteVarExpr { return new WriteVarExpr(this.name, value); }
-}
-
-
-export class WriteVarExpr extends Expression {
-  public value: Expression;
-  constructor(public name: string, value: Expression, type: Type = null) {
-    super(isPresent(type) ? type : value.type);
-    this.value = value;
-  }
-
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitWriteVarExpr(this, context);
-  }
-
-  toDeclStmt(type: Type = null, modifiers: StmtModifier[] = null): DeclareVarStmt {
-    return new DeclareVarStmt(this.name, this.value, type, modifiers);
-  }
-}
-
-
-export class WriteKeyExpr extends Expression {
-  public value: Expression;
-  constructor(public receiver: Expression, public index: Expression, value: Expression,
-              type: Type = null) {
-    super(isPresent(type) ? type : value.type);
-    this.value = value;
-  }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitWriteKeyExpr(this, context);
-  }
-}
-
-
-export class WritePropExpr extends Expression {
-  public value: Expression;
-  constructor(public receiver: Expression, public name: string, value: Expression,
-              type: Type = null) {
-    super(isPresent(type) ? type : value.type);
-    this.value = value;
-  }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitWritePropExpr(this, context);
-  }
-}
-
-export enum BuiltinMethod {
-  ConcatArray,
-  SubscribeObservable,
-  bind
-}
-
-export class InvokeMethodExpr extends Expression {
-  public name: string;
-  public builtin: BuiltinMethod;
-  constructor(public receiver: Expression, method: string | BuiltinMethod,
-              public args: Expression[], type: Type = null) {
-    super(type);
-    if (isString(method)) {
-      this.name = <string>method;
-      this.builtin = null;
-    } else {
-      this.name = null;
-      this.builtin = <BuiltinMethod>method;
-    }
-  }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitInvokeMethodExpr(this, context);
-  }
-}
-
-
-export class InvokeFunctionExpr extends Expression {
-  constructor(public fn: Expression, public args: Expression[], type: Type = null) { super(type); }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitInvokeFunctionExpr(this, context);
-  }
-}
-
-
-export class InstantiateExpr extends Expression {
-  constructor(public classExpr: Expression, public args: Expression[], type?: Type) { super(type); }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitInstantiateExpr(this, context);
-  }
-}
-
-
-export class LiteralExpr extends Expression {
-  constructor(public value: any, type: Type = null) { super(type); }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitLiteralExpr(this, context);
-  }
-}
-
-
-export class ExternalExpr extends Expression {
-  constructor(public value: CompileIdentifierMetadata, type: Type = null,
-              public typeParams: Type[] = null) {
-    super(type);
-  }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitExternalExpr(this, context);
-  }
-}
-
-
-export class ConditionalExpr extends Expression {
-  public trueCase: Expression;
-  constructor(public condition: Expression, trueCase: Expression,
-              public falseCase: Expression = null, type: Type = null) {
-    super(isPresent(type) ? type : trueCase.type);
-    this.trueCase = trueCase;
-  }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitConditionalExpr(this, context);
-  }
-}
-
-
-export class NotExpr extends Expression {
-  constructor(public condition: Expression) { super(BOOL_TYPE); }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitNotExpr(this, context);
-  }
-}
-
-export class CastExpr extends Expression {
-  constructor(public value: Expression, type: Type) { super(type); }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitCastExpr(this, context);
-  }
-}
-
-
-export class FnParam {
-  constructor(public name: string, public type: Type = null) {}
-}
-
-
-export class FunctionExpr extends Expression {
-  constructor(public params: FnParam[], public statements: Statement[], type: Type = null) {
-    super(type);
-  }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitFunctionExpr(this, context);
-  }
-
-  toDeclStmt(name: string, modifiers: StmtModifier[] = null): DeclareFunctionStmt {
-    return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers);
-  }
-}
-
-
-export class BinaryOperatorExpr extends Expression {
-  public lhs: Expression;
-  constructor(public operator: BinaryOperator, lhs: Expression, public rhs: Expression,
-              type: Type = null) {
-    super(isPresent(type) ? type : lhs.type);
-    this.lhs = lhs;
-  }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitBinaryOperatorExpr(this, context);
-  }
-}
-
-
-export class ReadPropExpr extends Expression {
-  constructor(public receiver: Expression, public name: string, type: Type = null) { super(type); }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitReadPropExpr(this, context);
-  }
-  set(value: Expression): WritePropExpr {
-    return new WritePropExpr(this.receiver, this.name, value);
-  }
-}
-
-
-export class ReadKeyExpr extends Expression {
-  constructor(public receiver: Expression, public index: Expression, type: Type = null) {
-    super(type);
-  }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitReadKeyExpr(this, context);
-  }
-  set(value: Expression): WriteKeyExpr {
-    return new WriteKeyExpr(this.receiver, this.index, value);
-  }
-}
-
-
-export class LiteralArrayExpr extends Expression {
-  public entries: Expression[];
-  constructor(entries: Expression[], type: Type = null) {
-    super(type);
-    this.entries = entries;
-  }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitLiteralArrayExpr(this, context);
-  }
-}
-
-
-export class LiteralMapExpr extends Expression {
-  public valueType: Type = null;
-  constructor(public entries: Array<Array<string | Expression>>, type: MapType = null) {
-    super(type);
-    if (isPresent(type)) {
-      this.valueType = type.valueType;
-    }
-  }
-  visitExpression(visitor: ExpressionVisitor, context: any): any {
-    return visitor.visitLiteralMapExpr(this, context);
-  }
-}
-
-export interface ExpressionVisitor {
-  visitReadVarExpr(ast: ReadVarExpr, context: any): any;
-  visitWriteVarExpr(expr: WriteVarExpr, context: any): any;
-  visitWriteKeyExpr(expr: WriteKeyExpr, context: any): any;
-  visitWritePropExpr(expr: WritePropExpr, context: any): any;
-  visitInvokeMethodExpr(ast: InvokeMethodExpr, context: any): any;
-  visitInvokeFunctionExpr(ast: InvokeFunctionExpr, context: any): any;
-  visitInstantiateExpr(ast: InstantiateExpr, context: any): any;
-  visitLiteralExpr(ast: LiteralExpr, context: any): any;
-  visitExternalExpr(ast: ExternalExpr, context: any): any;
-  visitConditionalExpr(ast: ConditionalExpr, context: any): any;
-  visitNotExpr(ast: NotExpr, context: any): any;
-  visitCastExpr(ast: CastExpr, context: any): any;
-  visitFunctionExpr(ast: FunctionExpr, context: any): any;
-  visitBinaryOperatorExpr(ast: BinaryOperatorExpr, context: any): any;
-  visitReadPropExpr(ast: ReadPropExpr, context: any): any;
-  visitReadKeyExpr(ast: ReadKeyExpr, context: any): any;
-  visitLiteralArrayExpr(ast: LiteralArrayExpr, context: any): any;
-  visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any;
-}
-
-export var THIS_EXPR = new ReadVarExpr(BuiltinVar.This);
-export var SUPER_EXPR = new ReadVarExpr(BuiltinVar.Super);
-export var CATCH_ERROR_VAR = new ReadVarExpr(BuiltinVar.CatchError);
-export var CATCH_STACK_VAR = new ReadVarExpr(BuiltinVar.CatchStack);
-export var NULL_EXPR = new LiteralExpr(null, null);
-
-//// Statements
-export enum StmtModifier {
-  Final,
-  Private
-}
-
-export abstract class Statement {
-  constructor(public modifiers: StmtModifier[] = null) {
-    if (isBlank(modifiers)) {
-      this.modifiers = [];
-    }
-  }
-
-  abstract visitStatement(visitor: StatementVisitor, context: any): any;
-
-  hasModifier(modifier: StmtModifier): boolean { return this.modifiers.indexOf(modifier) !== -1; }
-}
-
-
-export class DeclareVarStmt extends Statement {
-  public type: Type;
-  constructor(public name: string, public value: Expression, type: Type = null,
-              modifiers: StmtModifier[] = null) {
-    super(modifiers);
-    this.type = isPresent(type) ? type : value.type;
-  }
-
-  visitStatement(visitor: StatementVisitor, context: any): any {
-    return visitor.visitDeclareVarStmt(this, context);
-  }
-}
-
-export class DeclareFunctionStmt extends Statement {
-  constructor(public name: string, public params: FnParam[], public statements: Statement[],
-              public type: Type = null, modifiers: StmtModifier[] = null) {
-    super(modifiers);
-  }
-
-  visitStatement(visitor: StatementVisitor, context: any): any {
-    return visitor.visitDeclareFunctionStmt(this, context);
-  }
-}
-
-export class ExpressionStatement extends Statement {
-  constructor(public expr: Expression) { super(); }
-
-  visitStatement(visitor: StatementVisitor, context: any): any {
-    return visitor.visitExpressionStmt(this, context);
-  }
-}
-
-
-export class ReturnStatement extends Statement {
-  constructor(public value: Expression) { super(); }
-  visitStatement(visitor: StatementVisitor, context: any): any {
-    return visitor.visitReturnStmt(this, context);
-  }
-}
-
-export class AbstractClassPart {
-  constructor(public type: Type = null, public modifiers: StmtModifier[]) {
-    if (isBlank(modifiers)) {
-      this.modifiers = [];
-    }
-  }
-  hasModifier(modifier: StmtModifier): boolean { return this.modifiers.indexOf(modifier) !== -1; }
-}
-
-export class ClassField extends AbstractClassPart {
-  constructor(public name: string, type: Type = null, modifiers: StmtModifier[] = null) {
-    super(type, modifiers);
-  }
-}
-
-
-export class ClassMethod extends AbstractClassPart {
-  constructor(public name: string, public params: FnParam[], public body: Statement[],
-              type: Type = null, modifiers: StmtModifier[] = null) {
-    super(type, modifiers);
-  }
-}
-
-
-export class ClassGetter extends AbstractClassPart {
-  constructor(public name: string, public body: Statement[], type: Type = null,
-              modifiers: StmtModifier[] = null) {
-    super(type, modifiers);
-  }
-}
-
-
-export class ClassStmt extends Statement {
-  constructor(public name: string, public parent: Expression, public fields: ClassField[],
-              public getters: ClassGetter[], public constructorMethod: ClassMethod,
-              public methods: ClassMethod[], modifiers: StmtModifier[] = null) {
-    super(modifiers);
-  }
-  visitStatement(visitor: StatementVisitor, context: any): any {
-    return visitor.visitDeclareClassStmt(this, context);
-  }
-}
-
-
-export class IfStmt extends Statement {
-  constructor(public condition: Expression, public trueCase: Statement[],
-              public falseCase: Statement[] = /*@ts2dart_const*/[]) {
-    super();
-  }
-  visitStatement(visitor: StatementVisitor, context: any): any {
-    return visitor.visitIfStmt(this, context);
-  }
-}
-
-
-export class CommentStmt extends Statement {
-  constructor(public comment: string) { super(); }
-  visitStatement(visitor: StatementVisitor, context: any): any {
-    return visitor.visitCommentStmt(this, context);
-  }
-}
-
-
-export class TryCatchStmt extends Statement {
-  constructor(public bodyStmts: Statement[], public catchStmts: Statement[]) { super(); }
-  visitStatement(visitor: StatementVisitor, context: any): any {
-    return visitor.visitTryCatchStmt(this, context);
-  }
-}
-
-
-export class ThrowStmt extends Statement {
-  constructor(public error: Expression) { super(); }
-  visitStatement(visitor: StatementVisitor, context: any): any {
-    return visitor.visitThrowStmt(this, context);
-  }
-}
-
-export interface StatementVisitor {
-  visitDeclareVarStmt(stmt: DeclareVarStmt, context: any): any;
-  visitDeclareFunctionStmt(stmt: DeclareFunctionStmt, context: any): any;
-  visitExpressionStmt(stmt: ExpressionStatement, context: any): any;
-  visitReturnStmt(stmt: ReturnStatement, context: any): any;
-  visitDeclareClassStmt(stmt: ClassStmt, context: any): any;
-  visitIfStmt(stmt: IfStmt, context: any): any;
-  visitTryCatchStmt(stmt: TryCatchStmt, context: any): any;
-  visitThrowStmt(stmt: ThrowStmt, context: any): any;
-  visitCommentStmt(stmt: CommentStmt, context: any): any;
-}
-
-export class ExpressionTransformer implements StatementVisitor, ExpressionVisitor {
-  visitReadVarExpr(ast: ReadVarExpr, context: any): any { return ast; }
-  visitWriteVarExpr(expr: WriteVarExpr, context: any): any {
-    return new WriteVarExpr(expr.name, expr.value.visitExpression(this, context));
-  }
-  visitWriteKeyExpr(expr: WriteKeyExpr, context: any): any {
-    return new WriteKeyExpr(expr.receiver.visitExpression(this, context),
-                            expr.index.visitExpression(this, context),
-                            expr.value.visitExpression(this, context));
-  }
-  visitWritePropExpr(expr: WritePropExpr, context: any): any {
-    return new WritePropExpr(expr.receiver.visitExpression(this, context), expr.name,
-                             expr.value.visitExpression(this, context));
-  }
-  visitInvokeMethodExpr(ast: InvokeMethodExpr, context: any): any {
-    var method = isPresent(ast.builtin) ? ast.builtin : ast.name;
-    return new InvokeMethodExpr(ast.receiver.visitExpression(this, context), method,
-                                this.visitAllExpressions(ast.args, context), ast.type);
-  }
-  visitInvokeFunctionExpr(ast: InvokeFunctionExpr, context: any): any {
-    return new InvokeFunctionExpr(ast.fn.visitExpression(this, context),
-                                  this.visitAllExpressions(ast.args, context), ast.type);
-  }
-  visitInstantiateExpr(ast: InstantiateExpr, context: any): any {
-    return new InstantiateExpr(ast.classExpr.visitExpression(this, context),
-                               this.visitAllExpressions(ast.args, context), ast.type);
-  }
-  visitLiteralExpr(ast: LiteralExpr, context: any): any { return ast; }
-  visitExternalExpr(ast: ExternalExpr, context: any): any { return ast; }
-  visitConditionalExpr(ast: ConditionalExpr, context: any): any {
-    return new ConditionalExpr(ast.condition.visitExpression(this, context),
-                               ast.trueCase.visitExpression(this, context),
-                               ast.falseCase.visitExpression(this, context));
-  }
-  visitNotExpr(ast: NotExpr, context: any): any {
-    return new NotExpr(ast.condition.visitExpression(this, context));
-  }
-  visitCastExpr(ast: CastExpr, context: any): any {
-    return new CastExpr(ast.value.visitExpression(this, context), context);
-  }
-  visitFunctionExpr(ast: FunctionExpr, context: any): any {
-    // Don't descend into nested functions
-    return ast;
-  }
-  visitBinaryOperatorExpr(ast: BinaryOperatorExpr, context: any): any {
-    return new BinaryOperatorExpr(ast.operator, ast.lhs.visitExpression(this, context),
-                                  ast.rhs.visitExpression(this, context), ast.type);
-  }
-  visitReadPropExpr(ast: ReadPropExpr, context: any): any {
-    return new ReadPropExpr(ast.receiver.visitExpression(this, context), ast.name, ast.type);
-  }
-  visitReadKeyExpr(ast: ReadKeyExpr, context: any): any {
-    return new ReadKeyExpr(ast.receiver.visitExpression(this, context),
-                           ast.index.visitExpression(this, context), ast.type);
-  }
-  visitLiteralArrayExpr(ast: LiteralArrayExpr, context: any): any {
-    return new LiteralArrayExpr(this.visitAllExpressions(ast.entries, context));
-  }
-  visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any {
-    return new LiteralMapExpr(ast.entries.map(
-        (entry) => [entry[0], (<Expression>entry[1]).visitExpression(this, context)]));
-  }
-  visitAllExpressions(exprs: Expression[], context: any): Expression[] {
-    return exprs.map(expr => expr.visitExpression(this, context));
-  }
-
-  visitDeclareVarStmt(stmt: DeclareVarStmt, context: any): any {
-    return new DeclareVarStmt(stmt.name, stmt.value.visitExpression(this, context), stmt.type,
-                              stmt.modifiers);
-  }
-  visitDeclareFunctionStmt(stmt: DeclareFunctionStmt, context: any): any {
-    // Don't descend into nested functions
-    return stmt;
-  }
-  visitExpressionStmt(stmt: ExpressionStatement, context: any): any {
-    return new ExpressionStatement(stmt.expr.visitExpression(this, context));
-  }
-  visitReturnStmt(stmt: ReturnStatement, context: any): any {
-    return new ReturnStatement(stmt.value.visitExpression(this, context));
-  }
-  visitDeclareClassStmt(stmt: ClassStmt, context: any): any {
-    // Don't descend into nested functions
-    return stmt;
-  }
-  visitIfStmt(stmt: IfStmt, context: any): any {
-    return new IfStmt(stmt.condition.visitExpression(this, context),
-                      this.visitAllStatements(stmt.trueCase, context),
-                      this.visitAllStatements(stmt.falseCase, context));
-  }
-  visitTryCatchStmt(stmt: TryCatchStmt, context: any): any {
-    return new TryCatchStmt(this.visitAllStatements(stmt.bodyStmts, context),
-                            this.visitAllStatements(stmt.catchStmts, context));
-  }
-  visitThrowStmt(stmt: ThrowStmt, context: any): any {
-    return new ThrowStmt(stmt.error.visitExpression(this, context));
-  }
-  visitCommentStmt(stmt: CommentStmt, context: any): any { return stmt; }
-  visitAllStatements(stmts: Statement[], context: any): Statement[] {
-    return stmts.map(stmt => stmt.visitStatement(this, context));
-  }
-}
-
-
-export class RecursiveExpressionVisitor implements StatementVisitor, ExpressionVisitor {
-  visitReadVarExpr(ast: ReadVarExpr, context: any): any { return ast; }
-  visitWriteVarExpr(expr: WriteVarExpr, context: any): any {
-    expr.value.visitExpression(this, context);
-    return expr;
-  }
-  visitWriteKeyExpr(expr: WriteKeyExpr, context: any): any {
-    expr.receiver.visitExpression(this, context);
-    expr.index.visitExpression(this, context);
-    expr.value.visitExpression(this, context);
-    return expr;
-  }
-  visitWritePropExpr(expr: WritePropExpr, context: any): any {
-    expr.receiver.visitExpression(this, context);
-    expr.value.visitExpression(this, context);
-    return expr;
-  }
-  visitInvokeMethodExpr(ast: InvokeMethodExpr, context: any): any {
-    ast.receiver.visitExpression(this, context);
-    this.visitAllExpressions(ast.args, context);
-    return ast;
-  }
-  visitInvokeFunctionExpr(ast: InvokeFunctionExpr, context: any): any {
-    ast.fn.visitExpression(this, context);
-    this.visitAllExpressions(ast.args, context);
-    return ast;
-  }
-  visitInstantiateExpr(ast: InstantiateExpr, context: any): any {
-    ast.classExpr.visitExpression(this, context);
-    this.visitAllExpressions(ast.args, context);
-    return ast;
-  }
-  visitLiteralExpr(ast: LiteralExpr, context: any): any { return ast; }
-  visitExternalExpr(ast: ExternalExpr, context: any): any { return ast; }
-  visitConditionalExpr(ast: ConditionalExpr, context: any): any {
-    ast.condition.visitExpression(this, context);
-    ast.trueCase.visitExpression(this, context);
-    ast.falseCase.visitExpression(this, context);
-    return ast;
-  }
-  visitNotExpr(ast: NotExpr, context: any): any {
-    ast.condition.visitExpression(this, context);
-    return ast;
-  }
-  visitCastExpr(ast: CastExpr, context: any): any {
-    ast.value.visitExpression(this, context);
-    return ast;
-  }
-  visitFunctionExpr(ast: FunctionExpr, context: any): any { return ast; }
-  visitBinaryOperatorExpr(ast: BinaryOperatorExpr, context: any): any {
-    ast.lhs.visitExpression(this, context);
-    ast.rhs.visitExpression(this, context);
-    return ast;
-  }
-  visitReadPropExpr(ast: ReadPropExpr, context: any): any {
-    ast.receiver.visitExpression(this, context);
-    return ast;
-  }
-  visitReadKeyExpr(ast: ReadKeyExpr, context: any): any {
-    ast.receiver.visitExpression(this, context);
-    ast.index.visitExpression(this, context);
-    return ast;
-  }
-  visitLiteralArrayExpr(ast: LiteralArrayExpr, context: any): any {
-    this.visitAllExpressions(ast.entries, context);
-    return ast;
-  }
-  visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any {
-    ast.entries.forEach((entry) => (<Expression>entry[1]).visitExpression(this, context));
-    return ast;
-  }
-  visitAllExpressions(exprs: Expression[], context: any): void {
-    exprs.forEach(expr => expr.visitExpression(this, context));
-  }
-
-  visitDeclareVarStmt(stmt: DeclareVarStmt, context: any): any {
-    stmt.value.visitExpression(this, context);
-    return stmt;
-  }
-  visitDeclareFunctionStmt(stmt: DeclareFunctionStmt, context: any): any {
-    // Don't descend into nested functions
-    return stmt;
-  }
-  visitExpressionStmt(stmt: ExpressionStatement, context: any): any {
-    stmt.expr.visitExpression(this, context);
-    return stmt;
-  }
-  visitReturnStmt(stmt: ReturnStatement, context: any): any {
-    stmt.value.visitExpression(this, context);
-    return stmt;
-  }
-  visitDeclareClassStmt(stmt: ClassStmt, context: any): any {
-    // Don't descend into nested functions
-    return stmt;
-  }
-  visitIfStmt(stmt: IfStmt, context: any): any {
-    stmt.condition.visitExpression(this, context);
-    this.visitAllStatements(stmt.trueCase, context);
-    this.visitAllStatements(stmt.falseCase, context);
-    return stmt;
-  }
-  visitTryCatchStmt(stmt: TryCatchStmt, context: any): any {
-    this.visitAllStatements(stmt.bodyStmts, context);
-    this.visitAllStatements(stmt.catchStmts, context);
-    return stmt;
-  }
-  visitThrowStmt(stmt: ThrowStmt, context: any): any {
-    stmt.error.visitExpression(this, context);
-    return stmt;
-  }
-  visitCommentStmt(stmt: CommentStmt, context: any): any { return stmt; }
-  visitAllStatements(stmts: Statement[], context: any): void {
-    stmts.forEach(stmt => stmt.visitStatement(this, context));
-  }
-}
-
-export function replaceVarInExpression(varName: string, newValue: Expression,
-                                       expression: Expression): Expression {
-  var transformer = new _ReplaceVariableTransformer(varName, newValue);
-  return expression.visitExpression(transformer, null);
-}
-
-class _ReplaceVariableTransformer extends ExpressionTransformer {
-  constructor(private _varName: string, private _newValue: Expression) { super(); }
-  visitReadVarExpr(ast: ReadVarExpr, context: any): any {
-    return ast.name == this._varName ? this._newValue : ast;
-  }
-}
-
-export function findReadVarNames(stmts: Statement[]): Set<string> {
-  var finder = new _VariableFinder();
-  finder.visitAllStatements(stmts, null);
-  return finder.varNames;
-}
-
-class _VariableFinder extends RecursiveExpressionVisitor {
-  varNames = new Set<string>();
-  visitReadVarExpr(ast: ReadVarExpr, context: any): any {
-    this.varNames.add(ast.name);
-    return null;
-  }
-}
-
-export function variable(name: string, type: Type = null): ReadVarExpr {
-  return new ReadVarExpr(name, type);
-}
-
-export function importExpr(id: CompileIdentifierMetadata, typeParams: Type[] = null): ExternalExpr {
-  return new ExternalExpr(id, null, typeParams);
-}
-
-export function importType(id: CompileIdentifierMetadata, typeParams: Type[] = null,
-                           typeModifiers: TypeModifier[] = null): ExternalType {
-  return isPresent(id) ? new ExternalType(id, typeParams, typeModifiers) : null;
-}
-
-export function literal(value: any, type: Type = null): LiteralExpr {
-  return new LiteralExpr(value, type);
-}
-
-export function literalArr(values: Expression[], type: Type = null): LiteralArrayExpr {
-  return new LiteralArrayExpr(values, type);
-}
-
-export function literalMap(values: Array<Array<string | Expression>>,
-                           type: MapType = null): LiteralMapExpr {
-  return new LiteralMapExpr(values, type);
-}
-
-export function not(expr: Expression): NotExpr {
-  return new NotExpr(expr);
-}
-
-export function fn(params: FnParam[], body: Statement[], type: Type = null): FunctionExpr {
-  return new FunctionExpr(params, body, type);
-}
--- a/modules/@angular/compiler/src/output/output_interpreter.ts
+++ b/modules/@angular/compiler/src/output/output_interpreter.ts
@ -1,416 +0,0 @@
-import {reflector} from '@angular/core';
-import {isPresent, IS_DART, FunctionWrapper} from '../../src/facade/lang';
-import {ObservableWrapper} from '../../src/facade/async';
-import {BaseException, unimplemented} from '../../src/facade/exceptions';
-import {ListWrapper} from '../../src/facade/collection';
-
-import * as o from './output_ast';
-import {debugOutputAstAsDart} from './dart_emitter';
-import {debugOutputAstAsTypeScript} from './ts_emitter';
-
-export function interpretStatements(statements: o.Statement[], resultVar: string,
-                                    instanceFactory: InstanceFactory): any {
-  var stmtsWithReturn = statements.concat([new o.ReturnStatement(o.variable(resultVar))]);
-  var ctx = new _ExecutionContext(null, null, null, null, new Map<string, any>(),
-                                  new Map<string, any>(), new Map<string, Function>(),
-                                  new Map<string, Function>(), instanceFactory);
-  var visitor = new StatementInterpreter();
-  var result = visitor.visitAllStatements(stmtsWithReturn, ctx);
-  return isPresent(result) ? result.value : null;
-}
-
-export interface InstanceFactory {
-  createInstance(superClass: any, clazz: any, constructorArgs: any[], props: Map<string, any>,
-                 getters: Map<string, Function>, methods: Map<string, Function>): DynamicInstance;
-}
-
-export abstract class DynamicInstance {
-  get props(): Map<string, any> { return unimplemented(); }
-  get getters(): Map<string, Function> { return unimplemented(); }
-  get methods(): Map<string, any> { return unimplemented(); }
-  get clazz(): any { return unimplemented(); }
-}
-
-function isDynamicInstance(instance: any): any {
-  if (IS_DART) {
-    return instance instanceof DynamicInstance;
-  } else {
-    return isPresent(instance) && isPresent(instance.props) && isPresent(instance.getters) &&
-           isPresent(instance.methods);
-  }
-}
-
-function _executeFunctionStatements(varNames: string[], varValues: any[], statements: o.Statement[],
-                                    ctx: _ExecutionContext, visitor: StatementInterpreter): any {
-  var childCtx = ctx.createChildWihtLocalVars();
-  for (var i = 0; i < varNames.length; i++) {
-    childCtx.vars.set(varNames[i], varValues[i]);
-  }
-  var result = visitor.visitAllStatements(statements, childCtx);
-  return isPresent(result) ? result.value : null;
-}
-
-class _ExecutionContext {
-  constructor(public parent: _ExecutionContext, public superClass: any, public superInstance: any,
-              public className: string, public vars: Map<string, any>,
-              public props: Map<string, any>, public getters: Map<string, Function>,
-              public methods: Map<string, Function>, public instanceFactory: InstanceFactory) {}
-
-  createChildWihtLocalVars(): _ExecutionContext {
-    return new _ExecutionContext(this, this.superClass, this.superInstance, this.className,
-                                 new Map<string, any>(), this.props, this.getters, this.methods,
-                                 this.instanceFactory);
-  }
-}
-
-class ReturnValue {
-  constructor(public value: any) {}
-}
-
-class _DynamicClass {
-  constructor(private _classStmt: o.ClassStmt, private _ctx: _ExecutionContext,
-              private _visitor: StatementInterpreter) {}
-
-  instantiate(args: any[]): DynamicInstance {
-    var props = new Map<string, any>();
-    var getters = new Map<string, Function>();
-    var methods = new Map<string, Function>();
-    var superClass = this._classStmt.parent.visitExpression(this._visitor, this._ctx);
-    var instanceCtx =
-        new _ExecutionContext(this._ctx, superClass, null, this._classStmt.name, this._ctx.vars,
-                              props, getters, methods, this._ctx.instanceFactory);
-
-    this._classStmt.fields.forEach((field: o.ClassField) => { props.set(field.name, null); });
-    this._classStmt.getters.forEach((getter: o.ClassGetter) => {
-      getters.set(getter.name, () => _executeFunctionStatements([], [], getter.body, instanceCtx,
-                                                                this._visitor));
-    });
-    this._classStmt.methods.forEach((method: o.ClassMethod) => {
-      var paramNames = method.params.map(param => param.name);
-      methods.set(method.name, _declareFn(paramNames, method.body, instanceCtx, this._visitor));
-    });
-
-    var ctorParamNames = this._classStmt.constructorMethod.params.map(param => param.name);
-    _executeFunctionStatements(ctorParamNames, args, this._classStmt.constructorMethod.body,
-                               instanceCtx, this._visitor);
-    return instanceCtx.superInstance;
-  }
-
-  debugAst(): string { return this._visitor.debugAst(this._classStmt); }
-}
-
-class StatementInterpreter implements o.StatementVisitor, o.ExpressionVisitor {
-  debugAst(ast: o.Expression | o.Statement | o.Type): string {
-    return IS_DART ? debugOutputAstAsDart(ast) : debugOutputAstAsTypeScript(ast);
-  }
-
-  visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: _ExecutionContext): any {
-    ctx.vars.set(stmt.name, stmt.value.visitExpression(this, ctx));
-    return null;
-  }
-  visitWriteVarExpr(expr: o.WriteVarExpr, ctx: _ExecutionContext): any {
-    var value = expr.value.visitExpression(this, ctx);
-    var currCtx = ctx;
-    while (currCtx != null) {
-      if (currCtx.vars.has(expr.name)) {
-        currCtx.vars.set(expr.name, value);
-        return value;
-      }
-      currCtx = currCtx.parent;
-    }
-    throw new BaseException(`Not declared variable ${expr.name}`);
-  }
-  visitReadVarExpr(ast: o.ReadVarExpr, ctx: _ExecutionContext): any {
-    var varName = ast.name;
-    if (isPresent(ast.builtin)) {
-      switch (ast.builtin) {
-        case o.BuiltinVar.Super:
-        case o.BuiltinVar.This:
-          return ctx.superInstance;
-        case o.BuiltinVar.CatchError:
-          varName = CATCH_ERROR_VAR;
-          break;
-        case o.BuiltinVar.CatchStack:
-          varName = CATCH_STACK_VAR;
-          break;
-        default:
-          throw new BaseException(`Unknown builtin variable ${ast.builtin}`);
-      }
-    }
-    var currCtx = ctx;
-    while (currCtx != null) {
-      if (currCtx.vars.has(varName)) {
-        return currCtx.vars.get(varName);
-      }
-      currCtx = currCtx.parent;
-    }
-    throw new BaseException(`Not declared variable ${varName}`);
-  }
-  visitWriteKeyExpr(expr: o.WriteKeyExpr, ctx: _ExecutionContext): any {
-    var receiver = expr.receiver.visitExpression(this, ctx);
-    var index = expr.index.visitExpression(this, ctx);
-    var value = expr.value.visitExpression(this, ctx);
-    receiver[index] = value;
-    return value;
-  }
-  visitWritePropExpr(expr: o.WritePropExpr, ctx: _ExecutionContext): any {
-    var receiver = expr.receiver.visitExpression(this, ctx);
-    var value = expr.value.visitExpression(this, ctx);
-    if (isDynamicInstance(receiver)) {
-      var di = <DynamicInstance>receiver;
-      if (di.props.has(expr.name)) {
-        di.props.set(expr.name, value);
-      } else {
-        reflector.setter(expr.name)(receiver, value);
-      }
-    } else {
-      reflector.setter(expr.name)(receiver, value);
-    }
-    return value;
-  }
-
-  visitInvokeMethodExpr(expr: o.InvokeMethodExpr, ctx: _ExecutionContext): any {
-    var receiver = expr.receiver.visitExpression(this, ctx);
-    var args = this.visitAllExpressions(expr.args, ctx);
-    var result;
-    if (isPresent(expr.builtin)) {
-      switch (expr.builtin) {
-        case o.BuiltinMethod.ConcatArray:
-          result = ListWrapper.concat(receiver, args[0]);
-          break;
-        case o.BuiltinMethod.SubscribeObservable:
-          result = ObservableWrapper.subscribe(receiver, args[0]);
-          break;
-        case o.BuiltinMethod.bind:
-          if (IS_DART) {
-            result = receiver;
-          } else {
-            result = receiver.bind(args[0]);
-          }
-          break;
-        default:
-          throw new BaseException(`Unknown builtin method ${expr.builtin}`);
-      }
-    } else if (isDynamicInstance(receiver)) {
-      var di = <DynamicInstance>receiver;
-      if (di.methods.has(expr.name)) {
-        result = FunctionWrapper.apply(di.methods.get(expr.name), args);
-      } else {
-        result = reflector.method(expr.name)(receiver, args);
-      }
-    } else {
-      result = reflector.method(expr.name)(receiver, args);
-    }
-    return result;
-  }
-  visitInvokeFunctionExpr(stmt: o.InvokeFunctionExpr, ctx: _ExecutionContext): any {
-    var args = this.visitAllExpressions(stmt.args, ctx);
-    var fnExpr = stmt.fn;
-    if (fnExpr instanceof o.ReadVarExpr && fnExpr.builtin === o.BuiltinVar.Super) {
-      ctx.superInstance = ctx.instanceFactory.createInstance(ctx.superClass, ctx.className, args,
-                                                             ctx.props, ctx.getters, ctx.methods);
-      ctx.parent.superInstance = ctx.superInstance;
-      return null;
-    } else {
-      var fn = stmt.fn.visitExpression(this, ctx);
-      return FunctionWrapper.apply(fn, args);
-    }
-  }
-  visitReturnStmt(stmt: o.ReturnStatement, ctx: _ExecutionContext): any {
-    return new ReturnValue(stmt.value.visitExpression(this, ctx));
-  }
-  visitDeclareClassStmt(stmt: o.ClassStmt, ctx: _ExecutionContext): any {
-    var clazz = new _DynamicClass(stmt, ctx, this);
-    ctx.vars.set(stmt.name, clazz);
-    return null;
-  }
-  visitExpressionStmt(stmt: o.ExpressionStatement, ctx: _ExecutionContext): any {
-    return stmt.expr.visitExpression(this, ctx);
-  }
-  visitIfStmt(stmt: o.IfStmt, ctx: _ExecutionContext): any {
-    var condition = stmt.condition.visitExpression(this, ctx);
-    if (condition) {
-      return this.visitAllStatements(stmt.trueCase, ctx);
-    } else if (isPresent(stmt.falseCase)) {
-      return this.visitAllStatements(stmt.falseCase, ctx);
-    }
-    return null;
-  }
-  visitTryCatchStmt(stmt: o.TryCatchStmt, ctx: _ExecutionContext): any {
-    try {
-      return this.visitAllStatements(stmt.bodyStmts, ctx);
-    } catch (e) {
-      var childCtx = ctx.createChildWihtLocalVars();
-      childCtx.vars.set(CATCH_ERROR_VAR, e);
-      childCtx.vars.set(CATCH_STACK_VAR, e.stack);
-      return this.visitAllStatements(stmt.catchStmts, childCtx);
-    }
-  }
-  visitThrowStmt(stmt: o.ThrowStmt, ctx: _ExecutionContext): any {
-    throw stmt.error.visitExpression(this, ctx);
-  }
-  visitCommentStmt(stmt: o.CommentStmt, context?: any): any { return null; }
-  visitInstantiateExpr(ast: o.InstantiateExpr, ctx: _ExecutionContext): any {
-    var args = this.visitAllExpressions(ast.args, ctx);
-    var clazz = ast.classExpr.visitExpression(this, ctx);
-    if (clazz instanceof _DynamicClass) {
-      return clazz.instantiate(args);
-    } else {
-      return FunctionWrapper.apply(reflector.factory(clazz), args);
-    }
-  }
-  visitLiteralExpr(ast: o.LiteralExpr, ctx: _ExecutionContext): any { return ast.value; }
-  visitExternalExpr(ast: o.ExternalExpr, ctx: _ExecutionContext): any { return ast.value.runtime; }
-  visitConditionalExpr(ast: o.ConditionalExpr, ctx: _ExecutionContext): any {
-    if (ast.condition.visitExpression(this, ctx)) {
-      return ast.trueCase.visitExpression(this, ctx);
-    } else if (isPresent(ast.falseCase)) {
-      return ast.falseCase.visitExpression(this, ctx);
-    }
-    return null;
-  }
-  visitNotExpr(ast: o.NotExpr, ctx: _ExecutionContext): any {
-    return !ast.condition.visitExpression(this, ctx);
-  }
-  visitCastExpr(ast: o.CastExpr, ctx: _ExecutionContext): any {
-    return ast.value.visitExpression(this, ctx);
-  }
-  visitFunctionExpr(ast: o.FunctionExpr, ctx: _ExecutionContext): any {
-    var paramNames = ast.params.map((param) => param.name);
-    return _declareFn(paramNames, ast.statements, ctx, this);
-  }
-  visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: _ExecutionContext): any {
-    var paramNames = stmt.params.map((param) => param.name);
-    ctx.vars.set(stmt.name, _declareFn(paramNames, stmt.statements, ctx, this));
-    return null;
-  }
-  visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, ctx: _ExecutionContext): any {
-    var lhs = () => ast.lhs.visitExpression(this, ctx);
-    var rhs = () => ast.rhs.visitExpression(this, ctx);
-
-    switch (ast.operator) {
-      case o.BinaryOperator.Equals:
-        return lhs() == rhs();
-      case o.BinaryOperator.Identical:
-        return lhs() === rhs();
-      case o.BinaryOperator.NotEquals:
-        return lhs() != rhs();
-      case o.BinaryOperator.NotIdentical:
-        return lhs() !== rhs();
-      case o.BinaryOperator.And:
-        return lhs() && rhs();
-      case o.BinaryOperator.Or:
-        return lhs() || rhs();
-      case o.BinaryOperator.Plus:
-        return lhs() + rhs();
-      case o.BinaryOperator.Minus:
-        return lhs() - rhs();
-      case o.BinaryOperator.Divide:
-        return lhs() / rhs();
-      case o.BinaryOperator.Multiply:
-        return lhs() * rhs();
-      case o.BinaryOperator.Modulo:
-        return lhs() % rhs();
-      case o.BinaryOperator.Lower:
-        return lhs() < rhs();
-      case o.BinaryOperator.LowerEquals:
-        return lhs() <= rhs();
-      case o.BinaryOperator.Bigger:
-        return lhs() > rhs();
-      case o.BinaryOperator.BiggerEquals:
-        return lhs() >= rhs();
-      default:
-        throw new BaseException(`Unknown operator ${ast.operator}`);
-    }
-  }
-  visitReadPropExpr(ast: o.ReadPropExpr, ctx: _ExecutionContext): any {
-    var result;
-    var receiver = ast.receiver.visitExpression(this, ctx);
-    if (isDynamicInstance(receiver)) {
-      var di = <DynamicInstance>receiver;
-      if (di.props.has(ast.name)) {
-        result = di.props.get(ast.name);
-      } else if (di.getters.has(ast.name)) {
-        result = di.getters.get(ast.name)();
-      } else if (di.methods.has(ast.name)) {
-        result = di.methods.get(ast.name);
-      } else {
-        result = reflector.getter(ast.name)(receiver);
-      }
-    } else {
-      result = reflector.getter(ast.name)(receiver);
-    }
-    return result;
-  }
-  visitReadKeyExpr(ast: o.ReadKeyExpr, ctx: _ExecutionContext): any {
-    var receiver = ast.receiver.visitExpression(this, ctx);
-    var prop = ast.index.visitExpression(this, ctx);
-    return receiver[prop];
-  }
-  visitLiteralArrayExpr(ast: o.LiteralArrayExpr, ctx: _ExecutionContext): any {
-    return this.visitAllExpressions(ast.entries, ctx);
-  }
-  visitLiteralMapExpr(ast: o.LiteralMapExpr, ctx: _ExecutionContext): any {
-    var result = {};
-    ast.entries.forEach((entry) => result[<string>entry[0]] =
-                            (<o.Expression>entry[1]).visitExpression(this, ctx));
-    return result;
-  }
-
-  visitAllExpressions(expressions: o.Expression[], ctx: _ExecutionContext): any {
-    return expressions.map((expr) => expr.visitExpression(this, ctx));
-  }
-
-  visitAllStatements(statements: o.Statement[], ctx: _ExecutionContext): ReturnValue {
-    for (var i = 0; i < statements.length; i++) {
-      var stmt = statements[i];
-      var val = stmt.visitStatement(this, ctx);
-      if (val instanceof ReturnValue) {
-        return val;
-      }
-    }
-    return null;
-  }
-}
-
-function _declareFn(varNames: string[], statements: o.Statement[], ctx: _ExecutionContext,
-                    visitor: StatementInterpreter): Function {
-  switch (varNames.length) {
-    case 0:
-      return () => _executeFunctionStatements(varNames, [], statements, ctx, visitor);
-    case 1:
-      return (d0) => _executeFunctionStatements(varNames, [d0], statements, ctx, visitor);
-    case 2:
-      return (d0, d1) => _executeFunctionStatements(varNames, [d0, d1], statements, ctx, visitor);
-    case 3:
-      return (d0, d1, d2) =>
-                 _executeFunctionStatements(varNames, [d0, d1, d2], statements, ctx, visitor);
-    case 4:
-      return (d0, d1, d2, d3) =>
-                 _executeFunctionStatements(varNames, [d0, d1, d2, d3], statements, ctx, visitor);
-    case 5:
-      return (d0, d1, d2, d3, d4) => _executeFunctionStatements(varNames, [d0, d1, d2, d3, d4],
-                                                                statements, ctx, visitor);
-    case 6:
-      return (d0, d1, d2, d3, d4, d5) => _executeFunctionStatements(
-                 varNames, [d0, d1, d2, d3, d4, d5], statements, ctx, visitor);
-    case 7:
-      return (d0, d1, d2, d3, d4, d5, d6) => _executeFunctionStatements(
-                 varNames, [d0, d1, d2, d3, d4, d5, d6], statements, ctx, visitor);
-    case 8:
-      return (d0, d1, d2, d3, d4, d5, d6, d7) => _executeFunctionStatements(
-                 varNames, [d0, d1, d2, d3, d4, d5, d6, d7], statements, ctx, visitor);
-    case 9:
-      return (d0, d1, d2, d3, d4, d5, d6, d7, d8) => _executeFunctionStatements(
-                 varNames, [d0, d1, d2, d3, d4, d5, d6, d7, d8], statements, ctx, visitor);
-    case 10:
-      return (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) => _executeFunctionStatements(
-                 varNames, [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], statements, ctx, visitor);
-    default:
-      throw new BaseException(
-          'Declaring functions with more than 10 arguments is not supported right now');
-  }
-}
-
-var CATCH_ERROR_VAR = 'error';
-var CATCH_STACK_VAR = 'stack';
--- a/modules/@angular/compiler/src/output/output_jit.ts
+++ b/modules/@angular/compiler/src/output/output_jit.ts
@ -1,42 +0,0 @@
-import {
-  isPresent,
-  evalExpression,
-} from '../../src/facade/lang';
-import * as o from './output_ast';
-import {EmitterVisitorContext} from './abstract_emitter';
-import {AbstractJsEmitterVisitor} from './abstract_js_emitter';
-import {sanitizeIdentifier} from '../util';
-
-export function jitStatements(sourceUrl: string, statements: o.Statement[],
-                              resultVar: string): any {
-  var converter = new JitEmitterVisitor();
-  var ctx = EmitterVisitorContext.createRoot([resultVar]);
-  converter.visitAllStatements(statements, ctx);
-  return evalExpression(sourceUrl, resultVar, ctx.toSource(), converter.getArgs());
-}
-
-class JitEmitterVisitor extends AbstractJsEmitterVisitor {
-  private _evalArgNames: string[] = [];
-  private _evalArgValues: any[] = [];
-
-  getArgs(): {[key: string]: any} {
-    var result = {};
-    for (var i = 0; i < this._evalArgNames.length; i++) {
-      result[this._evalArgNames[i]] = this._evalArgValues[i];
-    }
-    return result;
-  }
-
-  visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any {
-    var value = ast.value.runtime;
-    var id = this._evalArgValues.indexOf(value);
-    if (id === -1) {
-      id = this._evalArgValues.length;
-      this._evalArgValues.push(value);
-      var name = isPresent(ast.value.name) ? sanitizeIdentifier(ast.value.name) : 'val';
-      this._evalArgNames.push(sanitizeIdentifier(`jit_${name}${id}`));
-    }
-    ctx.print(this._evalArgNames[id]);
-    return null;
-  }
-}
--- a/modules/@angular/compiler/src/output/path_util.ts
+++ b/modules/@angular/compiler/src/output/path_util.ts
@ -1,31 +0,0 @@
-import {BaseException} from '../../src/facade/exceptions';
-import {isPresent, isBlank, RegExpWrapper, Math} from '../../src/facade/lang';
-import {Injectable} from '@angular/core';
-
-// asset:<package-name>/<realm>/<path-to-module>
-var _ASSET_URL_RE = /asset:([^\/]+)\/([^\/]+)\/(.+)/g;
-
-/**
- * Interface that defines how import statements should be generated.
- */
-export abstract class ImportGenerator {
-  static parseAssetUrl(url: string): AssetUrl { return AssetUrl.parse(url); }
-
-  abstract getImportPath(moduleUrlStr: string, importedUrlStr: string): string;
-}
-
-export class AssetUrl {
-  static parse(url: string, allowNonMatching: boolean = true): AssetUrl {
-    var match = RegExpWrapper.firstMatch(_ASSET_URL_RE, url);
-    if (isPresent(match)) {
-      return new AssetUrl(match[1], match[2], match[3]);
-    }
-    if (allowNonMatching) {
-      return null;
-    }
-    throw new BaseException(`Url ${url} is not a valid asset: url`);
-  }
-
-  constructor(public packageName: string, public firstLevelDir: string, public modulePath: string) {
-  }
-}
--- a/modules/@angular/compiler/src/output/ts_emitter.ts
+++ b/modules/@angular/compiler/src/output/ts_emitter.ts
@ -1,324 +0,0 @@
-import * as o from './output_ast';
-import {isPresent, isBlank, isArray} from '../../src/facade/lang';
-import {BaseException} from '../../src/facade/exceptions';
-import {CompileIdentifierMetadata} from '../compile_metadata';
-import {
-  OutputEmitter,
-  EmitterVisitorContext,
-  AbstractEmitterVisitor,
-  CATCH_ERROR_VAR,
-  CATCH_STACK_VAR
-} from './abstract_emitter';
-import {ImportGenerator} from './path_util';
-
-var _debugModuleUrl = 'asset://debug/lib';
-
-export function debugOutputAstAsTypeScript(ast: o.Statement | o.Expression | o.Type |
-                                           any[]): string {
-  var converter = new _TsEmitterVisitor(_debugModuleUrl);
-  var ctx = EmitterVisitorContext.createRoot([]);
-  var asts: any[];
-  if (isArray(ast)) {
-    asts = <any[]>ast;
-  } else {
-    asts = [ast];
-  }
-  asts.forEach((ast) => {
-    if (ast instanceof o.Statement) {
-      ast.visitStatement(converter, ctx);
-    } else if (ast instanceof o.Expression) {
-      ast.visitExpression(converter, ctx);
-    } else if (ast instanceof o.Type) {
-      ast.visitType(converter, ctx);
-    } else {
-      throw new BaseException(`Don't know how to print debug info for ${ast}`);
-    }
-  });
-  return ctx.toSource();
-}
-
-export class TypeScriptEmitter implements OutputEmitter {
-  constructor(private _importGenerator: ImportGenerator) {}
-  emitStatements(moduleUrl: string, stmts: o.Statement[], exportedVars: string[]): string {
-    var converter = new _TsEmitterVisitor(moduleUrl);
-    var ctx = EmitterVisitorContext.createRoot(exportedVars);
-    converter.visitAllStatements(stmts, ctx);
-    var srcParts = [];
-    converter.importsWithPrefixes.forEach((prefix, importedModuleUrl) => {
-      // Note: can't write the real word for import as it screws up system.js auto detection...
-      srcParts.push(
-          `imp` +
-          `ort * as ${prefix} from '${this._importGenerator.getImportPath(moduleUrl, importedModuleUrl)}';`);
-    });
-    srcParts.push(ctx.toSource());
-    return srcParts.join('\n');
-  }
-}
-
-class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor {
-  constructor(private _moduleUrl: string) { super(false); }
-
-  importsWithPrefixes = new Map<string, string>();
-
-  visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any {
-    this._visitIdentifier(ast.value, ast.typeParams, ctx);
-    return null;
-  }
-  visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any {
-    if (ctx.isExportedVar(stmt.name)) {
-      ctx.print(`export `);
-    }
-    if (stmt.hasModifier(o.StmtModifier.Final)) {
-      ctx.print(`const`);
-    } else {
-      ctx.print(`var`);
-    }
-    ctx.print(` ${stmt.name}`);
-    if (isPresent(stmt.type)) {
-      ctx.print(`:`);
-      stmt.type.visitType(this, ctx);
-    }
-    ctx.print(` = `);
-    stmt.value.visitExpression(this, ctx);
-    ctx.println(`;`);
-    return null;
-  }
-  visitCastExpr(ast: o.CastExpr, ctx: EmitterVisitorContext): any {
-    ctx.print(`(<`);
-    ast.type.visitType(this, ctx);
-    ctx.print(`>`);
-    ast.value.visitExpression(this, ctx);
-    ctx.print(`)`);
-    return null;
-  }
-  visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {
-    ctx.pushClass(stmt);
-    if (ctx.isExportedVar(stmt.name)) {
-      ctx.print(`export `);
-    }
-    ctx.print(`class ${stmt.name}`);
-    if (isPresent(stmt.parent)) {
-      ctx.print(` extends `);
-      stmt.parent.visitExpression(this, ctx);
-    }
-    ctx.println(` {`);
-    ctx.incIndent();
-    stmt.fields.forEach((field) => this._visitClassField(field, ctx));
-    if (isPresent(stmt.constructorMethod)) {
-      this._visitClassConstructor(stmt, ctx);
-    }
-    stmt.getters.forEach((getter) => this._visitClassGetter(getter, ctx));
-    stmt.methods.forEach((method) => this._visitClassMethod(method, ctx));
-    ctx.decIndent();
-    ctx.println(`}`);
-    ctx.popClass();
-    return null;
-  }
-  private _visitClassField(field: o.ClassField, ctx: EmitterVisitorContext) {
-    if (field.hasModifier(o.StmtModifier.Private)) {
-      ctx.print(`private `);
-    }
-    ctx.print(field.name);
-    if (isPresent(field.type)) {
-      ctx.print(`:`);
-      field.type.visitType(this, ctx);
-    } else {
-      ctx.print(`: any`);
-    }
-    ctx.println(`;`);
-  }
-  private _visitClassGetter(getter: o.ClassGetter, ctx: EmitterVisitorContext) {
-    if (getter.hasModifier(o.StmtModifier.Private)) {
-      ctx.print(`private `);
-    }
-    ctx.print(`get ${getter.name}()`);
-    if (isPresent(getter.type)) {
-      ctx.print(`:`);
-      getter.type.visitType(this, ctx);
-    }
-    ctx.println(` {`);
-    ctx.incIndent();
-    this.visitAllStatements(getter.body, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-  }
-  private _visitClassConstructor(stmt: o.ClassStmt, ctx: EmitterVisitorContext) {
-    ctx.print(`constructor(`);
-    this._visitParams(stmt.constructorMethod.params, ctx);
-    ctx.println(`) {`);
-    ctx.incIndent();
-    this.visitAllStatements(stmt.constructorMethod.body, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-  }
-  private _visitClassMethod(method: o.ClassMethod, ctx: EmitterVisitorContext) {
-    if (method.hasModifier(o.StmtModifier.Private)) {
-      ctx.print(`private `);
-    }
-    ctx.print(`${method.name}(`);
-    this._visitParams(method.params, ctx);
-    ctx.print(`):`);
-    if (isPresent(method.type)) {
-      method.type.visitType(this, ctx);
-    } else {
-      ctx.print(`void`);
-    }
-    ctx.println(` {`);
-    ctx.incIndent();
-    this.visitAllStatements(method.body, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-  }
-  visitFunctionExpr(ast: o.FunctionExpr, ctx: EmitterVisitorContext): any {
-    ctx.print(`(`);
-    this._visitParams(ast.params, ctx);
-    ctx.print(`):`);
-    if (isPresent(ast.type)) {
-      ast.type.visitType(this, ctx);
-    } else {
-      ctx.print(`void`);
-    }
-    ctx.println(` => {`);
-    ctx.incIndent();
-    this.visitAllStatements(ast.statements, ctx);
-    ctx.decIndent();
-    ctx.print(`}`);
-    return null;
-  }
-  visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: EmitterVisitorContext): any {
-    if (ctx.isExportedVar(stmt.name)) {
-      ctx.print(`export `);
-    }
-    ctx.print(`function ${stmt.name}(`);
-    this._visitParams(stmt.params, ctx);
-    ctx.print(`):`);
-    if (isPresent(stmt.type)) {
-      stmt.type.visitType(this, ctx);
-    } else {
-      ctx.print(`void`);
-    }
-    ctx.println(` {`);
-    ctx.incIndent();
-    this.visitAllStatements(stmt.statements, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-    return null;
-  }
-  visitTryCatchStmt(stmt: o.TryCatchStmt, ctx: EmitterVisitorContext): any {
-    ctx.println(`try {`);
-    ctx.incIndent();
-    this.visitAllStatements(stmt.bodyStmts, ctx);
-    ctx.decIndent();
-    ctx.println(`} catch (${CATCH_ERROR_VAR.name}) {`);
-    ctx.incIndent();
-    var catchStmts = [
-      <o.Statement>CATCH_STACK_VAR.set(CATCH_ERROR_VAR.prop('stack'))
-          .toDeclStmt(null, [o.StmtModifier.Final])
-    ].concat(stmt.catchStmts);
-    this.visitAllStatements(catchStmts, ctx);
-    ctx.decIndent();
-    ctx.println(`}`);
-    return null;
-  }
-
-  visitBuiltintType(type: o.BuiltinType, ctx: EmitterVisitorContext): any {
-    var typeStr;
-    switch (type.name) {
-      case o.BuiltinTypeName.Bool:
-        typeStr = 'boolean';
-        break;
-      case o.BuiltinTypeName.Dynamic:
-        typeStr = 'any';
-        break;
-      case o.BuiltinTypeName.Function:
-        typeStr = 'Function';
-        break;
-      case o.BuiltinTypeName.Number:
-        typeStr = 'number';
-        break;
-      case o.BuiltinTypeName.Int:
-        typeStr = 'number';
-        break;
-      case o.BuiltinTypeName.String:
-        typeStr = 'string';
-        break;
-      default:
-        throw new BaseException(`Unsupported builtin type ${type.name}`);
-    }
-    ctx.print(typeStr);
-    return null;
-  }
-  visitExternalType(ast: o.ExternalType, ctx: EmitterVisitorContext): any {
-    this._visitIdentifier(ast.value, ast.typeParams, ctx);
-    return null;
-  }
-  visitArrayType(type: o.ArrayType, ctx: EmitterVisitorContext): any {
-    if (isPresent(type.of)) {
-      type.of.visitType(this, ctx);
-    } else {
-      ctx.print(`any`);
-    }
-    ctx.print(`[]`);
-    return null;
-  }
-  visitMapType(type: o.MapType, ctx: EmitterVisitorContext): any {
-    ctx.print(`{[key: string]:`);
-    if (isPresent(type.valueType)) {
-      type.valueType.visitType(this, ctx);
-    } else {
-      ctx.print(`any`);
-    }
-    ctx.print(`}`);
-    return null;
-  }
-
-  getBuiltinMethodName(method: o.BuiltinMethod): string {
-    var name;
-    switch (method) {
-      case o.BuiltinMethod.ConcatArray:
-        name = 'concat';
-        break;
-      case o.BuiltinMethod.SubscribeObservable:
-        name = 'subscribe';
-        break;
-      case o.BuiltinMethod.bind:
-        name = 'bind';
-        break;
-      default:
-        throw new BaseException(`Unknown builtin method: ${method}`);
-    }
-    return name;
-  }
-
-
-  private _visitParams(params: o.FnParam[], ctx: EmitterVisitorContext): void {
-    this.visitAllObjects((param) => {
-      ctx.print(param.name);
-      if (isPresent(param.type)) {
-        ctx.print(`:`);
-        param.type.visitType(this, ctx);
-      }
-    }, params, ctx, ',');
-  }
-
-  private _visitIdentifier(value: CompileIdentifierMetadata, typeParams: o.Type[],
-                           ctx: EmitterVisitorContext): void {
-    if (isBlank(value.name)) {
-      throw new BaseException(`Internal error: unknown identifier ${value}`);
-    }
-    if (isPresent(value.moduleUrl) && value.moduleUrl != this._moduleUrl) {
-      var prefix = this.importsWithPrefixes.get(value.moduleUrl);
-      if (isBlank(prefix)) {
-        prefix = `import${this.importsWithPrefixes.size}`;
-        this.importsWithPrefixes.set(value.moduleUrl, prefix);
-      }
-      ctx.print(`${prefix}.`);
-    }
-    ctx.print(value.name);
-    if (isPresent(typeParams) && typeParams.length > 0) {
-      ctx.print(`<`);
-      this.visitAllObjects((type) => type.visitType(this, ctx), typeParams, ctx, ',');
-      ctx.print(`>`);
-    }
-  }
-}
--- a/modules/@angular/compiler/src/provider_parser.ts
+++ b/modules/@angular/compiler/src/provider_parser.ts
@ -1,420 +0,0 @@
-import {isPresent, isBlank, isArray, normalizeBlank} from '../src/facade/lang';
-import {ListWrapper} from '../src/facade/collection';
-import {
-  VariableAst,
-  AttrAst,
-  DirectiveAst,
-  ProviderAst,
-  ProviderAstType,
-  ReferenceAst
-} from './template_ast';
-import {
-  CompileTypeMetadata,
-  CompileTokenMap,
-  CompileQueryMetadata,
-  CompileTokenMetadata,
-  CompileProviderMetadata,
-  CompileDirectiveMetadata,
-  CompileDiDependencyMetadata
-} from './compile_metadata';
-import {Identifiers, identifierToken} from './identifiers';
-import {ParseSourceSpan, ParseError} from './parse_util';
-
-export class ProviderError extends ParseError {
-  constructor(message: string, span: ParseSourceSpan) { super(span, message); }
-}
-
-export class ProviderViewContext {
-  /**
-   * @internal
-   */
-  viewQueries: CompileTokenMap<CompileQueryMetadata[]>;
-  /**
-   * @internal
-   */
-  viewProviders: CompileTokenMap<boolean>;
-  errors: ProviderError[] = [];
-
-  constructor(public component: CompileDirectiveMetadata, public sourceSpan: ParseSourceSpan) {
-    this.viewQueries = _getViewQueries(component);
-    this.viewProviders = new CompileTokenMap<boolean>();
-    _normalizeProviders(component.viewProviders, sourceSpan, this.errors)
-        .forEach((provider) => {
-          if (isBlank(this.viewProviders.get(provider.token))) {
-            this.viewProviders.add(provider.token, true);
-          }
-        });
-  }
-}
-
-export class ProviderElementContext {
-  private _contentQueries: CompileTokenMap<CompileQueryMetadata[]>;
-
-  private _transformedProviders = new CompileTokenMap<ProviderAst>();
-  private _seenProviders = new CompileTokenMap<boolean>();
-  private _allProviders: CompileTokenMap<ProviderAst>;
-  private _attrs: {[key: string]: string};
-  private _hasViewContainer: boolean = false;
-
-  constructor(private _viewContext: ProviderViewContext, private _parent: ProviderElementContext,
-              private _isViewRoot: boolean, private _directiveAsts: DirectiveAst[],
-              attrs: AttrAst[], refs: ReferenceAst[], private _sourceSpan: ParseSourceSpan) {
-    this._attrs = {};
-    attrs.forEach((attrAst) => this._attrs[attrAst.name] = attrAst.value);
-    var directivesMeta = _directiveAsts.map(directiveAst => directiveAst.directive);
-    this._allProviders =
-        _resolveProvidersFromDirectives(directivesMeta, _sourceSpan, _viewContext.errors);
-    this._contentQueries = _getContentQueries(directivesMeta);
-    var queriedTokens = new CompileTokenMap<boolean>();
-    this._allProviders.values().forEach(
-        (provider) => { this._addQueryReadsTo(provider.token, queriedTokens); });
-    refs.forEach((refAst) => {
-      this._addQueryReadsTo(new CompileTokenMetadata({value: refAst.name}), queriedTokens);
-    });
-    if (isPresent(queriedTokens.get(identifierToken(Identifiers.ViewContainerRef)))) {
-      this._hasViewContainer = true;
-    }
-
-    // create the providers that we know are eager first
-    this._allProviders.values().forEach((provider) => {
-      var eager = provider.eager || isPresent(queriedTokens.get(provider.token));
-      if (eager) {
-        this._getOrCreateLocalProvider(provider.providerType, provider.token, true);
-      }
-    });
-  }
-
-  afterElement() {
-    // collect lazy providers
-    this._allProviders.values().forEach((provider) => {
-      this._getOrCreateLocalProvider(provider.providerType, provider.token, false);
-    });
-  }
-
-  get transformProviders(): ProviderAst[] { return this._transformedProviders.values(); }
-
-  get transformedDirectiveAsts(): DirectiveAst[] {
-    var sortedProviderTypes =
-        this._transformedProviders.values().map(provider => provider.token.identifier);
-    var sortedDirectives = ListWrapper.clone(this._directiveAsts);
-    ListWrapper.sort(sortedDirectives,
-                     (dir1, dir2) => sortedProviderTypes.indexOf(dir1.directive.type) -
-                                     sortedProviderTypes.indexOf(dir2.directive.type));
-    return sortedDirectives;
-  }
-
-  get transformedHasViewContainer(): boolean { return this._hasViewContainer; }
-
-  private _addQueryReadsTo(token: CompileTokenMetadata, queryReadTokens: CompileTokenMap<boolean>) {
-    this._getQueriesFor(token).forEach((query) => {
-      var queryReadToken = isPresent(query.read) ? query.read : token;
-      if (isBlank(queryReadTokens.get(queryReadToken))) {
-        queryReadTokens.add(queryReadToken, true);
-      }
-    });
-  }
-
-  private _getQueriesFor(token: CompileTokenMetadata): CompileQueryMetadata[] {
-    var result: CompileQueryMetadata[] = [];
-    var currentEl: ProviderElementContext = this;
-    var distance = 0;
-    var queries: CompileQueryMetadata[];
-    while (currentEl !== null) {
-      queries = currentEl._contentQueries.get(token);
-      if (isPresent(queries)) {
-        ListWrapper.addAll(result, queries.filter((query) => query.descendants || distance <= 1));
-      }
-      if (currentEl._directiveAsts.length > 0) {
-        distance++;
-      }
-      currentEl = currentEl._parent;
-    }
-    queries = this._viewContext.viewQueries.get(token);
-    if (isPresent(queries)) {
-      ListWrapper.addAll(result, queries);
-    }
-    return result;
-  }
-
-
-  private _getOrCreateLocalProvider(requestingProviderType: ProviderAstType,
-                                    token: CompileTokenMetadata, eager: boolean): ProviderAst {
-    var resolvedProvider = this._allProviders.get(token);
-    if (isBlank(resolvedProvider) ||
-        ((requestingProviderType === ProviderAstType.Directive ||
-          requestingProviderType === ProviderAstType.PublicService) &&
-         resolvedProvider.providerType === ProviderAstType.PrivateService) ||
-        ((requestingProviderType === ProviderAstType.PrivateService ||
-          requestingProviderType === ProviderAstType.PublicService) &&
-         resolvedProvider.providerType === ProviderAstType.Builtin)) {
-      return null;
-    }
-    var transformedProviderAst = this._transformedProviders.get(token);
-    if (isPresent(transformedProviderAst)) {
-      return transformedProviderAst;
-    }
-    if (isPresent(this._seenProviders.get(token))) {
-      this._viewContext.errors.push(new ProviderError(
-          `Cannot instantiate cyclic dependency! ${token.name}`, this._sourceSpan));
-      return null;
-    }
-    this._seenProviders.add(token, true);
-    var transformedProviders = resolvedProvider.providers.map((provider) => {
-      var transformedUseValue = provider.useValue;
-      var transformedUseExisting = provider.useExisting;
-      var transformedDeps;
-      if (isPresent(provider.useExisting)) {
-        var existingDiDep = this._getDependency(
-            resolvedProvider.providerType,
-            new CompileDiDependencyMetadata({token: provider.useExisting}), eager);
-        if (isPresent(existingDiDep.token)) {
-          transformedUseExisting = existingDiDep.token;
-        } else {
-          transformedUseExisting = null;
-          transformedUseValue = existingDiDep.value;
-        }
-      } else if (isPresent(provider.useFactory)) {
-        var deps = isPresent(provider.deps) ? provider.deps : provider.useFactory.diDeps;
-        transformedDeps =
-            deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep, eager));
-      } else if (isPresent(provider.useClass)) {
-        var deps = isPresent(provider.deps) ? provider.deps : provider.useClass.diDeps;
-        transformedDeps =
-            deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep, eager));
-      }
-      return _transformProvider(provider, {
-        useExisting: transformedUseExisting,
-        useValue: transformedUseValue,
-        deps: transformedDeps
-      });
-    });
-    transformedProviderAst =
-        _transformProviderAst(resolvedProvider, {eager: eager, providers: transformedProviders});
-    this._transformedProviders.add(token, transformedProviderAst);
-    return transformedProviderAst;
-  }
-
-  private _getLocalDependency(requestingProviderType: ProviderAstType,
-                              dep: CompileDiDependencyMetadata,
-                              eager: boolean = null): CompileDiDependencyMetadata {
-    if (dep.isAttribute) {
-      var attrValue = this._attrs[dep.token.value];
-      return new CompileDiDependencyMetadata({isValue: true, value: normalizeBlank(attrValue)});
-    }
-    if (isPresent(dep.query) || isPresent(dep.viewQuery)) {
-      return dep;
-    }
-
-    if (isPresent(dep.token)) {
-      // access builtints
-      if ((requestingProviderType === ProviderAstType.Directive ||
-           requestingProviderType === ProviderAstType.Component)) {
-        if (dep.token.equalsTo(identifierToken(Identifiers.Renderer)) ||
-            dep.token.equalsTo(identifierToken(Identifiers.ElementRef)) ||
-            dep.token.equalsTo(identifierToken(Identifiers.ChangeDetectorRef)) ||
-            dep.token.equalsTo(identifierToken(Identifiers.TemplateRef))) {
-          return dep;
-        }
-        if (dep.token.equalsTo(identifierToken(Identifiers.ViewContainerRef))) {
-          this._hasViewContainer = true;
-        }
-      }
-      // access the injector
-      if (dep.token.equalsTo(identifierToken(Identifiers.Injector))) {
-        return dep;
-      }
-      // access providers
-      if (isPresent(this._getOrCreateLocalProvider(requestingProviderType, dep.token, eager))) {
-        return dep;
-      }
-    }
-    return null;
-  }
-
-  private _getDependency(requestingProviderType: ProviderAstType, dep: CompileDiDependencyMetadata,
-                         eager: boolean = null): CompileDiDependencyMetadata {
-    var currElement: ProviderElementContext = this;
-    var currEager: boolean = eager;
-    var result: CompileDiDependencyMetadata = null;
-    if (!dep.isSkipSelf) {
-      result = this._getLocalDependency(requestingProviderType, dep, eager);
-    }
-    if (dep.isSelf) {
-      if (isBlank(result) && dep.isOptional) {
-        result = new CompileDiDependencyMetadata({isValue: true, value: null});
-      }
-    } else {
-      // check parent elements
-      while (isBlank(result) && isPresent(currElement._parent)) {
-        var prevElement = currElement;
-        currElement = currElement._parent;
-        if (prevElement._isViewRoot) {
-          currEager = false;
-        }
-        result = currElement._getLocalDependency(ProviderAstType.PublicService, dep, currEager);
-      }
-      // check @Host restriction
-      if (isBlank(result)) {
-        if (!dep.isHost || this._viewContext.component.type.isHost ||
-            identifierToken(this._viewContext.component.type).equalsTo(dep.token) ||
-            isPresent(this._viewContext.viewProviders.get(dep.token))) {
-          result = dep;
-        } else {
-          result = dep.isOptional ?
-                       result = new CompileDiDependencyMetadata({isValue: true, value: null}) :
-                       null;
-        }
-      }
-    }
-    if (isBlank(result)) {
-      this._viewContext.errors.push(
-          new ProviderError(`No provider for ${dep.token.name}`, this._sourceSpan));
-    }
-    return result;
-  }
-}
-
-function _transformProvider(
-    provider: CompileProviderMetadata,
-    {useExisting, useValue, deps}:
-        {useExisting: CompileTokenMetadata, useValue: any, deps: CompileDiDependencyMetadata[]}) {
-  return new CompileProviderMetadata({
-    token: provider.token,
-    useClass: provider.useClass,
-    useExisting: useExisting,
-    useFactory: provider.useFactory,
-    useValue: useValue,
-    deps: deps,
-    multi: provider.multi
-  });
-}
-
-function _transformProviderAst(
-    provider: ProviderAst,
-    {eager, providers}: {eager: boolean, providers: CompileProviderMetadata[]}): ProviderAst {
-  return new ProviderAst(provider.token, provider.multiProvider, provider.eager || eager, providers,
-                         provider.providerType, provider.sourceSpan);
-}
-
-function _normalizeProviders(
-    providers: Array<CompileProviderMetadata | CompileTypeMetadata | any[]>,
-    sourceSpan: ParseSourceSpan, targetErrors: ParseError[],
-    targetProviders: CompileProviderMetadata[] = null): CompileProviderMetadata[] {
-  if (isBlank(targetProviders)) {
-    targetProviders = [];
-  }
-  if (isPresent(providers)) {
-    providers.forEach((provider) => {
-      if (isArray(provider)) {
-        _normalizeProviders(<any[]>provider, sourceSpan, targetErrors, targetProviders);
-      } else {
-        var normalizeProvider: CompileProviderMetadata;
-        if (provider instanceof CompileProviderMetadata) {
-          normalizeProvider = provider;
-        } else if (provider instanceof CompileTypeMetadata) {
-          normalizeProvider = new CompileProviderMetadata(
-              {token: new CompileTokenMetadata({identifier: provider}), useClass: provider});
-        } else {
-          targetErrors.push(new ProviderError(`Unknown provider type ${provider}`, sourceSpan));
-        }
-        if (isPresent(normalizeProvider)) {
-          targetProviders.push(normalizeProvider);
-        }
-      }
-    });
-  }
-  return targetProviders;
-}
-
-
-function _resolveProvidersFromDirectives(directives: CompileDirectiveMetadata[],
-                                         sourceSpan: ParseSourceSpan,
-                                         targetErrors: ParseError[]): CompileTokenMap<ProviderAst> {
-  var providersByToken = new CompileTokenMap<ProviderAst>();
-  directives.forEach((directive) => {
-    var dirProvider = new CompileProviderMetadata(
-        {token: new CompileTokenMetadata({identifier: directive.type}), useClass: directive.type});
-    _resolveProviders([dirProvider],
-                      directive.isComponent ? ProviderAstType.Component : ProviderAstType.Directive,
-                      true, sourceSpan, targetErrors, providersByToken);
-  });
-
-  // Note: directives need to be able to overwrite providers of a component!
-  var directivesWithComponentFirst =
-      directives.filter(dir => dir.isComponent).concat(directives.filter(dir => !dir.isComponent));
-  directivesWithComponentFirst.forEach((directive) => {
-    _resolveProviders(_normalizeProviders(directive.providers, sourceSpan, targetErrors),
-                      ProviderAstType.PublicService, false, sourceSpan, targetErrors,
-                      providersByToken);
-    _resolveProviders(_normalizeProviders(directive.viewProviders, sourceSpan, targetErrors),
-                      ProviderAstType.PrivateService, false, sourceSpan, targetErrors,
-                      providersByToken);
-  });
-  return providersByToken;
-}
-
-function _resolveProviders(providers: CompileProviderMetadata[], providerType: ProviderAstType,
-                           eager: boolean, sourceSpan: ParseSourceSpan, targetErrors: ParseError[],
-                           targetProvidersByToken: CompileTokenMap<ProviderAst>) {
-  providers.forEach((provider) => {
-    var resolvedProvider = targetProvidersByToken.get(provider.token);
-    if (isPresent(resolvedProvider) && resolvedProvider.multiProvider !== provider.multi) {
-      targetErrors.push(new ProviderError(
-          `Mixing multi and non multi provider is not possible for token ${resolvedProvider.token.name}`,
-          sourceSpan));
-    }
-    if (isBlank(resolvedProvider)) {
-      resolvedProvider = new ProviderAst(provider.token, provider.multi, eager, [provider],
-                                         providerType, sourceSpan);
-      targetProvidersByToken.add(provider.token, resolvedProvider);
-    } else {
-      if (!provider.multi) {
-        ListWrapper.clear(resolvedProvider.providers);
-      }
-      resolvedProvider.providers.push(provider);
-    }
-  });
-}
-
-
-function _getViewQueries(
-    component: CompileDirectiveMetadata): CompileTokenMap<CompileQueryMetadata[]> {
-  var viewQueries = new CompileTokenMap<CompileQueryMetadata[]>();
-  if (isPresent(component.viewQueries)) {
-    component.viewQueries.forEach((query) => _addQueryToTokenMap(viewQueries, query));
-  }
-  component.type.diDeps.forEach((dep) => {
-    if (isPresent(dep.viewQuery)) {
-      _addQueryToTokenMap(viewQueries, dep.viewQuery);
-    }
-  });
-  return viewQueries;
-}
-
-function _getContentQueries(
-    directives: CompileDirectiveMetadata[]): CompileTokenMap<CompileQueryMetadata[]> {
-  var contentQueries = new CompileTokenMap<CompileQueryMetadata[]>();
-  directives.forEach(directive => {
-    if (isPresent(directive.queries)) {
-      directive.queries.forEach((query) => _addQueryToTokenMap(contentQueries, query));
-    }
-    directive.type.diDeps.forEach((dep) => {
-      if (isPresent(dep.query)) {
-        _addQueryToTokenMap(contentQueries, dep.query);
-      }
-    });
-  });
-  return contentQueries;
-}
-
-function _addQueryToTokenMap(map: CompileTokenMap<CompileQueryMetadata[]>,
-                             query: CompileQueryMetadata) {
-  query.selectors.forEach((token: CompileTokenMetadata) => {
-    var entry = map.get(token);
-    if (isBlank(entry)) {
-      entry = [];
-      map.add(token, entry);
-    }
-    entry.push(query);
-  });
-}
--- a/modules/@angular/compiler/src/runtime_compiler.ts
+++ b/modules/@angular/compiler/src/runtime_compiler.ts
@ -1,210 +0,0 @@
-import {Injectable, ComponentFactory, ComponentResolver} from '@angular/core';
-
-import {
-  IS_DART,
-  Type,
-  isBlank,
-} from '../src/facade/lang';
-import {BaseException} from '../src/facade/exceptions';
-import {
-  ListWrapper,
-} from '../src/facade/collection';
-import {PromiseWrapper} from '../src/facade/async';
-import {
-  createHostComponentMeta,
-  CompileDirectiveMetadata,
-  CompilePipeMetadata,
-  CompileIdentifierMetadata
-} from './compile_metadata';
-import {
-  TemplateAst,
-} from './template_ast';
-import {StyleCompiler, StylesCompileDependency, StylesCompileResult} from './style_compiler';
-import {ViewCompiler} from './view_compiler/view_compiler';
-import {TemplateParser} from './template_parser';
-import {DirectiveNormalizer} from './directive_normalizer';
-import {CompileMetadataResolver} from './metadata_resolver';
-import {CompilerConfig} from './config';
-import * as ir from './output/output_ast';
-import {jitStatements} from './output/output_jit';
-import {interpretStatements} from './output/output_interpreter';
-import {InterpretiveAppViewInstanceFactory} from './output/interpretive_view';
-import {XHR} from './xhr';
-
-/**
- * An internal module of the Angular compiler that begins with component types,
- * extracts templates, and eventually produces a compiled version of the component
- * ready for linking into an application.
- */
-@Injectable()
-export class RuntimeCompiler implements ComponentResolver {
-  private _styleCache: Map<string, Promise<string>> = new Map<string, Promise<string>>();
-  private _hostCacheKeys = new Map<Type, any>();
-  private _compiledTemplateCache = new Map<any, CompiledTemplate>();
-  private _compiledTemplateDone = new Map<any, Promise<CompiledTemplate>>();
-
-  constructor(private _metadataResolver: CompileMetadataResolver,
-              private _templateNormalizer: DirectiveNormalizer,
-              private _templateParser: TemplateParser, private _styleCompiler: StyleCompiler,
-              private _viewCompiler: ViewCompiler, private _xhr: XHR,
-              private _genConfig: CompilerConfig) {}
-
-  resolveComponent(componentType: Type): Promise<ComponentFactory<any>> {
-    var compMeta: CompileDirectiveMetadata =
-        this._metadataResolver.getDirectiveMetadata(componentType);
-    var hostCacheKey = this._hostCacheKeys.get(componentType);
-    if (isBlank(hostCacheKey)) {
-      hostCacheKey = new Object();
-      this._hostCacheKeys.set(componentType, hostCacheKey);
-      assertComponent(compMeta);
-      var hostMeta: CompileDirectiveMetadata =
-          createHostComponentMeta(compMeta.type, compMeta.selector);
-
-      this._loadAndCompileComponent(hostCacheKey, hostMeta, [compMeta], [], []);
-    }
-    return this._compiledTemplateDone.get(hostCacheKey)
-        .then((compiledTemplate: CompiledTemplate) => new ComponentFactory(
-                  compMeta.selector, compiledTemplate.viewFactory, componentType));
-  }
-
-  clearCache() {
-    this._styleCache.clear();
-    this._compiledTemplateCache.clear();
-    this._compiledTemplateDone.clear();
-    this._hostCacheKeys.clear();
-  }
-
-
-  private _loadAndCompileComponent(cacheKey: any, compMeta: CompileDirectiveMetadata,
-                                   viewDirectives: CompileDirectiveMetadata[],
-                                   pipes: CompilePipeMetadata[],
-                                   compilingComponentsPath: any[]): CompiledTemplate {
-    var compiledTemplate = this._compiledTemplateCache.get(cacheKey);
-    var done = this._compiledTemplateDone.get(cacheKey);
-    if (isBlank(compiledTemplate)) {
-      compiledTemplate = new CompiledTemplate();
-      this._compiledTemplateCache.set(cacheKey, compiledTemplate);
-      done =
-          PromiseWrapper.all(
-                            [<any>this._compileComponentStyles(compMeta)].concat(viewDirectives.map(
-                                dirMeta => this._templateNormalizer.normalizeDirective(dirMeta))))
-              .then((stylesAndNormalizedViewDirMetas: any[]) => {
-                var normalizedViewDirMetas = stylesAndNormalizedViewDirMetas.slice(1);
-                var styles = stylesAndNormalizedViewDirMetas[0];
-                var parsedTemplate =
-                    this._templateParser.parse(compMeta, compMeta.template.template,
-                                               normalizedViewDirMetas, pipes, compMeta.type.name);
-
-                var childPromises = [];
-                compiledTemplate.init(this._compileComponent(compMeta, parsedTemplate, styles,
-                                                             pipes, compilingComponentsPath,
-                                                             childPromises));
-                return PromiseWrapper.all(childPromises).then((_) => { return compiledTemplate; });
-              });
-      this._compiledTemplateDone.set(cacheKey, done);
-    }
-    return compiledTemplate;
-  }
-
-  private _compileComponent(compMeta: CompileDirectiveMetadata, parsedTemplate: TemplateAst[],
-                            styles: string[], pipes: CompilePipeMetadata[],
-                            compilingComponentsPath: any[],
-                            childPromises: Promise<any>[]): Function {
-    var compileResult = this._viewCompiler.compileComponent(
-        compMeta, parsedTemplate,
-        new ir.ExternalExpr(new CompileIdentifierMetadata({runtime: styles})), pipes);
-    compileResult.dependencies.forEach((dep) => {
-      var childCompilingComponentsPath = ListWrapper.clone(compilingComponentsPath);
-
-      var childCacheKey = dep.comp.type.runtime;
-      var childViewDirectives: CompileDirectiveMetadata[] =
-          this._metadataResolver.getViewDirectivesMetadata(dep.comp.type.runtime);
-      var childViewPipes: CompilePipeMetadata[] =
-          this._metadataResolver.getViewPipesMetadata(dep.comp.type.runtime);
-      var childIsRecursive = ListWrapper.contains(childCompilingComponentsPath, childCacheKey);
-      childCompilingComponentsPath.push(childCacheKey);
-
-      var childComp =
-          this._loadAndCompileComponent(dep.comp.type.runtime, dep.comp, childViewDirectives,
-                                        childViewPipes, childCompilingComponentsPath);
-      dep.factoryPlaceholder.runtime = childComp.proxyViewFactory;
-      dep.factoryPlaceholder.name = `viewFactory_${dep.comp.type.name}`;
-      if (!childIsRecursive) {
-        // Only wait for a child if it is not a cycle
-        childPromises.push(this._compiledTemplateDone.get(childCacheKey));
-      }
-    });
-    var factory;
-    if (IS_DART || !this._genConfig.useJit) {
-      factory = interpretStatements(compileResult.statements, compileResult.viewFactoryVar,
-                                    new InterpretiveAppViewInstanceFactory());
-    } else {
-      factory = jitStatements(`${compMeta.type.name}.template.js`, compileResult.statements,
-                              compileResult.viewFactoryVar);
-    }
-    return factory;
-  }
-
-  private _compileComponentStyles(compMeta: CompileDirectiveMetadata): Promise<string[]> {
-    var compileResult = this._styleCompiler.compileComponent(compMeta);
-    return this._resolveStylesCompileResult(compMeta.type.name, compileResult);
-  }
-
-  private _resolveStylesCompileResult(sourceUrl: string,
-                                      result: StylesCompileResult): Promise<string[]> {
-    var promises = result.dependencies.map((dep) => this._loadStylesheetDep(dep));
-    return PromiseWrapper.all(promises)
-        .then((cssTexts) => {
-          var nestedCompileResultPromises = [];
-          for (var i = 0; i < result.dependencies.length; i++) {
-            var dep = result.dependencies[i];
-            var cssText = cssTexts[i];
-            var nestedCompileResult =
-                this._styleCompiler.compileStylesheet(dep.moduleUrl, cssText, dep.isShimmed);
-            nestedCompileResultPromises.push(
-                this._resolveStylesCompileResult(dep.moduleUrl, nestedCompileResult));
-          }
-          return PromiseWrapper.all(nestedCompileResultPromises);
-        })
-        .then((nestedStylesArr) => {
-          for (var i = 0; i < result.dependencies.length; i++) {
-            var dep = result.dependencies[i];
-            dep.valuePlaceholder.runtime = nestedStylesArr[i];
-            dep.valuePlaceholder.name = `importedStyles${i}`;
-          }
-          if (IS_DART || !this._genConfig.useJit) {
-            return interpretStatements(result.statements, result.stylesVar,
-                                       new InterpretiveAppViewInstanceFactory());
-          } else {
-            return jitStatements(`${sourceUrl}.css.js`, result.statements, result.stylesVar);
-          }
-        });
-  }
-
-  private _loadStylesheetDep(dep: StylesCompileDependency): Promise<string> {
-    var cacheKey = `${dep.moduleUrl}${dep.isShimmed ? '.shim' : ''}`;
-    var cssTextPromise = this._styleCache.get(cacheKey);
-    if (isBlank(cssTextPromise)) {
-      cssTextPromise = this._xhr.get(dep.moduleUrl);
-      this._styleCache.set(cacheKey, cssTextPromise);
-    }
-    return cssTextPromise;
-  }
-}
-
-class CompiledTemplate {
-  viewFactory: Function = null;
-  proxyViewFactory: Function;
-  constructor() {
-    this.proxyViewFactory = (viewUtils, childInjector, contextEl) =>
-        this.viewFactory(viewUtils, childInjector, contextEl);
-  }
-
-  init(viewFactory: Function) { this.viewFactory = viewFactory; }
-}
-
-function assertComponent(meta: CompileDirectiveMetadata) {
-  if (!meta.isComponent) {
-    throw new BaseException(`Could not compile '${meta.type.name}' because it is not a component.`);
-  }
-}
--- a/modules/@angular/compiler/src/schema/dom_element_schema_registry.ts
+++ b/modules/@angular/compiler/src/schema/dom_element_schema_registry.ts
@ -1,261 +0,0 @@
-import {Injectable} from '@angular/core';
-import {isPresent} from '../facade/lang';
-import {StringMapWrapper} from '../facade/collection';
-import {ElementSchemaRegistry} from './element_schema_registry';
-
-const EVENT = 'event';
-const BOOLEAN = 'boolean';
-const NUMBER = 'number';
-const STRING = 'string';
-const OBJECT = 'object';
-
-/**
- * This array represents the DOM schema. It encodes inheritance, properties, and events.
- *
- * ## Overview
- *
- * Each line represents one kind of element. The `element_inheritance` and properties are joined
- * using `element_inheritance|preperties` syntax.
- *
- * ## Element Inheritance
- *
- * The `element_inheritance` can be further subdivided as `element1,element2,...^parentElement`.
- * Here the individual elements are separated by `,` (commas). Every element in the list
- * has identical properties.
- *
- * An `element` may inherit additional properties from `parentElement` If no `^parentElement` is
- * specified then `""` (blank) element is assumed.
- *
- * NOTE: The blank element inherits from root `*` element, the super element of all elements.
- *
- * NOTE an element prefix such as `@svg:` has no special meaning to the schema.
- *
- * ## Properties
- *
- * Each element has a set of properties separated by `,` (commas). Each property can be prefixed
- * by a special character designating its type:
- *
- * - (no prefix): property is a string.
- * - `*`: property represents an event.
- * - `!`: property is a boolean.
- * - `#`: property is a number.
- * - `%`: property is an object.
- *
- * ## Query
- *
- * The class creates an internal squas representaino which allows to easily answer the query of
- * if a given property exist on a given element.
- *
- * NOTE: We don't yet support querying for types or events.
- * NOTE: This schema is auto extracted from `schema_extractor.ts` located in the test folder.
- */
-const SCHEMA: string[] =
-    /*@ts2dart_const*/ ([
-      '*|%classList,className,id,innerHTML,*beforecopy,*beforecut,*beforepaste,*copy,*cut,*paste,*search,*selectstart,*webkitfullscreenchange,*webkitfullscreenerror,*wheel,outerHTML,#scrollLeft,#scrollTop',
-      '^*|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*autocomplete,*autocompleteerror,*beforecopy,*beforecut,*beforepaste,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*copy,*cuechange,*cut,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*message,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*mozfullscreenchange,*mozfullscreenerror,*mozpointerlockchange,*mozpointerlockerror,*paste,*pause,*play,*playing,*progress,*ratechange,*reset,*resize,*scroll,*search,*seeked,*seeking,*select,*selectstart,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,*webglcontextcreationerror,*webglcontextlost,*webglcontextrestored,*webkitfullscreenchange,*webkitfullscreenerror,*wheel,outerText,!spellcheck,%style,#tabIndex,title,!translate',
-      'media|!autoplay,!controls,%crossOrigin,#currentTime,!defaultMuted,#defaultPlaybackRate,!disableRemotePlayback,!loop,!muted,*encrypted,#playbackRate,preload,src,#volume',
-      '@svg:^*|*abort,*autocomplete,*autocompleteerror,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,%style,#tabIndex',
-      '@svg:graphics^@svg:|',
-      '@svg:animation^@svg:|*begin,*end,*repeat',
-      '@svg:geometry^@svg:|',
-      '@svg:componentTransferFunction^@svg:|',
-      '@svg:gradient^@svg:|',
-      '@svg:textContent^@svg:graphics|',
-      '@svg:textPositioning^@svg:textContent|',
-      'a|charset,coords,download,hash,host,hostname,href,hreflang,name,password,pathname,ping,port,protocol,rel,rev,search,shape,target,text,type,username',
-      'area|alt,coords,hash,host,hostname,href,!noHref,password,pathname,ping,port,protocol,search,shape,target,username',
-      'audio^media|',
-      'br|clear',
-      'base|href,target',
-      'body|aLink,background,bgColor,link,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,text,vLink',
-      'button|!autofocus,!disabled,formAction,formEnctype,formMethod,!formNoValidate,formTarget,name,type,value',
-      'canvas|#height,#width',
-      'content|select',
-      'dl|!compact',
-      'datalist|',
-      'details|!open',
-      'dialog|!open,returnValue',
-      'dir|!compact',
-      'div|align',
-      'embed|align,height,name,src,type,width',
-      'fieldset|!disabled,name',
-      'font|color,face,size',
-      'form|acceptCharset,action,autocomplete,encoding,enctype,method,name,!noValidate,target',
-      'frame|frameBorder,longDesc,marginHeight,marginWidth,name,!noResize,scrolling,src',
-      'frameset|cols,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,rows',
-      'hr|align,color,!noShade,size,width',
-      'head|',
-      'h1,h2,h3,h4,h5,h6|align',
-      'html|version',
-      'iframe|align,!allowFullscreen,frameBorder,height,longDesc,marginHeight,marginWidth,name,%sandbox,scrolling,src,srcdoc,width',
-      'img|align,alt,border,%crossOrigin,#height,#hspace,!isMap,longDesc,lowsrc,name,sizes,src,srcset,useMap,#vspace,#width',
-      'input|accept,align,alt,autocapitalize,autocomplete,!autofocus,!checked,!defaultChecked,defaultValue,dirName,!disabled,%files,formAction,formEnctype,formMethod,!formNoValidate,formTarget,#height,!incremental,!indeterminate,max,#maxLength,min,#minLength,!multiple,name,pattern,placeholder,!readOnly,!required,selectionDirection,#selectionEnd,#selectionStart,#size,src,step,type,useMap,value,%valueAsDate,#valueAsNumber,#width',
-      'keygen|!autofocus,challenge,!disabled,keytype,name',
-      'li|type,#value',
-      'label|htmlFor',
-      'legend|align',
-      'link|as,charset,%crossOrigin,!disabled,href,hreflang,integrity,media,rel,%relList,rev,%sizes,target,type',
-      'map|name',
-      'marquee|behavior,bgColor,direction,height,#hspace,#loop,#scrollAmount,#scrollDelay,!trueSpeed,#vspace,width',
-      'menu|!compact',
-      'meta|content,httpEquiv,name,scheme',
-      'meter|#high,#low,#max,#min,#optimum,#value',
-      'ins,del|cite,dateTime',
-      'ol|!compact,!reversed,#start,type',
-      'object|align,archive,border,code,codeBase,codeType,data,!declare,height,#hspace,name,standby,type,useMap,#vspace,width',
-      'optgroup|!disabled,label',
-      'option|!defaultSelected,!disabled,label,!selected,text,value',
-      'output|defaultValue,%htmlFor,name,value',
-      'p|align',
-      'param|name,type,value,valueType',
-      'picture|',
-      'pre|#width',
-      'progress|#max,#value',
-      'q,blockquote,cite|',
-      'script|!async,charset,%crossOrigin,!defer,event,htmlFor,integrity,src,text,type',
-      'select|!autofocus,!disabled,#length,!multiple,name,!required,#selectedIndex,#size,value',
-      'shadow|',
-      'source|media,sizes,src,srcset,type',
-      'span|',
-      'style|!disabled,media,type',
-      'caption|align',
-      'th,td|abbr,align,axis,bgColor,ch,chOff,#colSpan,headers,height,!noWrap,#rowSpan,scope,vAlign,width',
-      'col,colgroup|align,ch,chOff,#span,vAlign,width',
-      'table|align,bgColor,border,%caption,cellPadding,cellSpacing,frame,rules,summary,%tFoot,%tHead,width',
-      'tr|align,bgColor,ch,chOff,vAlign',
-      'tfoot,thead,tbody|align,ch,chOff,vAlign',
-      'template|',
-      'textarea|autocapitalize,!autofocus,#cols,defaultValue,dirName,!disabled,#maxLength,#minLength,name,placeholder,!readOnly,!required,#rows,selectionDirection,#selectionEnd,#selectionStart,value,wrap',
-      'title|text',
-      'track|!default,kind,label,src,srclang',
-      'ul|!compact,type',
-      'unknown|',
-      'video^media|#height,poster,#width',
-      '@svg:a^@svg:graphics|',
-      '@svg:animate^@svg:animation|',
-      '@svg:animateMotion^@svg:animation|',
-      '@svg:animateTransform^@svg:animation|',
-      '@svg:circle^@svg:geometry|',
-      '@svg:clipPath^@svg:graphics|',
-      '@svg:cursor^@svg:|',
-      '@svg:defs^@svg:graphics|',
-      '@svg:desc^@svg:|',
-      '@svg:discard^@svg:|',
-      '@svg:ellipse^@svg:geometry|',
-      '@svg:feBlend^@svg:|',
-      '@svg:feColorMatrix^@svg:|',
-      '@svg:feComponentTransfer^@svg:|',
-      '@svg:feComposite^@svg:|',
-      '@svg:feConvolveMatrix^@svg:|',
-      '@svg:feDiffuseLighting^@svg:|',
-      '@svg:feDisplacementMap^@svg:|',
-      '@svg:feDistantLight^@svg:|',
-      '@svg:feDropShadow^@svg:|',
-      '@svg:feFlood^@svg:|',
-      '@svg:feFuncA^@svg:componentTransferFunction|',
-      '@svg:feFuncB^@svg:componentTransferFunction|',
-      '@svg:feFuncG^@svg:componentTransferFunction|',
-      '@svg:feFuncR^@svg:componentTransferFunction|',
-      '@svg:feGaussianBlur^@svg:|',
-      '@svg:feImage^@svg:|',
-      '@svg:feMerge^@svg:|',
-      '@svg:feMergeNode^@svg:|',
-      '@svg:feMorphology^@svg:|',
-      '@svg:feOffset^@svg:|',
-      '@svg:fePointLight^@svg:|',
-      '@svg:feSpecularLighting^@svg:|',
-      '@svg:feSpotLight^@svg:|',
-      '@svg:feTile^@svg:|',
-      '@svg:feTurbulence^@svg:|',
-      '@svg:filter^@svg:|',
-      '@svg:foreignObject^@svg:graphics|',
-      '@svg:g^@svg:graphics|',
-      '@svg:image^@svg:graphics|',
-      '@svg:line^@svg:geometry|',
-      '@svg:linearGradient^@svg:gradient|',
-      '@svg:mpath^@svg:|',
-      '@svg:marker^@svg:|',
-      '@svg:mask^@svg:|',
-      '@svg:metadata^@svg:|',
-      '@svg:path^@svg:geometry|',
-      '@svg:pattern^@svg:|',
-      '@svg:polygon^@svg:geometry|',
-      '@svg:polyline^@svg:geometry|',
-      '@svg:radialGradient^@svg:gradient|',
-      '@svg:rect^@svg:geometry|',
-      '@svg:svg^@svg:graphics|#currentScale,#zoomAndPan',
-      '@svg:script^@svg:|type',
-      '@svg:set^@svg:animation|',
-      '@svg:stop^@svg:|',
-      '@svg:style^@svg:|!disabled,media,title,type',
-      '@svg:switch^@svg:graphics|',
-      '@svg:symbol^@svg:|',
-      '@svg:tspan^@svg:textPositioning|',
-      '@svg:text^@svg:textPositioning|',
-      '@svg:textPath^@svg:textContent|',
-      '@svg:title^@svg:|',
-      '@svg:use^@svg:graphics|',
-      '@svg:view^@svg:|#zoomAndPan'
-    ]);
-
-var attrToPropMap: {[name: string]: string} = <any>{
-  'class': 'className',
-  'innerHtml': 'innerHTML',
-  'readonly': 'readOnly',
-  'tabindex': 'tabIndex'
-};
-
-
-@Injectable()
-export class DomElementSchemaRegistry implements ElementSchemaRegistry {
-  schema = <{[element: string]: {[property: string]: string}}>{};
-
-  constructor() {
-    SCHEMA.forEach(encodedType => {
-      var parts = encodedType.split('|');
-      var properties = parts[1].split(',');
-      var typeParts = (parts[0] + '^').split('^');
-      var typeName = typeParts[0];
-      var type = <{[property: string]: string}>{};
-      typeName.split(',').forEach(tag => this.schema[tag] = type);
-      var superType = this.schema[typeParts[1]];
-      if (isPresent(superType)) {
-        StringMapWrapper.forEach(superType, (v, k) => type[k] = v);
-      }
-      properties.forEach((property: string) => {
-        if (property == '') {
-        } else if (property.startsWith('*')) {
-          // We don't yet support events.
-          // type[property.substring(1)] = EVENT;
-        } else if (property.startsWith('!')) {
-          type[property.substring(1)] = BOOLEAN;
-        } else if (property.startsWith('#')) {
-          type[property.substring(1)] = NUMBER;
-        } else if (property.startsWith('%')) {
-          type[property.substring(1)] = OBJECT;
-        } else {
-          type[property] = STRING;
-        }
-      });
-    });
-  }
-
-  hasProperty(tagName: string, propName: string): boolean {
-    if (tagName.indexOf('-') !== -1) {
-      // can't tell now as we don't know which properties a custom element will get
-      // once it is instantiated
-      return true;
-    } else {
-      var elementProperties = this.schema[tagName.toLowerCase()];
-      if (!isPresent(elementProperties)) {
-        elementProperties = this.schema['unknown'];
-      }
-      return isPresent(elementProperties[propName]);
-    }
-  }
-
-  getMappedPropName(propName: string): string {
-    var mappedPropName = StringMapWrapper.get(attrToPropMap, propName);
-    return isPresent(mappedPropName) ? mappedPropName : propName;
-  }
-}
--- a/modules/@angular/compiler/src/style_compiler.ts
+++ b/modules/@angular/compiler/src/style_compiler.ts
@ -1,72 +0,0 @@
-import {ViewEncapsulation, Injectable} from '@angular/core';
-import {CompileIdentifierMetadata, CompileDirectiveMetadata} from './compile_metadata';
-import * as o from './output/output_ast';
-import {ShadowCss} from './shadow_css';
-import {UrlResolver} from './url_resolver';
-import {extractStyleUrls} from './style_url_resolver';
-import {isPresent} from '../src/facade/lang';
-
-const COMPONENT_VARIABLE = '%COMP%';
-const HOST_ATTR = /*@ts2dart_const*/ `_nghost-${COMPONENT_VARIABLE}`;
-const CONTENT_ATTR = /*@ts2dart_const*/ `_ngcontent-${COMPONENT_VARIABLE}`;
-
-export class StylesCompileDependency {
-  constructor(public moduleUrl: string, public isShimmed: boolean,
-              public valuePlaceholder: CompileIdentifierMetadata) {}
-}
-
-export class StylesCompileResult {
-  constructor(public statements: o.Statement[], public stylesVar: string,
-              public dependencies: StylesCompileDependency[]) {}
-}
-
-@Injectable()
-export class StyleCompiler {
-  private _shadowCss: ShadowCss = new ShadowCss();
-
-  constructor(private _urlResolver: UrlResolver) {}
-
-  compileComponent(comp: CompileDirectiveMetadata): StylesCompileResult {
-    var shim = comp.template.encapsulation === ViewEncapsulation.Emulated;
-    return this._compileStyles(getStylesVarName(comp), comp.template.styles,
-                               comp.template.styleUrls, shim);
-  }
-
-  compileStylesheet(stylesheetUrl: string, cssText: string,
-                    isShimmed: boolean): StylesCompileResult {
-    var styleWithImports = extractStyleUrls(this._urlResolver, stylesheetUrl, cssText);
-    return this._compileStyles(getStylesVarName(null), [styleWithImports.style],
-                               styleWithImports.styleUrls, isShimmed);
-  }
-
-  private _compileStyles(stylesVar: string, plainStyles: string[], absUrls: string[],
-                         shim: boolean): StylesCompileResult {
-    var styleExpressions =
-        plainStyles.map(plainStyle => o.literal(this._shimIfNeeded(plainStyle, shim)));
-    var dependencies = [];
-    for (var i = 0; i < absUrls.length; i++) {
-      var identifier = new CompileIdentifierMetadata({name: getStylesVarName(null)});
-      dependencies.push(new StylesCompileDependency(absUrls[i], shim, identifier));
-      styleExpressions.push(new o.ExternalExpr(identifier));
-    }
-    // styles variable contains plain strings and arrays of other styles arrays (recursive),
-    // so we set its type to dynamic.
-    var stmt = o.variable(stylesVar)
-                   .set(o.literalArr(styleExpressions,
-                                     new o.ArrayType(o.DYNAMIC_TYPE, [o.TypeModifier.Const])))
-                   .toDeclStmt(null, [o.StmtModifier.Final]);
-    return new StylesCompileResult([stmt], stylesVar, dependencies);
-  }
-
-  private _shimIfNeeded(style: string, shim: boolean): string {
-    return shim ? this._shadowCss.shimCssText(style, CONTENT_ATTR, HOST_ATTR) : style;
-  }
-}
-
-function getStylesVarName(component: CompileDirectiveMetadata): string {
-  var result = `styles`;
-  if (isPresent(component)) {
-    result += `_${component.type.name}`;
-  }
-  return result;
-}
--- a/modules/@angular/compiler/src/util.ts
+++ b/modules/@angular/compiler/src/util.ts
@ -1,87 +0,0 @@
-import {
-  IS_DART,
-  StringWrapper,
-  Math,
-  isBlank,
-  isArray,
-  isStrictStringMap,
-  isPrimitive
-} from './facade/lang';
-import {StringMapWrapper} from './facade/collection';
-
-export var MODULE_SUFFIX = IS_DART ? '.dart' : '';
-
-var CAMEL_CASE_REGEXP = /([A-Z])/g;
-var DASH_CASE_REGEXP = /-([a-z])/g;
-
-export function camelCaseToDashCase(input: string): string {
-  return StringWrapper.replaceAllMapped(input, CAMEL_CASE_REGEXP,
-                                        (m) => { return '-' + m[1].toLowerCase(); });
-}
-
-export function dashCaseToCamelCase(input: string): string {
-  return StringWrapper.replaceAllMapped(input, DASH_CASE_REGEXP,
-                                        (m) => { return m[1].toUpperCase(); });
-}
-
-export function splitAtColon(input: string, defaultValues: string[]): string[] {
-  var parts = StringWrapper.split(input.trim(), /\s*:\s*/g);
-  if (parts.length > 1) {
-    return parts;
-  } else {
-    return defaultValues;
-  }
-}
-
-export function sanitizeIdentifier(name: string): string {
-  return StringWrapper.replaceAll(name, /\W/g, '_');
-}
-
-export function visitValue(value: any, visitor: ValueVisitor, context: any): any {
-  if (isArray(value)) {
-    return visitor.visitArray(<any[]>value, context);
-  } else if (isStrictStringMap(value)) {
-    return visitor.visitStringMap(<{[key: string]: any}>value, context);
-  } else if (isBlank(value) || isPrimitive(value)) {
-    return visitor.visitPrimitive(value, context);
-  } else {
-    return visitor.visitOther(value, context);
-  }
-}
-
-export interface ValueVisitor {
-  visitArray(arr: any[], context: any): any;
-  visitStringMap(map: {[key: string]: any}, context: any): any;
-  visitPrimitive(value: any, context: any): any;
-  visitOther(value: any, context: any): any;
-}
-
-export class ValueTransformer implements ValueVisitor {
-  visitArray(arr: any[], context: any): any {
-    return arr.map(value => visitValue(value, this, context));
-  }
-  visitStringMap(map: {[key: string]: any}, context: any): any {
-    var result = {};
-    StringMapWrapper.forEach(map,
-                             (value, key) => { result[key] = visitValue(value, this, context); });
-    return result;
-  }
-  visitPrimitive(value: any, context: any): any { return value; }
-  visitOther(value: any, context: any): any { return value; }
-}
-
-export function assetUrl(pkg: string, path: string = null, type: string = 'src'): string {
-  if (IS_DART) {
-    if (path == null) {
-      return `asset:angular2/${pkg}/${pkg}.dart`;
-    } else {
-      return `asset:angular2/lib/${pkg}/src/${path}.dart`;
-    }
-  } else {
-    if (path == null) {
-      return `asset:@angular/lib/${pkg}/index`;
-    } else {
-      return `asset:@angular/lib/${pkg}/src/${path}`;
-    }
-  }
-}
--- a/modules/@angular/compiler/src/view_compiler/compile_binding.ts
+++ b/modules/@angular/compiler/src/view_compiler/compile_binding.ts
@ -1,6 +0,0 @@
-import {CompileNode} from './compile_element';
-import {TemplateAst} from '../template_ast';
-
-export class CompileBinding {
-  constructor(public node: CompileNode, public sourceAst: TemplateAst) {}
-}
--- a/modules/@angular/compiler/src/view_compiler/compile_element.ts
+++ b/modules/@angular/compiler/src/view_compiler/compile_element.ts
@ -1,427 +0,0 @@
-import {BaseException} from '@angular/core';
-import {isPresent, isBlank} from '../../src/facade/lang';
-import {ListWrapper, StringMapWrapper} from '../../src/facade/collection';
-
-import * as o from '../output/output_ast';
-import {Identifiers, identifierToken} from '../identifiers';
-import {InjectMethodVars} from './constants';
-import {CompileView} from './compile_view';
-import {TemplateAst, ProviderAst, ProviderAstType, ReferenceAst} from '../template_ast';
-import {
-  CompileTokenMap,
-  CompileDirectiveMetadata,
-  CompileTokenMetadata,
-  CompileQueryMetadata,
-  CompileProviderMetadata,
-  CompileDiDependencyMetadata,
-  CompileIdentifierMetadata,
-} from '../compile_metadata';
-import {getPropertyInView, createDiTokenExpression, injectFromViewParentInjector} from './util';
-import {CompileQuery, createQueryList, addQueryToTokenMap} from './compile_query';
-import {CompileMethod} from './compile_method';
-import {ValueTransformer, visitValue} from '../util';
-
-export class CompileNode {
-  constructor(public parent: CompileElement, public view: CompileView, public nodeIndex: number,
-              public renderNode: o.Expression, public sourceAst: TemplateAst) {}
-
-  isNull(): boolean { return isBlank(this.renderNode); }
-
-  isRootElement(): boolean { return this.view != this.parent.view; }
-}
-
-export class CompileElement extends CompileNode {
-  static createNull(): CompileElement {
-    return new CompileElement(null, null, null, null, null, null, [], [], false, false, []);
-  }
-
-  private _compViewExpr: o.Expression = null;
-  public appElement: o.ReadPropExpr;
-  public elementRef: o.Expression;
-  public injector: o.Expression;
-  private _instances = new CompileTokenMap<o.Expression>();
-  private _resolvedProviders: CompileTokenMap<ProviderAst>;
-
-  private _queryCount = 0;
-  private _queries = new CompileTokenMap<CompileQuery[]>();
-  private _componentConstructorViewQueryLists: o.Expression[] = [];
-
-  public contentNodesByNgContentIndex: Array<o.Expression>[] = null;
-  public embeddedView: CompileView;
-  public directiveInstances: o.Expression[];
-  public referenceTokens: {[key: string]: CompileTokenMetadata};
-
-  constructor(parent: CompileElement, view: CompileView, nodeIndex: number,
-              renderNode: o.Expression, sourceAst: TemplateAst,
-              public component: CompileDirectiveMetadata,
-              private _directives: CompileDirectiveMetadata[],
-              private _resolvedProvidersArray: ProviderAst[], public hasViewContainer: boolean,
-              public hasEmbeddedView: boolean, references: ReferenceAst[]) {
-    super(parent, view, nodeIndex, renderNode, sourceAst);
-    this.referenceTokens = {};
-    references.forEach(ref => this.referenceTokens[ref.name] = ref.value);
-
-    this.elementRef = o.importExpr(Identifiers.ElementRef).instantiate([this.renderNode]);
-    this._instances.add(identifierToken(Identifiers.ElementRef), this.elementRef);
-    this.injector = o.THIS_EXPR.callMethod('injector', [o.literal(this.nodeIndex)]);
-    this._instances.add(identifierToken(Identifiers.Injector), this.injector);
-    this._instances.add(identifierToken(Identifiers.Renderer), o.THIS_EXPR.prop('renderer'));
-    if (this.hasViewContainer || this.hasEmbeddedView || isPresent(this.component)) {
-      this._createAppElement();
-    }
-  }
-
-  private _createAppElement() {
-    var fieldName = `_appEl_${this.nodeIndex}`;
-    var parentNodeIndex = this.isRootElement() ? null : this.parent.nodeIndex;
-    // private is fine here as no child view will reference an AppElement
-    this.view.fields.push(new o.ClassField(fieldName, o.importType(Identifiers.AppElement),
-                                           [o.StmtModifier.Private]));
-    var statement = o.THIS_EXPR.prop(fieldName)
-                        .set(o.importExpr(Identifiers.AppElement)
-                                 .instantiate([
-                                   o.literal(this.nodeIndex),
-                                   o.literal(parentNodeIndex),
-                                   o.THIS_EXPR,
-                                   this.renderNode
-                                 ]))
-                        .toStmt();
-    this.view.createMethod.addStmt(statement);
-    this.appElement = o.THIS_EXPR.prop(fieldName);
-    this._instances.add(identifierToken(Identifiers.AppElement), this.appElement);
-  }
-
-  setComponentView(compViewExpr: o.Expression) {
-    this._compViewExpr = compViewExpr;
-    this.contentNodesByNgContentIndex =
-        ListWrapper.createFixedSize(this.component.template.ngContentSelectors.length);
-    for (var i = 0; i < this.contentNodesByNgContentIndex.length; i++) {
-      this.contentNodesByNgContentIndex[i] = [];
-    }
-  }
-
-  setEmbeddedView(embeddedView: CompileView) {
-    this.embeddedView = embeddedView;
-    if (isPresent(embeddedView)) {
-      var createTemplateRefExpr =
-          o.importExpr(Identifiers.TemplateRef_)
-              .instantiate([this.appElement, this.embeddedView.viewFactory]);
-      var provider = new CompileProviderMetadata(
-          {token: identifierToken(Identifiers.TemplateRef), useValue: createTemplateRefExpr});
-      // Add TemplateRef as first provider as it does not have deps on other providers
-      this._resolvedProvidersArray.unshift(new ProviderAst(provider.token, false, true, [provider],
-                                                           ProviderAstType.Builtin,
-                                                           this.sourceAst.sourceSpan));
-    }
-  }
-
-  beforeChildren(): void {
-    if (this.hasViewContainer) {
-      this._instances.add(identifierToken(Identifiers.ViewContainerRef),
-                          this.appElement.prop('vcRef'));
-    }
-
-    this._resolvedProviders = new CompileTokenMap<ProviderAst>();
-    this._resolvedProvidersArray.forEach(provider =>
-                                             this._resolvedProviders.add(provider.token, provider));
-
-    // create all the provider instances, some in the view constructor,
-    // some as getters. We rely on the fact that they are already sorted topologically.
-    this._resolvedProviders.values().forEach((resolvedProvider) => {
-      var providerValueExpressions = resolvedProvider.providers.map((provider) => {
-        if (isPresent(provider.useExisting)) {
-          return this._getDependency(
-              resolvedProvider.providerType,
-              new CompileDiDependencyMetadata({token: provider.useExisting}));
-        } else if (isPresent(provider.useFactory)) {
-          var deps = isPresent(provider.deps) ? provider.deps : provider.useFactory.diDeps;
-          var depsExpr = deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep));
-          return o.importExpr(provider.useFactory).callFn(depsExpr);
-        } else if (isPresent(provider.useClass)) {
-          var deps = isPresent(provider.deps) ? provider.deps : provider.useClass.diDeps;
-          var depsExpr = deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep));
-          return o.importExpr(provider.useClass)
-              .instantiate(depsExpr, o.importType(provider.useClass));
-        } else {
-          return _convertValueToOutputAst(provider.useValue);
-        }
-      });
-      var propName = `_${resolvedProvider.token.name}_${this.nodeIndex}_${this._instances.size}`;
-      var instance =
-          createProviderProperty(propName, resolvedProvider, providerValueExpressions,
-                                 resolvedProvider.multiProvider, resolvedProvider.eager, this);
-      this._instances.add(resolvedProvider.token, instance);
-    });
-
-    this.directiveInstances =
-        this._directives.map((directive) => this._instances.get(identifierToken(directive.type)));
-    for (var i = 0; i < this.directiveInstances.length; i++) {
-      var directiveInstance = this.directiveInstances[i];
-      var directive = this._directives[i];
-      directive.queries.forEach((queryMeta) => { this._addQuery(queryMeta, directiveInstance); });
-    }
-    var queriesWithReads: _QueryWithRead[] = [];
-    this._resolvedProviders.values().forEach((resolvedProvider) => {
-      var queriesForProvider = this._getQueriesFor(resolvedProvider.token);
-      ListWrapper.addAll(
-          queriesWithReads,
-          queriesForProvider.map(query => new _QueryWithRead(query, resolvedProvider.token)));
-    });
-    StringMapWrapper.forEach(this.referenceTokens, (_, varName) => {
-      var token = this.referenceTokens[varName];
-      var varValue;
-      if (isPresent(token)) {
-        varValue = this._instances.get(token);
-      } else {
-        varValue = this.renderNode;
-      }
-      this.view.locals.set(varName, varValue);
-      var varToken = new CompileTokenMetadata({value: varName});
-      ListWrapper.addAll(queriesWithReads, this._getQueriesFor(varToken)
-                                               .map(query => new _QueryWithRead(query, varToken)));
-    });
-    queriesWithReads.forEach((queryWithRead) => {
-      var value: o.Expression;
-      if (isPresent(queryWithRead.read.identifier)) {
-        // query for an identifier
-        value = this._instances.get(queryWithRead.read);
-      } else {
-        // query for a reference
-        var token = this.referenceTokens[queryWithRead.read.value];
-        if (isPresent(token)) {
-          value = this._instances.get(token);
-        } else {
-          value = this.elementRef;
-        }
-      }
-      if (isPresent(value)) {
-        queryWithRead.query.addValue(value, this.view);
-      }
-    });
-
-    if (isPresent(this.component)) {
-      var componentConstructorViewQueryList =
-          isPresent(this.component) ? o.literalArr(this._componentConstructorViewQueryLists) :
-                                      o.NULL_EXPR;
-      var compExpr = isPresent(this.getComponent()) ? this.getComponent() : o.NULL_EXPR;
-      this.view.createMethod.addStmt(
-          this.appElement.callMethod(
-                             'initComponent',
-                             [compExpr, componentConstructorViewQueryList, this._compViewExpr])
-              .toStmt());
-    }
-  }
-
-  afterChildren(childNodeCount: number) {
-    this._resolvedProviders.values().forEach((resolvedProvider) => {
-      // Note: afterChildren is called after recursing into children.
-      // This is good so that an injector match in an element that is closer to a requesting element
-      // matches first.
-      var providerExpr = this._instances.get(resolvedProvider.token);
-      // Note: view providers are only visible on the injector of that element.
-      // This is not fully correct as the rules during codegen don't allow a directive
-      // to get hold of a view provdier on the same element. We still do this semantic
-      // as it simplifies our model to having only one runtime injector per element.
-      var providerChildNodeCount =
-          resolvedProvider.providerType === ProviderAstType.PrivateService ? 0 : childNodeCount;
-      this.view.injectorGetMethod.addStmt(createInjectInternalCondition(
-          this.nodeIndex, providerChildNodeCount, resolvedProvider, providerExpr));
-    });
-
-    this._queries.values().forEach(
-        (queries) =>
-            queries.forEach((query) => query.afterChildren(this.view.updateContentQueriesMethod)));
-  }
-
-  addContentNode(ngContentIndex: number, nodeExpr: o.Expression) {
-    this.contentNodesByNgContentIndex[ngContentIndex].push(nodeExpr);
-  }
-
-  getComponent(): o.Expression {
-    return isPresent(this.component) ? this._instances.get(identifierToken(this.component.type)) :
-                                       null;
-  }
-
-  getProviderTokens(): o.Expression[] {
-    return this._resolvedProviders.values().map(
-        (resolvedProvider) => createDiTokenExpression(resolvedProvider.token));
-  }
-
-  private _getQueriesFor(token: CompileTokenMetadata): CompileQuery[] {
-    var result: CompileQuery[] = [];
-    var currentEl: CompileElement = this;
-    var distance = 0;
-    var queries: CompileQuery[];
-    while (!currentEl.isNull()) {
-      queries = currentEl._queries.get(token);
-      if (isPresent(queries)) {
-        ListWrapper.addAll(result,
-                           queries.filter((query) => query.meta.descendants || distance <= 1));
-      }
-      if (currentEl._directives.length > 0) {
-        distance++;
-      }
-      currentEl = currentEl.parent;
-    }
-    queries = this.view.componentView.viewQueries.get(token);
-    if (isPresent(queries)) {
-      ListWrapper.addAll(result, queries);
-    }
-    return result;
-  }
-
-  private _addQuery(queryMeta: CompileQueryMetadata,
-                    directiveInstance: o.Expression): CompileQuery {
-    var propName = `_query_${queryMeta.selectors[0].name}_${this.nodeIndex}_${this._queryCount++}`;
-    var queryList = createQueryList(queryMeta, directiveInstance, propName, this.view);
-    var query = new CompileQuery(queryMeta, queryList, directiveInstance, this.view);
-    addQueryToTokenMap(this._queries, query);
-    return query;
-  }
-
-  private _getLocalDependency(requestingProviderType: ProviderAstType,
-                              dep: CompileDiDependencyMetadata): o.Expression {
-    var result = null;
-    // constructor content query
-    if (isBlank(result) && isPresent(dep.query)) {
-      result = this._addQuery(dep.query, null).queryList;
-    }
-
-    // constructor view query
-    if (isBlank(result) && isPresent(dep.viewQuery)) {
-      result = createQueryList(
-          dep.viewQuery, null,
-          `_viewQuery_${dep.viewQuery.selectors[0].name}_${this.nodeIndex}_${this._componentConstructorViewQueryLists.length}`,
-          this.view);
-      this._componentConstructorViewQueryLists.push(result);
-    }
-
-    if (isPresent(dep.token)) {
-      // access builtins with special visibility
-      if (isBlank(result)) {
-        if (dep.token.equalsTo(identifierToken(Identifiers.ChangeDetectorRef))) {
-          if (requestingProviderType === ProviderAstType.Component) {
-            return this._compViewExpr.prop('ref');
-          } else {
-            return getPropertyInView(o.THIS_EXPR.prop('ref'), this.view, this.view.componentView);
-          }
-        }
-      }
-      // access regular providers on the element
-      if (isBlank(result)) {
-        result = this._instances.get(dep.token);
-      }
-    }
-    return result;
-  }
-
-  private _getDependency(requestingProviderType: ProviderAstType,
-                         dep: CompileDiDependencyMetadata): o.Expression {
-    var currElement: CompileElement = this;
-    var result = null;
-    if (dep.isValue) {
-      result = o.literal(dep.value);
-    }
-    if (isBlank(result) && !dep.isSkipSelf) {
-      result = this._getLocalDependency(requestingProviderType, dep);
-    }
-    // check parent elements
-    while (isBlank(result) && !currElement.parent.isNull()) {
-      currElement = currElement.parent;
-      result = currElement._getLocalDependency(ProviderAstType.PublicService,
-                                               new CompileDiDependencyMetadata({token: dep.token}));
-    }
-
-    if (isBlank(result)) {
-      result = injectFromViewParentInjector(dep.token, dep.isOptional);
-    }
-    if (isBlank(result)) {
-      result = o.NULL_EXPR;
-    }
-    return getPropertyInView(result, this.view, currElement.view);
-  }
-}
-
-function createInjectInternalCondition(nodeIndex: number, childNodeCount: number,
-                                       provider: ProviderAst,
-                                       providerExpr: o.Expression): o.Statement {
-  var indexCondition;
-  if (childNodeCount > 0) {
-    indexCondition = o.literal(nodeIndex)
-                         .lowerEquals(InjectMethodVars.requestNodeIndex)
-                         .and(InjectMethodVars.requestNodeIndex.lowerEquals(
-                             o.literal(nodeIndex + childNodeCount)));
-  } else {
-    indexCondition = o.literal(nodeIndex).identical(InjectMethodVars.requestNodeIndex);
-  }
-  return new o.IfStmt(
-      InjectMethodVars.token.identical(createDiTokenExpression(provider.token)).and(indexCondition),
-      [new o.ReturnStatement(providerExpr)]);
-}
-
-function createProviderProperty(propName: string, provider: ProviderAst,
-                                providerValueExpressions: o.Expression[], isMulti: boolean,
-                                isEager: boolean, compileElement: CompileElement): o.Expression {
-  var view = compileElement.view;
-  var resolvedProviderValueExpr;
-  var type;
-  if (isMulti) {
-    resolvedProviderValueExpr = o.literalArr(providerValueExpressions);
-    type = new o.ArrayType(o.DYNAMIC_TYPE);
-  } else {
-    resolvedProviderValueExpr = providerValueExpressions[0];
-    type = providerValueExpressions[0].type;
-  }
-  if (isBlank(type)) {
-    type = o.DYNAMIC_TYPE;
-  }
-  if (isEager) {
-    view.fields.push(new o.ClassField(propName, type));
-    view.createMethod.addStmt(o.THIS_EXPR.prop(propName).set(resolvedProviderValueExpr).toStmt());
-  } else {
-    var internalField = `_${propName}`;
-    view.fields.push(new o.ClassField(internalField, type));
-    var getter = new CompileMethod(view);
-    getter.resetDebugInfo(compileElement.nodeIndex, compileElement.sourceAst);
-    // Note: Equals is important for JS so that it also checks the undefined case!
-    getter.addStmt(
-        new o.IfStmt(o.THIS_EXPR.prop(internalField).isBlank(),
-                     [o.THIS_EXPR.prop(internalField).set(resolvedProviderValueExpr).toStmt()]));
-    getter.addStmt(new o.ReturnStatement(o.THIS_EXPR.prop(internalField)));
-    view.getters.push(new o.ClassGetter(propName, getter.finish(), type));
-  }
-  return o.THIS_EXPR.prop(propName);
-}
-
-class _QueryWithRead {
-  public read: CompileTokenMetadata;
-  constructor(public query: CompileQuery, match: CompileTokenMetadata) {
-    this.read = isPresent(query.meta.read) ? query.meta.read : match;
-  }
-}
-
-function _convertValueToOutputAst(value: any): o.Expression {
-  return visitValue(value, new _ValueOutputAstTransformer(), null);
-}
-
-class _ValueOutputAstTransformer extends ValueTransformer {
-  visitArray(arr: any[], context: any): o.Expression {
-    return o.literalArr(arr.map(value => visitValue(value, this, context)));
-  }
-  visitStringMap(map: {[key: string]: any}, context: any): o.Expression {
-    var entries = [];
-    StringMapWrapper.forEach(
-        map, (value, key) => { entries.push([key, visitValue(value, this, context)]); });
-    return o.literalMap(entries);
-  }
-  visitPrimitive(value: any, context: any): o.Expression { return o.literal(value); }
-  visitOther(value: any, context: any): o.Expression {
-    if (value instanceof CompileIdentifierMetadata) {
-      return o.importExpr(value);
-    } else if (value instanceof o.Expression) {
-      return value;
-    } else {
-      throw new BaseException(`Illegal state: Don't now how to compile value ${value}`);
-    }
-  }
-}
--- a/modules/@angular/compiler/src/view_compiler/compile_method.ts
+++ b/modules/@angular/compiler/src/view_compiler/compile_method.ts
@ -1,75 +0,0 @@
-import {isPresent} from '../../src/facade/lang';
-import {ListWrapper} from '../../src/facade/collection';
-
-import * as o from '../output/output_ast';
-import {TemplateAst} from '../template_ast';
-
-import {CompileView} from './compile_view';
-
-class _DebugState {
-  constructor(public nodeIndex: number, public sourceAst: TemplateAst) {}
-}
-
-var NULL_DEBUG_STATE = new _DebugState(null, null);
-
-export class CompileMethod {
-  private _newState: _DebugState = NULL_DEBUG_STATE;
-  private _currState: _DebugState = NULL_DEBUG_STATE;
-
-  private _debugEnabled: boolean;
-
-  private _bodyStatements: o.Statement[] = [];
-
-  constructor(private _view: CompileView) {
-    this._debugEnabled = this._view.genConfig.genDebugInfo;
-  }
-
-  private _updateDebugContextIfNeeded() {
-    if (this._newState.nodeIndex !== this._currState.nodeIndex ||
-        this._newState.sourceAst !== this._currState.sourceAst) {
-      var expr = this._updateDebugContext(this._newState);
-      if (isPresent(expr)) {
-        this._bodyStatements.push(expr.toStmt());
-      }
-    }
-  }
-
-  private _updateDebugContext(newState: _DebugState): o.Expression {
-    this._currState = this._newState = newState;
-    if (this._debugEnabled) {
-      var sourceLocation =
-          isPresent(newState.sourceAst) ? newState.sourceAst.sourceSpan.start : null;
-
-      return o.THIS_EXPR.callMethod('debug', [
-        o.literal(newState.nodeIndex),
-        isPresent(sourceLocation) ? o.literal(sourceLocation.line) : o.NULL_EXPR,
-        isPresent(sourceLocation) ? o.literal(sourceLocation.col) : o.NULL_EXPR
-      ]);
-    } else {
-      return null;
-    }
-  }
-
-  resetDebugInfoExpr(nodeIndex: number, templateAst: TemplateAst): o.Expression {
-    var res = this._updateDebugContext(new _DebugState(nodeIndex, templateAst));
-    return isPresent(res) ? res : o.NULL_EXPR;
-  }
-
-  resetDebugInfo(nodeIndex: number, templateAst: TemplateAst) {
-    this._newState = new _DebugState(nodeIndex, templateAst);
-  }
-
-  addStmt(stmt: o.Statement) {
-    this._updateDebugContextIfNeeded();
-    this._bodyStatements.push(stmt);
-  }
-
-  addStmts(stmts: o.Statement[]) {
-    this._updateDebugContextIfNeeded();
-    ListWrapper.addAll(this._bodyStatements, stmts);
-  }
-
-  finish(): o.Statement[] { return this._bodyStatements; }
-
-  isEmpty(): boolean { return this._bodyStatements.length === 0; }
-}
--- a/modules/@angular/compiler/src/view_compiler/compile_pipe.ts
+++ b/modules/@angular/compiler/src/view_compiler/compile_pipe.ts
@ -1,75 +0,0 @@
-import {isBlank, isPresent} from '../facade/lang';
-import {BaseException} from '../facade/exceptions';
-import * as o from '../output/output_ast';
-import {CompileView} from './compile_view';
-import {CompilePipeMetadata} from '../compile_metadata';
-import {Identifiers, identifierToken} from '../identifiers';
-import {injectFromViewParentInjector, createPureProxy, getPropertyInView} from './util';
-
-class _PurePipeProxy {
-  constructor(public instance: o.ReadPropExpr, public argCount: number) {}
-}
-
-export class CompilePipe {
-  meta: CompilePipeMetadata;
-  instance: o.ReadPropExpr;
-  private _purePipeProxies: _PurePipeProxy[] = [];
-
-  constructor(public view: CompileView, name: string) {
-    this.meta = _findPipeMeta(view, name);
-    this.instance = o.THIS_EXPR.prop(`_pipe_${name}_${view.pipeCount++}`);
-  }
-
-  get pure(): boolean { return this.meta.pure; }
-
-  create(): void {
-    var deps = this.meta.type.diDeps.map((diDep) => {
-      if (diDep.token.equalsTo(identifierToken(Identifiers.ChangeDetectorRef))) {
-        return getPropertyInView(o.THIS_EXPR.prop('ref'), this.view, this.view.componentView);
-      }
-      return injectFromViewParentInjector(diDep.token, false);
-    });
-    this.view.fields.push(new o.ClassField(this.instance.name, o.importType(this.meta.type)));
-    this.view.createMethod.resetDebugInfo(null, null);
-    this.view.createMethod.addStmt(o.THIS_EXPR.prop(this.instance.name)
-                                       .set(o.importExpr(this.meta.type).instantiate(deps))
-                                       .toStmt());
-    this._purePipeProxies.forEach((purePipeProxy) => {
-      createPureProxy(
-          this.instance.prop('transform').callMethod(o.BuiltinMethod.bind, [this.instance]),
-          purePipeProxy.argCount, purePipeProxy.instance, this.view);
-    });
-  }
-
-  call(callingView: CompileView, args: o.Expression[]): o.Expression {
-    if (this.meta.pure) {
-      var purePipeProxy = new _PurePipeProxy(
-          o.THIS_EXPR.prop(`${this.instance.name}_${this._purePipeProxies.length}`), args.length);
-      this._purePipeProxies.push(purePipeProxy);
-      return getPropertyInView(
-                 o.importExpr(Identifiers.castByValue)
-                     .callFn([purePipeProxy.instance, this.instance.prop('transform')]),
-                 callingView, this.view)
-          .callFn(args);
-    } else {
-      return getPropertyInView(this.instance, callingView, this.view).callMethod('transform', args);
-    }
-  }
-}
-
-
-function _findPipeMeta(view: CompileView, name: string): CompilePipeMetadata {
-  var pipeMeta: CompilePipeMetadata = null;
-  for (var i = view.pipeMetas.length - 1; i >= 0; i--) {
-    var localPipeMeta = view.pipeMetas[i];
-    if (localPipeMeta.name == name) {
-      pipeMeta = localPipeMeta;
-      break;
-    }
-  }
-  if (isBlank(pipeMeta)) {
-    throw new BaseException(
-        `Illegal state: Could not find pipe ${name} although the parser should have detected this error!`);
-  }
-  return pipeMeta;
-}
--- a/modules/@angular/compiler/src/view_compiler/compile_query.ts
+++ b/modules/@angular/compiler/src/view_compiler/compile_query.ts
@ -1,113 +0,0 @@
-import {isPresent, isBlank} from '../../src/facade/lang';
-import {ListWrapper} from '../../src/facade/collection';
-
-import * as o from '../output/output_ast';
-import {Identifiers} from '../identifiers';
-
-import {CompileQueryMetadata, CompileTokenMap} from '../compile_metadata';
-
-import {CompileView} from './compile_view';
-import {CompileElement} from './compile_element';
-import {CompileMethod} from './compile_method';
-import {getPropertyInView} from './util';
-
-class ViewQueryValues {
-  constructor(public view: CompileView, public values: Array<o.Expression | ViewQueryValues>) {}
-}
-
-export class CompileQuery {
-  private _values: ViewQueryValues;
-
-  constructor(public meta: CompileQueryMetadata, public queryList: o.Expression,
-              public ownerDirectiveExpression: o.Expression, public view: CompileView) {
-    this._values = new ViewQueryValues(view, []);
-  }
-
-  addValue(value: o.Expression, view: CompileView) {
-    var currentView = view;
-    var elPath: CompileElement[] = [];
-    while (isPresent(currentView) && currentView !== this.view) {
-      var parentEl = currentView.declarationElement;
-      elPath.unshift(parentEl);
-      currentView = parentEl.view;
-    }
-    var queryListForDirtyExpr = getPropertyInView(this.queryList, view, this.view);
-
-    var viewValues = this._values;
-    elPath.forEach((el) => {
-      var last =
-          viewValues.values.length > 0 ? viewValues.values[viewValues.values.length - 1] : null;
-      if (last instanceof ViewQueryValues && last.view === el.embeddedView) {
-        viewValues = last;
-      } else {
-        var newViewValues = new ViewQueryValues(el.embeddedView, []);
-        viewValues.values.push(newViewValues);
-        viewValues = newViewValues;
-      }
-    });
-    viewValues.values.push(value);
-
-    if (elPath.length > 0) {
-      view.dirtyParentQueriesMethod.addStmt(
-          queryListForDirtyExpr.callMethod('setDirty', []).toStmt());
-    }
-  }
-
-  afterChildren(targetMethod: CompileMethod) {
-    var values = createQueryValues(this._values);
-    var updateStmts = [this.queryList.callMethod('reset', [o.literalArr(values)]).toStmt()];
-    if (isPresent(this.ownerDirectiveExpression)) {
-      var valueExpr = this.meta.first ? this.queryList.prop('first') : this.queryList;
-      updateStmts.push(
-          this.ownerDirectiveExpression.prop(this.meta.propertyName).set(valueExpr).toStmt());
-    }
-    if (!this.meta.first) {
-      updateStmts.push(this.queryList.callMethod('notifyOnChanges', []).toStmt());
-    }
-    targetMethod.addStmt(new o.IfStmt(this.queryList.prop('dirty'), updateStmts));
-  }
-}
-
-function createQueryValues(viewValues: ViewQueryValues): o.Expression[] {
-  return ListWrapper.flatten(viewValues.values.map((entry) => {
-    if (entry instanceof ViewQueryValues) {
-      return mapNestedViews(entry.view.declarationElement.appElement, entry.view,
-                            createQueryValues(entry));
-    } else {
-      return <o.Expression>entry;
-    }
-  }));
-}
-
-function mapNestedViews(declarationAppElement: o.Expression, view: CompileView,
-                        expressions: o.Expression[]): o.Expression {
-  var adjustedExpressions: o.Expression[] = expressions.map((expr) => {
-    return o.replaceVarInExpression(o.THIS_EXPR.name, o.variable('nestedView'), expr);
-  });
-  return declarationAppElement.callMethod('mapNestedViews', [
-    o.variable(view.className),
-    o.fn([new o.FnParam('nestedView', view.classType)],
-         [new o.ReturnStatement(o.literalArr(adjustedExpressions))])
-  ]);
-}
-
-export function createQueryList(query: CompileQueryMetadata, directiveInstance: o.Expression,
-                                propertyName: string, compileView: CompileView): o.Expression {
-  compileView.fields.push(new o.ClassField(propertyName, o.importType(Identifiers.QueryList)));
-  var expr = o.THIS_EXPR.prop(propertyName);
-  compileView.createMethod.addStmt(o.THIS_EXPR.prop(propertyName)
-                                       .set(o.importExpr(Identifiers.QueryList).instantiate([]))
-                                       .toStmt());
-  return expr;
-}
-
-export function addQueryToTokenMap(map: CompileTokenMap<CompileQuery[]>, query: CompileQuery) {
-  query.meta.selectors.forEach((selector) => {
-    var entry = map.get(selector);
-    if (isBlank(entry)) {
-      entry = [];
-      map.add(selector, entry);
-    }
-    entry.push(query);
-  });
-}
--- a/modules/@angular/compiler/src/view_compiler/compile_view.ts
+++ b/modules/@angular/compiler/src/view_compiler/compile_view.ts
@ -1,210 +0,0 @@
-import {ViewType} from '../../core_private';
-
-import {isPresent, isBlank} from '../../src/facade/lang';
-import {ListWrapper} from '../../src/facade/collection';
-
-import * as o from '../output/output_ast';
-import {EventHandlerVars} from './constants';
-import {CompileQuery, createQueryList, addQueryToTokenMap} from './compile_query';
-import {NameResolver} from './expression_converter';
-import {CompileElement, CompileNode} from './compile_element';
-import {CompileMethod} from './compile_method';
-import {CompilePipe} from './compile_pipe';
-import {
-  CompileDirectiveMetadata,
-  CompilePipeMetadata,
-  CompileIdentifierMetadata,
-  CompileTokenMap
-} from '../compile_metadata';
-import {
-  getViewFactoryName,
-  injectFromViewParentInjector,
-  createDiTokenExpression,
-  getPropertyInView,
-  createPureProxy
-} from './util';
-import {CompilerConfig} from '../config';
-import {CompileBinding} from './compile_binding';
-import {Identifiers} from '../identifiers';
-
-export class CompileView implements NameResolver {
-  public viewType: ViewType;
-  public viewQueries: CompileTokenMap<CompileQuery[]>;
-
-  public nodes: CompileNode[] = [];
-  // root nodes or AppElements for ViewContainers
-  public rootNodesOrAppElements: o.Expression[] = [];
-
-  public bindings: CompileBinding[] = [];
-
-  public classStatements: o.Statement[] = [];
-  public createMethod: CompileMethod;
-  public injectorGetMethod: CompileMethod;
-  public updateContentQueriesMethod: CompileMethod;
-  public dirtyParentQueriesMethod: CompileMethod;
-  public updateViewQueriesMethod: CompileMethod;
-  public detectChangesInInputsMethod: CompileMethod;
-  public detectChangesRenderPropertiesMethod: CompileMethod;
-  public afterContentLifecycleCallbacksMethod: CompileMethod;
-  public afterViewLifecycleCallbacksMethod: CompileMethod;
-  public destroyMethod: CompileMethod;
-  public eventHandlerMethods: o.ClassMethod[] = [];
-
-  public fields: o.ClassField[] = [];
-  public getters: o.ClassGetter[] = [];
-  public disposables: o.Expression[] = [];
-  public subscriptions: o.Expression[] = [];
-
-  public componentView: CompileView;
-  public purePipes = new Map<string, CompilePipe>();
-  public pipes: CompilePipe[] = [];
-  public locals = new Map<string, o.Expression>();
-  public className: string;
-  public classType: o.Type;
-  public viewFactory: o.ReadVarExpr;
-
-  public literalArrayCount = 0;
-  public literalMapCount = 0;
-  public pipeCount = 0;
-
-  public componentContext: o.Expression;
-
-  constructor(public component: CompileDirectiveMetadata, public genConfig: CompilerConfig,
-              public pipeMetas: CompilePipeMetadata[], public styles: o.Expression,
-              public viewIndex: number, public declarationElement: CompileElement,
-              public templateVariableBindings: string[][]) {
-    this.createMethod = new CompileMethod(this);
-    this.injectorGetMethod = new CompileMethod(this);
-    this.updateContentQueriesMethod = new CompileMethod(this);
-    this.dirtyParentQueriesMethod = new CompileMethod(this);
-    this.updateViewQueriesMethod = new CompileMethod(this);
-    this.detectChangesInInputsMethod = new CompileMethod(this);
-    this.detectChangesRenderPropertiesMethod = new CompileMethod(this);
-
-    this.afterContentLifecycleCallbacksMethod = new CompileMethod(this);
-    this.afterViewLifecycleCallbacksMethod = new CompileMethod(this);
-    this.destroyMethod = new CompileMethod(this);
-
-    this.viewType = getViewType(component, viewIndex);
-    this.className = `_View_${component.type.name}${viewIndex}`;
-    this.classType = o.importType(new CompileIdentifierMetadata({name: this.className}));
-    this.viewFactory = o.variable(getViewFactoryName(component, viewIndex));
-    if (this.viewType === ViewType.COMPONENT || this.viewType === ViewType.HOST) {
-      this.componentView = this;
-    } else {
-      this.componentView = this.declarationElement.view.componentView;
-    }
-    this.componentContext =
-        getPropertyInView(o.THIS_EXPR.prop('context'), this, this.componentView);
-
-    var viewQueries = new CompileTokenMap<CompileQuery[]>();
-    if (this.viewType === ViewType.COMPONENT) {
-      var directiveInstance = o.THIS_EXPR.prop('context');
-      ListWrapper.forEachWithIndex(this.component.viewQueries, (queryMeta, queryIndex) => {
-        var propName = `_viewQuery_${queryMeta.selectors[0].name}_${queryIndex}`;
-        var queryList = createQueryList(queryMeta, directiveInstance, propName, this);
-        var query = new CompileQuery(queryMeta, queryList, directiveInstance, this);
-        addQueryToTokenMap(viewQueries, query);
-      });
-      var constructorViewQueryCount = 0;
-      this.component.type.diDeps.forEach((dep) => {
-        if (isPresent(dep.viewQuery)) {
-          var queryList = o.THIS_EXPR.prop('declarationAppElement')
-                              .prop('componentConstructorViewQueries')
-                              .key(o.literal(constructorViewQueryCount++));
-          var query = new CompileQuery(dep.viewQuery, queryList, null, this);
-          addQueryToTokenMap(viewQueries, query);
-        }
-      });
-    }
-    this.viewQueries = viewQueries;
-    templateVariableBindings.forEach(
-        (entry) => { this.locals.set(entry[1], o.THIS_EXPR.prop('context').prop(entry[0])); });
-
-    if (!this.declarationElement.isNull()) {
-      this.declarationElement.setEmbeddedView(this);
-    }
-  }
-
-  callPipe(name: string, input: o.Expression, args: o.Expression[]): o.Expression {
-    var compView = this.componentView;
-    var pipe = compView.purePipes.get(name);
-    if (isBlank(pipe)) {
-      pipe = new CompilePipe(compView, name);
-      if (pipe.pure) {
-        compView.purePipes.set(name, pipe);
-      }
-      compView.pipes.push(pipe);
-    }
-    return pipe.call(this, [input].concat(args));
-  }
-
-  getLocal(name: string): o.Expression {
-    if (name == EventHandlerVars.event.name) {
-      return EventHandlerVars.event;
-    }
-    var currView: CompileView = this;
-    var result = currView.locals.get(name);
-    while (isBlank(result) && isPresent(currView.declarationElement.view)) {
-      currView = currView.declarationElement.view;
-      result = currView.locals.get(name);
-    }
-    if (isPresent(result)) {
-      return getPropertyInView(result, this, currView);
-    } else {
-      return null;
-    }
-  }
-
-  createLiteralArray(values: o.Expression[]): o.Expression {
-    if (values.length === 0) {
-      return o.importExpr(Identifiers.EMPTY_ARRAY);
-    }
-    var proxyExpr = o.THIS_EXPR.prop(`_arr_${this.literalArrayCount++}`);
-    var proxyParams: o.FnParam[] = [];
-    var proxyReturnEntries: o.Expression[] = [];
-    for (var i = 0; i < values.length; i++) {
-      var paramName = `p${i}`;
-      proxyParams.push(new o.FnParam(paramName));
-      proxyReturnEntries.push(o.variable(paramName));
-    }
-    createPureProxy(o.fn(proxyParams, [new o.ReturnStatement(o.literalArr(proxyReturnEntries))]),
-                    values.length, proxyExpr, this);
-    return proxyExpr.callFn(values);
-  }
-
-  createLiteralMap(entries: Array<Array<string | o.Expression>>): o.Expression {
-    if (entries.length === 0) {
-      return o.importExpr(Identifiers.EMPTY_MAP);
-    }
-    var proxyExpr = o.THIS_EXPR.prop(`_map_${this.literalMapCount++}`);
-    var proxyParams: o.FnParam[] = [];
-    var proxyReturnEntries: Array<Array<string | o.Expression>> = [];
-    var values: o.Expression[] = [];
-    for (var i = 0; i < entries.length; i++) {
-      var paramName = `p${i}`;
-      proxyParams.push(new o.FnParam(paramName));
-      proxyReturnEntries.push([entries[i][0], o.variable(paramName)]);
-      values.push(<o.Expression>entries[i][1]);
-    }
-    createPureProxy(o.fn(proxyParams, [new o.ReturnStatement(o.literalMap(proxyReturnEntries))]),
-                    entries.length, proxyExpr, this);
-    return proxyExpr.callFn(values);
-  }
-
-  afterNodes() {
-    this.pipes.forEach((pipe) => pipe.create());
-    this.viewQueries.values().forEach(
-        (queries) => queries.forEach((query) => query.afterChildren(this.updateViewQueriesMethod)));
-  }
-}
-
-function getViewType(component: CompileDirectiveMetadata, embeddedTemplateIndex: number): ViewType {
-  if (embeddedTemplateIndex > 0) {
-    return ViewType.EMBEDDED;
-  } else if (component.type.isHost) {
-    return ViewType.HOST;
-  } else {
-    return ViewType.COMPONENT;
-  }
-}
--- a/modules/@angular/compiler/src/view_compiler/constants.ts
+++ b/modules/@angular/compiler/src/view_compiler/constants.ts
@ -1,83 +0,0 @@
-import {ChangeDetectionStrategy, ViewEncapsulation} from '@angular/core';
-import {ChangeDetectorState, ViewType} from '../../core_private';
-
-import {isBlank, resolveEnumToken} from '../../src/facade/lang';
-import {CompileIdentifierMetadata} from '../compile_metadata';
-import * as o from '../output/output_ast';
-import {Identifiers} from '../identifiers';
-
-function _enumExpression(classIdentifier: CompileIdentifierMetadata, value: any): o.Expression {
-  if (isBlank(value)) return o.NULL_EXPR;
-  var name = resolveEnumToken(classIdentifier.runtime, value);
-  return o.importExpr(new CompileIdentifierMetadata({
-    name: `${classIdentifier.name}.${name}`,
-    moduleUrl: classIdentifier.moduleUrl,
-    runtime: value
-  }));
-}
-
-export class ViewTypeEnum {
-  static fromValue(value: ViewType): o.Expression {
-    return _enumExpression(Identifiers.ViewType, value);
-  }
-  static HOST = ViewTypeEnum.fromValue(ViewType.HOST);
-  static COMPONENT = ViewTypeEnum.fromValue(ViewType.COMPONENT);
-  static EMBEDDED = ViewTypeEnum.fromValue(ViewType.EMBEDDED);
-}
-
-export class ViewEncapsulationEnum {
-  static fromValue(value: ViewEncapsulation): o.Expression {
-    return _enumExpression(Identifiers.ViewEncapsulation, value);
-  }
-  static Emulated = ViewEncapsulationEnum.fromValue(ViewEncapsulation.Emulated);
-  static Native = ViewEncapsulationEnum.fromValue(ViewEncapsulation.Native);
-  static None = ViewEncapsulationEnum.fromValue(ViewEncapsulation.None);
-}
-
-export class ChangeDetectorStateEnum {
-  static fromValue(value: ChangeDetectorState): o.Expression {
-    return _enumExpression(Identifiers.ChangeDetectorState, value);
-  }
-  static NeverChecked = ChangeDetectorStateEnum.fromValue(ChangeDetectorState.NeverChecked);
-  static CheckedBefore = ChangeDetectorStateEnum.fromValue(ChangeDetectorState.CheckedBefore);
-  static Errored = ChangeDetectorStateEnum.fromValue(ChangeDetectorState.Errored);
-}
-
-export class ChangeDetectionStrategyEnum {
-  static fromValue(value: ChangeDetectionStrategy): o.Expression {
-    return _enumExpression(Identifiers.ChangeDetectionStrategy, value);
-  }
-  static CheckOnce = ChangeDetectionStrategyEnum.fromValue(ChangeDetectionStrategy.CheckOnce);
-  static Checked = ChangeDetectionStrategyEnum.fromValue(ChangeDetectionStrategy.Checked);
-  static CheckAlways = ChangeDetectionStrategyEnum.fromValue(ChangeDetectionStrategy.CheckAlways);
-  static Detached = ChangeDetectionStrategyEnum.fromValue(ChangeDetectionStrategy.Detached);
-  static OnPush = ChangeDetectionStrategyEnum.fromValue(ChangeDetectionStrategy.OnPush);
-  static Default = ChangeDetectionStrategyEnum.fromValue(ChangeDetectionStrategy.Default);
-}
-
-export class ViewConstructorVars {
-  static viewUtils = o.variable('viewUtils');
-  static parentInjector = o.variable('parentInjector');
-  static declarationEl = o.variable('declarationEl');
-}
-
-export class ViewProperties {
-  static renderer = o.THIS_EXPR.prop('renderer');
-  static projectableNodes = o.THIS_EXPR.prop('projectableNodes');
-  static viewUtils = o.THIS_EXPR.prop('viewUtils');
-}
-
-export class EventHandlerVars { static event = o.variable('$event'); }
-
-export class InjectMethodVars {
-  static token = o.variable('token');
-  static requestNodeIndex = o.variable('requestNodeIndex');
-  static notFoundResult = o.variable('notFoundResult');
-}
-
-export class DetectChangesVars {
-  static throwOnChange = o.variable(`throwOnChange`);
-  static changes = o.variable(`changes`);
-  static changed = o.variable(`changed`);
-  static valUnwrapper = o.variable(`valUnwrapper`);
-}
--- a/modules/@angular/compiler/src/view_compiler/event_binder.ts
+++ b/modules/@angular/compiler/src/view_compiler/event_binder.ts
@ -1,164 +0,0 @@
-import {isBlank, isPresent, StringWrapper} from '../../src/facade/lang';
-import {ListWrapper, StringMapWrapper} from '../../src/facade/collection';
-
-import {EventHandlerVars, ViewProperties} from './constants';
-
-import * as o from '../output/output_ast';
-import {CompileElement} from './compile_element';
-import {CompileMethod} from './compile_method';
-
-import {BoundEventAst, DirectiveAst} from '../template_ast';
-import {CompileDirectiveMetadata} from '../compile_metadata';
-
-import {convertCdStatementToIr} from './expression_converter';
-import {CompileBinding} from './compile_binding';
-
-export class CompileEventListener {
-  private _method: CompileMethod;
-  private _hasComponentHostListener: boolean = false;
-  private _methodName: string;
-  private _eventParam: o.FnParam;
-  private _actionResultExprs: o.Expression[] = [];
-
-  static getOrCreate(compileElement: CompileElement, eventTarget: string, eventName: string,
-                     targetEventListeners: CompileEventListener[]): CompileEventListener {
-    var listener = targetEventListeners.find(listener => listener.eventTarget == eventTarget &&
-                                                         listener.eventName == eventName);
-    if (isBlank(listener)) {
-      listener = new CompileEventListener(compileElement, eventTarget, eventName,
-                                          targetEventListeners.length);
-      targetEventListeners.push(listener);
-    }
-    return listener;
-  }
-
-  constructor(public compileElement: CompileElement, public eventTarget: string,
-              public eventName: string, listenerIndex: number) {
-    this._method = new CompileMethod(compileElement.view);
-    this._methodName =
-        `_handle_${santitizeEventName(eventName)}_${compileElement.nodeIndex}_${listenerIndex}`;
-    this._eventParam =
-        new o.FnParam(EventHandlerVars.event.name,
-                      o.importType(this.compileElement.view.genConfig.renderTypes.renderEvent));
-  }
-
-  addAction(hostEvent: BoundEventAst, directive: CompileDirectiveMetadata,
-            directiveInstance: o.Expression) {
-    if (isPresent(directive) && directive.isComponent) {
-      this._hasComponentHostListener = true;
-    }
-    this._method.resetDebugInfo(this.compileElement.nodeIndex, hostEvent);
-    var context = isPresent(directiveInstance) ? directiveInstance :
-                                                 this.compileElement.view.componentContext;
-    var actionStmts = convertCdStatementToIr(this.compileElement.view, context, hostEvent.handler);
-    var lastIndex = actionStmts.length - 1;
-    if (lastIndex >= 0) {
-      var lastStatement = actionStmts[lastIndex];
-      var returnExpr = convertStmtIntoExpression(lastStatement);
-      var preventDefaultVar = o.variable(`pd_${this._actionResultExprs.length}`);
-      this._actionResultExprs.push(preventDefaultVar);
-      if (isPresent(returnExpr)) {
-        // Note: We need to cast the result of the method call to dynamic,
-        // as it might be a void method!
-        actionStmts[lastIndex] =
-            preventDefaultVar.set(returnExpr.cast(o.DYNAMIC_TYPE).notIdentical(o.literal(false)))
-                .toDeclStmt(null, [o.StmtModifier.Final]);
-      }
-    }
-    this._method.addStmts(actionStmts);
-  }
-
-  finishMethod() {
-    var markPathToRootStart = this._hasComponentHostListener ?
-                                  this.compileElement.appElement.prop('componentView') :
-                                  o.THIS_EXPR;
-    var resultExpr: o.Expression = o.literal(true);
-    this._actionResultExprs.forEach((expr) => { resultExpr = resultExpr.and(expr); });
-    var stmts =
-        (<o.Statement[]>[markPathToRootStart.callMethod('markPathToRootAsCheckOnce', []).toStmt()])
-            .concat(this._method.finish())
-            .concat([new o.ReturnStatement(resultExpr)]);
-    // private is fine here as no child view will reference the event handler...
-    this.compileElement.view.eventHandlerMethods.push(new o.ClassMethod(
-        this._methodName, [this._eventParam], stmts, o.BOOL_TYPE, [o.StmtModifier.Private]));
-  }
-
-  listenToRenderer() {
-    var listenExpr;
-    var eventListener = o.THIS_EXPR.callMethod(
-        'eventHandler',
-        [o.THIS_EXPR.prop(this._methodName).callMethod(o.BuiltinMethod.bind, [o.THIS_EXPR])]);
-    if (isPresent(this.eventTarget)) {
-      listenExpr = ViewProperties.renderer.callMethod(
-          'listenGlobal', [o.literal(this.eventTarget), o.literal(this.eventName), eventListener]);
-    } else {
-      listenExpr = ViewProperties.renderer.callMethod(
-          'listen', [this.compileElement.renderNode, o.literal(this.eventName), eventListener]);
-    }
-    var disposable = o.variable(`disposable_${this.compileElement.view.disposables.length}`);
-    this.compileElement.view.disposables.push(disposable);
-    // private is fine here as no child view will reference the event handler...
-    this.compileElement.view.createMethod.addStmt(
-        disposable.set(listenExpr).toDeclStmt(o.FUNCTION_TYPE, [o.StmtModifier.Private]));
-  }
-
-  listenToDirective(directiveInstance: o.Expression, observablePropName: string) {
-    var subscription = o.variable(`subscription_${this.compileElement.view.subscriptions.length}`);
-    this.compileElement.view.subscriptions.push(subscription);
-    var eventListener = o.THIS_EXPR.callMethod(
-        'eventHandler',
-        [o.THIS_EXPR.prop(this._methodName).callMethod(o.BuiltinMethod.bind, [o.THIS_EXPR])]);
-    this.compileElement.view.createMethod.addStmt(
-        subscription.set(directiveInstance.prop(observablePropName)
-                             .callMethod(o.BuiltinMethod.SubscribeObservable, [eventListener]))
-            .toDeclStmt(null, [o.StmtModifier.Final]));
-  }
-}
-
-export function collectEventListeners(hostEvents: BoundEventAst[], dirs: DirectiveAst[],
-                                      compileElement: CompileElement): CompileEventListener[] {
-  var eventListeners: CompileEventListener[] = [];
-  hostEvents.forEach((hostEvent) => {
-    compileElement.view.bindings.push(new CompileBinding(compileElement, hostEvent));
-    var listener = CompileEventListener.getOrCreate(compileElement, hostEvent.target,
-                                                    hostEvent.name, eventListeners);
-    listener.addAction(hostEvent, null, null);
-  });
-  ListWrapper.forEachWithIndex(dirs, (directiveAst, i) => {
-    var directiveInstance = compileElement.directiveInstances[i];
-    directiveAst.hostEvents.forEach((hostEvent) => {
-      compileElement.view.bindings.push(new CompileBinding(compileElement, hostEvent));
-      var listener = CompileEventListener.getOrCreate(compileElement, hostEvent.target,
-                                                      hostEvent.name, eventListeners);
-      listener.addAction(hostEvent, directiveAst.directive, directiveInstance);
-    });
-  });
-  eventListeners.forEach((listener) => listener.finishMethod());
-  return eventListeners;
-}
-
-export function bindDirectiveOutputs(directiveAst: DirectiveAst, directiveInstance: o.Expression,
-                                     eventListeners: CompileEventListener[]) {
-  StringMapWrapper.forEach(directiveAst.directive.outputs, (eventName, observablePropName) => {
-    eventListeners.filter(listener => listener.eventName == eventName)
-        .forEach(
-            (listener) => { listener.listenToDirective(directiveInstance, observablePropName); });
-  });
-}
-
-export function bindRenderOutputs(eventListeners: CompileEventListener[]) {
-  eventListeners.forEach(listener => listener.listenToRenderer());
-}
-
-function convertStmtIntoExpression(stmt: o.Statement): o.Expression {
-  if (stmt instanceof o.ExpressionStatement) {
-    return stmt.expr;
-  } else if (stmt instanceof o.ReturnStatement) {
-    return stmt.value;
-  }
-  return null;
-}
-
-function santitizeEventName(name: string): string {
-  return StringWrapper.replaceAll(name, /[^a-zA-Z_]/g, '_');
-}
--- a/modules/@angular/compiler/src/view_compiler/expression_converter.ts
+++ b/modules/@angular/compiler/src/view_compiler/expression_converter.ts
@ -1,252 +0,0 @@
-import {BaseException} from '../../src/facade/exceptions';
-import {isBlank, isPresent, isArray} from '../../src/facade/lang';
-
-import * as cdAst from '../expression_parser/ast';
-import * as o from '../output/output_ast';
-import {Identifiers} from '../identifiers';
-
-var IMPLICIT_RECEIVER = o.variable('#implicit');
-
-export interface NameResolver {
-  callPipe(name: string, input: o.Expression, args: o.Expression[]): o.Expression;
-  getLocal(name: string): o.Expression;
-  createLiteralArray(values: o.Expression[]): o.Expression;
-  createLiteralMap(values: Array<Array<string | o.Expression>>): o.Expression;
-}
-
-export class ExpressionWithWrappedValueInfo {
-  constructor(public expression: o.Expression, public needsValueUnwrapper: boolean) {}
-}
-
-export function convertCdExpressionToIr(
-    nameResolver: NameResolver, implicitReceiver: o.Expression, expression: cdAst.AST,
-    valueUnwrapper: o.ReadVarExpr): ExpressionWithWrappedValueInfo {
-  var visitor = new _AstToIrVisitor(nameResolver, implicitReceiver, valueUnwrapper);
-  var irAst: o.Expression = expression.visit(visitor, _Mode.Expression);
-  return new ExpressionWithWrappedValueInfo(irAst, visitor.needsValueUnwrapper);
-}
-
-export function convertCdStatementToIr(nameResolver: NameResolver, implicitReceiver: o.Expression,
-                                       stmt: cdAst.AST): o.Statement[] {
-  var visitor = new _AstToIrVisitor(nameResolver, implicitReceiver, null);
-  var statements = [];
-  flattenStatements(stmt.visit(visitor, _Mode.Statement), statements);
-  return statements;
-}
-
-enum _Mode {
-  Statement,
-  Expression
-}
-
-function ensureStatementMode(mode: _Mode, ast: cdAst.AST) {
-  if (mode !== _Mode.Statement) {
-    throw new BaseException(`Expected a statement, but saw ${ast}`);
-  }
-}
-
-function ensureExpressionMode(mode: _Mode, ast: cdAst.AST) {
-  if (mode !== _Mode.Expression) {
-    throw new BaseException(`Expected an expression, but saw ${ast}`);
-  }
-}
-
-function convertToStatementIfNeeded(mode: _Mode, expr: o.Expression): o.Expression | o.Statement {
-  if (mode === _Mode.Statement) {
-    return expr.toStmt();
-  } else {
-    return expr;
-  }
-}
-
-class _AstToIrVisitor implements cdAst.AstVisitor {
-  public needsValueUnwrapper: boolean = false;
-
-  constructor(private _nameResolver: NameResolver, private _implicitReceiver: o.Expression,
-              private _valueUnwrapper: o.ReadVarExpr) {}
-
-  visitBinary(ast: cdAst.Binary, mode: _Mode): any {
-    var op;
-    switch (ast.operation) {
-      case '+':
-        op = o.BinaryOperator.Plus;
-        break;
-      case '-':
-        op = o.BinaryOperator.Minus;
-        break;
-      case '*':
-        op = o.BinaryOperator.Multiply;
-        break;
-      case '/':
-        op = o.BinaryOperator.Divide;
-        break;
-      case '%':
-        op = o.BinaryOperator.Modulo;
-        break;
-      case '&&':
-        op = o.BinaryOperator.And;
-        break;
-      case '||':
-        op = o.BinaryOperator.Or;
-        break;
-      case '==':
-        op = o.BinaryOperator.Equals;
-        break;
-      case '!=':
-        op = o.BinaryOperator.NotEquals;
-        break;
-      case '===':
-        op = o.BinaryOperator.Identical;
-        break;
-      case '!==':
-        op = o.BinaryOperator.NotIdentical;
-        break;
-      case '<':
-        op = o.BinaryOperator.Lower;
-        break;
-      case '>':
-        op = o.BinaryOperator.Bigger;
-        break;
-      case '<=':
-        op = o.BinaryOperator.LowerEquals;
-        break;
-      case '>=':
-        op = o.BinaryOperator.BiggerEquals;
-        break;
-      default:
-        throw new BaseException(`Unsupported operation ${ast.operation}`);
-    }
-
-    return convertToStatementIfNeeded(
-        mode, new o.BinaryOperatorExpr(op, ast.left.visit(this, _Mode.Expression),
-                                       ast.right.visit(this, _Mode.Expression)));
-  }
-  visitChain(ast: cdAst.Chain, mode: _Mode): any {
-    ensureStatementMode(mode, ast);
-    return this.visitAll(ast.expressions, mode);
-  }
-  visitConditional(ast: cdAst.Conditional, mode: _Mode): any {
-    var value: o.Expression = ast.condition.visit(this, _Mode.Expression);
-    return convertToStatementIfNeeded(
-        mode, value.conditional(ast.trueExp.visit(this, _Mode.Expression),
-                                ast.falseExp.visit(this, _Mode.Expression)));
-  }
-  visitPipe(ast: cdAst.BindingPipe, mode: _Mode): any {
-    var input = ast.exp.visit(this, _Mode.Expression);
-    var args = this.visitAll(ast.args, _Mode.Expression);
-    var value = this._nameResolver.callPipe(ast.name, input, args);
-    this.needsValueUnwrapper = true;
-    return convertToStatementIfNeeded(mode, this._valueUnwrapper.callMethod('unwrap', [value]));
-  }
-  visitFunctionCall(ast: cdAst.FunctionCall, mode: _Mode): any {
-    return convertToStatementIfNeeded(mode, ast.target.visit(this, _Mode.Expression)
-                                                .callFn(this.visitAll(ast.args, _Mode.Expression)));
-  }
-  visitImplicitReceiver(ast: cdAst.ImplicitReceiver, mode: _Mode): any {
-    ensureExpressionMode(mode, ast);
-    return IMPLICIT_RECEIVER;
-  }
-  visitInterpolation(ast: cdAst.Interpolation, mode: _Mode): any {
-    ensureExpressionMode(mode, ast);
-    var args = [o.literal(ast.expressions.length)];
-    for (var i = 0; i < ast.strings.length - 1; i++) {
-      args.push(o.literal(ast.strings[i]));
-      args.push(ast.expressions[i].visit(this, _Mode.Expression));
-    }
-    args.push(o.literal(ast.strings[ast.strings.length - 1]));
-    return o.importExpr(Identifiers.interpolate).callFn(args);
-  }
-  visitKeyedRead(ast: cdAst.KeyedRead, mode: _Mode): any {
-    return convertToStatementIfNeeded(
-        mode, ast.obj.visit(this, _Mode.Expression).key(ast.key.visit(this, _Mode.Expression)));
-  }
-  visitKeyedWrite(ast: cdAst.KeyedWrite, mode: _Mode): any {
-    var obj: o.Expression = ast.obj.visit(this, _Mode.Expression);
-    var key: o.Expression = ast.key.visit(this, _Mode.Expression);
-    var value: o.Expression = ast.value.visit(this, _Mode.Expression);
-    return convertToStatementIfNeeded(mode, obj.key(key).set(value));
-  }
-  visitLiteralArray(ast: cdAst.LiteralArray, mode: _Mode): any {
-    return convertToStatementIfNeeded(
-        mode, this._nameResolver.createLiteralArray(this.visitAll(ast.expressions, mode)));
-  }
-  visitLiteralMap(ast: cdAst.LiteralMap, mode: _Mode): any {
-    var parts = [];
-    for (var i = 0; i < ast.keys.length; i++) {
-      parts.push([ast.keys[i], ast.values[i].visit(this, _Mode.Expression)]);
-    }
-    return convertToStatementIfNeeded(mode, this._nameResolver.createLiteralMap(parts));
-  }
-  visitLiteralPrimitive(ast: cdAst.LiteralPrimitive, mode: _Mode): any {
-    return convertToStatementIfNeeded(mode, o.literal(ast.value));
-  }
-  visitMethodCall(ast: cdAst.MethodCall, mode: _Mode): any {
-    var args = this.visitAll(ast.args, _Mode.Expression);
-    var result = null;
-    var receiver = ast.receiver.visit(this, _Mode.Expression);
-    if (receiver === IMPLICIT_RECEIVER) {
-      var varExpr = this._nameResolver.getLocal(ast.name);
-      if (isPresent(varExpr)) {
-        result = varExpr.callFn(args);
-      } else {
-        receiver = this._implicitReceiver;
-      }
-    }
-    if (isBlank(result)) {
-      result = receiver.callMethod(ast.name, args);
-    }
-    return convertToStatementIfNeeded(mode, result);
-  }
-  visitPrefixNot(ast: cdAst.PrefixNot, mode: _Mode): any {
-    return convertToStatementIfNeeded(mode, o.not(ast.expression.visit(this, _Mode.Expression)));
-  }
-  visitPropertyRead(ast: cdAst.PropertyRead, mode: _Mode): any {
-    var result = null;
-    var receiver = ast.receiver.visit(this, _Mode.Expression);
-    if (receiver === IMPLICIT_RECEIVER) {
-      result = this._nameResolver.getLocal(ast.name);
-      if (isBlank(result)) {
-        receiver = this._implicitReceiver;
-      }
-    }
-    if (isBlank(result)) {
-      result = receiver.prop(ast.name);
-    }
-    return convertToStatementIfNeeded(mode, result);
-  }
-  visitPropertyWrite(ast: cdAst.PropertyWrite, mode: _Mode): any {
-    var receiver: o.Expression = ast.receiver.visit(this, _Mode.Expression);
-    if (receiver === IMPLICIT_RECEIVER) {
-      var varExpr = this._nameResolver.getLocal(ast.name);
-      if (isPresent(varExpr)) {
-        throw new BaseException('Cannot assign to a reference or variable!');
-      }
-      receiver = this._implicitReceiver;
-    }
-    return convertToStatementIfNeeded(
-        mode, receiver.prop(ast.name).set(ast.value.visit(this, _Mode.Expression)));
-  }
-  visitSafePropertyRead(ast: cdAst.SafePropertyRead, mode: _Mode): any {
-    var receiver = ast.receiver.visit(this, _Mode.Expression);
-    return convertToStatementIfNeeded(
-        mode, receiver.isBlank().conditional(o.NULL_EXPR, receiver.prop(ast.name)));
-  }
-  visitSafeMethodCall(ast: cdAst.SafeMethodCall, mode: _Mode): any {
-    var receiver = ast.receiver.visit(this, _Mode.Expression);
-    var args = this.visitAll(ast.args, _Mode.Expression);
-    return convertToStatementIfNeeded(
-        mode, receiver.isBlank().conditional(o.NULL_EXPR, receiver.callMethod(ast.name, args)));
-  }
-  visitAll(asts: cdAst.AST[], mode: _Mode): any { return asts.map(ast => ast.visit(this, mode)); }
-  visitQuote(ast: cdAst.Quote, mode: _Mode): any {
-    throw new BaseException('Quotes are not supported for evaluation!');
-  }
-}
-
-function flattenStatements(arg: any, output: o.Statement[]) {
-  if (isArray(arg)) {
-    (<any[]>arg).forEach((entry) => flattenStatements(entry, output));
-  } else {
-    output.push(arg);
-  }
-}
--- a/modules/@angular/compiler/src/view_compiler/lifecycle_binder.ts
+++ b/modules/@angular/compiler/src/view_compiler/lifecycle_binder.ts
@ -1,88 +0,0 @@
-import {LifecycleHooks} from '../../core_private';
-import * as o from '../output/output_ast';
-import {DetectChangesVars, ChangeDetectorStateEnum} from './constants';
-import {CompileDirectiveMetadata, CompilePipeMetadata} from '../compile_metadata';
-import {DirectiveAst} from '../template_ast';
-import {CompileElement} from './compile_element';
-import {CompileView} from './compile_view';
-
-
-
-var STATE_IS_NEVER_CHECKED =
-    o.THIS_EXPR.prop('cdState').identical(ChangeDetectorStateEnum.NeverChecked);
-var NOT_THROW_ON_CHANGES = o.not(DetectChangesVars.throwOnChange);
-
-export function bindDirectiveDetectChangesLifecycleCallbacks(
-    directiveAst: DirectiveAst, directiveInstance: o.Expression, compileElement: CompileElement) {
-  var view = compileElement.view;
-  var detectChangesInInputsMethod = view.detectChangesInInputsMethod;
-  var lifecycleHooks = directiveAst.directive.lifecycleHooks;
-  if (lifecycleHooks.indexOf(LifecycleHooks.OnChanges) !== -1 && directiveAst.inputs.length > 0) {
-    detectChangesInInputsMethod.addStmt(new o.IfStmt(
-        DetectChangesVars.changes.notIdentical(o.NULL_EXPR),
-        [directiveInstance.callMethod('ngOnChanges', [DetectChangesVars.changes]).toStmt()]));
-  }
-  if (lifecycleHooks.indexOf(LifecycleHooks.OnInit) !== -1) {
-    detectChangesInInputsMethod.addStmt(
-        new o.IfStmt(STATE_IS_NEVER_CHECKED.and(NOT_THROW_ON_CHANGES),
-                     [directiveInstance.callMethod('ngOnInit', []).toStmt()]));
-  }
-  if (lifecycleHooks.indexOf(LifecycleHooks.DoCheck) !== -1) {
-    detectChangesInInputsMethod.addStmt(new o.IfStmt(
-        NOT_THROW_ON_CHANGES, [directiveInstance.callMethod('ngDoCheck', []).toStmt()]));
-  }
-}
-
-export function bindDirectiveAfterContentLifecycleCallbacks(directiveMeta: CompileDirectiveMetadata,
-                                                            directiveInstance: o.Expression,
-                                                            compileElement: CompileElement) {
-  var view = compileElement.view;
-  var lifecycleHooks = directiveMeta.lifecycleHooks;
-  var afterContentLifecycleCallbacksMethod = view.afterContentLifecycleCallbacksMethod;
-  afterContentLifecycleCallbacksMethod.resetDebugInfo(compileElement.nodeIndex,
-                                                      compileElement.sourceAst);
-  if (lifecycleHooks.indexOf(LifecycleHooks.AfterContentInit) !== -1) {
-    afterContentLifecycleCallbacksMethod.addStmt(new o.IfStmt(
-        STATE_IS_NEVER_CHECKED, [directiveInstance.callMethod('ngAfterContentInit', []).toStmt()]));
-  }
-  if (lifecycleHooks.indexOf(LifecycleHooks.AfterContentChecked) !== -1) {
-    afterContentLifecycleCallbacksMethod.addStmt(
-        directiveInstance.callMethod('ngAfterContentChecked', []).toStmt());
-  }
-}
-
-export function bindDirectiveAfterViewLifecycleCallbacks(directiveMeta: CompileDirectiveMetadata,
-                                                         directiveInstance: o.Expression,
-                                                         compileElement: CompileElement) {
-  var view = compileElement.view;
-  var lifecycleHooks = directiveMeta.lifecycleHooks;
-  var afterViewLifecycleCallbacksMethod = view.afterViewLifecycleCallbacksMethod;
-  afterViewLifecycleCallbacksMethod.resetDebugInfo(compileElement.nodeIndex,
-                                                   compileElement.sourceAst);
-  if (lifecycleHooks.indexOf(LifecycleHooks.AfterViewInit) !== -1) {
-    afterViewLifecycleCallbacksMethod.addStmt(new o.IfStmt(
-        STATE_IS_NEVER_CHECKED, [directiveInstance.callMethod('ngAfterViewInit', []).toStmt()]));
-  }
-  if (lifecycleHooks.indexOf(LifecycleHooks.AfterViewChecked) !== -1) {
-    afterViewLifecycleCallbacksMethod.addStmt(
-        directiveInstance.callMethod('ngAfterViewChecked', []).toStmt());
-  }
-}
-
-export function bindDirectiveDestroyLifecycleCallbacks(directiveMeta: CompileDirectiveMetadata,
-                                                       directiveInstance: o.Expression,
-                                                       compileElement: CompileElement) {
-  var onDestroyMethod = compileElement.view.destroyMethod;
-  onDestroyMethod.resetDebugInfo(compileElement.nodeIndex, compileElement.sourceAst);
-  if (directiveMeta.lifecycleHooks.indexOf(LifecycleHooks.OnDestroy) !== -1) {
-    onDestroyMethod.addStmt(directiveInstance.callMethod('ngOnDestroy', []).toStmt());
-  }
-}
-
-export function bindPipeDestroyLifecycleCallbacks(pipeMeta: CompilePipeMetadata,
-                                                  pipeInstance: o.Expression, view: CompileView) {
-  var onDestroyMethod = view.destroyMethod;
-  if (pipeMeta.lifecycleHooks.indexOf(LifecycleHooks.OnDestroy) !== -1) {
-    onDestroyMethod.addStmt(pipeInstance.callMethod('ngOnDestroy', []).toStmt());
-  }
-}
--- a/modules/@angular/compiler/src/view_compiler/property_binder.ts
+++ b/modules/@angular/compiler/src/view_compiler/property_binder.ts
@ -1,210 +0,0 @@
-import {LifecycleHooks, isDefaultChangeDetectionStrategy} from '../../core_private';
-
-import {isBlank, isPresent} from '../../src/facade/lang';
-
-import * as cdAst from '../expression_parser/ast';
-import * as o from '../output/output_ast';
-import {Identifiers} from '../identifiers';
-import {DetectChangesVars} from './constants';
-
-import {
-  BoundTextAst,
-  BoundElementPropertyAst,
-  DirectiveAst,
-  PropertyBindingType,
-} from '../template_ast';
-
-import {CompileView} from './compile_view';
-import {CompileElement, CompileNode} from './compile_element';
-import {CompileMethod} from './compile_method';
-
-import {camelCaseToDashCase} from '../util';
-
-import {convertCdExpressionToIr} from './expression_converter';
-
-import {CompileBinding} from './compile_binding';
-
-
-function createBindFieldExpr(exprIndex: number): o.ReadPropExpr {
-  return o.THIS_EXPR.prop(`_expr_${exprIndex}`);
-}
-
-function createCurrValueExpr(exprIndex: number): o.ReadVarExpr {
-  return o.variable(`currVal_${exprIndex}`);
-}
-
-function bind(view: CompileView, currValExpr: o.ReadVarExpr, fieldExpr: o.ReadPropExpr,
-              parsedExpression: cdAst.AST, context: o.Expression, actions: o.Statement[],
-              method: CompileMethod) {
-  var checkExpression =
-      convertCdExpressionToIr(view, context, parsedExpression, DetectChangesVars.valUnwrapper);
-  if (isBlank(checkExpression.expression)) {
-    // e.g. an empty expression was given
-    return;
-  }
-
-  // private is fine here as no child view will reference the cached value...
-  view.fields.push(new o.ClassField(fieldExpr.name, null, [o.StmtModifier.Private]));
-  view.createMethod.addStmt(
-      o.THIS_EXPR.prop(fieldExpr.name).set(o.importExpr(Identifiers.uninitialized)).toStmt());
-
-  if (checkExpression.needsValueUnwrapper) {
-    var initValueUnwrapperStmt = DetectChangesVars.valUnwrapper.callMethod('reset', []).toStmt();
-    method.addStmt(initValueUnwrapperStmt);
-  }
-  method.addStmt(
-      currValExpr.set(checkExpression.expression).toDeclStmt(null, [o.StmtModifier.Final]));
-
-  var condition: o.Expression =
-      o.importExpr(Identifiers.checkBinding)
-          .callFn([DetectChangesVars.throwOnChange, fieldExpr, currValExpr]);
-  if (checkExpression.needsValueUnwrapper) {
-    condition = DetectChangesVars.valUnwrapper.prop('hasWrappedValue').or(condition);
-  }
-  method.addStmt(new o.IfStmt(
-      condition,
-      actions.concat([<o.Statement>o.THIS_EXPR.prop(fieldExpr.name).set(currValExpr).toStmt()])));
-}
-
-export function bindRenderText(boundText: BoundTextAst, compileNode: CompileNode,
-                               view: CompileView) {
-  var bindingIndex = view.bindings.length;
-  view.bindings.push(new CompileBinding(compileNode, boundText));
-  var currValExpr = createCurrValueExpr(bindingIndex);
-  var valueField = createBindFieldExpr(bindingIndex);
-  view.detectChangesRenderPropertiesMethod.resetDebugInfo(compileNode.nodeIndex, boundText);
-
-  bind(view, currValExpr, valueField, boundText.value, view.componentContext,
-       [
-         o.THIS_EXPR.prop('renderer')
-             .callMethod('setText', [compileNode.renderNode, currValExpr])
-             .toStmt()
-       ],
-       view.detectChangesRenderPropertiesMethod);
-}
-
-function bindAndWriteToRenderer(boundProps: BoundElementPropertyAst[], context: o.Expression,
-                                compileElement: CompileElement) {
-  var view = compileElement.view;
-  var renderNode = compileElement.renderNode;
-  boundProps.forEach((boundProp) => {
-    var bindingIndex = view.bindings.length;
-    view.bindings.push(new CompileBinding(compileElement, boundProp));
-    view.detectChangesRenderPropertiesMethod.resetDebugInfo(compileElement.nodeIndex, boundProp);
-    var fieldExpr = createBindFieldExpr(bindingIndex);
-    var currValExpr = createCurrValueExpr(bindingIndex);
-    var renderMethod: string;
-    var renderValue: o.Expression = currValExpr;
-    var updateStmts = [];
-    switch (boundProp.type) {
-      case PropertyBindingType.Property:
-        renderMethod = 'setElementProperty';
-        if (view.genConfig.logBindingUpdate) {
-          updateStmts.push(logBindingUpdateStmt(renderNode, boundProp.name, currValExpr));
-        }
-        break;
-      case PropertyBindingType.Attribute:
-        renderMethod = 'setElementAttribute';
-        renderValue =
-            renderValue.isBlank().conditional(o.NULL_EXPR, renderValue.callMethod('toString', []));
-        break;
-      case PropertyBindingType.Class:
-        renderMethod = 'setElementClass';
-        break;
-      case PropertyBindingType.Style:
-        renderMethod = 'setElementStyle';
-        var strValue: o.Expression = renderValue.callMethod('toString', []);
-        if (isPresent(boundProp.unit)) {
-          strValue = strValue.plus(o.literal(boundProp.unit));
-        }
-        renderValue = renderValue.isBlank().conditional(o.NULL_EXPR, strValue);
-        break;
-    }
-    updateStmts.push(
-        o.THIS_EXPR.prop('renderer')
-            .callMethod(renderMethod, [renderNode, o.literal(boundProp.name), renderValue])
-            .toStmt());
-
-    bind(view, currValExpr, fieldExpr, boundProp.value, context, updateStmts,
-         view.detectChangesRenderPropertiesMethod);
-  });
-}
-
-export function bindRenderInputs(boundProps: BoundElementPropertyAst[],
-                                 compileElement: CompileElement): void {
-  bindAndWriteToRenderer(boundProps, compileElement.view.componentContext, compileElement);
-}
-
-export function bindDirectiveHostProps(directiveAst: DirectiveAst, directiveInstance: o.Expression,
-                                       compileElement: CompileElement): void {
-  bindAndWriteToRenderer(directiveAst.hostProperties, directiveInstance, compileElement);
-}
-
-export function bindDirectiveInputs(directiveAst: DirectiveAst, directiveInstance: o.Expression,
-                                    compileElement: CompileElement) {
-  if (directiveAst.inputs.length === 0) {
-    return;
-  }
-  var view = compileElement.view;
-  var detectChangesInInputsMethod = view.detectChangesInInputsMethod;
-  detectChangesInInputsMethod.resetDebugInfo(compileElement.nodeIndex, compileElement.sourceAst);
-
-  var lifecycleHooks = directiveAst.directive.lifecycleHooks;
-  var calcChangesMap = lifecycleHooks.indexOf(LifecycleHooks.OnChanges) !== -1;
-  var isOnPushComp = directiveAst.directive.isComponent &&
-                     !isDefaultChangeDetectionStrategy(directiveAst.directive.changeDetection);
-  if (calcChangesMap) {
-    detectChangesInInputsMethod.addStmt(DetectChangesVars.changes.set(o.NULL_EXPR).toStmt());
-  }
-  if (isOnPushComp) {
-    detectChangesInInputsMethod.addStmt(DetectChangesVars.changed.set(o.literal(false)).toStmt());
-  }
-  directiveAst.inputs.forEach((input) => {
-    var bindingIndex = view.bindings.length;
-    view.bindings.push(new CompileBinding(compileElement, input));
-    detectChangesInInputsMethod.resetDebugInfo(compileElement.nodeIndex, input);
-    var fieldExpr = createBindFieldExpr(bindingIndex);
-    var currValExpr = createCurrValueExpr(bindingIndex);
-    var statements: o.Statement[] =
-        [directiveInstance.prop(input.directiveName).set(currValExpr).toStmt()];
-    if (calcChangesMap) {
-      statements.push(new o.IfStmt(DetectChangesVars.changes.identical(o.NULL_EXPR), [
-        DetectChangesVars.changes.set(o.literalMap([], new o.MapType(
-                                                           o.importType(Identifiers.SimpleChange))))
-            .toStmt()
-      ]));
-      statements.push(
-          DetectChangesVars.changes.key(o.literal(input.directiveName))
-              .set(o.importExpr(Identifiers.SimpleChange).instantiate([fieldExpr, currValExpr]))
-              .toStmt());
-    }
-    if (isOnPushComp) {
-      statements.push(DetectChangesVars.changed.set(o.literal(true)).toStmt());
-    }
-    if (view.genConfig.logBindingUpdate) {
-      statements.push(
-          logBindingUpdateStmt(compileElement.renderNode, input.directiveName, currValExpr));
-    }
-    bind(view, currValExpr, fieldExpr, input.value, view.componentContext, statements,
-         detectChangesInInputsMethod);
-  });
-  if (isOnPushComp) {
-    detectChangesInInputsMethod.addStmt(new o.IfStmt(DetectChangesVars.changed, [
-      compileElement.appElement.prop('componentView')
-          .callMethod('markAsCheckOnce', [])
-          .toStmt()
-    ]));
-  }
-}
-
-function logBindingUpdateStmt(renderNode: o.Expression, propName: string,
-                              value: o.Expression): o.Statement {
-  return o.THIS_EXPR.prop('renderer')
-      .callMethod('setBindingDebugInfo',
-                  [
-                    renderNode,
-                    o.literal(`ng-reflect-${camelCaseToDashCase(propName)}`),
-                    value.isBlank().conditional(o.NULL_EXPR, value.callMethod('toString', []))
-                  ])
-      .toStmt();
-}
--- a/modules/@angular/compiler/src/view_compiler/util.ts
+++ b/modules/@angular/compiler/src/view_compiler/util.ts
@ -1,98 +0,0 @@
-import {isPresent, isBlank} from '../../src/facade/lang';
-import {BaseException} from '../../src/facade/exceptions';
-
-import * as o from '../output/output_ast';
-import {
-  CompileTokenMetadata,
-  CompileDirectiveMetadata,
-} from '../compile_metadata';
-import {CompileView} from './compile_view';
-import {Identifiers} from '../identifiers';
-
-export function getPropertyInView(property: o.Expression, callingView: CompileView,
-                                  definedView: CompileView): o.Expression {
-  if (callingView === definedView) {
-    return property;
-  } else {
-    var viewProp: o.Expression = o.THIS_EXPR;
-    var currView: CompileView = callingView;
-    while (currView !== definedView && isPresent(currView.declarationElement.view)) {
-      currView = currView.declarationElement.view;
-      viewProp = viewProp.prop('parent');
-    }
-    if (currView !== definedView) {
-      throw new BaseException(
-          `Internal error: Could not calculate a property in a parent view: ${property}`);
-    }
-    if (property instanceof o.ReadPropExpr) {
-      let readPropExpr: o.ReadPropExpr = property;
-      // Note: Don't cast for members of the AppView base class...
-      if (definedView.fields.some((field) => field.name == readPropExpr.name) ||
-          definedView.getters.some((field) => field.name == readPropExpr.name)) {
-        viewProp = viewProp.cast(definedView.classType);
-      }
-    }
-    return o.replaceVarInExpression(o.THIS_EXPR.name, viewProp, property);
-  }
-}
-
-export function injectFromViewParentInjector(token: CompileTokenMetadata,
-                                             optional: boolean): o.Expression {
-  var args = [createDiTokenExpression(token)];
-  if (optional) {
-    args.push(o.NULL_EXPR);
-  }
-  return o.THIS_EXPR.prop('parentInjector').callMethod('get', args);
-}
-
-export function getViewFactoryName(component: CompileDirectiveMetadata,
-                                   embeddedTemplateIndex: number): string {
-  return `viewFactory_${component.type.name}${embeddedTemplateIndex}`;
-}
-
-
-export function createDiTokenExpression(token: CompileTokenMetadata): o.Expression {
-  if (isPresent(token.value)) {
-    return o.literal(token.value);
-  } else if (token.identifierIsInstance) {
-    return o.importExpr(token.identifier)
-        .instantiate([], o.importType(token.identifier, [], [o.TypeModifier.Const]));
-  } else {
-    return o.importExpr(token.identifier);
-  }
-}
-
-export function createFlatArray(expressions: o.Expression[]): o.Expression {
-  var lastNonArrayExpressions = [];
-  var result: o.Expression = o.literalArr([]);
-  for (var i = 0; i < expressions.length; i++) {
-    var expr = expressions[i];
-    if (expr.type instanceof o.ArrayType) {
-      if (lastNonArrayExpressions.length > 0) {
-        result =
-            result.callMethod(o.BuiltinMethod.ConcatArray, [o.literalArr(lastNonArrayExpressions)]);
-        lastNonArrayExpressions = [];
-      }
-      result = result.callMethod(o.BuiltinMethod.ConcatArray, [expr]);
-    } else {
-      lastNonArrayExpressions.push(expr);
-    }
-  }
-  if (lastNonArrayExpressions.length > 0) {
-    result =
-        result.callMethod(o.BuiltinMethod.ConcatArray, [o.literalArr(lastNonArrayExpressions)]);
-  }
-  return result;
-}
-
-export function createPureProxy(fn: o.Expression, argCount: number, pureProxyProp: o.ReadPropExpr,
-                                view: CompileView) {
-  view.fields.push(new o.ClassField(pureProxyProp.name, null));
-  var pureProxyId =
-      argCount < Identifiers.pureProxies.length ? Identifiers.pureProxies[argCount] : null;
-  if (isBlank(pureProxyId)) {
-    throw new BaseException(`Unsupported number of argument for pure functions: ${argCount}`);
-  }
-  view.createMethod.addStmt(
-      o.THIS_EXPR.prop(pureProxyProp.name).set(o.importExpr(pureProxyId).callFn([fn])).toStmt());
-}
--- a/modules/@angular/compiler/src/view_compiler/view_binder.ts
+++ b/modules/@angular/compiler/src/view_compiler/view_binder.ts
@ -1,119 +0,0 @@
-import {
-  ListWrapper,
-} from '../../src/facade/collection';
-import {
-  TemplateAst,
-  TemplateAstVisitor,
-  NgContentAst,
-  EmbeddedTemplateAst,
-  ElementAst,
-  ReferenceAst,
-  VariableAst,
-  BoundEventAst,
-  BoundElementPropertyAst,
-  AttrAst,
-  BoundTextAst,
-  TextAst,
-  DirectiveAst,
-  BoundDirectivePropertyAst,
-  templateVisitAll,
-} from '../template_ast';
-import {
-  bindRenderText,
-  bindRenderInputs,
-  bindDirectiveInputs,
-  bindDirectiveHostProps
-} from './property_binder';
-import {bindRenderOutputs, collectEventListeners, bindDirectiveOutputs} from './event_binder';
-import {
-  bindDirectiveAfterContentLifecycleCallbacks,
-  bindDirectiveAfterViewLifecycleCallbacks,
-  bindDirectiveDestroyLifecycleCallbacks,
-  bindPipeDestroyLifecycleCallbacks,
-  bindDirectiveDetectChangesLifecycleCallbacks
-} from './lifecycle_binder';
-import {CompileView} from './compile_view';
-import {CompileElement, CompileNode} from './compile_element';
-
-export function bindView(view: CompileView, parsedTemplate: TemplateAst[]): void {
-  var visitor = new ViewBinderVisitor(view);
-  templateVisitAll(visitor, parsedTemplate);
-  view.pipes.forEach(
-      (pipe) => { bindPipeDestroyLifecycleCallbacks(pipe.meta, pipe.instance, pipe.view); });
-}
-
-class ViewBinderVisitor implements TemplateAstVisitor {
-  private _nodeIndex: number = 0;
-
-  constructor(public view: CompileView) {}
-
-  visitBoundText(ast: BoundTextAst, parent: CompileElement): any {
-    var node = this.view.nodes[this._nodeIndex++];
-    bindRenderText(ast, node, this.view);
-    return null;
-  }
-  visitText(ast: TextAst, parent: CompileElement): any {
-    this._nodeIndex++;
-    return null;
-  }
-
-  visitNgContent(ast: NgContentAst, parent: CompileElement): any { return null; }
-
-  visitElement(ast: ElementAst, parent: CompileElement): any {
-    var compileElement = <CompileElement>this.view.nodes[this._nodeIndex++];
-    var eventListeners = collectEventListeners(ast.outputs, ast.directives, compileElement);
-    bindRenderInputs(ast.inputs, compileElement);
-    bindRenderOutputs(eventListeners);
-    ListWrapper.forEachWithIndex(ast.directives, (directiveAst, index) => {
-      var directiveInstance = compileElement.directiveInstances[index];
-      bindDirectiveInputs(directiveAst, directiveInstance, compileElement);
-      bindDirectiveDetectChangesLifecycleCallbacks(directiveAst, directiveInstance, compileElement);
-
-      bindDirectiveHostProps(directiveAst, directiveInstance, compileElement);
-      bindDirectiveOutputs(directiveAst, directiveInstance, eventListeners);
-    });
-    templateVisitAll(this, ast.children, compileElement);
-    // afterContent and afterView lifecycles need to be called bottom up
-    // so that children are notified before parents
-    ListWrapper.forEachWithIndex(ast.directives, (directiveAst, index) => {
-      var directiveInstance = compileElement.directiveInstances[index];
-      bindDirectiveAfterContentLifecycleCallbacks(directiveAst.directive, directiveInstance,
-                                                  compileElement);
-      bindDirectiveAfterViewLifecycleCallbacks(directiveAst.directive, directiveInstance,
-                                               compileElement);
-      bindDirectiveDestroyLifecycleCallbacks(directiveAst.directive, directiveInstance,
-                                             compileElement);
-    });
-    return null;
-  }
-
-  visitEmbeddedTemplate(ast: EmbeddedTemplateAst, parent: CompileElement): any {
-    var compileElement = <CompileElement>this.view.nodes[this._nodeIndex++];
-    var eventListeners = collectEventListeners(ast.outputs, ast.directives, compileElement);
-    ListWrapper.forEachWithIndex(ast.directives, (directiveAst, index) => {
-      var directiveInstance = compileElement.directiveInstances[index];
-      bindDirectiveInputs(directiveAst, directiveInstance, compileElement);
-      bindDirectiveDetectChangesLifecycleCallbacks(directiveAst, directiveInstance, compileElement);
-      bindDirectiveOutputs(directiveAst, directiveInstance, eventListeners);
-      bindDirectiveAfterContentLifecycleCallbacks(directiveAst.directive, directiveInstance,
-                                                  compileElement);
-      bindDirectiveAfterViewLifecycleCallbacks(directiveAst.directive, directiveInstance,
-                                               compileElement);
-      bindDirectiveDestroyLifecycleCallbacks(directiveAst.directive, directiveInstance,
-                                             compileElement);
-    });
-    bindView(compileElement.embeddedView, ast.children);
-    return null;
-  }
-
-  visitAttr(ast: AttrAst, ctx: any): any { return null; }
-  visitDirective(ast: DirectiveAst, ctx: any): any { return null; }
-  visitEvent(ast: BoundEventAst, eventTargetAndNames: Map<string, BoundEventAst>): any {
-    return null;
-  }
-
-  visitReference(ast: ReferenceAst, ctx: any): any { return null; }
-  visitVariable(ast: VariableAst, ctx: any): any { return null; }
-  visitDirectiveProperty(ast: BoundDirectivePropertyAst, context: any): any { return null; }
-  visitElementProperty(ast: BoundElementPropertyAst, context: any): any { return null; }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Alex Eagle	4945e73588	docs(changelog): update change log to beta.2	2016-01-28 11:34:11 -08:00
Alex Eagle	8a00a863ac	chore(release): bump version to beta.2	2016-01-28 11:27:47 -08:00
				`@ -1 +0,0 @@`
				`export './src/core/change_detection/constants.dart' show SelectorMatcher, CssSelector;`