diff --git a/angular/common/index.ts b/angular/common/index.ts
new file mode 100644
index 0000000..e727e2e
--- /dev/null
+++ b/angular/common/index.ts
@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+// This file is not used to build this module. It is only used during editing
+// by the TypeScript language service and during build for verification. `ngc`
+// replaces this file with production index.ts when it rewrites private symbol
+// names.
+
+export * from './public_api';
diff --git a/angular/common/public_api.ts b/angular/common/public_api.ts
new file mode 100644
index 0000000..a55ca93
--- /dev/null
+++ b/angular/common/public_api.ts
@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the common package.
+ */
+export * from './src/common';
+
+// This file only reexports content of the `src` folder. Keep it that way.
diff --git a/angular/common/src/common.ts b/angular/common/src/common.ts
new file mode 100644
index 0000000..5e79a49
--- /dev/null
+++ b/angular/common/src/common.ts
@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the common package.
+ */
+export * from './location/index';
+export {NgLocaleLocalization, NgLocalization} from './localization';
+export {parseCookieValue as ɵparseCookieValue} from './cookie';
+export {CommonModule, DeprecatedI18NPipesModule} from './common_module';
+export {NgClass, NgFor, NgForOf, NgForOfContext, NgIf, NgIfContext, NgPlural, NgPluralCase, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgTemplateOutlet, NgComponentOutlet} from './directives/index';
+export {DOCUMENT} from './dom_tokens';
+export {AsyncPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, JsonPipe, LowerCasePipe, CurrencyPipe, DecimalPipe, PercentPipe, SlicePipe, UpperCasePipe, TitleCasePipe} from './pipes/index';
+export {PLATFORM_BROWSER_ID as ɵPLATFORM_BROWSER_ID, PLATFORM_SERVER_ID as ɵPLATFORM_SERVER_ID, PLATFORM_WORKER_APP_ID as ɵPLATFORM_WORKER_APP_ID, PLATFORM_WORKER_UI_ID as ɵPLATFORM_WORKER_UI_ID, isPlatformBrowser, isPlatformServer, isPlatformWorkerApp, isPlatformWorkerUi} from './platform_id';
+export {VERSION} from './version';
diff --git a/angular/common/src/common_module.ts b/angular/common/src/common_module.ts
new file mode 100644
index 0000000..4a75bb4
--- /dev/null
+++ b/angular/common/src/common_module.ts
@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {NgModule} from '@angular/core';
+
+import {COMMON_DEPRECATED_DIRECTIVES, COMMON_DIRECTIVES} from './directives/index';
+import {NgLocaleLocalization, NgLocalization} from './localization';
+import {COMMON_PIPES} from './pipes/index';
+
+
+// Note: This does not contain the location providers,
+// as they need some platform specific implementations to work.
+/**
+ * The module that includes all the basic Angular directives like {@link NgIf}, {@link NgForOf}, ...
+ *
+ * @stable
+ */
+@NgModule({
+  declarations: [COMMON_DIRECTIVES, COMMON_PIPES],
+  exports: [COMMON_DIRECTIVES, COMMON_PIPES],
+  providers: [
+    {provide: NgLocalization, useClass: NgLocaleLocalization},
+  ],
+})
+export class CommonModule {
+}
+
+/**
+ * I18N pipes are being changed to move away from using the JS Intl API.
+ *
+ * The former pipes relying on the Intl API will be moved to this module while the `CommonModule`
+ * will contain the new pipes that do not rely on Intl.
+ *
+ * As a first step this module is created empty to ease the migration.
+ *
+ * see https://github.com/angular/angular/pull/18284
+ *
+ * @deprecated from v5
+ */
+@NgModule({declarations: [], exports: []})
+export class DeprecatedI18NPipesModule {
+}
diff --git a/angular/common/src/cookie.ts b/angular/common/src/cookie.ts
new file mode 100644
index 0000000..1e577cf
--- /dev/null
+++ b/angular/common/src/cookie.ts
@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export function parseCookieValue(cookieStr: string, name: string): string|null {
+  name = encodeURIComponent(name);
+  for (const cookie of cookieStr.split(';')) {
+    const eqIndex = cookie.indexOf('=');
+    const [cookieName, cookieValue]: string[] =
+        eqIndex == -1 ? [cookie, ''] : [cookie.slice(0, eqIndex), cookie.slice(eqIndex + 1)];
+    if (cookieName.trim() === name) {
+      return decodeURIComponent(cookieValue);
+    }
+  }
+  return null;
+}
diff --git a/angular/common/src/directives/index.ts b/angular/common/src/directives/index.ts
new file mode 100644
index 0000000..b78d576
--- /dev/null
+++ b/angular/common/src/directives/index.ts
@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Provider} from '@angular/core';
+
+import {NgClass} from './ng_class';
+import {NgComponentOutlet} from './ng_component_outlet';
+import {NgFor, NgForOf, NgForOfContext} from './ng_for_of';
+import {NgIf, NgIfContext} from './ng_if';
+import {NgPlural, NgPluralCase} from './ng_plural';
+import {NgStyle} from './ng_style';
+import {NgSwitch, NgSwitchCase, NgSwitchDefault} from './ng_switch';
+import {NgTemplateOutlet} from './ng_template_outlet';
+
+export {
+  NgClass,
+  NgComponentOutlet,
+  NgFor,
+  NgForOf,
+  NgForOfContext,
+  NgIf,
+  NgIfContext,
+  NgPlural,
+  NgPluralCase,
+  NgStyle,
+  NgSwitch,
+  NgSwitchCase,
+  NgSwitchDefault,
+  NgTemplateOutlet
+};
+
+
+
+/**
+ * A collection of Angular directives that are likely to be used in each and every Angular
+ * application.
+ */
+export const COMMON_DIRECTIVES: Provider[] = [
+  NgClass,
+  NgComponentOutlet,
+  NgForOf,
+  NgIf,
+  NgTemplateOutlet,
+  NgStyle,
+  NgSwitch,
+  NgSwitchCase,
+  NgSwitchDefault,
+  NgPlural,
+  NgPluralCase,
+];
+
+/**
+ * A collection of deprecated directives that are no longer part of the core module.
+ */
+export const COMMON_DEPRECATED_DIRECTIVES: Provider[] = [NgFor];
diff --git a/angular/common/src/directives/ng_class.ts b/angular/common/src/directives/ng_class.ts
new file mode 100644
index 0000000..73ec957
--- /dev/null
+++ b/angular/common/src/directives/ng_class.ts
@@ -0,0 +1,142 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Directive, DoCheck, ElementRef, Input, IterableChanges, IterableDiffer, IterableDiffers, KeyValueChanges, KeyValueDiffer, KeyValueDiffers, Renderer, ɵisListLikeIterable as isListLikeIterable, ɵstringify as stringify} from '@angular/core';
+
+/**
+ * @ngModule CommonModule
+ *
+ * @whatItDoes Adds and removes CSS classes on an HTML element.
+ *
+ * @howToUse
+ * ```
+ *     <some-element [ngClass]="'first second'">...</some-element>
+ *
+ *     <some-element [ngClass]="['first', 'second']">...</some-element>
+ *
+ *     <some-element [ngClass]="{'first': true, 'second': true, 'third': false}">...</some-element>
+ *
+ *     <some-element [ngClass]="stringExp|arrayExp|objExp">...</some-element>
+ *
+ *     <some-element [ngClass]="{'class1 class2 class3' : true}">...</some-element>
+ * ```
+ *
+ * @description
+ *
+ * The CSS classes are updated as follows, depending on the type of the expression evaluation:
+ * - `string` - the CSS classes listed in the string (space delimited) are added,
+ * - `Array` - the CSS classes declared as Array elements are added,
+ * - `Object` - keys are CSS classes that get added when the expression given in the value
+ *              evaluates to a truthy value, otherwise they are removed.
+ *
+ * @stable
+ */
+@Directive({selector: '[ngClass]'})
+export class NgClass implements DoCheck {
+  private _iterableDiffer: IterableDiffer<string>|null;
+  private _keyValueDiffer: KeyValueDiffer<string, any>|null;
+  private _initialClasses: string[] = [];
+  private _rawClass: string[]|Set<string>|{[klass: string]: any};
+
+  constructor(
+      private _iterableDiffers: IterableDiffers, private _keyValueDiffers: KeyValueDiffers,
+      private _ngEl: ElementRef, private _renderer: Renderer) {}
+
+  @Input('class')
+  set klass(v: string) {
+    this._applyInitialClasses(true);
+    this._initialClasses = typeof v === 'string' ? v.split(/\s+/) : [];
+    this._applyInitialClasses(false);
+    this._applyClasses(this._rawClass, false);
+  }
+
+  @Input()
+  set ngClass(v: string|string[]|Set<string>|{[klass: string]: any}) {
+    this._cleanupClasses(this._rawClass);
+
+    this._iterableDiffer = null;
+    this._keyValueDiffer = null;
+
+    this._rawClass = typeof v === 'string' ? v.split(/\s+/) : v;
+
+    if (this._rawClass) {
+      if (isListLikeIterable(this._rawClass)) {
+        this._iterableDiffer = this._iterableDiffers.find(this._rawClass).create();
+      } else {
+        this._keyValueDiffer = this._keyValueDiffers.find(this._rawClass).create();
+      }
+    }
+  }
+
+  ngDoCheck(): void {
+    if (this._iterableDiffer) {
+      const iterableChanges = this._iterableDiffer.diff(this._rawClass as string[]);
+      if (iterableChanges) {
+        this._applyIterableChanges(iterableChanges);
+      }
+    } else if (this._keyValueDiffer) {
+      const keyValueChanges = this._keyValueDiffer.diff(this._rawClass as{[k: string]: any});
+      if (keyValueChanges) {
+        this._applyKeyValueChanges(keyValueChanges);
+      }
+    }
+  }
+
+  private _cleanupClasses(rawClassVal: string[]|{[klass: string]: any}): void {
+    this._applyClasses(rawClassVal, true);
+    this._applyInitialClasses(false);
+  }
+
+  private _applyKeyValueChanges(changes: KeyValueChanges<string, any>): void {
+    changes.forEachAddedItem((record) => this._toggleClass(record.key, record.currentValue));
+    changes.forEachChangedItem((record) => this._toggleClass(record.key, record.currentValue));
+    changes.forEachRemovedItem((record) => {
+      if (record.previousValue) {
+        this._toggleClass(record.key, false);
+      }
+    });
+  }
+
+  private _applyIterableChanges(changes: IterableChanges<string>): void {
+    changes.forEachAddedItem((record) => {
+      if (typeof record.item === 'string') {
+        this._toggleClass(record.item, true);
+      } else {
+        throw new Error(
+            `NgClass can only toggle CSS classes expressed as strings, got ${stringify(record.item)}`);
+      }
+    });
+
+    changes.forEachRemovedItem((record) => this._toggleClass(record.item, false));
+  }
+
+  private _applyInitialClasses(isCleanup: boolean) {
+    this._initialClasses.forEach(klass => this._toggleClass(klass, !isCleanup));
+  }
+
+  private _applyClasses(
+      rawClassVal: string[]|Set<string>|{[klass: string]: any}, isCleanup: boolean) {
+    if (rawClassVal) {
+      if (Array.isArray(rawClassVal) || rawClassVal instanceof Set) {
+        (<any>rawClassVal).forEach((klass: string) => this._toggleClass(klass, !isCleanup));
+      } else {
+        Object.keys(rawClassVal).forEach(klass => {
+          if (rawClassVal[klass] != null) this._toggleClass(klass, !isCleanup);
+        });
+      }
+    }
+  }
+
+  private _toggleClass(klass: string, enabled: any): void {
+    klass = klass.trim();
+    if (klass) {
+      klass.split(/\s+/g).forEach(
+          klass => { this._renderer.setElementClass(this._ngEl.nativeElement, klass, !!enabled); });
+    }
+  }
+}
diff --git a/angular/common/src/directives/ng_component_outlet.ts b/angular/common/src/directives/ng_component_outlet.ts
new file mode 100644
index 0000000..3c018a7
--- /dev/null
+++ b/angular/common/src/directives/ng_component_outlet.ts
@@ -0,0 +1,112 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ComponentFactoryResolver, ComponentRef, Directive, Injector, Input, NgModuleFactory, NgModuleRef, OnChanges, OnDestroy, SimpleChanges, StaticProvider, Type, ViewContainerRef} from '@angular/core';
+
+
+/**
+ * Instantiates a single {@link Component} type and inserts its Host View into current View.
+ * `NgComponentOutlet` provides a declarative approach for dynamic component creation.
+ *
+ * `NgComponentOutlet` requires a component type, if a falsy value is set the view will clear and
+ * any existing component will get destroyed.
+ *
+ * ### Fine tune control
+ *
+ * You can control the component creation process by using the following optional attributes:
+ *
+ * * `ngComponentOutletInjector`: Optional custom {@link Injector} that will be used as parent for
+ * the Component. Defaults to the injector of the current view container.
+ *
+ * * `ngComponentOutletContent`: Optional list of projectable nodes to insert into the content
+ * section of the component, if exists.
+ *
+ * * `ngComponentOutletNgModuleFactory`: Optional module factory to allow dynamically loading other
+ * module, then load a component from that module.
+ *
+ * ### Syntax
+ *
+ * Simple
+ * ```
+ * <ng-container *ngComponentOutlet="componentTypeExpression"></ng-container>
+ * ```
+ *
+ * Customized injector/content
+ * ```
+ * <ng-container *ngComponentOutlet="componentTypeExpression;
+ *                                   injector: injectorExpression;
+ *                                   content: contentNodesExpression;">
+ * </ng-container>
+ * ```
+ *
+ * Customized ngModuleFactory
+ * ```
+ * <ng-container *ngComponentOutlet="componentTypeExpression;
+ *                                   ngModuleFactory: moduleFactory;">
+ * </ng-container>
+ * ```
+ * ## Example
+ *
+ * {@example common/ngComponentOutlet/ts/module.ts region='SimpleExample'}
+ *
+ * A more complete example with additional options:
+ *
+ * {@example common/ngComponentOutlet/ts/module.ts region='CompleteExample'}
+
+ * A more complete example with ngModuleFactory:
+ *
+ * {@example common/ngComponentOutlet/ts/module.ts region='NgModuleFactoryExample'}
+ *
+ * @experimental
+ */
+@Directive({selector: '[ngComponentOutlet]'})
+export class NgComponentOutlet implements OnChanges, OnDestroy {
+  @Input() ngComponentOutlet: Type<any>;
+  @Input() ngComponentOutletInjector: Injector;
+  @Input() ngComponentOutletContent: any[][];
+  @Input() ngComponentOutletNgModuleFactory: NgModuleFactory<any>;
+
+  private _componentRef: ComponentRef<any>|null = null;
+  private _moduleRef: NgModuleRef<any>|null = null;
+
+  constructor(private _viewContainerRef: ViewContainerRef) {}
+
+  ngOnChanges(changes: SimpleChanges) {
+    this._viewContainerRef.clear();
+    this._componentRef = null;
+
+    if (this.ngComponentOutlet) {
+      const elInjector = this.ngComponentOutletInjector || this._viewContainerRef.parentInjector;
+
+      if (changes['ngComponentOutletNgModuleFactory']) {
+        if (this._moduleRef) this._moduleRef.destroy();
+
+        if (this.ngComponentOutletNgModuleFactory) {
+          const parentModule = elInjector.get(NgModuleRef);
+          this._moduleRef = this.ngComponentOutletNgModuleFactory.create(parentModule.injector);
+        } else {
+          this._moduleRef = null;
+        }
+      }
+
+      const componentFactoryResolver = this._moduleRef ? this._moduleRef.componentFactoryResolver :
+                                                         elInjector.get(ComponentFactoryResolver);
+
+      const componentFactory =
+          componentFactoryResolver.resolveComponentFactory(this.ngComponentOutlet);
+
+      this._componentRef = this._viewContainerRef.createComponent(
+          componentFactory, this._viewContainerRef.length, elInjector,
+          this.ngComponentOutletContent);
+    }
+  }
+
+  ngOnDestroy() {
+    if (this._moduleRef) this._moduleRef.destroy();
+  }
+}
diff --git a/angular/common/src/directives/ng_for_of.ts b/angular/common/src/directives/ng_for_of.ts
new file mode 100644
index 0000000..1441567
--- /dev/null
+++ b/angular/common/src/directives/ng_for_of.ts
@@ -0,0 +1,214 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ChangeDetectorRef, Directive, DoCheck, EmbeddedViewRef, Input, IterableChangeRecord, IterableChanges, IterableDiffer, IterableDiffers, NgIterable, OnChanges, SimpleChanges, TemplateRef, TrackByFunction, ViewContainerRef, forwardRef, isDevMode} from '@angular/core';
+
+/**
+ * @stable
+ */
+export class NgForOfContext<T> {
+  constructor(
+      public $implicit: T, public ngForOf: NgIterable<T>, public index: number,
+      public count: number) {}
+
+  get first(): boolean { return this.index === 0; }
+
+  get last(): boolean { return this.index === this.count - 1; }
+
+  get even(): boolean { return this.index % 2 === 0; }
+
+  get odd(): boolean { return !this.even; }
+}
+
+/**
+ * The `NgForOf` directive instantiates a template once per item from an iterable. The context
+ * for each instantiated template inherits from the outer context with the given loop variable
+ * set to the current item from the iterable.
+ *
+ * ### Local Variables
+ *
+ * `NgForOf` provides several exported values that can be aliased to local variables:
+ *
+ * - `$implicit: T`: The value of the individual items in the iterable (`ngForOf`).
+ * - `ngForOf: NgIterable<T>`: The value of the iterable expression. Useful when the expression is
+ * more complex then a property access, for example when using the async pipe (`userStreams |
+ * async`).
+ * - `index: number`: The index of the current item in the iterable.
+ * - `first: boolean`: True when the item is the first item in the iterable.
+ * - `last: boolean`: True when the item is the last item in the iterable.
+ * - `even: boolean`: True when the item has an even index in the iterable.
+ * - `odd: boolean`: True when the item has an odd index in the iterable.
+ *
+ * ```
+ * <li *ngFor="let user of userObservable | async as users; index as i; first as isFirst">
+ *    {{i}}/{{users.length}}. {{user}} <span *ngIf="isFirst">default</span>
+ * </li>
+ * ```
+ *
+ * ### Change Propagation
+ *
+ * When the contents of the iterator changes, `NgForOf` makes the corresponding changes to the DOM:
+ *
+ * * When an item is added, a new instance of the template is added to the DOM.
+ * * When an item is removed, its template instance is removed from the DOM.
+ * * When items are reordered, their respective templates are reordered in the DOM.
+ * * Otherwise, the DOM element for that item will remain the same.
+ *
+ * Angular uses object identity to track insertions and deletions within the iterator and reproduce
+ * those changes in the DOM. This has important implications for animations and any stateful
+ * controls (such as `<input>` elements which accept user input) that are present. Inserted rows can
+ * be animated in, deleted rows can be animated out, and unchanged rows retain any unsaved state
+ * such as user input.
+ *
+ * It is possible for the identities of elements in the iterator to change while the data does not.
+ * This can happen, for example, if the iterator produced from an RPC to the server, and that
+ * RPC is re-run. Even if the data hasn't changed, the second response will produce objects with
+ * different identities, and Angular will tear down the entire DOM and rebuild it (as if all old
+ * elements were deleted and all new elements inserted). This is an expensive operation and should
+ * be avoided if possible.
+ *
+ * To customize the default tracking algorithm, `NgForOf` supports `trackBy` option.
+ * `trackBy` takes a function which has two arguments: `index` and `item`.
+ * If `trackBy` is given, Angular tracks changes by the return value of the function.
+ *
+ * ### Syntax
+ *
+ * - `<li *ngFor="let item of items; index as i; trackBy: trackByFn">...</li>`
+ * - `<li template="ngFor let item of items; index as i; trackBy: trackByFn">...</li>`
+ *
+ * With `<ng-template>` element:
+ *
+ * ```
+ * <ng-template ngFor let-item [ngForOf]="items" let-i="index" [ngForTrackBy]="trackByFn">
+ *   <li>...</li>
+ * </ng-template>
+ * ```
+ *
+ * ### Example
+ *
+ * See a [live demo](http://plnkr.co/edit/KVuXxDp0qinGDyo307QW?p=preview) for a more detailed
+ * example.
+ *
+ * @stable
+ */
+@Directive({selector: '[ngFor][ngForOf]'})
+export class NgForOf<T> implements DoCheck, OnChanges {
+  @Input() ngForOf: NgIterable<T>;
+  @Input()
+  set ngForTrackBy(fn: TrackByFunction<T>) {
+    if (isDevMode() && fn != null && typeof fn !== 'function') {
+      // TODO(vicb): use a log service once there is a public one available
+      if (<any>console && <any>console.warn) {
+        console.warn(
+            `trackBy must be a function, but received ${JSON.stringify(fn)}. ` +
+            `See https://angular.io/docs/ts/latest/api/common/index/NgFor-directive.html#!#change-propagation for more information.`);
+      }
+    }
+    this._trackByFn = fn;
+  }
+
+  get ngForTrackBy(): TrackByFunction<T> { return this._trackByFn; }
+
+  private _differ: IterableDiffer<T>|null = null;
+  private _trackByFn: TrackByFunction<T>;
+
+  constructor(
+      private _viewContainer: ViewContainerRef, private _template: TemplateRef<NgForOfContext<T>>,
+      private _differs: IterableDiffers) {}
+
+  @Input()
+  set ngForTemplate(value: TemplateRef<NgForOfContext<T>>) {
+    // TODO(TS2.1): make TemplateRef<Partial<NgForRowOf<T>>> once we move to TS v2.1
+    // The current type is too restrictive; a template that just uses index, for example,
+    // should be acceptable.
+    if (value) {
+      this._template = value;
+    }
+  }
+
+  ngOnChanges(changes: SimpleChanges): void {
+    if ('ngForOf' in changes) {
+      // React on ngForOf changes only once all inputs have been initialized
+      const value = changes['ngForOf'].currentValue;
+      if (!this._differ && value) {
+        try {
+          this._differ = this._differs.find(value).create(this.ngForTrackBy);
+        } catch (e) {
+          throw new Error(
+              `Cannot find a differ supporting object '${value}' of type '${getTypeNameForDebugging(value)}'. NgFor only supports binding to Iterables such as Arrays.`);
+        }
+      }
+    }
+  }
+
+  ngDoCheck(): void {
+    if (this._differ) {
+      const changes = this._differ.diff(this.ngForOf);
+      if (changes) this._applyChanges(changes);
+    }
+  }
+
+  private _applyChanges(changes: IterableChanges<T>) {
+    const insertTuples: RecordViewTuple<T>[] = [];
+    changes.forEachOperation(
+        (item: IterableChangeRecord<any>, adjustedPreviousIndex: number, currentIndex: number) => {
+          if (item.previousIndex == null) {
+            const view = this._viewContainer.createEmbeddedView(
+                this._template, new NgForOfContext<T>(null !, this.ngForOf, -1, -1), currentIndex);
+            const tuple = new RecordViewTuple<T>(item, view);
+            insertTuples.push(tuple);
+          } else if (currentIndex == null) {
+            this._viewContainer.remove(adjustedPreviousIndex);
+          } else {
+            const view = this._viewContainer.get(adjustedPreviousIndex) !;
+            this._viewContainer.move(view, currentIndex);
+            const tuple = new RecordViewTuple(item, <EmbeddedViewRef<NgForOfContext<T>>>view);
+            insertTuples.push(tuple);
+          }
+        });
+
+    for (let i = 0; i < insertTuples.length; i++) {
+      this._perViewChange(insertTuples[i].view, insertTuples[i].record);
+    }
+
+    for (let i = 0, ilen = this._viewContainer.length; i < ilen; i++) {
+      const viewRef = <EmbeddedViewRef<NgForOfContext<T>>>this._viewContainer.get(i);
+      viewRef.context.index = i;
+      viewRef.context.count = ilen;
+    }
+
+    changes.forEachIdentityChange((record: any) => {
+      const viewRef =
+          <EmbeddedViewRef<NgForOfContext<T>>>this._viewContainer.get(record.currentIndex);
+      viewRef.context.$implicit = record.item;
+    });
+  }
+
+  private _perViewChange(
+      view: EmbeddedViewRef<NgForOfContext<T>>, record: IterableChangeRecord<any>) {
+    view.context.$implicit = record.item;
+  }
+}
+
+class RecordViewTuple<T> {
+  constructor(public record: any, public view: EmbeddedViewRef<NgForOfContext<T>>) {}
+}
+
+/**
+ * @deprecated from v4.0.0 - Use NgForOf<any> instead.
+ */
+export type NgFor = NgForOf<any>;
+
+/**
+ * @deprecated from v4.0.0 - Use NgForOf instead.
+ */
+export const NgFor = NgForOf;
+
+export function getTypeNameForDebugging(type: any): string {
+  return type['name'] || typeof type;
+}
diff --git a/angular/common/src/directives/ng_if.ts b/angular/common/src/directives/ng_if.ts
new file mode 100644
index 0000000..8943fd6
--- /dev/null
+++ b/angular/common/src/directives/ng_if.ts
@@ -0,0 +1,163 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Directive, EmbeddedViewRef, Input, TemplateRef, ViewContainerRef} from '@angular/core';
+
+
+/**
+ * Conditionally includes a template based on the value of an `expression`.
+ *
+ * `ngIf` evaluates the `expression` and then renders the `then` or `else` template in its place
+ * when expression is truthy or falsy respectively. Typically the:
+ *  - `then` template is the inline template of `ngIf` unless bound to a different value.
+ *  - `else` template is blank unless it is bound.
+ *
+ * ## Most common usage
+ *
+ * The most common usage of the `ngIf` directive is to conditionally show the inline template as
+ * seen in this example:
+ * {@example common/ngIf/ts/module.ts region='NgIfSimple'}
+ *
+ * ## Showing an alternative template using `else`
+ *
+ * If it is necessary to display a template when the `expression` is falsy use the `else` template
+ * binding as shown. Note that the `else` binding points to a `<ng-template>` labeled `#elseBlock`.
+ * The template can be defined anywhere in the component view but is typically placed right after
+ * `ngIf` for readability.
+ *
+ * {@example common/ngIf/ts/module.ts region='NgIfElse'}
+ *
+ * ## Using non-inlined `then` template
+ *
+ * Usually the `then` template is the inlined template of the `ngIf`, but it can be changed using
+ * a binding (just like `else`). Because `then` and `else` are bindings, the template references can
+ * change at runtime as shown in this example.
+ *
+ * {@example common/ngIf/ts/module.ts region='NgIfThenElse'}
+ *
+ * ## Storing conditional result in a variable
+ *
+ * A common pattern is that we need to show a set of properties from the same object. If the
+ * object is undefined, then we have to use the safe-traversal-operator `?.` to guard against
+ * dereferencing a `null` value. This is especially the case when waiting on async data such as
+ * when using the `async` pipe as shown in following example:
+ *
+ * ```
+ * Hello {{ (userStream|async)?.last }}, {{ (userStream|async)?.first }}!
+ * ```
+ *
+ * There are several inefficiencies in the above example:
+ *  - We create multiple subscriptions on `userStream`. One for each `async` pipe, or two in the
+ *    example above.
+ *  - We cannot display an alternative screen while waiting for the data to arrive asynchronously.
+ *  - We have to use the safe-traversal-operator `?.` to access properties, which is cumbersome.
+ *  - We have to place the `async` pipe in parenthesis.
+ *
+ * A better way to do this is to use `ngIf` and store the result of the condition in a local
+ * variable as shown in the the example below:
+ *
+ * {@example common/ngIf/ts/module.ts region='NgIfAs'}
+ *
+ * Notice that:
+ *  - We use only one `async` pipe and hence only one subscription gets created.
+ *  - `ngIf` stores the result of the `userStream|async` in the local variable `user`.
+ *  - The local `user` can then be bound repeatedly in a more efficient way.
+ *  - No need to use the safe-traversal-operator `?.` to access properties as `ngIf` will only
+ *    display the data if `userStream` returns a value.
+ *  - We can display an alternative template while waiting for the data.
+ *
+ * ### Syntax
+ *
+ * Simple form:
+ * - `<div *ngIf="condition">...</div>`
+ * - `<div template="ngIf condition">...</div>`
+ * - `<ng-template [ngIf]="condition"><div>...</div></ng-template>`
+ *
+ * Form with an else block:
+ * ```
+ * <div *ngIf="condition; else elseBlock">...</div>
+ * <ng-template #elseBlock>...</ng-template>
+ * ```
+ *
+ * Form with a `then` and `else` block:
+ * ```
+ * <div *ngIf="condition; then thenBlock else elseBlock"></div>
+ * <ng-template #thenBlock>...</ng-template>
+ * <ng-template #elseBlock>...</ng-template>
+ * ```
+ *
+ * Form with storing the value locally:
+ * ```
+ * <div *ngIf="condition as value; else elseBlock">{{value}}</div>
+ * <ng-template #elseBlock>...</ng-template>
+ * ```
+ *
+ * @stable
+ */
+@Directive({selector: '[ngIf]'})
+export class NgIf {
+  private _context: NgIfContext = new NgIfContext();
+  private _thenTemplateRef: TemplateRef<NgIfContext>|null = null;
+  private _elseTemplateRef: TemplateRef<NgIfContext>|null = null;
+  private _thenViewRef: EmbeddedViewRef<NgIfContext>|null = null;
+  private _elseViewRef: EmbeddedViewRef<NgIfContext>|null = null;
+
+  constructor(private _viewContainer: ViewContainerRef, templateRef: TemplateRef<NgIfContext>) {
+    this._thenTemplateRef = templateRef;
+  }
+
+  @Input()
+  set ngIf(condition: any) {
+    this._context.$implicit = this._context.ngIf = condition;
+    this._updateView();
+  }
+
+  @Input()
+  set ngIfThen(templateRef: TemplateRef<NgIfContext>) {
+    this._thenTemplateRef = templateRef;
+    this._thenViewRef = null;  // clear previous view if any.
+    this._updateView();
+  }
+
+  @Input()
+  set ngIfElse(templateRef: TemplateRef<NgIfContext>) {
+    this._elseTemplateRef = templateRef;
+    this._elseViewRef = null;  // clear previous view if any.
+    this._updateView();
+  }
+
+  private _updateView() {
+    if (this._context.$implicit) {
+      if (!this._thenViewRef) {
+        this._viewContainer.clear();
+        this._elseViewRef = null;
+        if (this._thenTemplateRef) {
+          this._thenViewRef =
+              this._viewContainer.createEmbeddedView(this._thenTemplateRef, this._context);
+        }
+      }
+    } else {
+      if (!this._elseViewRef) {
+        this._viewContainer.clear();
+        this._thenViewRef = null;
+        if (this._elseTemplateRef) {
+          this._elseViewRef =
+              this._viewContainer.createEmbeddedView(this._elseTemplateRef, this._context);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @stable
+ */
+export class NgIfContext {
+  public $implicit: any = null;
+  public ngIf: any = null;
+}
diff --git a/angular/common/src/directives/ng_plural.ts b/angular/common/src/directives/ng_plural.ts
new file mode 100644
index 0000000..e014a5e
--- /dev/null
+++ b/angular/common/src/directives/ng_plural.ts
@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Attribute, Directive, Host, Input, TemplateRef, ViewContainerRef} from '@angular/core';
+
+import {NgLocalization, getPluralCategory} from '../localization';
+
+import {SwitchView} from './ng_switch';
+
+
+/**
+ * @ngModule CommonModule
+ *
+ * @whatItDoes Adds / removes DOM sub-trees based on a numeric value. Tailored for pluralization.
+ *
+ * @howToUse
+ * ```
+ * <some-element [ngPlural]="value">
+ *   <ng-template ngPluralCase="=0">there is nothing</ng-template>
+ *   <ng-template ngPluralCase="=1">there is one</ng-template>
+ *   <ng-template ngPluralCase="few">there are a few</ng-template>
+ * </some-element>
+ * ```
+ *
+ * @description
+ *
+ * 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 a container element that sets the `[ngPlural]` attribute
+ * to a switch expression. Inner elements with a `[ngPluralCase]` 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 for the defined locale.
+ *
+ * See http://cldr.unicode.org/index/cldr-spec/plural-rules
+ *
+ * @experimental
+ */
+@Directive({selector: '[ngPlural]'})
+export class NgPlural {
+  private _switchValue: number;
+  private _activeView: SwitchView;
+  private _caseViews: {[k: string]: SwitchView} = {};
+
+  constructor(private _localization: NgLocalization) {}
+
+  @Input()
+  set ngPlural(value: number) {
+    this._switchValue = value;
+    this._updateView();
+  }
+
+  addCase(value: string, switchView: SwitchView): void { this._caseViews[value] = switchView; }
+
+  private _updateView(): void {
+    this._clearViews();
+
+    const cases = Object.keys(this._caseViews);
+    const key = getPluralCategory(this._switchValue, cases, this._localization);
+    this._activateView(this._caseViews[key]);
+  }
+
+  private _clearViews() {
+    if (this._activeView) this._activeView.destroy();
+  }
+
+  private _activateView(view: SwitchView) {
+    if (view) {
+      this._activeView = view;
+      this._activeView.create();
+    }
+  }
+}
+
+/**
+ * @ngModule CommonModule
+ *
+ * @whatItDoes Creates a view that will be added/removed from the parent {@link NgPlural} when the
+ *             given expression matches the plural expression according to CLDR rules.
+ *
+ * @howToUse
+ * ```
+ * <some-element [ngPlural]="value">
+ *   <ng-template ngPluralCase="=0">...</ng-template>
+ *   <ng-template ngPluralCase="other">...</ng-template>
+ * </some-element>
+ *```
+ *
+ * See {@link NgPlural} for more details and example.
+ *
+ * @experimental
+ */
+@Directive({selector: '[ngPluralCase]'})
+export class NgPluralCase {
+  constructor(
+      @Attribute('ngPluralCase') public value: string, template: TemplateRef<Object>,
+      viewContainer: ViewContainerRef, @Host() ngPlural: NgPlural) {
+    const isANumber: boolean = !isNaN(Number(value));
+    ngPlural.addCase(isANumber ? `=${value}` : value, new SwitchView(viewContainer, template));
+  }
+}
diff --git a/angular/common/src/directives/ng_style.ts b/angular/common/src/directives/ng_style.ts
new file mode 100644
index 0000000..524f482
--- /dev/null
+++ b/angular/common/src/directives/ng_style.ts
@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Directive, DoCheck, ElementRef, Input, KeyValueChanges, KeyValueDiffer, KeyValueDiffers, Renderer} from '@angular/core';
+
+/**
+ * @ngModule CommonModule
+ *
+ * @whatItDoes Update an HTML element styles.
+ *
+ * @howToUse
+ * ```
+ * <some-element [ngStyle]="{'font-style': styleExp}">...</some-element>
+ *
+ * <some-element [ngStyle]="{'max-width.px': widthExp}">...</some-element>
+ *
+ * <some-element [ngStyle]="objExp">...</some-element>
+ * ```
+ *
+ * @description
+ *
+ * The styles are updated according to the value of the expression evaluation:
+ * - keys are style names with an optional `.<unit>` suffix (ie 'top.px', 'font-style.em'),
+ * - values are the values assigned to those properties (expressed in the given unit).
+ *
+ * @stable
+ */
+@Directive({selector: '[ngStyle]'})
+export class NgStyle implements DoCheck {
+  private _ngStyle: {[key: string]: string};
+  private _differ: KeyValueDiffer<string, string|number>;
+
+  constructor(
+      private _differs: KeyValueDiffers, private _ngEl: ElementRef, private _renderer: Renderer) {}
+
+  @Input()
+  set ngStyle(v: {[key: string]: string}) {
+    this._ngStyle = v;
+    if (!this._differ && v) {
+      this._differ = this._differs.find(v).create();
+    }
+  }
+
+  ngDoCheck() {
+    if (this._differ) {
+      const changes = this._differ.diff(this._ngStyle);
+      if (changes) {
+        this._applyChanges(changes);
+      }
+    }
+  }
+
+  private _applyChanges(changes: KeyValueChanges<string, string|number>): void {
+    changes.forEachRemovedItem((record) => this._setStyle(record.key, null));
+    changes.forEachAddedItem((record) => this._setStyle(record.key, record.currentValue));
+    changes.forEachChangedItem((record) => this._setStyle(record.key, record.currentValue));
+  }
+
+  private _setStyle(nameAndUnit: string, value: string|number|null|undefined): void {
+    const [name, unit] = nameAndUnit.split('.');
+    value = value != null && unit ? `${value}${unit}` : value;
+
+    this._renderer.setElementStyle(this._ngEl.nativeElement, name, value as string);
+  }
+}
diff --git a/angular/common/src/directives/ng_switch.ts b/angular/common/src/directives/ng_switch.ts
new file mode 100644
index 0000000..1e7f10d
--- /dev/null
+++ b/angular/common/src/directives/ng_switch.ts
@@ -0,0 +1,200 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Directive, DoCheck, Host, Input, TemplateRef, ViewContainerRef} from '@angular/core';
+
+export class SwitchView {
+  private _created = false;
+
+  constructor(
+      private _viewContainerRef: ViewContainerRef, private _templateRef: TemplateRef<Object>) {}
+
+  create(): void {
+    this._created = true;
+    this._viewContainerRef.createEmbeddedView(this._templateRef);
+  }
+
+  destroy(): void {
+    this._created = false;
+    this._viewContainerRef.clear();
+  }
+
+  enforceState(created: boolean) {
+    if (created && !this._created) {
+      this.create();
+    } else if (!created && this._created) {
+      this.destroy();
+    }
+  }
+}
+
+/**
+ * @ngModule CommonModule
+ *
+ * @whatItDoes Adds / removes DOM sub-trees when the nest match expressions matches the switch
+ *             expression.
+ *
+ * @howToUse
+ * ```
+ *     <container-element [ngSwitch]="switch_expression">
+ *       <some-element *ngSwitchCase="match_expression_1">...</some-element>
+ *       <some-element *ngSwitchCase="match_expression_2">...</some-element>
+ *       <some-other-element *ngSwitchCase="match_expression_3">...</some-other-element>
+ *       <ng-container *ngSwitchCase="match_expression_3">
+ *         <!-- use a ng-container to group multiple root nodes -->
+ *         <inner-element></inner-element>
+ *         <inner-other-element></inner-other-element>
+ *       </ng-container>
+ *       <some-element *ngSwitchDefault>...</some-element>
+ *     </container-element>
+ * ```
+ * @description
+ *
+ * `NgSwitch` stamps out nested views when their match expression value matches the value of the
+ * switch expression.
+ *
+ * In other words:
+ * - you define a container element (where you place the directive with a switch expression on the
+ * `[ngSwitch]="..."` attribute)
+ * - you define inner views inside the `NgSwitch` and place a `*ngSwitchCase` attribute on the view
+ * root elements.
+ *
+ * Elements within `NgSwitch` but outside of a `NgSwitchCase` or `NgSwitchDefault` directives will
+ * be preserved at the location.
+ *
+ * The `ngSwitchCase` directive informs the parent `NgSwitch` of which view to display when the
+ * expression is evaluated.
+ * When no matching expression is found on a `ngSwitchCase` view, the `ngSwitchDefault` view is
+ * stamped out.
+ *
+ * @stable
+ */
+@Directive({selector: '[ngSwitch]'})
+export class NgSwitch {
+  private _defaultViews: SwitchView[];
+  private _defaultUsed = false;
+  private _caseCount = 0;
+  private _lastCaseCheckIndex = 0;
+  private _lastCasesMatched = false;
+  private _ngSwitch: any;
+
+  @Input()
+  set ngSwitch(newValue: any) {
+    this._ngSwitch = newValue;
+    if (this._caseCount === 0) {
+      this._updateDefaultCases(true);
+    }
+  }
+
+  /** @internal */
+  _addCase(): number { return this._caseCount++; }
+
+  /** @internal */
+  _addDefault(view: SwitchView) {
+    if (!this._defaultViews) {
+      this._defaultViews = [];
+    }
+    this._defaultViews.push(view);
+  }
+
+  /** @internal */
+  _matchCase(value: any): boolean {
+    const matched = value == this._ngSwitch;
+    this._lastCasesMatched = this._lastCasesMatched || matched;
+    this._lastCaseCheckIndex++;
+    if (this._lastCaseCheckIndex === this._caseCount) {
+      this._updateDefaultCases(!this._lastCasesMatched);
+      this._lastCaseCheckIndex = 0;
+      this._lastCasesMatched = false;
+    }
+    return matched;
+  }
+
+  private _updateDefaultCases(useDefault: boolean) {
+    if (this._defaultViews && useDefault !== this._defaultUsed) {
+      this._defaultUsed = useDefault;
+      for (let i = 0; i < this._defaultViews.length; i++) {
+        const defaultView = this._defaultViews[i];
+        defaultView.enforceState(useDefault);
+      }
+    }
+  }
+}
+
+/**
+ * @ngModule CommonModule
+ *
+ * @whatItDoes Creates a view that will be added/removed from the parent {@link NgSwitch} when the
+ *             given expression evaluate to respectively the same/different value as the switch
+ *             expression.
+ *
+ * @howToUse
+ * ```
+ * <container-element [ngSwitch]="switch_expression">
+ *   <some-element *ngSwitchCase="match_expression_1">...</some-element>
+ * </container-element>
+ *```
+ * @description
+ *
+ * Insert the sub-tree when the expression evaluates to the same value as the enclosing switch
+ * expression.
+ *
+ * If multiple match expressions match the switch expression value, all of them are displayed.
+ *
+ * See {@link NgSwitch} for more details and example.
+ *
+ * @stable
+ */
+@Directive({selector: '[ngSwitchCase]'})
+export class NgSwitchCase implements DoCheck {
+  private _view: SwitchView;
+
+  @Input()
+  ngSwitchCase: any;
+
+  constructor(
+      viewContainer: ViewContainerRef, templateRef: TemplateRef<Object>,
+      @Host() private ngSwitch: NgSwitch) {
+    ngSwitch._addCase();
+    this._view = new SwitchView(viewContainer, templateRef);
+  }
+
+  ngDoCheck() { this._view.enforceState(this.ngSwitch._matchCase(this.ngSwitchCase)); }
+}
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Creates a view that is added to the parent {@link NgSwitch} when no case expressions
+ * match the
+ *             switch expression.
+ *
+ * @howToUse
+ * ```
+ * <container-element [ngSwitch]="switch_expression">
+ *   <some-element *ngSwitchCase="match_expression_1">...</some-element>
+ *   <some-other-element *ngSwitchDefault>...</some-other-element>
+ * </container-element>
+ * ```
+ *
+ * @description
+ *
+ * Insert the sub-tree when no case expressions evaluate to the same value as the enclosing switch
+ * expression.
+ *
+ * See {@link NgSwitch} for more details and example.
+ *
+ * @stable
+ */
+@Directive({selector: '[ngSwitchDefault]'})
+export class NgSwitchDefault {
+  constructor(
+      viewContainer: ViewContainerRef, templateRef: TemplateRef<Object>,
+      @Host() ngSwitch: NgSwitch) {
+    ngSwitch._addDefault(new SwitchView(viewContainer, templateRef));
+  }
+}
diff --git a/angular/common/src/directives/ng_template_outlet.ts b/angular/common/src/directives/ng_template_outlet.ts
new file mode 100644
index 0000000..5912f9c
--- /dev/null
+++ b/angular/common/src/directives/ng_template_outlet.ts
@@ -0,0 +1,106 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Directive, EmbeddedViewRef, Input, OnChanges, SimpleChange, SimpleChanges, TemplateRef, ViewContainerRef} from '@angular/core';
+
+/**
+ * @ngModule CommonModule
+ *
+ * @whatItDoes Inserts an embedded view from a prepared `TemplateRef`
+ *
+ * @howToUse
+ * ```
+ * <ng-container *ngTemplateOutlet="templateRefExp; context: contextExp"></ng-container>
+ * ```
+ *
+ * @description
+ *
+ * You can attach a context object to the `EmbeddedViewRef` by setting `[ngTemplateOutletContext]`.
+ * `[ngTemplateOutletContext]` should be an object, the object's keys will be available for binding
+ * by the local template `let` declarations.
+ *
+ * Note: using the key `$implicit` in the context object will set it's value as default.
+ *
+ * ## Example
+ *
+ * {@example common/ngTemplateOutlet/ts/module.ts region='NgTemplateOutlet'}
+ *
+ * @stable
+ */
+@Directive({selector: '[ngTemplateOutlet]'})
+export class NgTemplateOutlet implements OnChanges {
+  private _viewRef: EmbeddedViewRef<any>;
+
+  @Input() public ngTemplateOutletContext: Object;
+
+  @Input() public ngTemplateOutlet: TemplateRef<any>;
+
+  constructor(private _viewContainerRef: ViewContainerRef) {}
+
+  /**
+   * @deprecated v4.0.0 - Renamed to ngTemplateOutletContext.
+   */
+  @Input()
+  set ngOutletContext(context: Object) { this.ngTemplateOutletContext = context; }
+
+  ngOnChanges(changes: SimpleChanges) {
+    const recreateView = this._shouldRecreateView(changes);
+
+    if (recreateView) {
+      if (this._viewRef) {
+        this._viewContainerRef.remove(this._viewContainerRef.indexOf(this._viewRef));
+      }
+
+      if (this.ngTemplateOutlet) {
+        this._viewRef = this._viewContainerRef.createEmbeddedView(
+            this.ngTemplateOutlet, this.ngTemplateOutletContext);
+      }
+    } else {
+      if (this._viewRef && this.ngTemplateOutletContext) {
+        this._updateExistingContext(this.ngTemplateOutletContext);
+      }
+    }
+  }
+
+  /**
+   * We need to re-create existing embedded view if:
+   * - templateRef has changed
+   * - context has changes
+   *
+   * We mark context object as changed when the corresponding object
+   * shape changes (new properties are added or existing properties are removed).
+   * In other words we consider context with the same properties as "the same" even
+   * if object reference changes (see https://github.com/angular/angular/issues/13407).
+   */
+  private _shouldRecreateView(changes: SimpleChanges): boolean {
+    const ctxChange = changes['ngTemplateOutletContext'];
+    return !!changes['ngTemplateOutlet'] || (ctxChange && this._hasContextShapeChanged(ctxChange));
+  }
+
+  private _hasContextShapeChanged(ctxChange: SimpleChange): boolean {
+    const prevCtxKeys = Object.keys(ctxChange.previousValue || {});
+    const currCtxKeys = Object.keys(ctxChange.currentValue || {});
+
+    if (prevCtxKeys.length === currCtxKeys.length) {
+      for (let propName of currCtxKeys) {
+        if (prevCtxKeys.indexOf(propName) === -1) {
+          return true;
+        }
+      }
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  private _updateExistingContext(ctx: Object): void {
+    for (let propName of Object.keys(ctx)) {
+      (<any>this._viewRef.context)[propName] = (<any>this.ngTemplateOutletContext)[propName];
+    }
+  }
+}
diff --git a/angular/common/src/dom_tokens.ts b/angular/common/src/dom_tokens.ts
new file mode 100644
index 0000000..c31db44
--- /dev/null
+++ b/angular/common/src/dom_tokens.ts
@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {InjectionToken} from '@angular/core';
+
+/**
+ * A DI Token representing the main rendering context. In a browser this is the DOM Document.
+ *
+ * Note: Document might not be available in the Application Context when Application and Rendering
+ * Contexts are not the same (e.g. when running the application into a Web Worker).
+ *
+ * @stable
+ */
+export const DOCUMENT = new InjectionToken<Document>('DocumentToken');
diff --git a/angular/common/src/localization.ts b/angular/common/src/localization.ts
new file mode 100644
index 0000000..c2deb74
--- /dev/null
+++ b/angular/common/src/localization.ts
@@ -0,0 +1,401 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, Injectable, LOCALE_ID} from '@angular/core';
+
+/**
+ * @experimental
+ */
+export abstract class NgLocalization { abstract getPluralCategory(value: any): string; }
+
+
+/**
+ * Returns the plural category for a given value.
+ * - "=value" when the case exists,
+ * - the plural category otherwise
+ *
+ * @internal
+ */
+export function getPluralCategory(
+    value: number, cases: string[], ngLocalization: NgLocalization): string {
+  let key = `=${value}`;
+
+  if (cases.indexOf(key) > -1) {
+    return key;
+  }
+
+  key = ngLocalization.getPluralCategory(value);
+
+  if (cases.indexOf(key) > -1) {
+    return key;
+  }
+
+  if (cases.indexOf('other') > -1) {
+    return 'other';
+  }
+
+  throw new Error(`No plural message found for value "${value}"`);
+}
+
+/**
+ * Returns the plural case based on the locale
+ *
+ * @experimental
+ */
+@Injectable()
+export class NgLocaleLocalization extends NgLocalization {
+  constructor(@Inject(LOCALE_ID) protected locale: string) { super(); }
+
+  getPluralCategory(value: any): string {
+    const plural = getPluralCase(this.locale, value);
+
+    switch (plural) {
+      case Plural.Zero:
+        return 'zero';
+      case Plural.One:
+        return 'one';
+      case Plural.Two:
+        return 'two';
+      case Plural.Few:
+        return 'few';
+      case Plural.Many:
+        return 'many';
+      default:
+        return 'other';
+    }
+  }
+}
+
+// This is generated code DO NOT MODIFY
+// see angular/script/cldr/gen_plural_rules.js
+
+/** @experimental */
+export enum Plural {
+  Zero,
+  One,
+  Two,
+  Few,
+  Many,
+  Other,
+}
+
+/**
+ * Returns the plural case based on the locale
+ *
+ * @experimental
+ */
+export function getPluralCase(locale: string, nLike: number | string): Plural {
+  // TODO(vicb): lazy compute
+  if (typeof nLike === 'string') {
+    nLike = parseInt(<string>nLike, 10);
+  }
+  const n: number = nLike as number;
+  const nDecimal = n.toString().replace(/^[^.]*\.?/, '');
+  const i = Math.floor(Math.abs(n));
+  const v = nDecimal.length;
+  const f = parseInt(nDecimal, 10);
+  const t = parseInt(n.toString().replace(/^[^.]*\.?|0+$/g, ''), 10) || 0;
+
+  const lang = locale.split('-')[0].toLowerCase();
+
+  switch (lang) {
+    case 'af':
+    case 'asa':
+    case 'az':
+    case 'bem':
+    case 'bez':
+    case 'bg':
+    case 'brx':
+    case 'ce':
+    case 'cgg':
+    case 'chr':
+    case 'ckb':
+    case 'ee':
+    case 'el':
+    case 'eo':
+    case 'es':
+    case 'eu':
+    case 'fo':
+    case 'fur':
+    case 'gsw':
+    case 'ha':
+    case 'haw':
+    case 'hu':
+    case 'jgo':
+    case 'jmc':
+    case 'ka':
+    case 'kk':
+    case 'kkj':
+    case 'kl':
+    case 'ks':
+    case 'ksb':
+    case 'ky':
+    case 'lb':
+    case 'lg':
+    case 'mas':
+    case 'mgo':
+    case 'ml':
+    case 'mn':
+    case 'nb':
+    case 'nd':
+    case 'ne':
+    case 'nn':
+    case 'nnh':
+    case 'nyn':
+    case 'om':
+    case 'or':
+    case 'os':
+    case 'ps':
+    case 'rm':
+    case 'rof':
+    case 'rwk':
+    case 'saq':
+    case 'seh':
+    case 'sn':
+    case 'so':
+    case 'sq':
+    case 'ta':
+    case 'te':
+    case 'teo':
+    case 'tk':
+    case 'tr':
+    case 'ug':
+    case 'uz':
+    case 'vo':
+    case 'vun':
+    case 'wae':
+    case 'xog':
+      if (n === 1) return Plural.One;
+      return Plural.Other;
+    case 'ak':
+    case 'ln':
+    case 'mg':
+    case 'pa':
+    case 'ti':
+      if (n === Math.floor(n) && n >= 0 && n <= 1) return Plural.One;
+      return Plural.Other;
+    case 'am':
+    case 'as':
+    case 'bn':
+    case 'fa':
+    case 'gu':
+    case 'hi':
+    case 'kn':
+    case 'mr':
+    case 'zu':
+      if (i === 0 || n === 1) return Plural.One;
+      return Plural.Other;
+    case 'ar':
+      if (n === 0) return Plural.Zero;
+      if (n === 1) return Plural.One;
+      if (n === 2) return Plural.Two;
+      if (n % 100 === Math.floor(n % 100) && n % 100 >= 3 && n % 100 <= 10) return Plural.Few;
+      if (n % 100 === Math.floor(n % 100) && n % 100 >= 11 && n % 100 <= 99) return Plural.Many;
+      return Plural.Other;
+    case 'ast':
+    case 'ca':
+    case 'de':
+    case 'en':
+    case 'et':
+    case 'fi':
+    case 'fy':
+    case 'gl':
+    case 'it':
+    case 'nl':
+    case 'sv':
+    case 'sw':
+    case 'ur':
+    case 'yi':
+      if (i === 1 && v === 0) return Plural.One;
+      return Plural.Other;
+    case 'be':
+      if (n % 10 === 1 && !(n % 100 === 11)) return Plural.One;
+      if (n % 10 === Math.floor(n % 10) && n % 10 >= 2 && n % 10 <= 4 &&
+          !(n % 100 >= 12 && n % 100 <= 14))
+        return Plural.Few;
+      if (n % 10 === 0 || n % 10 === Math.floor(n % 10) && n % 10 >= 5 && n % 10 <= 9 ||
+          n % 100 === Math.floor(n % 100) && n % 100 >= 11 && n % 100 <= 14)
+        return Plural.Many;
+      return Plural.Other;
+    case 'br':
+      if (n % 10 === 1 && !(n % 100 === 11 || n % 100 === 71 || n % 100 === 91)) return Plural.One;
+      if (n % 10 === 2 && !(n % 100 === 12 || n % 100 === 72 || n % 100 === 92)) return Plural.Two;
+      if (n % 10 === Math.floor(n % 10) && (n % 10 >= 3 && n % 10 <= 4 || n % 10 === 9) &&
+          !(n % 100 >= 10 && n % 100 <= 19 || n % 100 >= 70 && n % 100 <= 79 ||
+            n % 100 >= 90 && n % 100 <= 99))
+        return Plural.Few;
+      if (!(n === 0) && n % 1e6 === 0) return Plural.Many;
+      return Plural.Other;
+    case 'bs':
+    case 'hr':
+    case 'sr':
+      if (v === 0 && i % 10 === 1 && !(i % 100 === 11) || f % 10 === 1 && !(f % 100 === 11))
+        return Plural.One;
+      if (v === 0 && i % 10 === Math.floor(i % 10) && i % 10 >= 2 && i % 10 <= 4 &&
+              !(i % 100 >= 12 && i % 100 <= 14) ||
+          f % 10 === Math.floor(f % 10) && f % 10 >= 2 && f % 10 <= 4 &&
+              !(f % 100 >= 12 && f % 100 <= 14))
+        return Plural.Few;
+      return Plural.Other;
+    case 'cs':
+    case 'sk':
+      if (i === 1 && v === 0) return Plural.One;
+      if (i === Math.floor(i) && i >= 2 && i <= 4 && v === 0) return Plural.Few;
+      if (!(v === 0)) return Plural.Many;
+      return Plural.Other;
+    case 'cy':
+      if (n === 0) return Plural.Zero;
+      if (n === 1) return Plural.One;
+      if (n === 2) return Plural.Two;
+      if (n === 3) return Plural.Few;
+      if (n === 6) return Plural.Many;
+      return Plural.Other;
+    case 'da':
+      if (n === 1 || !(t === 0) && (i === 0 || i === 1)) return Plural.One;
+      return Plural.Other;
+    case 'dsb':
+    case 'hsb':
+      if (v === 0 && i % 100 === 1 || f % 100 === 1) return Plural.One;
+      if (v === 0 && i % 100 === 2 || f % 100 === 2) return Plural.Two;
+      if (v === 0 && i % 100 === Math.floor(i % 100) && i % 100 >= 3 && i % 100 <= 4 ||
+          f % 100 === Math.floor(f % 100) && f % 100 >= 3 && f % 100 <= 4)
+        return Plural.Few;
+      return Plural.Other;
+    case 'ff':
+    case 'fr':
+    case 'hy':
+    case 'kab':
+      if (i === 0 || i === 1) return Plural.One;
+      return Plural.Other;
+    case 'fil':
+      if (v === 0 && (i === 1 || i === 2 || i === 3) ||
+          v === 0 && !(i % 10 === 4 || i % 10 === 6 || i % 10 === 9) ||
+          !(v === 0) && !(f % 10 === 4 || f % 10 === 6 || f % 10 === 9))
+        return Plural.One;
+      return Plural.Other;
+    case 'ga':
+      if (n === 1) return Plural.One;
+      if (n === 2) return Plural.Two;
+      if (n === Math.floor(n) && n >= 3 && n <= 6) return Plural.Few;
+      if (n === Math.floor(n) && n >= 7 && n <= 10) return Plural.Many;
+      return Plural.Other;
+    case 'gd':
+      if (n === 1 || n === 11) return Plural.One;
+      if (n === 2 || n === 12) return Plural.Two;
+      if (n === Math.floor(n) && (n >= 3 && n <= 10 || n >= 13 && n <= 19)) return Plural.Few;
+      return Plural.Other;
+    case 'gv':
+      if (v === 0 && i % 10 === 1) return Plural.One;
+      if (v === 0 && i % 10 === 2) return Plural.Two;
+      if (v === 0 &&
+          (i % 100 === 0 || i % 100 === 20 || i % 100 === 40 || i % 100 === 60 || i % 100 === 80))
+        return Plural.Few;
+      if (!(v === 0)) return Plural.Many;
+      return Plural.Other;
+    case 'he':
+      if (i === 1 && v === 0) return Plural.One;
+      if (i === 2 && v === 0) return Plural.Two;
+      if (v === 0 && !(n >= 0 && n <= 10) && n % 10 === 0) return Plural.Many;
+      return Plural.Other;
+    case 'is':
+      if (t === 0 && i % 10 === 1 && !(i % 100 === 11) || !(t === 0)) return Plural.One;
+      return Plural.Other;
+    case 'ksh':
+      if (n === 0) return Plural.Zero;
+      if (n === 1) return Plural.One;
+      return Plural.Other;
+    case 'kw':
+    case 'naq':
+    case 'se':
+    case 'smn':
+      if (n === 1) return Plural.One;
+      if (n === 2) return Plural.Two;
+      return Plural.Other;
+    case 'lag':
+      if (n === 0) return Plural.Zero;
+      if ((i === 0 || i === 1) && !(n === 0)) return Plural.One;
+      return Plural.Other;
+    case 'lt':
+      if (n % 10 === 1 && !(n % 100 >= 11 && n % 100 <= 19)) return Plural.One;
+      if (n % 10 === Math.floor(n % 10) && n % 10 >= 2 && n % 10 <= 9 &&
+          !(n % 100 >= 11 && n % 100 <= 19))
+        return Plural.Few;
+      if (!(f === 0)) return Plural.Many;
+      return Plural.Other;
+    case 'lv':
+    case 'prg':
+      if (n % 10 === 0 || n % 100 === Math.floor(n % 100) && n % 100 >= 11 && n % 100 <= 19 ||
+          v === 2 && f % 100 === Math.floor(f % 100) && f % 100 >= 11 && f % 100 <= 19)
+        return Plural.Zero;
+      if (n % 10 === 1 && !(n % 100 === 11) || v === 2 && f % 10 === 1 && !(f % 100 === 11) ||
+          !(v === 2) && f % 10 === 1)
+        return Plural.One;
+      return Plural.Other;
+    case 'mk':
+      if (v === 0 && i % 10 === 1 || f % 10 === 1) return Plural.One;
+      return Plural.Other;
+    case 'mt':
+      if (n === 1) return Plural.One;
+      if (n === 0 || n % 100 === Math.floor(n % 100) && n % 100 >= 2 && n % 100 <= 10)
+        return Plural.Few;
+      if (n % 100 === Math.floor(n % 100) && n % 100 >= 11 && n % 100 <= 19) return Plural.Many;
+      return Plural.Other;
+    case 'pl':
+      if (i === 1 && v === 0) return Plural.One;
+      if (v === 0 && i % 10 === Math.floor(i % 10) && i % 10 >= 2 && i % 10 <= 4 &&
+          !(i % 100 >= 12 && i % 100 <= 14))
+        return Plural.Few;
+      if (v === 0 && !(i === 1) && i % 10 === Math.floor(i % 10) && i % 10 >= 0 && i % 10 <= 1 ||
+          v === 0 && i % 10 === Math.floor(i % 10) && i % 10 >= 5 && i % 10 <= 9 ||
+          v === 0 && i % 100 === Math.floor(i % 100) && i % 100 >= 12 && i % 100 <= 14)
+        return Plural.Many;
+      return Plural.Other;
+    case 'pt':
+      if (n === Math.floor(n) && n >= 0 && n <= 2 && !(n === 2)) return Plural.One;
+      return Plural.Other;
+    case 'ro':
+      if (i === 1 && v === 0) return Plural.One;
+      if (!(v === 0) || n === 0 ||
+          !(n === 1) && n % 100 === Math.floor(n % 100) && n % 100 >= 1 && n % 100 <= 19)
+        return Plural.Few;
+      return Plural.Other;
+    case 'ru':
+    case 'uk':
+      if (v === 0 && i % 10 === 1 && !(i % 100 === 11)) return Plural.One;
+      if (v === 0 && i % 10 === Math.floor(i % 10) && i % 10 >= 2 && i % 10 <= 4 &&
+          !(i % 100 >= 12 && i % 100 <= 14))
+        return Plural.Few;
+      if (v === 0 && i % 10 === 0 ||
+          v === 0 && i % 10 === Math.floor(i % 10) && i % 10 >= 5 && i % 10 <= 9 ||
+          v === 0 && i % 100 === Math.floor(i % 100) && i % 100 >= 11 && i % 100 <= 14)
+        return Plural.Many;
+      return Plural.Other;
+    case 'shi':
+      if (i === 0 || n === 1) return Plural.One;
+      if (n === Math.floor(n) && n >= 2 && n <= 10) return Plural.Few;
+      return Plural.Other;
+    case 'si':
+      if (n === 0 || n === 1 || i === 0 && f === 1) return Plural.One;
+      return Plural.Other;
+    case 'sl':
+      if (v === 0 && i % 100 === 1) return Plural.One;
+      if (v === 0 && i % 100 === 2) return Plural.Two;
+      if (v === 0 && i % 100 === Math.floor(i % 100) && i % 100 >= 3 && i % 100 <= 4 || !(v === 0))
+        return Plural.Few;
+      return Plural.Other;
+    case 'tzm':
+      if (n === Math.floor(n) && n >= 0 && n <= 1 || n === Math.floor(n) && n >= 11 && n <= 99)
+        return Plural.One;
+      return Plural.Other;
+    // When there is no specification, the default is always "other"
+    // Spec: http://cldr.unicode.org/index/cldr-spec/plural-rules
+    // > other (required—general plural form — also used if the language only has a single form)
+    default:
+      return Plural.Other;
+  }
+}
diff --git a/angular/common/src/location/hash_location_strategy.ts b/angular/common/src/location/hash_location_strategy.ts
new file mode 100644
index 0000000..70bd232
--- /dev/null
+++ b/angular/common/src/location/hash_location_strategy.ts
@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, Injectable, Optional} from '@angular/core';
+
+
+import {Location} from './location';
+import {APP_BASE_HREF, LocationStrategy} from './location_strategy';
+import {LocationChangeListener, PlatformLocation} from './platform_location';
+
+
+
+/**
+ * @whatItDoes Use URL hash for storing application location data.
+ * @description
+ * `HashLocationStrategy` is a {@link LocationStrategy} used to configure the
+ * {@link Location} service to represent its state in the
+ * [hash fragment](https://en.wikipedia.org/wiki/Uniform_Resource_Locator#Syntax)
+ * of the browser's URL.
+ *
+ * For instance, if you call `location.go('/foo')`, the browser's URL will become
+ * `example.com#/foo`.
+ *
+ * ### Example
+ *
+ * {@example common/location/ts/hash_location_component.ts region='LocationComponent'}
+ *
+ * @stable
+ */
+@Injectable()
+export class HashLocationStrategy extends LocationStrategy {
+  private _baseHref: string = '';
+  constructor(
+      private _platformLocation: PlatformLocation,
+      @Optional() @Inject(APP_BASE_HREF) _baseHref?: string) {
+    super();
+    if (_baseHref != null) {
+      this._baseHref = _baseHref;
+    }
+  }
+
+  onPopState(fn: LocationChangeListener): void {
+    this._platformLocation.onPopState(fn);
+    this._platformLocation.onHashChange(fn);
+  }
+
+  getBaseHref(): string { return this._baseHref; }
+
+  path(includeHash: boolean = false): string {
+    // the hash value is always prefixed with a `#`
+    // and if it is empty then it will stay empty
+    let path = this._platformLocation.hash;
+    if (path == null) path = '#';
+
+    return path.length > 0 ? path.substring(1) : path;
+  }
+
+  prepareExternalUrl(internal: string): string {
+    const url = Location.joinWithSlash(this._baseHref, internal);
+    return url.length > 0 ? ('#' + url) : url;
+  }
+
+  pushState(state: any, title: string, path: string, queryParams: string) {
+    let url: string|null =
+        this.prepareExternalUrl(path + Location.normalizeQueryParams(queryParams));
+    if (url.length == 0) {
+      url = this._platformLocation.pathname;
+    }
+    this._platformLocation.pushState(state, title, url);
+  }
+
+  replaceState(state: any, title: string, path: string, queryParams: string) {
+    let url = this.prepareExternalUrl(path + Location.normalizeQueryParams(queryParams));
+    if (url.length == 0) {
+      url = this._platformLocation.pathname;
+    }
+    this._platformLocation.replaceState(state, title, url);
+  }
+
+  forward(): void { this._platformLocation.forward(); }
+
+  back(): void { this._platformLocation.back(); }
+}
diff --git a/angular/common/src/location/index.ts b/angular/common/src/location/index.ts
new file mode 100644
index 0000000..5707ccd
--- /dev/null
+++ b/angular/common/src/location/index.ts
@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export * from './platform_location';
+export * from './location_strategy';
+export * from './hash_location_strategy';
+export * from './path_location_strategy';
+export * from './location';
diff --git a/angular/common/src/location/location.ts b/angular/common/src/location/location.ts
new file mode 100644
index 0000000..ed89526
--- /dev/null
+++ b/angular/common/src/location/location.ts
@@ -0,0 +1,189 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {EventEmitter, Injectable} from '@angular/core';
+
+import {LocationStrategy} from './location_strategy';
+
+/** @experimental */
+export interface PopStateEvent {
+  pop?: boolean;
+  type?: string;
+  url?: string;
+}
+
+/**
+ * @whatItDoes `Location` is a service that applications can use to interact with a browser's URL.
+ * @description
+ * Depending on which {@link LocationStrategy} is used, `Location` will either persist
+ * to the URL's path or the URL's hash segment.
+ *
+ * Note: it's better to use {@link Router#navigate} service to trigger route changes. Use
+ * `Location` only if you need to interact with or create normalized URLs outside of
+ * routing.
+ *
+ * `Location` is responsible for normalizing the URL against the application's base href.
+ * A normalized URL is absolute from the URL host, includes the application's base href, and has no
+ * trailing slash:
+ * - `/my/app/user/123` is normalized
+ * - `my/app/user/123` **is not** normalized
+ * - `/my/app/user/123/` **is not** normalized
+ *
+ * ### Example
+ * {@example common/location/ts/path_location_component.ts region='LocationComponent'}
+ * @stable
+ */
+@Injectable()
+export class Location {
+  /** @internal */
+  _subject: EventEmitter<any> = new EventEmitter();
+  /** @internal */
+  _baseHref: string;
+  /** @internal */
+  _platformStrategy: LocationStrategy;
+
+  constructor(platformStrategy: LocationStrategy) {
+    this._platformStrategy = platformStrategy;
+    const browserBaseHref = this._platformStrategy.getBaseHref();
+    this._baseHref = Location.stripTrailingSlash(_stripIndexHtml(browserBaseHref));
+    this._platformStrategy.onPopState((ev) => {
+      this._subject.emit({
+        'url': this.path(true),
+        'pop': true,
+        'type': ev.type,
+      });
+    });
+  }
+
+  /**
+   * Returns the normalized URL path.
+   */
+  // TODO: vsavkin. Remove the boolean flag and always include hash once the deprecated router is
+  // removed.
+  path(includeHash: boolean = false): string {
+    return this.normalize(this._platformStrategy.path(includeHash));
+  }
+
+  /**
+   * Normalizes the given path and compares to the current normalized path.
+   */
+  isCurrentPathEqualTo(path: string, query: string = ''): boolean {
+    return this.path() == this.normalize(path + Location.normalizeQueryParams(query));
+  }
+
+  /**
+   * Given a string representing a URL, returns the normalized URL path without leading or
+   * trailing slashes.
+   */
+  normalize(url: string): string {
+    return Location.stripTrailingSlash(_stripBaseHref(this._baseHref, _stripIndexHtml(url)));
+  }
+
+  /**
+   * Given a string representing a URL, returns the platform-specific external URL path.
+   * If the given URL doesn't begin with a leading slash (`'/'`), this method adds one
+   * before normalizing. This method will also add a hash if `HashLocationStrategy` is
+   * used, or the `APP_BASE_HREF` if the `PathLocationStrategy` is in use.
+   */
+  prepareExternalUrl(url: string): string {
+    if (url && url[0] !== '/') {
+      url = '/' + url;
+    }
+    return this._platformStrategy.prepareExternalUrl(url);
+  }
+
+  // TODO: rename this method to pushState
+  /**
+   * Changes the browsers URL to the normalized version of the given URL, and pushes a
+   * new item onto the platform's history.
+   */
+  go(path: string, query: string = ''): void {
+    this._platformStrategy.pushState(null, '', path, query);
+  }
+
+  /**
+   * Changes the browsers URL to the normalized version of the given URL, and replaces
+   * the top item on the platform's history stack.
+   */
+  replaceState(path: string, query: string = ''): void {
+    this._platformStrategy.replaceState(null, '', path, query);
+  }
+
+  /**
+   * Navigates forward in the platform's history.
+   */
+  forward(): void { this._platformStrategy.forward(); }
+
+  /**
+   * Navigates back in the platform's history.
+   */
+  back(): void { this._platformStrategy.back(); }
+
+  /**
+   * Subscribe to the platform's `popState` events.
+   */
+  subscribe(
+      onNext: (value: PopStateEvent) => void, onThrow?: ((exception: any) => void)|null,
+      onReturn?: (() => void)|null): Object {
+    return this._subject.subscribe({next: onNext, error: onThrow, complete: onReturn});
+  }
+
+  /**
+   * Given a string of url parameters, prepend with '?' if needed, otherwise return parameters as
+   * is.
+   */
+  public static normalizeQueryParams(params: string): string {
+    return params && params[0] !== '?' ? '?' + params : params;
+  }
+
+  /**
+   * Given 2 parts of a url, join them with a slash if needed.
+   */
+  public static joinWithSlash(start: string, end: string): string {
+    if (start.length == 0) {
+      return end;
+    }
+    if (end.length == 0) {
+      return start;
+    }
+    let slashes = 0;
+    if (start.endsWith('/')) {
+      slashes++;
+    }
+    if (end.startsWith('/')) {
+      slashes++;
+    }
+    if (slashes == 2) {
+      return start + end.substring(1);
+    }
+    if (slashes == 1) {
+      return start + end;
+    }
+    return start + '/' + end;
+  }
+
+  /**
+   * If url has a trailing slash, remove it, otherwise return url as is. This
+   * method looks for the first occurence of either #, ?, or the end of the
+   * line as `/` characters after any of these should not be replaced.
+   */
+  public static stripTrailingSlash(url: string): string {
+    const match = url.match(/#|\?|$/);
+    const pathEndIdx = match && match.index || url.length;
+    const droppedSlashIdx = pathEndIdx - (url[pathEndIdx - 1] === '/' ? 1 : 0);
+    return url.slice(0, droppedSlashIdx) + url.slice(pathEndIdx);
+  }
+}
+
+function _stripBaseHref(baseHref: string, url: string): string {
+  return baseHref && url.startsWith(baseHref) ? url.substring(baseHref.length) : url;
+}
+
+function _stripIndexHtml(url: string): string {
+  return url.replace(/\/index.html$/, '');
+}
diff --git a/angular/common/src/location/location_strategy.ts b/angular/common/src/location/location_strategy.ts
new file mode 100644
index 0000000..d5b1997
--- /dev/null
+++ b/angular/common/src/location/location_strategy.ts
@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {InjectionToken} from '@angular/core';
+import {LocationChangeListener} from './platform_location';
+
+/**
+ * `LocationStrategy` is responsible for representing and reading route state
+ * from the browser's URL. Angular provides two strategies:
+ * {@link HashLocationStrategy} and {@link PathLocationStrategy}.
+ *
+ * This is used under the hood of the {@link Location} service.
+ *
+ * Applications should use the {@link Router} or {@link Location} services to
+ * interact with application route state.
+ *
+ * For instance, {@link HashLocationStrategy} produces URLs like
+ * `http://example.com#/foo`, and {@link PathLocationStrategy} produces
+ * `http://example.com/foo` as an equivalent URL.
+ *
+ * See these two classes for more.
+ *
+ * @stable
+ */
+export abstract class LocationStrategy {
+  abstract path(includeHash?: boolean): string;
+  abstract prepareExternalUrl(internal: string): string;
+  abstract pushState(state: any, title: string, url: string, queryParams: string): void;
+  abstract replaceState(state: any, title: string, url: string, queryParams: string): void;
+  abstract forward(): void;
+  abstract back(): void;
+  abstract onPopState(fn: LocationChangeListener): void;
+  abstract getBaseHref(): string;
+}
+
+
+/**
+ * The `APP_BASE_HREF` token represents the base href to be used with the
+ * {@link PathLocationStrategy}.
+ *
+ * If you're using {@link PathLocationStrategy}, you must provide a provider to a string
+ * representing the URL prefix that should be preserved when generating and recognizing
+ * URLs.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * import {Component, NgModule} from '@angular/core';
+ * import {APP_BASE_HREF} from '@angular/common';
+ *
+ * @NgModule({
+ *   providers: [{provide: APP_BASE_HREF, useValue: '/my/app'}]
+ * })
+ * class AppModule {}
+ * ```
+ *
+ * @stable
+ */
+export const APP_BASE_HREF = new InjectionToken<string>('appBaseHref');
diff --git a/angular/common/src/location/path_location_strategy.ts b/angular/common/src/location/path_location_strategy.ts
new file mode 100644
index 0000000..d3ccf7e
--- /dev/null
+++ b/angular/common/src/location/path_location_strategy.ts
@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, Injectable, Optional} from '@angular/core';
+
+
+import {Location} from './location';
+import {APP_BASE_HREF, LocationStrategy} from './location_strategy';
+import {LocationChangeListener, PlatformLocation} from './platform_location';
+
+
+
+/**
+ * @whatItDoes Use URL for storing application location data.
+ * @description
+ * `PathLocationStrategy` is a {@link LocationStrategy} used to configure the
+ * {@link Location} service to represent its state in the
+ * [path](https://en.wikipedia.org/wiki/Uniform_Resource_Locator#Syntax) of the
+ * browser's URL.
+ *
+ * If you're using `PathLocationStrategy`, you must provide a {@link APP_BASE_HREF}
+ * or add a base element to the document. This URL prefix that will be preserved
+ * when generating and recognizing URLs.
+ *
+ * For instance, if you provide an `APP_BASE_HREF` of `'/my/app'` and call
+ * `location.go('/foo')`, the browser's URL will become
+ * `example.com/my/app/foo`.
+ *
+ * Similarly, if you add `<base href='/my/app'/>` to the document and call
+ * `location.go('/foo')`, the browser's URL will become
+ * `example.com/my/app/foo`.
+ *
+ * ### Example
+ *
+ * {@example common/location/ts/path_location_component.ts region='LocationComponent'}
+ *
+ * @stable
+ */
+@Injectable()
+export class PathLocationStrategy extends LocationStrategy {
+  private _baseHref: string;
+
+  constructor(
+      private _platformLocation: PlatformLocation,
+      @Optional() @Inject(APP_BASE_HREF) href?: string) {
+    super();
+
+    if (href == null) {
+      href = this._platformLocation.getBaseHrefFromDOM();
+    }
+
+    if (href == null) {
+      throw new Error(
+          `No base href set. Please provide a value for the APP_BASE_HREF token or add a base element to the document.`);
+    }
+
+    this._baseHref = href;
+  }
+
+  onPopState(fn: LocationChangeListener): void {
+    this._platformLocation.onPopState(fn);
+    this._platformLocation.onHashChange(fn);
+  }
+
+  getBaseHref(): string { return this._baseHref; }
+
+  prepareExternalUrl(internal: string): string {
+    return Location.joinWithSlash(this._baseHref, internal);
+  }
+
+  path(includeHash: boolean = false): string {
+    const pathname = this._platformLocation.pathname +
+        Location.normalizeQueryParams(this._platformLocation.search);
+    const hash = this._platformLocation.hash;
+    return hash && includeHash ? `${pathname}${hash}` : pathname;
+  }
+
+  pushState(state: any, title: string, url: string, queryParams: string) {
+    const externalUrl = this.prepareExternalUrl(url + Location.normalizeQueryParams(queryParams));
+    this._platformLocation.pushState(state, title, externalUrl);
+  }
+
+  replaceState(state: any, title: string, url: string, queryParams: string) {
+    const externalUrl = this.prepareExternalUrl(url + Location.normalizeQueryParams(queryParams));
+    this._platformLocation.replaceState(state, title, externalUrl);
+  }
+
+  forward(): void { this._platformLocation.forward(); }
+
+  back(): void { this._platformLocation.back(); }
+}
diff --git a/angular/common/src/location/platform_location.ts b/angular/common/src/location/platform_location.ts
new file mode 100644
index 0000000..0f5cb5f
--- /dev/null
+++ b/angular/common/src/location/platform_location.ts
@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {InjectionToken} from '@angular/core';
+/**
+ * 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, `@angular/platform-browser` provides an
+ * implementation specific to the browser environment, while `@angular/platform-webworker` provides
+ * one suitable for use with web workers.
+ *
+ * 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.
+ *
+ * @stable
+ */
+export abstract class PlatformLocation {
+  abstract getBaseHrefFromDOM(): string;
+  abstract onPopState(fn: LocationChangeListener): void;
+  abstract onHashChange(fn: LocationChangeListener): void;
+
+  abstract get pathname(): string;
+  abstract get search(): string;
+  abstract get hash(): string;
+
+  abstract replaceState(state: any, title: string, url: string): void;
+
+  abstract pushState(state: any, title: string, url: string): void;
+
+  abstract forward(): void;
+
+  abstract back(): void;
+}
+
+/**
+ * @whatItDoes indicates when a location is initialized
+ * @experimental
+ */
+export const LOCATION_INITIALIZED = new InjectionToken<Promise<any>>('Location Initialized');
+
+/**
+ * A serializable version of the event from onPopState or onHashChange
+ *
+ * @experimental
+ */
+export interface LocationChangeEvent { type: string; }
+
+/**
+ * @experimental
+ */
+export interface LocationChangeListener { (e: LocationChangeEvent): any; }
diff --git a/angular/common/src/pipes/async_pipe.ts b/angular/common/src/pipes/async_pipe.ts
new file mode 100644
index 0000000..e53de75
--- /dev/null
+++ b/angular/common/src/pipes/async_pipe.ts
@@ -0,0 +1,145 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ChangeDetectorRef, EventEmitter, OnDestroy, Pipe, PipeTransform, WrappedValue, ɵisObservable, ɵisPromise} from '@angular/core';
+import {Observable} from 'rxjs/Observable';
+import {ISubscription} from 'rxjs/Subscription';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
+
+interface SubscriptionStrategy {
+  createSubscription(async: Observable<any>|Promise<any>, updateLatestValue: any): ISubscription
+      |Promise<any>;
+  dispose(subscription: ISubscription|Promise<any>): void;
+  onDestroy(subscription: ISubscription|Promise<any>): void;
+}
+
+class ObservableStrategy implements SubscriptionStrategy {
+  createSubscription(async: Observable<any>, updateLatestValue: any): ISubscription {
+    return async.subscribe({next: updateLatestValue, error: (e: any) => { throw e; }});
+  }
+
+  dispose(subscription: ISubscription): void { subscription.unsubscribe(); }
+
+  onDestroy(subscription: ISubscription): void { subscription.unsubscribe(); }
+}
+
+class PromiseStrategy implements SubscriptionStrategy {
+  createSubscription(async: Promise<any>, updateLatestValue: (v: any) => any): Promise<any> {
+    return async.then(updateLatestValue, e => { throw e; });
+  }
+
+  dispose(subscription: Promise<any>): void {}
+
+  onDestroy(subscription: Promise<any>): void {}
+}
+
+const _promiseStrategy = new PromiseStrategy();
+const _observableStrategy = new ObservableStrategy();
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Unwraps a value from an asynchronous primitive.
+ * @howToUse `observable_or_promise_expression | async`
+ * @description
+ * The `async` pipe subscribes to an `Observable` or `Promise` and returns the latest value it has
+ * emitted. When a new value is emitted, the `async` pipe marks the component to be checked for
+ * changes. When the component gets destroyed, the `async` pipe unsubscribes automatically to avoid
+ * potential memory leaks.
+ *
+ *
+ * ## Examples
+ *
+ * This example binds a `Promise` to the view. Clicking the `Resolve` button resolves the
+ * promise.
+ *
+ * {@example common/pipes/ts/async_pipe.ts region='AsyncPipePromise'}
+ *
+ * It's also possible to use `async` with Observables. The example below binds the `time` Observable
+ * to the view. The Observable continuously updates the view with the current time.
+ *
+ * {@example common/pipes/ts/async_pipe.ts region='AsyncPipeObservable'}
+ *
+ * @stable
+ */
+@Pipe({name: 'async', pure: false})
+export class AsyncPipe implements OnDestroy, PipeTransform {
+  private _latestValue: any = null;
+  private _latestReturnedValue: any = null;
+
+  private _subscription: ISubscription|Promise<any>|null = null;
+  private _obj: Observable<any>|Promise<any>|EventEmitter<any>|null = null;
+  private _strategy: SubscriptionStrategy = null !;
+
+  constructor(private _ref: ChangeDetectorRef) {}
+
+  ngOnDestroy(): void {
+    if (this._subscription) {
+      this._dispose();
+    }
+  }
+
+  transform<T>(obj: null): null;
+  transform<T>(obj: undefined): undefined;
+  transform<T>(obj: Observable<T>): T|null;
+  transform<T>(obj: Promise<T>): T|null;
+  transform(obj: Observable<any>|Promise<any>|null|undefined): any {
+    if (!this._obj) {
+      if (obj) {
+        this._subscribe(obj);
+      }
+      this._latestReturnedValue = this._latestValue;
+      return this._latestValue;
+    }
+
+    if (obj !== this._obj) {
+      this._dispose();
+      return this.transform(obj as any);
+    }
+
+    if (this._latestValue === this._latestReturnedValue) {
+      return this._latestReturnedValue;
+    }
+
+    this._latestReturnedValue = this._latestValue;
+    return WrappedValue.wrap(this._latestValue);
+  }
+
+  private _subscribe(obj: Observable<any>|Promise<any>|EventEmitter<any>): void {
+    this._obj = obj;
+    this._strategy = this._selectStrategy(obj);
+    this._subscription = this._strategy.createSubscription(
+        obj, (value: Object) => this._updateLatestValue(obj, value));
+  }
+
+  private _selectStrategy(obj: Observable<any>|Promise<any>|EventEmitter<any>): any {
+    if (ɵisPromise(obj)) {
+      return _promiseStrategy;
+    }
+
+    if (ɵisObservable(obj)) {
+      return _observableStrategy;
+    }
+
+    throw invalidPipeArgumentError(AsyncPipe, obj);
+  }
+
+  private _dispose(): void {
+    this._strategy.dispose(this._subscription !);
+    this._latestValue = null;
+    this._latestReturnedValue = null;
+    this._subscription = null;
+    this._obj = null;
+  }
+
+  private _updateLatestValue(async: any, value: Object): void {
+    if (async === this._obj) {
+      this._latestValue = value;
+      this._ref.markForCheck();
+    }
+  }
+}
diff --git a/angular/common/src/pipes/case_conversion_pipes.ts b/angular/common/src/pipes/case_conversion_pipes.ts
new file mode 100644
index 0000000..59390e4
--- /dev/null
+++ b/angular/common/src/pipes/case_conversion_pipes.ts
@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Pipe, PipeTransform} from '@angular/core';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
+
+/**
+ * Transforms text to lowercase.
+ *
+ * {@example  common/pipes/ts/lowerupper_pipe.ts region='LowerUpperPipe' }
+ *
+ * @stable
+ */
+@Pipe({name: 'lowercase'})
+export class LowerCasePipe implements PipeTransform {
+  transform(value: string): string {
+    if (!value) return value;
+    if (typeof value !== 'string') {
+      throw invalidPipeArgumentError(LowerCasePipe, value);
+    }
+    return value.toLowerCase();
+  }
+}
+
+
+/**
+ * Helper method to transform a single word to titlecase.
+ *
+ * @stable
+ */
+function titleCaseWord(word: string) {
+  if (!word) return word;
+  return word[0].toUpperCase() + word.substr(1).toLowerCase();
+}
+
+/**
+ * Transforms text to titlecase.
+ *
+ * @stable
+ */
+@Pipe({name: 'titlecase'})
+export class TitleCasePipe implements PipeTransform {
+  transform(value: string): string {
+    if (!value) return value;
+    if (typeof value !== 'string') {
+      throw invalidPipeArgumentError(TitleCasePipe, value);
+    }
+
+    return value.split(/\b/g).map(word => titleCaseWord(word)).join('');
+  }
+}
+
+/**
+ * Transforms text to uppercase.
+ *
+ * @stable
+ */
+@Pipe({name: 'uppercase'})
+export class UpperCasePipe implements PipeTransform {
+  transform(value: string): string {
+    if (!value) return value;
+    if (typeof value !== 'string') {
+      throw invalidPipeArgumentError(UpperCasePipe, value);
+    }
+    return value.toUpperCase();
+  }
+}
diff --git a/angular/common/src/pipes/date_pipe.ts b/angular/common/src/pipes/date_pipe.ts
new file mode 100644
index 0000000..aec4cee
--- /dev/null
+++ b/angular/common/src/pipes/date_pipe.ts
@@ -0,0 +1,175 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, LOCALE_ID, Pipe, PipeTransform} from '@angular/core';
+import {DateFormatter} from './intl';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
+import {isNumeric} from './number_pipe';
+
+const ISO8601_DATE_REGEX =
+    /^(\d{4})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/;
+//    1        2       3         4          5          6          7          8  9     10      11
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Formats a date according to locale rules.
+ * @howToUse `date_expression | date[:format]`
+ * @description
+ *
+ * Where:
+ * - `expression` is a date object or a number (milliseconds since UTC epoch) or an ISO string
+ * (https://www.w3.org/TR/NOTE-datetime).
+ * - `format` indicates which date/time components to include. The format can be predefined as
+ *   shown below or custom as shown in the table.
+ *   - `'medium'`: equivalent to `'yMMMdjms'` (e.g. `Sep 3, 2010, 12:05:08 PM` for `en-US`)
+ *   - `'short'`: equivalent to `'yMdjm'` (e.g. `9/3/2010, 12:05 PM` for `en-US`)
+ *   - `'fullDate'`: equivalent to `'yMMMMEEEEd'` (e.g. `Friday, September 3, 2010` for `en-US`)
+ *   - `'longDate'`: equivalent to `'yMMMMd'` (e.g. `September 3, 2010` for `en-US`)
+ *   - `'mediumDate'`: equivalent to `'yMMMd'` (e.g. `Sep 3, 2010` for `en-US`)
+ *   - `'shortDate'`: equivalent to `'yMd'` (e.g. `9/3/2010` for `en-US`)
+ *   - `'mediumTime'`: equivalent to `'jms'` (e.g. `12:05:08 PM` for `en-US`)
+ *   - `'shortTime'`: equivalent to `'jm'` (e.g. `12:05 PM` for `en-US`)
+ *
+ *
+ *  | Component | Symbol | Narrow | Short Form   | Long Form         | Numeric   | 2-digit   |
+ *  |-----------|:------:|--------|--------------|-------------------|-----------|-----------|
+ *  | era       |   G    | G (A)  | GGG (AD)     | GGGG (Anno Domini)| -         | -         |
+ *  | year      |   y    | -      | -            | -                 | y (2015)  | yy (15)   |
+ *  | month     |   M    | L (S)  | MMM (Sep)    | MMMM (September)  | M (9)     | MM (09)   |
+ *  | day       |   d    | -      | -            | -                 | d (3)     | dd (03)   |
+ *  | weekday   |   E    | E (S)  | EEE (Sun)    | EEEE (Sunday)     | -         | -         |
+ *  | hour      |   j    | -      | -            | -                 | j (1 PM)  | jj (1 PM) |
+ *  | hour12    |   h    | -      | -            | -                 | h (1)     | hh (01)   |
+ *  | hour24    |   H    | -      | -            | -                 | H (13)    | HH (13)   |
+ *  | minute    |   m    | -      | -            | -                 | m (5)     | mm (05)   |
+ *  | second    |   s    | -      | -            | -                 | s (9)     | ss (09)   |
+ *  | timezone  |   z    | -      | -            | z (Pacific Standard Time)| -  | -         |
+ *  | timezone  |   Z    | -      | Z (GMT-8:00) | -                 | -         | -         |
+ *  | timezone  |   a    | -      | a (PM)       | -                 | -         | -         |
+ *
+ * In javascript, only the components specified will be respected (not the ordering,
+ * punctuations, ...) and details of the formatting will be dependent on the locale.
+ *
+ * Timezone of the formatted text will be the local system timezone of the end-user's machine.
+ *
+ * When the expression is a ISO string without time (e.g. 2016-09-19) the time zone offset is not
+ * applied and the formatted text will have the same day, month and year of the expression.
+ *
+ * WARNINGS:
+ * - this pipe is marked as pure hence it will not be re-evaluated when the input is mutated.
+ *   Instead users should treat the date as an immutable object and change the reference when the
+ *   pipe needs to re-run (this is to avoid reformatting the date on every change detection run
+ *   which would be an expensive operation).
+ * - this pipe uses the Internationalization API. Therefore it is only reliable in Chrome and Opera
+ *   browsers.
+ *
+ * ### Examples
+ *
+ * Assuming `dateObj` is (year: 2015, month: 6, day: 15, hour: 21, minute: 43, second: 11)
+ * in the _local_ time and locale is 'en-US':
+ *
+ * ```
+ *     {{ dateObj | date }}               // output is 'Jun 15, 2015'
+ *     {{ dateObj | date:'medium' }}      // output is 'Jun 15, 2015, 9:43:11 PM'
+ *     {{ dateObj | date:'shortTime' }}   // output is '9:43 PM'
+ *     {{ dateObj | date:'mmss' }}        // output is '43:11'
+ * ```
+ *
+ * {@example common/pipes/ts/date_pipe.ts region='DatePipe'}
+ *
+ * @stable
+ */
+@Pipe({name: 'date', pure: true})
+export class DatePipe implements PipeTransform {
+  /** @internal */
+  static _ALIASES: {[key: string]: string} = {
+    'medium': 'yMMMdjms',
+    'short': 'yMdjm',
+    'fullDate': 'yMMMMEEEEd',
+    'longDate': 'yMMMMd',
+    'mediumDate': 'yMMMd',
+    'shortDate': 'yMd',
+    'mediumTime': 'jms',
+    'shortTime': 'jm'
+  };
+
+  constructor(@Inject(LOCALE_ID) private _locale: string) {}
+
+  transform(value: any, pattern: string = 'mediumDate'): string|null {
+    let date: Date;
+
+    if (isBlank(value) || value !== value) return null;
+
+    if (typeof value === 'string') {
+      value = value.trim();
+    }
+
+    if (isDate(value)) {
+      date = value;
+    } else if (isNumeric(value)) {
+      date = new Date(parseFloat(value));
+    } else if (typeof value === 'string' && /^(\d{4}-\d{1,2}-\d{1,2})$/.test(value)) {
+      /**
+      * For ISO Strings without time the day, month and year must be extracted from the ISO String
+      * before Date creation to avoid time offset and errors in the new Date.
+      * If we only replace '-' with ',' in the ISO String ("2015,01,01"), and try to create a new
+      * date, some browsers (e.g. IE 9) will throw an invalid Date error
+      * If we leave the '-' ("2015-01-01") and try to create a new Date("2015-01-01") the timeoffset
+      * is applied
+      * Note: ISO months are 0 for January, 1 for February, ...
+      */
+      const [y, m, d] = value.split('-').map((val: string) => parseInt(val, 10));
+      date = new Date(y, m - 1, d);
+    } else {
+      date = new Date(value);
+    }
+
+    if (!isDate(date)) {
+      let match: RegExpMatchArray|null;
+      if ((typeof value === 'string') && (match = value.match(ISO8601_DATE_REGEX))) {
+        date = isoStringToDate(match);
+      } else {
+        throw invalidPipeArgumentError(DatePipe, value);
+      }
+    }
+
+    return DateFormatter.format(date, this._locale, DatePipe._ALIASES[pattern] || pattern);
+  }
+}
+
+function isBlank(obj: any): boolean {
+  return obj == null || obj === '';
+}
+
+function isDate(obj: any): obj is Date {
+  return obj instanceof Date && !isNaN(obj.valueOf());
+}
+
+function isoStringToDate(match: RegExpMatchArray): Date {
+  const date = new Date(0);
+  let tzHour = 0;
+  let tzMin = 0;
+  const dateSetter = match[8] ? date.setUTCFullYear : date.setFullYear;
+  const timeSetter = match[8] ? date.setUTCHours : date.setHours;
+
+  if (match[9]) {
+    tzHour = toInt(match[9] + match[10]);
+    tzMin = toInt(match[9] + match[11]);
+  }
+  dateSetter.call(date, toInt(match[1]), toInt(match[2]) - 1, toInt(match[3]));
+  const h = toInt(match[4] || '0') - tzHour;
+  const m = toInt(match[5] || '0') - tzMin;
+  const s = toInt(match[6] || '0');
+  const ms = Math.round(parseFloat('0.' + (match[7] || 0)) * 1000);
+  timeSetter.call(date, h, m, s, ms);
+  return date;
+}
+
+function toInt(str: string): number {
+  return parseInt(str, 10);
+}
diff --git a/angular/common/src/pipes/i18n_plural_pipe.ts b/angular/common/src/pipes/i18n_plural_pipe.ts
new file mode 100644
index 0000000..dc0909d
--- /dev/null
+++ b/angular/common/src/pipes/i18n_plural_pipe.ts
@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Pipe, PipeTransform} from '@angular/core';
+import {NgLocalization, getPluralCategory} from '../localization';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
+
+const _INTERPOLATION_REGEXP: RegExp = /#/g;
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Maps a value to a string that pluralizes the value according to locale rules.
+ * @howToUse `expression | i18nPlural:mapping`
+ * @description
+ *
+ *  Where:
+ *  - `expression` is a number.
+ *  - `mapping` is an object that mimics the ICU format, see
+ *    http://userguide.icu-project.org/formatparse/messages
+ *
+ *  ## Example
+ *
+ * {@example common/pipes/ts/i18n_pipe.ts region='I18nPluralPipeComponent'}
+ *
+ * @experimental
+ */
+@Pipe({name: 'i18nPlural', pure: true})
+export class I18nPluralPipe implements PipeTransform {
+  constructor(private _localization: NgLocalization) {}
+
+  transform(value: number, pluralMap: {[count: string]: string}): string {
+    if (value == null) return '';
+
+    if (typeof pluralMap !== 'object' || pluralMap === null) {
+      throw invalidPipeArgumentError(I18nPluralPipe, pluralMap);
+    }
+
+    const key = getPluralCategory(value, Object.keys(pluralMap), this._localization);
+
+    return pluralMap[key].replace(_INTERPOLATION_REGEXP, value.toString());
+  }
+}
diff --git a/angular/common/src/pipes/i18n_select_pipe.ts b/angular/common/src/pipes/i18n_select_pipe.ts
new file mode 100644
index 0000000..84a44e4
--- /dev/null
+++ b/angular/common/src/pipes/i18n_select_pipe.ts
@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Pipe, PipeTransform} from '@angular/core';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Generic selector that displays the string that matches the current value.
+ * @howToUse `expression | i18nSelect:mapping`
+ * @description
+ *
+ *  Where `mapping` is an object that indicates the text that should be displayed
+ *  for different values of the provided `expression`.
+ *  If none of the keys of the mapping match the value of the `expression`, then the content
+ *  of the `other` key is returned when present, otherwise an empty string is returned.
+ *
+ *  ## Example
+ *
+ * {@example common/pipes/ts/i18n_pipe.ts region='I18nSelectPipeComponent'}
+ *
+ *  @experimental
+ */
+@Pipe({name: 'i18nSelect', pure: true})
+export class I18nSelectPipe implements PipeTransform {
+  transform(value: string|null|undefined, mapping: {[key: string]: string}): string {
+    if (value == null) return '';
+
+    if (typeof mapping !== 'object' || typeof value !== 'string') {
+      throw invalidPipeArgumentError(I18nSelectPipe, mapping);
+    }
+
+    if (mapping.hasOwnProperty(value)) {
+      return mapping[value];
+    }
+
+    if (mapping.hasOwnProperty('other')) {
+      return mapping['other'];
+    }
+
+    return '';
+  }
+}
diff --git a/angular/common/src/pipes/index.ts b/angular/common/src/pipes/index.ts
new file mode 100644
index 0000000..7014c62
--- /dev/null
+++ b/angular/common/src/pipes/index.ts
@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * This module provides a set of common Pipes.
+ */
+import {AsyncPipe} from './async_pipe';
+import {LowerCasePipe, TitleCasePipe, UpperCasePipe} from './case_conversion_pipes';
+import {DatePipe} from './date_pipe';
+import {I18nPluralPipe} from './i18n_plural_pipe';
+import {I18nSelectPipe} from './i18n_select_pipe';
+import {JsonPipe} from './json_pipe';
+import {CurrencyPipe, DecimalPipe, PercentPipe} from './number_pipe';
+import {SlicePipe} from './slice_pipe';
+
+export {
+  AsyncPipe,
+  CurrencyPipe,
+  DatePipe,
+  DecimalPipe,
+  I18nPluralPipe,
+  I18nSelectPipe,
+  JsonPipe,
+  LowerCasePipe,
+  PercentPipe,
+  SlicePipe,
+  TitleCasePipe,
+  UpperCasePipe
+};
+
+
+/**
+ * A collection of Angular pipes that are likely to be used in each and every application.
+ */
+export const COMMON_PIPES = [
+  AsyncPipe,
+  UpperCasePipe,
+  LowerCasePipe,
+  JsonPipe,
+  SlicePipe,
+  DecimalPipe,
+  PercentPipe,
+  TitleCasePipe,
+  CurrencyPipe,
+  DatePipe,
+  I18nPluralPipe,
+  I18nSelectPipe,
+];
diff --git a/angular/common/src/pipes/intl.ts b/angular/common/src/pipes/intl.ts
new file mode 100644
index 0000000..483e89f
--- /dev/null
+++ b/angular/common/src/pipes/intl.ts
@@ -0,0 +1,226 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export enum NumberFormatStyle {
+  Decimal,
+  Percent,
+  Currency,
+}
+
+export class NumberFormatter {
+  static format(num: number, locale: string, style: NumberFormatStyle, opts: {
+    minimumIntegerDigits?: number,
+    minimumFractionDigits?: number,
+    maximumFractionDigits?: number,
+    currency?: string|null,
+    currencyAsSymbol?: boolean
+  } = {}): string {
+    const {minimumIntegerDigits, minimumFractionDigits, maximumFractionDigits, currency,
+           currencyAsSymbol = false} = opts;
+    const options: Intl.NumberFormatOptions = {
+      minimumIntegerDigits,
+      minimumFractionDigits,
+      maximumFractionDigits,
+      style: NumberFormatStyle[style].toLowerCase()
+    };
+
+    if (style == NumberFormatStyle.Currency) {
+      options.currency = typeof currency == 'string' ? currency : undefined;
+      options.currencyDisplay = currencyAsSymbol ? 'symbol' : 'code';
+    }
+    return new Intl.NumberFormat(locale, options).format(num);
+  }
+}
+
+type DateFormatterFn = (date: Date, locale: string) => string;
+
+const DATE_FORMATS_SPLIT =
+    /((?:[^yMLdHhmsazZEwGjJ']+)|(?:'(?:[^']|'')*')|(?:E+|y+|M+|L+|d+|H+|h+|J+|j+|m+|s+|a|z|Z|G+|w+))(.*)/;
+
+const PATTERN_ALIASES: {[format: string]: DateFormatterFn} = {
+  // Keys are quoted so they do not get renamed during closure compilation.
+  'yMMMdjms': datePartGetterFactory(combine([
+    digitCondition('year', 1),
+    nameCondition('month', 3),
+    digitCondition('day', 1),
+    digitCondition('hour', 1),
+    digitCondition('minute', 1),
+    digitCondition('second', 1),
+  ])),
+  'yMdjm': datePartGetterFactory(combine([
+    digitCondition('year', 1), digitCondition('month', 1), digitCondition('day', 1),
+    digitCondition('hour', 1), digitCondition('minute', 1)
+  ])),
+  'yMMMMEEEEd': datePartGetterFactory(combine([
+    digitCondition('year', 1), nameCondition('month', 4), nameCondition('weekday', 4),
+    digitCondition('day', 1)
+  ])),
+  'yMMMMd': datePartGetterFactory(
+      combine([digitCondition('year', 1), nameCondition('month', 4), digitCondition('day', 1)])),
+  'yMMMd': datePartGetterFactory(
+      combine([digitCondition('year', 1), nameCondition('month', 3), digitCondition('day', 1)])),
+  'yMd': datePartGetterFactory(
+      combine([digitCondition('year', 1), digitCondition('month', 1), digitCondition('day', 1)])),
+  'jms': datePartGetterFactory(combine(
+      [digitCondition('hour', 1), digitCondition('second', 1), digitCondition('minute', 1)])),
+  'jm': datePartGetterFactory(combine([digitCondition('hour', 1), digitCondition('minute', 1)]))
+};
+
+const DATE_FORMATS: {[format: string]: DateFormatterFn} = {
+  // Keys are quoted so they do not get renamed.
+  'yyyy': datePartGetterFactory(digitCondition('year', 4)),
+  'yy': datePartGetterFactory(digitCondition('year', 2)),
+  'y': datePartGetterFactory(digitCondition('year', 1)),
+  'MMMM': datePartGetterFactory(nameCondition('month', 4)),
+  'MMM': datePartGetterFactory(nameCondition('month', 3)),
+  'MM': datePartGetterFactory(digitCondition('month', 2)),
+  'M': datePartGetterFactory(digitCondition('month', 1)),
+  'LLLL': datePartGetterFactory(nameCondition('month', 4)),
+  'L': datePartGetterFactory(nameCondition('month', 1)),
+  'dd': datePartGetterFactory(digitCondition('day', 2)),
+  'd': datePartGetterFactory(digitCondition('day', 1)),
+  'HH': digitModifier(
+      hourExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 2), false)))),
+  'H': hourExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 1), false))),
+  'hh': digitModifier(
+      hourExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 2), true)))),
+  'h': hourExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 1), true))),
+  'jj': datePartGetterFactory(digitCondition('hour', 2)),
+  'j': datePartGetterFactory(digitCondition('hour', 1)),
+  'mm': digitModifier(datePartGetterFactory(digitCondition('minute', 2))),
+  'm': datePartGetterFactory(digitCondition('minute', 1)),
+  'ss': digitModifier(datePartGetterFactory(digitCondition('second', 2))),
+  's': datePartGetterFactory(digitCondition('second', 1)),
+  // while ISO 8601 requires fractions to be prefixed with `.` or `,`
+  // we can be just safely rely on using `sss` since we currently don't support single or two digit
+  // fractions
+  'sss': datePartGetterFactory(digitCondition('second', 3)),
+  'EEEE': datePartGetterFactory(nameCondition('weekday', 4)),
+  'EEE': datePartGetterFactory(nameCondition('weekday', 3)),
+  'EE': datePartGetterFactory(nameCondition('weekday', 2)),
+  'E': datePartGetterFactory(nameCondition('weekday', 1)),
+  'a': hourClockExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 1), true))),
+  'Z': timeZoneGetter('short'),
+  'z': timeZoneGetter('long'),
+  'ww': datePartGetterFactory({}),  // Week of year, padded (00-53). Week 01 is the week with the
+                                    // first Thursday of the year. not support ?
+  'w':
+      datePartGetterFactory({}),  // Week of year (0-53). Week 1 is the week with the first Thursday
+                                  // of the year not support ?
+  'G': datePartGetterFactory(nameCondition('era', 1)),
+  'GG': datePartGetterFactory(nameCondition('era', 2)),
+  'GGG': datePartGetterFactory(nameCondition('era', 3)),
+  'GGGG': datePartGetterFactory(nameCondition('era', 4))
+};
+
+
+function digitModifier(inner: DateFormatterFn): DateFormatterFn {
+  return function(date: Date, locale: string): string {
+    const result = inner(date, locale);
+    return result.length == 1 ? '0' + result : result;
+  };
+}
+
+function hourClockExtractor(inner: DateFormatterFn): DateFormatterFn {
+  return function(date: Date, locale: string): string { return inner(date, locale).split(' ')[1]; };
+}
+
+function hourExtractor(inner: DateFormatterFn): DateFormatterFn {
+  return function(date: Date, locale: string): string { return inner(date, locale).split(' ')[0]; };
+}
+
+function intlDateFormat(date: Date, locale: string, options: Intl.DateTimeFormatOptions): string {
+  return new Intl.DateTimeFormat(locale, options).format(date).replace(/[\u200e\u200f]/g, '');
+}
+
+function timeZoneGetter(timezone: string): DateFormatterFn {
+  // To workaround `Intl` API restriction for single timezone let format with 24 hours
+  const options = {hour: '2-digit', hour12: false, timeZoneName: timezone};
+  return function(date: Date, locale: string): string {
+    const result = intlDateFormat(date, locale, options);
+    // Then extract first 3 letters that related to hours
+    return result ? result.substring(3) : '';
+  };
+}
+
+function hour12Modify(
+    options: Intl.DateTimeFormatOptions, value: boolean): Intl.DateTimeFormatOptions {
+  options.hour12 = value;
+  return options;
+}
+
+function digitCondition(prop: string, len: number): Intl.DateTimeFormatOptions {
+  const result: {[k: string]: string} = {};
+  result[prop] = len === 2 ? '2-digit' : 'numeric';
+  return result;
+}
+
+function nameCondition(prop: string, len: number): Intl.DateTimeFormatOptions {
+  const result: {[k: string]: string} = {};
+  if (len < 4) {
+    result[prop] = len > 1 ? 'short' : 'narrow';
+  } else {
+    result[prop] = 'long';
+  }
+
+  return result;
+}
+
+function combine(options: Intl.DateTimeFormatOptions[]): Intl.DateTimeFormatOptions {
+  return options.reduce((merged, opt) => ({...merged, ...opt}), {});
+}
+
+function datePartGetterFactory(ret: Intl.DateTimeFormatOptions): DateFormatterFn {
+  return (date: Date, locale: string): string => intlDateFormat(date, locale, ret);
+}
+
+const DATE_FORMATTER_CACHE = new Map<string, string[]>();
+
+function dateFormatter(format: string, date: Date, locale: string): string {
+  const fn = PATTERN_ALIASES[format];
+
+  if (fn) return fn(date, locale);
+
+  const cacheKey = format;
+  let parts = DATE_FORMATTER_CACHE.get(cacheKey);
+
+  if (!parts) {
+    parts = [];
+    let match: RegExpExecArray|null;
+    DATE_FORMATS_SPLIT.exec(format);
+
+    let _format: string|null = format;
+    while (_format) {
+      match = DATE_FORMATS_SPLIT.exec(_format);
+      if (match) {
+        parts = parts.concat(match.slice(1));
+        _format = parts.pop() !;
+      } else {
+        parts.push(_format);
+        _format = null;
+      }
+    }
+
+    DATE_FORMATTER_CACHE.set(cacheKey, parts);
+  }
+
+  return parts.reduce((text, part) => {
+    const fn = DATE_FORMATS[part];
+    return text + (fn ? fn(date, locale) : partToTime(part));
+  }, '');
+}
+
+function partToTime(part: string): string {
+  return part === '\'\'' ? '\'' : part.replace(/(^'|'$)/g, '').replace(/''/g, '\'');
+}
+
+export class DateFormatter {
+  static format(date: Date, locale: string, pattern: string): string {
+    return dateFormatter(pattern, date, locale);
+  }
+}
diff --git a/angular/common/src/pipes/invalid_pipe_argument_error.ts b/angular/common/src/pipes/invalid_pipe_argument_error.ts
new file mode 100644
index 0000000..92add35
--- /dev/null
+++ b/angular/common/src/pipes/invalid_pipe_argument_error.ts
@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Type, ɵstringify as stringify} from '@angular/core';
+
+export function invalidPipeArgumentError(type: Type<any>, value: Object) {
+  return Error(`InvalidPipeArgument: '${value}' for pipe '${stringify(type)}'`);
+}
diff --git a/angular/common/src/pipes/json_pipe.ts b/angular/common/src/pipes/json_pipe.ts
new file mode 100644
index 0000000..887c830
--- /dev/null
+++ b/angular/common/src/pipes/json_pipe.ts
@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Pipe, PipeTransform} from '@angular/core';
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Converts value into JSON string.
+ * @howToUse `expression | json`
+ * @description
+ *
+ * Converts value into string using `JSON.stringify`. Useful for debugging.
+ *
+ * ### Example
+ * {@example common/pipes/ts/json_pipe.ts region='JsonPipe'}
+ *
+ * @stable
+ */
+@Pipe({name: 'json', pure: false})
+export class JsonPipe implements PipeTransform {
+  transform(value: any): string { return JSON.stringify(value, null, 2); }
+}
diff --git a/angular/common/src/pipes/number_pipe.ts b/angular/common/src/pipes/number_pipe.ts
new file mode 100644
index 0000000..ae170dd
--- /dev/null
+++ b/angular/common/src/pipes/number_pipe.ts
@@ -0,0 +1,174 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, LOCALE_ID, Pipe, PipeTransform, Type} from '@angular/core';
+import {NumberFormatStyle, NumberFormatter} from './intl';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
+
+const _NUMBER_FORMAT_REGEXP = /^(\d+)?\.((\d+)(-(\d+))?)?$/;
+
+function formatNumber(
+    pipe: Type<any>, locale: string, value: number | string, style: NumberFormatStyle,
+    digits?: string | null, currency: string | null = null,
+    currencyAsSymbol: boolean = false): string|null {
+  if (value == null) return null;
+
+  // Convert strings to numbers
+  value = typeof value === 'string' && isNumeric(value) ? +value : value;
+  if (typeof value !== 'number') {
+    throw invalidPipeArgumentError(pipe, value);
+  }
+
+  let minInt: number|undefined = undefined;
+  let minFraction: number|undefined = undefined;
+  let maxFraction: number|undefined = undefined;
+  if (style !== NumberFormatStyle.Currency) {
+    // rely on Intl default for currency
+    minInt = 1;
+    minFraction = 0;
+    maxFraction = 3;
+  }
+
+  if (digits) {
+    const parts = digits.match(_NUMBER_FORMAT_REGEXP);
+    if (parts === null) {
+      throw new Error(`${digits} is not a valid digit info for number pipes`);
+    }
+    if (parts[1] != null) {  // min integer digits
+      minInt = parseIntAutoRadix(parts[1]);
+    }
+    if (parts[3] != null) {  // min fraction digits
+      minFraction = parseIntAutoRadix(parts[3]);
+    }
+    if (parts[5] != null) {  // max fraction digits
+      maxFraction = parseIntAutoRadix(parts[5]);
+    }
+  }
+
+  return NumberFormatter.format(value as number, locale, style, {
+    minimumIntegerDigits: minInt,
+    minimumFractionDigits: minFraction,
+    maximumFractionDigits: maxFraction,
+    currency: currency,
+    currencyAsSymbol: currencyAsSymbol,
+  });
+}
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Formats a number according to locale rules.
+ * @howToUse `number_expression | number[:digitInfo]`
+ *
+ * Formats a number as text. Group sizing and separator and other locale-specific
+ * configurations are based on the active locale.
+ *
+ * where `expression` is a number:
+ *  - `digitInfo` is a `string` which has a following format: <br>
+ *     <code>{minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}</code>
+ *   - `minIntegerDigits` is the minimum number of integer digits to use. Defaults to `1`.
+ *   - `minFractionDigits` is the minimum number of digits after fraction. Defaults to `0`.
+ *   - `maxFractionDigits` is the maximum number of digits after fraction. Defaults to `3`.
+ *
+ * For more information on the acceptable range for each of these numbers and other
+ * details see your native internationalization library.
+ *
+ * WARNING: this pipe uses the Internationalization API which is not yet available in all browsers
+ * and may require a polyfill. See [Browser Support](guide/browser-support) for details.
+ *
+ * ### Example
+ *
+ * {@example common/pipes/ts/number_pipe.ts region='NumberPipe'}
+ *
+ * @stable
+ */
+@Pipe({name: 'number'})
+export class DecimalPipe implements PipeTransform {
+  constructor(@Inject(LOCALE_ID) private _locale: string) {}
+
+  transform(value: any, digits?: string): string|null {
+    return formatNumber(DecimalPipe, this._locale, value, NumberFormatStyle.Decimal, digits);
+  }
+}
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Formats a number as a percentage according to locale rules.
+ * @howToUse `number_expression | percent[:digitInfo]`
+ *
+ * @description
+ *
+ * Formats a number as percentage.
+ *
+ * - `digitInfo` See {@link DecimalPipe} for detailed description.
+ *
+ * WARNING: this pipe uses the Internationalization API which is not yet available in all browsers
+ * and may require a polyfill. See [Browser Support](guide/browser-support) for details.
+ *
+ * ### Example
+ *
+ * {@example common/pipes/ts/number_pipe.ts region='PercentPipe'}
+ *
+ * @stable
+ */
+@Pipe({name: 'percent'})
+export class PercentPipe implements PipeTransform {
+  constructor(@Inject(LOCALE_ID) private _locale: string) {}
+
+  transform(value: any, digits?: string): string|null {
+    return formatNumber(PercentPipe, this._locale, value, NumberFormatStyle.Percent, digits);
+  }
+}
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Formats a number as currency using locale rules.
+ * @howToUse `number_expression | currency[:currencyCode[:symbolDisplay[:digitInfo]]]`
+ * @description
+ *
+ * Use `currency` to format a number as currency.
+ *
+ * - `currencyCode` is the [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code, such
+ *    as `USD` for the US dollar and `EUR` for the euro.
+ * - `symbolDisplay` is a boolean indicating whether to use the currency symbol or code.
+ *   - `true`: use symbol (e.g. `$`).
+ *   - `false`(default): use code (e.g. `USD`).
+ * - `digitInfo` See {@link DecimalPipe} for detailed description.
+ *
+ * WARNING: this pipe uses the Internationalization API which is not yet available in all browsers
+ * and may require a polyfill. See [Browser Support](guide/browser-support) for details.
+ *
+ * ### Example
+ *
+ * {@example common/pipes/ts/number_pipe.ts region='CurrencyPipe'}
+ *
+ * @stable
+ */
+@Pipe({name: 'currency'})
+export class CurrencyPipe implements PipeTransform {
+  constructor(@Inject(LOCALE_ID) private _locale: string) {}
+
+  transform(
+      value: any, currencyCode: string = 'USD', symbolDisplay: boolean = false,
+      digits?: string): string|null {
+    return formatNumber(
+        CurrencyPipe, this._locale, value, NumberFormatStyle.Currency, digits, currencyCode,
+        symbolDisplay);
+  }
+}
+
+function parseIntAutoRadix(text: string): number {
+  const result: number = parseInt(text);
+  if (isNaN(result)) {
+    throw new Error('Invalid integer literal when parsing ' + text);
+  }
+  return result;
+}
+
+export function isNumeric(value: any): boolean {
+  return !isNaN(value - parseFloat(value));
+}
diff --git a/angular/common/src/pipes/slice_pipe.ts b/angular/common/src/pipes/slice_pipe.ts
new file mode 100644
index 0000000..6466d26
--- /dev/null
+++ b/angular/common/src/pipes/slice_pipe.ts
@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Pipe, PipeTransform} from '@angular/core';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Creates a new List or String containing a subset (slice) of the elements.
+ * @howToUse `array_or_string_expression | slice:start[:end]`
+ * @description
+ *
+ * Where the input expression is a `List` or `String`, and:
+ * - `start`: The starting index of the subset to return.
+ *   - **a positive integer**: return the item at `start` index and all items after
+ *     in the list or string expression.
+ *   - **a negative integer**: return the item at `start` index from the end and all items after
+ *     in the list or string expression.
+ *   - **if positive and greater than the size of the expression**: return an empty list or string.
+ *   - **if negative and greater than the size of the expression**: return entire list or string.
+ * - `end`: The ending index of the subset to return.
+ *   - **omitted**: return all items until the end.
+ *   - **if positive**: return all items before `end` index of the list or string.
+ *   - **if negative**: return all items before `end` index from the end of the list or string.
+ *
+ * All behavior is based on the expected behavior of the JavaScript API `Array.prototype.slice()`
+ * and `String.prototype.slice()`.
+ *
+ * When operating on a [List], the returned list is always a copy even when all
+ * the elements are being returned.
+ *
+ * When operating on a blank value, the pipe returns the blank value.
+ *
+ * ## List Example
+ *
+ * This `ngFor` example:
+ *
+ * {@example common/pipes/ts/slice_pipe.ts region='SlicePipe_list'}
+ *
+ * produces the following:
+ *
+ *     <li>b</li>
+ *     <li>c</li>
+ *
+ * ## String Examples
+ *
+ * {@example common/pipes/ts/slice_pipe.ts region='SlicePipe_string'}
+ *
+ * @stable
+ */
+
+@Pipe({name: 'slice', pure: false})
+export class SlicePipe implements PipeTransform {
+  transform(value: any, start: number, end?: number): any {
+    if (value == null) return value;
+
+    if (!this.supports(value)) {
+      throw invalidPipeArgumentError(SlicePipe, value);
+    }
+
+    return value.slice(start, end);
+  }
+
+  private supports(obj: any): boolean { return typeof obj === 'string' || Array.isArray(obj); }
+}
diff --git a/angular/common/src/platform_id.ts b/angular/common/src/platform_id.ts
new file mode 100644
index 0000000..2a27926
--- /dev/null
+++ b/angular/common/src/platform_id.ts
@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export const PLATFORM_BROWSER_ID = 'browser';
+export const PLATFORM_SERVER_ID = 'server';
+export const PLATFORM_WORKER_APP_ID = 'browserWorkerApp';
+export const PLATFORM_WORKER_UI_ID = 'browserWorkerUi';
+
+/**
+ * Returns whether a platform id represents a browser platform.
+ * @experimental
+ */
+export function isPlatformBrowser(platformId: Object): boolean {
+  return platformId === PLATFORM_BROWSER_ID;
+}
+
+/**
+ * Returns whether a platform id represents a server platform.
+ * @experimental
+ */
+export function isPlatformServer(platformId: Object): boolean {
+  return platformId === PLATFORM_SERVER_ID;
+}
+
+/**
+ * Returns whether a platform id represents a web worker app platform.
+ * @experimental
+ */
+export function isPlatformWorkerApp(platformId: Object): boolean {
+  return platformId === PLATFORM_WORKER_APP_ID;
+}
+
+/**
+ * Returns whether a platform id represents a web worker UI platform.
+ * @experimental
+ */
+export function isPlatformWorkerUi(platformId: Object): boolean {
+  return platformId === PLATFORM_WORKER_UI_ID;
+}
diff --git a/angular/common/src/version.ts b/angular/common/src/version.ts
new file mode 100644
index 0000000..19db5be
--- /dev/null
+++ b/angular/common/src/version.ts
@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the common package.
+ */
+
+import {Version} from '@angular/core';
+/**
+ * @stable
+ */
+export const VERSION = new Version('0.0.0-PLACEHOLDER');
diff --git a/angular/compiler/index.ts b/angular/compiler/index.ts
new file mode 100644
index 0000000..03a69b6
--- /dev/null
+++ b/angular/compiler/index.ts
@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the compiler package.
+ */
+export * from './src/compiler';
+
+// This file only reexports content of the `src` folder. Keep it that way.
diff --git a/angular/compiler/src/aot/compiler.ts b/angular/compiler/src/aot/compiler.ts
new file mode 100644
index 0000000..76d3aca
--- /dev/null
+++ b/angular/compiler/src/aot/compiler.ts
@@ -0,0 +1,578 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileNgModuleSummary, CompilePipeMetadata, CompileProviderMetadata, CompileStylesheetMetadata, CompileSummaryKind, CompileTypeMetadata, CompileTypeSummary, componentFactoryName, createHostComponentMeta, flatten, identifierName, sourceUrl, templateSourceUrl} from '../compile_metadata';
+import {CompilerConfig} from '../config';
+import {Identifiers, createTokenForExternalReference} from '../identifiers';
+import {CompileMetadataResolver} from '../metadata_resolver';
+import {NgModuleCompiler} from '../ng_module_compiler';
+import {OutputEmitter} from '../output/abstract_emitter';
+import * as o from '../output/output_ast';
+import {CompiledStylesheet, StyleCompiler} from '../style_compiler';
+import {SummaryResolver} from '../summary_resolver';
+import {TemplateParser} from '../template_parser/template_parser';
+import {OutputContext, syntaxError} from '../util';
+import {ViewCompileResult, ViewCompiler} from '../view_compiler/view_compiler';
+
+import {AotCompilerHost} from './compiler_host';
+import {GeneratedFile} from './generated_file';
+import {StaticReflector} from './static_reflector';
+import {StaticSymbol} from './static_symbol';
+import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
+import {createForJitStub, serializeSummaries} from './summary_serializer';
+import {ngfactoryFilePath, splitTypescriptSuffix, summaryFileName, summaryForJitFileName, summaryForJitName} from './util';
+
+export class AotCompiler {
+  constructor(
+      private _config: CompilerConfig, private _host: AotCompilerHost,
+      private _reflector: StaticReflector, private _metadataResolver: CompileMetadataResolver,
+      private _templateParser: TemplateParser, private _styleCompiler: StyleCompiler,
+      private _viewCompiler: ViewCompiler, private _ngModuleCompiler: NgModuleCompiler,
+      private _outputEmitter: OutputEmitter,
+      private _summaryResolver: SummaryResolver<StaticSymbol>, private _localeId: string|null,
+      private _translationFormat: string|null, private _enableSummariesForJit: boolean|null,
+      private _symbolResolver: StaticSymbolResolver) {}
+
+  clearCache() { this._metadataResolver.clearCache(); }
+
+  analyzeModulesSync(rootFiles: string[]): NgAnalyzedModules {
+    const programSymbols = extractProgramSymbols(this._symbolResolver, rootFiles, this._host);
+    const analyzeResult =
+        analyzeAndValidateNgModules(programSymbols, this._host, this._metadataResolver);
+    analyzeResult.ngModules.forEach(
+        ngModule => this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
+            ngModule.type.reference, true));
+    return analyzeResult;
+  }
+
+  analyzeModulesAsync(rootFiles: string[]): Promise<NgAnalyzedModules> {
+    const programSymbols = extractProgramSymbols(this._symbolResolver, rootFiles, this._host);
+    const analyzeResult =
+        analyzeAndValidateNgModules(programSymbols, this._host, this._metadataResolver);
+    return Promise
+        .all(analyzeResult.ngModules.map(
+            ngModule => this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
+                ngModule.type.reference, false)))
+        .then(() => analyzeResult);
+  }
+
+  emitAllStubs(analyzeResult: NgAnalyzedModules): GeneratedFile[] {
+    const {files} = analyzeResult;
+    const sourceModules = files.map(
+        file =>
+            this._compileStubFile(file.srcUrl, file.directives, file.pipes, file.ngModules, false));
+    return flatten(sourceModules);
+  }
+
+  emitPartialStubs(analyzeResult: NgAnalyzedModules): GeneratedFile[] {
+    const {files} = analyzeResult;
+    const sourceModules = files.map(
+        file =>
+            this._compileStubFile(file.srcUrl, file.directives, file.pipes, file.ngModules, true));
+    return flatten(sourceModules);
+  }
+
+  emitAllImpls(analyzeResult: NgAnalyzedModules): GeneratedFile[] {
+    const {ngModuleByPipeOrDirective, files} = analyzeResult;
+    const sourceModules = files.map(
+        file => this._compileImplFile(
+            file.srcUrl, ngModuleByPipeOrDirective, file.directives, file.pipes, file.ngModules,
+            file.injectables));
+    return flatten(sourceModules);
+  }
+
+  private _compileStubFile(
+      srcFileUrl: string, directives: StaticSymbol[], pipes: StaticSymbol[],
+      ngModules: StaticSymbol[], partial: boolean): GeneratedFile[] {
+    // partial is true when we only need the files we are certain will produce a factory and/or
+    // summary.
+    // This is the normal case for `ngc` but if we assume libraryies are generating their own
+    // factories
+    // then we might need a factory for a file that re-exports a module or factory which we cannot
+    // know
+    // ahead of time so we need a stub generate for all non-.d.ts files. The .d.ts files do not need
+    // to
+    // be excluded here because they are excluded when the modules are analyzed. If a factory ends
+    // up
+    // not being needed, the factory file is not written in writeFile callback.
+    const fileSuffix = splitTypescriptSuffix(srcFileUrl, true)[1];
+    const generatedFiles: GeneratedFile[] = [];
+
+    const ngFactoryOutputCtx = this._createOutputContext(ngfactoryFilePath(srcFileUrl, true));
+    const jitSummaryOutputCtx = this._createOutputContext(summaryForJitFileName(srcFileUrl, true));
+
+    // create exports that user code can reference
+    ngModules.forEach((ngModuleReference) => {
+      this._ngModuleCompiler.createStub(ngFactoryOutputCtx, ngModuleReference);
+      createForJitStub(jitSummaryOutputCtx, ngModuleReference);
+    });
+
+    let partialJitStubRequired = false;
+    let partialFactoryStubRequired = false;
+
+    // create stubs for external stylesheets (always empty, as users should not import anything from
+    // the generated code)
+    directives.forEach((dirType) => {
+      const compMeta = this._metadataResolver.getDirectiveMetadata(<any>dirType);
+
+      partialJitStubRequired = true;
+
+      if (!compMeta.isComponent) {
+        return;
+      }
+      // Note: compMeta is a component and therefore template is non null.
+      compMeta.template !.externalStylesheets.forEach((stylesheetMeta) => {
+        const styleContext = this._createOutputContext(_stylesModuleUrl(
+            stylesheetMeta.moduleUrl !, this._styleCompiler.needsStyleShim(compMeta), fileSuffix));
+        _createTypeReferenceStub(styleContext, Identifiers.ComponentFactory);
+        generatedFiles.push(this._codegenSourceModule(stylesheetMeta.moduleUrl !, styleContext));
+      });
+
+      partialFactoryStubRequired = true;
+    });
+
+    // If we need all the stubs to be generated then insert an arbitrary reference into the stub
+    if ((partialFactoryStubRequired || !partial) && ngFactoryOutputCtx.statements.length <= 0) {
+      _createTypeReferenceStub(ngFactoryOutputCtx, Identifiers.ComponentFactory);
+    }
+    if ((partialJitStubRequired || !partial || (pipes && pipes.length > 0)) &&
+        jitSummaryOutputCtx.statements.length <= 0) {
+      _createTypeReferenceStub(jitSummaryOutputCtx, Identifiers.ComponentFactory);
+    }
+
+    // Note: we are creating stub ngfactory/ngsummary for all source files,
+    // as the real calculation requires almost the same logic as producing the real content for
+    // them. Our pipeline will filter out empty ones at the end. Because of this filter, however,
+    // stub references to the reference type needs to be generated even if the user cannot
+    // refer to type from the `.d.ts` file to prevent the file being elided from the emit.
+    generatedFiles.push(this._codegenSourceModule(srcFileUrl, ngFactoryOutputCtx));
+    if (this._enableSummariesForJit) {
+      generatedFiles.push(this._codegenSourceModule(srcFileUrl, jitSummaryOutputCtx));
+    }
+
+    return generatedFiles;
+  }
+
+  private _compileImplFile(
+      srcFileUrl: string, ngModuleByPipeOrDirective: Map<StaticSymbol, CompileNgModuleMetadata>,
+      directives: StaticSymbol[], pipes: StaticSymbol[], ngModules: StaticSymbol[],
+      injectables: StaticSymbol[]): GeneratedFile[] {
+    const fileSuffix = splitTypescriptSuffix(srcFileUrl, true)[1];
+    const generatedFiles: GeneratedFile[] = [];
+
+    const outputCtx = this._createOutputContext(ngfactoryFilePath(srcFileUrl, true));
+
+    generatedFiles.push(
+        ...this._createSummary(srcFileUrl, directives, pipes, ngModules, injectables, outputCtx));
+
+    // compile all ng modules
+    ngModules.forEach((ngModuleType) => this._compileModule(outputCtx, ngModuleType));
+
+    // compile components
+    directives.forEach((dirType) => {
+      const compMeta = this._metadataResolver.getDirectiveMetadata(<any>dirType);
+      if (!compMeta.isComponent) {
+        return;
+      }
+      const ngModule = ngModuleByPipeOrDirective.get(dirType);
+      if (!ngModule) {
+        throw new Error(
+            `Internal Error: cannot determine the module for component ${identifierName(compMeta.type)}!`);
+      }
+
+      // compile styles
+      const componentStylesheet = this._styleCompiler.compileComponent(outputCtx, compMeta);
+      // Note: compMeta is a component and therefore template is non null.
+      compMeta.template !.externalStylesheets.forEach((stylesheetMeta) => {
+        generatedFiles.push(
+            this._codegenStyles(stylesheetMeta.moduleUrl !, compMeta, stylesheetMeta, fileSuffix));
+      });
+
+      // compile components
+      const compViewVars = this._compileComponent(
+          outputCtx, compMeta, ngModule, ngModule.transitiveModule.directives, componentStylesheet,
+          fileSuffix);
+      this._compileComponentFactory(outputCtx, compMeta, ngModule, fileSuffix);
+    });
+    if (outputCtx.statements.length > 0) {
+      const srcModule = this._codegenSourceModule(srcFileUrl, outputCtx);
+      generatedFiles.unshift(srcModule);
+    }
+    return generatedFiles;
+  }
+
+  private _createSummary(
+      srcFileName: string, directives: StaticSymbol[], pipes: StaticSymbol[],
+      ngModules: StaticSymbol[], injectables: StaticSymbol[],
+      ngFactoryCtx: OutputContext): GeneratedFile[] {
+    const symbolSummaries = this._symbolResolver.getSymbolsOf(srcFileName)
+                                .map(symbol => this._symbolResolver.resolveSymbol(symbol));
+    const typeData: {
+      summary: CompileTypeSummary,
+      metadata: CompileNgModuleMetadata | CompileDirectiveMetadata | CompilePipeMetadata |
+          CompileTypeMetadata
+    }[] =
+        [
+          ...ngModules.map(ref => ({
+                             summary: this._metadataResolver.getNgModuleSummary(ref) !,
+                             metadata: this._metadataResolver.getNgModuleMetadata(ref) !
+                           })),
+          ...directives.map(ref => ({
+                              summary: this._metadataResolver.getDirectiveSummary(ref) !,
+                              metadata: this._metadataResolver.getDirectiveMetadata(ref) !
+                            })),
+          ...pipes.map(ref => ({
+                         summary: this._metadataResolver.getPipeSummary(ref) !,
+                         metadata: this._metadataResolver.getPipeMetadata(ref) !
+                       })),
+          ...injectables.map(ref => ({
+                               summary: this._metadataResolver.getInjectableSummary(ref) !,
+                               metadata: this._metadataResolver.getInjectableSummary(ref) !.type
+                             }))
+        ];
+    const forJitOutputCtx = this._createOutputContext(summaryForJitFileName(srcFileName, true));
+    const {json, exportAs} = serializeSummaries(
+        srcFileName, forJitOutputCtx, this._summaryResolver, this._symbolResolver, symbolSummaries,
+        typeData);
+    exportAs.forEach((entry) => {
+      ngFactoryCtx.statements.push(
+          o.variable(entry.exportAs).set(ngFactoryCtx.importExpr(entry.symbol)).toDeclStmt(null, [
+            o.StmtModifier.Exported
+          ]));
+    });
+    const summaryJson = new GeneratedFile(srcFileName, summaryFileName(srcFileName), json);
+    if (this._enableSummariesForJit) {
+      return [summaryJson, this._codegenSourceModule(srcFileName, forJitOutputCtx)];
+    };
+
+    return [summaryJson];
+  }
+
+  private _compileModule(outputCtx: OutputContext, ngModuleType: StaticSymbol): void {
+    const ngModule = this._metadataResolver.getNgModuleMetadata(ngModuleType) !;
+    const providers: CompileProviderMetadata[] = [];
+
+    if (this._localeId) {
+      providers.push({
+        token: createTokenForExternalReference(this._reflector, Identifiers.LOCALE_ID),
+        useValue: this._localeId,
+      });
+    }
+
+    if (this._translationFormat) {
+      providers.push({
+        token: createTokenForExternalReference(this._reflector, Identifiers.TRANSLATIONS_FORMAT),
+        useValue: this._translationFormat
+      });
+    }
+
+    this._ngModuleCompiler.compile(outputCtx, ngModule, providers);
+  }
+
+  private _compileComponentFactory(
+      outputCtx: OutputContext, compMeta: CompileDirectiveMetadata,
+      ngModule: CompileNgModuleMetadata, fileSuffix: string): void {
+    const hostType = this._metadataResolver.getHostComponentType(compMeta.type.reference);
+    const hostMeta = createHostComponentMeta(
+        hostType, compMeta, this._metadataResolver.getHostComponentViewClass(hostType));
+    const hostViewFactoryVar =
+        this._compileComponent(outputCtx, hostMeta, ngModule, [compMeta.type], null, fileSuffix)
+            .viewClassVar;
+    const compFactoryVar = componentFactoryName(compMeta.type.reference);
+    const inputsExprs: o.LiteralMapEntry[] = [];
+    for (let propName in compMeta.inputs) {
+      const templateName = compMeta.inputs[propName];
+      // Don't quote so that the key gets minified...
+      inputsExprs.push(new o.LiteralMapEntry(propName, o.literal(templateName), false));
+    }
+    const outputsExprs: o.LiteralMapEntry[] = [];
+    for (let propName in compMeta.outputs) {
+      const templateName = compMeta.outputs[propName];
+      // Don't quote so that the key gets minified...
+      outputsExprs.push(new o.LiteralMapEntry(propName, o.literal(templateName), false));
+    }
+
+    outputCtx.statements.push(
+        o.variable(compFactoryVar)
+            .set(o.importExpr(Identifiers.createComponentFactory).callFn([
+              o.literal(compMeta.selector), outputCtx.importExpr(compMeta.type.reference),
+              o.variable(hostViewFactoryVar), new o.LiteralMapExpr(inputsExprs),
+              new o.LiteralMapExpr(outputsExprs),
+              o.literalArr(
+                  compMeta.template !.ngContentSelectors.map(selector => o.literal(selector)))
+            ]))
+            .toDeclStmt(
+                o.importType(
+                    Identifiers.ComponentFactory,
+                    [o.expressionType(outputCtx.importExpr(compMeta.type.reference)) !],
+                    [o.TypeModifier.Const]),
+                [o.StmtModifier.Final, o.StmtModifier.Exported]));
+  }
+
+  private _compileComponent(
+      outputCtx: OutputContext, compMeta: CompileDirectiveMetadata,
+      ngModule: CompileNgModuleMetadata, directiveIdentifiers: CompileIdentifierMetadata[],
+      componentStyles: CompiledStylesheet|null, fileSuffix: string): ViewCompileResult {
+    const directives =
+        directiveIdentifiers.map(dir => this._metadataResolver.getDirectiveSummary(dir.reference));
+    const pipes = ngModule.transitiveModule.pipes.map(
+        pipe => this._metadataResolver.getPipeSummary(pipe.reference));
+
+    const preserveWhitespaces = compMeta !.template !.preserveWhitespaces;
+    const {template: parsedTemplate, pipes: usedPipes} = this._templateParser.parse(
+        compMeta, compMeta.template !.template !, directives, pipes, ngModule.schemas,
+        templateSourceUrl(ngModule.type, compMeta, compMeta.template !), preserveWhitespaces);
+    const stylesExpr = componentStyles ? o.variable(componentStyles.stylesVar) : o.literalArr([]);
+    const viewResult = this._viewCompiler.compileComponent(
+        outputCtx, compMeta, parsedTemplate, stylesExpr, usedPipes);
+    if (componentStyles) {
+      _resolveStyleStatements(
+          this._symbolResolver, componentStyles, this._styleCompiler.needsStyleShim(compMeta),
+          fileSuffix);
+    }
+    return viewResult;
+  }
+
+  private _createOutputContext(genFilePath: string): OutputContext {
+    const importExpr = (symbol: StaticSymbol, typeParams: o.Type[] | null = null) => {
+      if (!(symbol instanceof StaticSymbol)) {
+        throw new Error(`Internal error: unknown identifier ${JSON.stringify(symbol)}`);
+      }
+      const arity = this._symbolResolver.getTypeArity(symbol) || 0;
+      const {filePath, name, members} = this._symbolResolver.getImportAs(symbol) || symbol;
+      const importModule = this._symbolResolver.fileNameToModuleName(filePath, genFilePath);
+
+      // It should be good enough to compare filePath to genFilePath and if they are equal
+      // there is a self reference. However, ngfactory files generate to .ts but their
+      // symbols have .d.ts so a simple compare is insufficient. They should be canonical
+      // and is tracked by #17705.
+      const selfReference = this._symbolResolver.fileNameToModuleName(genFilePath, genFilePath);
+      const moduleName = importModule === selfReference ? null : importModule;
+
+      // If we are in a type expression that refers to a generic type then supply
+      // the required type parameters. If there were not enough type parameters
+      // supplied, supply any as the type. Outside a type expression the reference
+      // should not supply type parameters and be treated as a simple value reference
+      // to the constructor function itself.
+      const suppliedTypeParams = typeParams || [];
+      const missingTypeParamsCount = arity - suppliedTypeParams.length;
+      const allTypeParams =
+          suppliedTypeParams.concat(new Array(missingTypeParamsCount).fill(o.DYNAMIC_TYPE));
+      return members.reduce(
+          (expr, memberName) => expr.prop(memberName),
+          <o.Expression>o.importExpr(
+              new o.ExternalReference(moduleName, name, null), allTypeParams));
+    };
+
+    return {statements: [], genFilePath, importExpr};
+  }
+
+  private _codegenStyles(
+      srcFileUrl: string, compMeta: CompileDirectiveMetadata,
+      stylesheetMetadata: CompileStylesheetMetadata, fileSuffix: string): GeneratedFile {
+    const outputCtx = this._createOutputContext(_stylesModuleUrl(
+        stylesheetMetadata.moduleUrl !, this._styleCompiler.needsStyleShim(compMeta), fileSuffix));
+    const compiledStylesheet =
+        this._styleCompiler.compileStyles(outputCtx, compMeta, stylesheetMetadata);
+    _resolveStyleStatements(
+        this._symbolResolver, compiledStylesheet, this._styleCompiler.needsStyleShim(compMeta),
+        fileSuffix);
+    return this._codegenSourceModule(srcFileUrl, outputCtx);
+  }
+
+  private _codegenSourceModule(srcFileUrl: string, ctx: OutputContext): GeneratedFile {
+    return new GeneratedFile(srcFileUrl, ctx.genFilePath, ctx.statements);
+  }
+}
+
+function _createTypeReferenceStub(outputCtx: OutputContext, reference: o.ExternalReference) {
+  outputCtx.statements.push(o.importExpr(reference).toStmt());
+}
+
+function _resolveStyleStatements(
+    symbolResolver: StaticSymbolResolver, compileResult: CompiledStylesheet, needsShim: boolean,
+    fileSuffix: string): void {
+  compileResult.dependencies.forEach((dep) => {
+    dep.setValue(symbolResolver.getStaticSymbol(
+        _stylesModuleUrl(dep.moduleUrl, needsShim, fileSuffix), dep.name));
+  });
+}
+
+function _stylesModuleUrl(stylesheetUrl: string, shim: boolean, suffix: string): string {
+  return `${stylesheetUrl}${shim ? '.shim' : ''}.ngstyle${suffix}`;
+}
+
+export interface NgAnalyzedModules {
+  ngModules: CompileNgModuleMetadata[];
+  ngModuleByPipeOrDirective: Map<StaticSymbol, CompileNgModuleMetadata>;
+  files: Array<{
+    srcUrl: string,
+    directives: StaticSymbol[],
+    pipes: StaticSymbol[],
+    ngModules: StaticSymbol[],
+    injectables: StaticSymbol[]
+  }>;
+  symbolsMissingModule?: StaticSymbol[];
+}
+
+export interface NgAnalyzeModulesHost { isSourceFile(filePath: string): boolean; }
+
+// Returns all the source files and a mapping from modules to directives
+export function analyzeNgModules(
+    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
+    metadataResolver: CompileMetadataResolver): NgAnalyzedModules {
+  const {ngModules, symbolsMissingModule} =
+      _createNgModules(programStaticSymbols, host, metadataResolver);
+  return _analyzeNgModules(programStaticSymbols, ngModules, symbolsMissingModule, metadataResolver);
+}
+
+export function analyzeAndValidateNgModules(
+    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
+    metadataResolver: CompileMetadataResolver): NgAnalyzedModules {
+  const result = analyzeNgModules(programStaticSymbols, host, metadataResolver);
+  if (result.symbolsMissingModule && result.symbolsMissingModule.length) {
+    const messages = result.symbolsMissingModule.map(
+        s =>
+            `Cannot determine the module for class ${s.name} in ${s.filePath}! Add ${s.name} to the NgModule to fix it.`);
+    throw syntaxError(messages.join('\n'));
+  }
+  return result;
+}
+
+function _analyzeNgModules(
+    programSymbols: StaticSymbol[], ngModuleMetas: CompileNgModuleMetadata[],
+    symbolsMissingModule: StaticSymbol[],
+    metadataResolver: CompileMetadataResolver): NgAnalyzedModules {
+  const moduleMetasByRef = new Map<any, CompileNgModuleMetadata>();
+  ngModuleMetas.forEach((ngModule) => moduleMetasByRef.set(ngModule.type.reference, ngModule));
+  const ngModuleByPipeOrDirective = new Map<StaticSymbol, CompileNgModuleMetadata>();
+  const ngModulesByFile = new Map<string, StaticSymbol[]>();
+  const ngDirectivesByFile = new Map<string, StaticSymbol[]>();
+  const ngPipesByFile = new Map<string, StaticSymbol[]>();
+  const ngInjectablesByFile = new Map<string, StaticSymbol[]>();
+  const filePaths = new Set<string>();
+
+  // Make sure we produce an analyzed file for each input file
+  programSymbols.forEach((symbol) => {
+    const filePath = symbol.filePath;
+    filePaths.add(filePath);
+    if (metadataResolver.isInjectable(symbol)) {
+      ngInjectablesByFile.set(filePath, (ngInjectablesByFile.get(filePath) || []).concat(symbol));
+    }
+  });
+
+  // Looping over all modules to construct:
+  // - a map from file to modules `ngModulesByFile`,
+  // - a map from file to directives `ngDirectivesByFile`,
+  // - a map from file to pipes `ngPipesByFile`,
+  // - a map from directive/pipe to module `ngModuleByPipeOrDirective`.
+  ngModuleMetas.forEach((ngModuleMeta) => {
+    const srcFileUrl = ngModuleMeta.type.reference.filePath;
+    filePaths.add(srcFileUrl);
+    ngModulesByFile.set(
+        srcFileUrl, (ngModulesByFile.get(srcFileUrl) || []).concat(ngModuleMeta.type.reference));
+
+    ngModuleMeta.declaredDirectives.forEach((dirIdentifier) => {
+      const fileUrl = dirIdentifier.reference.filePath;
+      filePaths.add(fileUrl);
+      ngDirectivesByFile.set(
+          fileUrl, (ngDirectivesByFile.get(fileUrl) || []).concat(dirIdentifier.reference));
+      ngModuleByPipeOrDirective.set(dirIdentifier.reference, ngModuleMeta);
+    });
+    ngModuleMeta.declaredPipes.forEach((pipeIdentifier) => {
+      const fileUrl = pipeIdentifier.reference.filePath;
+      filePaths.add(fileUrl);
+      ngPipesByFile.set(
+          fileUrl, (ngPipesByFile.get(fileUrl) || []).concat(pipeIdentifier.reference));
+      ngModuleByPipeOrDirective.set(pipeIdentifier.reference, ngModuleMeta);
+    });
+  });
+
+  const files: {
+    srcUrl: string,
+    directives: StaticSymbol[],
+    pipes: StaticSymbol[],
+    ngModules: StaticSymbol[],
+    injectables: StaticSymbol[]
+  }[] = [];
+
+  filePaths.forEach((srcUrl) => {
+    const directives = ngDirectivesByFile.get(srcUrl) || [];
+    const pipes = ngPipesByFile.get(srcUrl) || [];
+    const ngModules = ngModulesByFile.get(srcUrl) || [];
+    const injectables = ngInjectablesByFile.get(srcUrl) || [];
+    files.push({srcUrl, directives, pipes, ngModules, injectables});
+  });
+
+  return {
+    // map directive/pipe to module
+    ngModuleByPipeOrDirective,
+    // list modules and directives for every source file
+    files,
+    ngModules: ngModuleMetas, symbolsMissingModule
+  };
+}
+
+export function extractProgramSymbols(
+    staticSymbolResolver: StaticSymbolResolver, files: string[],
+    host: NgAnalyzeModulesHost): StaticSymbol[] {
+  const staticSymbols: StaticSymbol[] = [];
+  files.filter(fileName => host.isSourceFile(fileName)).forEach(sourceFile => {
+    staticSymbolResolver.getSymbolsOf(sourceFile).forEach((symbol) => {
+      const resolvedSymbol = staticSymbolResolver.resolveSymbol(symbol);
+      const symbolMeta = resolvedSymbol.metadata;
+      if (symbolMeta) {
+        if (symbolMeta.__symbolic != 'error') {
+          // Ignore symbols that are only included to record error information.
+          staticSymbols.push(resolvedSymbol.symbol);
+        }
+      }
+    });
+  });
+
+  return staticSymbols;
+}
+
+// Load the NgModules and check
+// that all directives / pipes that are present in the program
+// are also declared by a module.
+function _createNgModules(
+    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
+    metadataResolver: CompileMetadataResolver):
+    {ngModules: CompileNgModuleMetadata[], symbolsMissingModule: StaticSymbol[]} {
+  const ngModules = new Map<any, CompileNgModuleMetadata>();
+  const programPipesAndDirectives: StaticSymbol[] = [];
+  const ngModulePipesAndDirective = new Set<StaticSymbol>();
+
+  const addNgModule = (staticSymbol: any) => {
+    if (ngModules.has(staticSymbol) || !host.isSourceFile(staticSymbol.filePath)) {
+      return false;
+    }
+    const ngModule = metadataResolver.getNgModuleMetadata(staticSymbol, false);
+    if (ngModule) {
+      ngModules.set(ngModule.type.reference, ngModule);
+      ngModule.declaredDirectives.forEach((dir) => ngModulePipesAndDirective.add(dir.reference));
+      ngModule.declaredPipes.forEach((pipe) => ngModulePipesAndDirective.add(pipe.reference));
+      // For every input module add the list of transitively included modules
+      ngModule.transitiveModule.modules.forEach(modMeta => addNgModule(modMeta.reference));
+    }
+    return !!ngModule;
+  };
+  programStaticSymbols.forEach((staticSymbol) => {
+    if (!addNgModule(staticSymbol) &&
+        (metadataResolver.isDirective(staticSymbol) || metadataResolver.isPipe(staticSymbol))) {
+      programPipesAndDirectives.push(staticSymbol);
+    }
+  });
+
+  // Throw an error if any of the program pipe or directives is not declared by a module
+  const symbolsMissingModule =
+      programPipesAndDirectives.filter(s => !ngModulePipesAndDirective.has(s));
+
+  return {ngModules: Array.from(ngModules.values()), symbolsMissingModule};
+}
diff --git a/angular/compiler/src/aot/compiler_factory.ts b/angular/compiler/src/aot/compiler_factory.ts
new file mode 100644
index 0000000..f8155da
--- /dev/null
+++ b/angular/compiler/src/aot/compiler_factory.ts
@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompilerConfig} from '../config';
+import {MissingTranslationStrategy, ViewEncapsulation} from '../core';
+import {DirectiveNormalizer} from '../directive_normalizer';
+import {DirectiveResolver} from '../directive_resolver';
+import {Lexer} from '../expression_parser/lexer';
+import {Parser} from '../expression_parser/parser';
+import {I18NHtmlParser} from '../i18n/i18n_html_parser';
+import {CompileMetadataResolver} from '../metadata_resolver';
+import {HtmlParser} from '../ml_parser/html_parser';
+import {NgModuleCompiler} from '../ng_module_compiler';
+import {NgModuleResolver} from '../ng_module_resolver';
+import {TypeScriptEmitter} from '../output/ts_emitter';
+import {PipeResolver} from '../pipe_resolver';
+import {DomElementSchemaRegistry} from '../schema/dom_element_schema_registry';
+import {StyleCompiler} from '../style_compiler';
+import {TemplateParser} from '../template_parser/template_parser';
+import {UrlResolver} from '../url_resolver';
+import {syntaxError} from '../util';
+import {ViewCompiler} from '../view_compiler/view_compiler';
+
+import {AotCompiler} from './compiler';
+import {AotCompilerHost} from './compiler_host';
+import {AotCompilerOptions} from './compiler_options';
+import {StaticReflector} from './static_reflector';
+import {StaticSymbol, StaticSymbolCache} from './static_symbol';
+import {StaticSymbolResolver} from './static_symbol_resolver';
+import {AotSummaryResolver} from './summary_resolver';
+
+export function createAotUrlResolver(host: {
+  resourceNameToFileName(resourceName: string, containingFileName: string): string | null;
+}): UrlResolver {
+  return {
+    resolve: (basePath: string, url: string) => {
+      const filePath = host.resourceNameToFileName(url, basePath);
+      if (!filePath) {
+        throw syntaxError(`Couldn't resolve resource ${url} from ${basePath}`);
+      }
+      return filePath;
+    }
+  };
+}
+
+/**
+ * Creates a new AotCompiler based on options and a host.
+ */
+export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCompilerOptions):
+    {compiler: AotCompiler, reflector: StaticReflector} {
+  let translations: string = options.translations || '';
+
+  const urlResolver = createAotUrlResolver(compilerHost);
+  const symbolCache = new StaticSymbolCache();
+  const summaryResolver = new AotSummaryResolver(compilerHost, symbolCache);
+  const symbolResolver = new StaticSymbolResolver(compilerHost, symbolCache, summaryResolver);
+  const staticReflector = new StaticReflector(summaryResolver, symbolResolver);
+  const htmlParser = new I18NHtmlParser(
+      new HtmlParser(), translations, options.i18nFormat, options.missingTranslation, console);
+  const config = new CompilerConfig({
+    defaultEncapsulation: ViewEncapsulation.Emulated,
+    useJit: false,
+    enableLegacyTemplate: options.enableLegacyTemplate !== false,
+    missingTranslation: options.missingTranslation,
+    preserveWhitespaces: options.preserveWhitespaces,
+  });
+  const normalizer = new DirectiveNormalizer(
+      {get: (url: string) => compilerHost.loadResource(url)}, urlResolver, htmlParser, config);
+  const expressionParser = new Parser(new Lexer());
+  const elementSchemaRegistry = new DomElementSchemaRegistry();
+  const tmplParser = new TemplateParser(
+      config, staticReflector, expressionParser, elementSchemaRegistry, htmlParser, console, []);
+  const resolver = new CompileMetadataResolver(
+      config, new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
+      new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer,
+      console, symbolCache, staticReflector);
+  // TODO(vicb): do not pass options.i18nFormat here
+  const viewCompiler = new ViewCompiler(config, staticReflector, elementSchemaRegistry);
+  const compiler = new AotCompiler(
+      config, compilerHost, staticReflector, resolver, tmplParser, new StyleCompiler(urlResolver),
+      viewCompiler, new NgModuleCompiler(staticReflector), new TypeScriptEmitter(), summaryResolver,
+      options.locale || null, options.i18nFormat || null, options.enableSummariesForJit || null,
+      symbolResolver);
+  return {compiler, reflector: staticReflector};
+}
diff --git a/angular/compiler/src/aot/compiler_host.ts b/angular/compiler/src/aot/compiler_host.ts
new file mode 100644
index 0000000..00bbf1e
--- /dev/null
+++ b/angular/compiler/src/aot/compiler_host.ts
@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {StaticSymbolResolverHost} from './static_symbol_resolver';
+import {AotSummaryResolverHost} from './summary_resolver';
+
+/**
+ * The host of the AotCompiler disconnects the implementation from TypeScript / other language
+ * services and from underlying file systems.
+ */
+export interface AotCompilerHost extends StaticSymbolResolverHost, AotSummaryResolverHost {
+  /**
+   * Converts a path that refers to a resource into an absolute filePath
+   * that can be later on used for loading the resource via `loadResource.
+   */
+  resourceNameToFileName(resourceName: string, containingFileName: string): string|null;
+  /**
+   * Loads a resource (e.g. html / css)
+   */
+  loadResource(path: string): Promise<string>|string;
+}
diff --git a/angular/compiler/src/aot/compiler_options.ts b/angular/compiler/src/aot/compiler_options.ts
new file mode 100644
index 0000000..5528e9b
--- /dev/null
+++ b/angular/compiler/src/aot/compiler_options.ts
@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {MissingTranslationStrategy} from '../core';
+
+export interface AotCompilerOptions {
+  locale?: string;
+  i18nFormat?: string;
+  translations?: string;
+  missingTranslation?: MissingTranslationStrategy;
+  enableLegacyTemplate?: boolean;
+  enableSummariesForJit?: boolean;
+  preserveWhitespaces?: boolean;
+}
diff --git a/angular/compiler/src/aot/generated_file.ts b/angular/compiler/src/aot/generated_file.ts
new file mode 100644
index 0000000..226126f
--- /dev/null
+++ b/angular/compiler/src/aot/generated_file.ts
@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {sourceUrl} from '../compile_metadata';
+import {Statement} from '../output/output_ast';
+import {TypeScriptEmitter} from '../output/ts_emitter';
+
+export class GeneratedFile {
+  public source: string|null;
+  public stmts: Statement[]|null;
+
+  constructor(
+      public srcFileUrl: string, public genFileUrl: string, sourceOrStmts: string|Statement[]) {
+    if (typeof sourceOrStmts === 'string') {
+      this.source = sourceOrStmts;
+      this.stmts = null;
+    } else {
+      this.source = null;
+      this.stmts = sourceOrStmts;
+    }
+  }
+}
+
+export function toTypeScript(file: GeneratedFile, preamble: string = ''): string {
+  if (!file.stmts) {
+    throw new Error(`Illegal state: No stmts present on GeneratedFile ${file.genFileUrl}`);
+  }
+  return new TypeScriptEmitter().emitStatements(
+      sourceUrl(file.srcFileUrl), file.genFileUrl, file.stmts, preamble);
+}
diff --git a/angular/compiler/src/aot/static_reflector.ts b/angular/compiler/src/aot/static_reflector.ts
new file mode 100644
index 0000000..0a72ad9
--- /dev/null
+++ b/angular/compiler/src/aot/static_reflector.ts
@@ -0,0 +1,751 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileSummaryKind} from '../compile_metadata';
+import {CompileReflector} from '../compile_reflector';
+import {MetadataFactory, createAttribute, createComponent, createContentChild, createContentChildren, createDirective, createHost, createHostBinding, createHostListener, createInject, createInjectable, createInput, createNgModule, createOptional, createOutput, createPipe, createSelf, createSkipSelf, createViewChild, createViewChildren} from '../core';
+import * as o from '../output/output_ast';
+import {SummaryResolver} from '../summary_resolver';
+import {syntaxError} from '../util';
+
+import {StaticSymbol} from './static_symbol';
+import {StaticSymbolResolver} from './static_symbol_resolver';
+
+const ANGULAR_CORE = '@angular/core';
+const ANGULAR_ROUTER = '@angular/router';
+
+const HIDDEN_KEY = /^\$.*\$$/;
+
+const IGNORE = {
+  __symbolic: 'ignore'
+};
+
+const USE_VALUE = 'useValue';
+const PROVIDE = 'provide';
+const REFERENCE_SET = new Set([USE_VALUE, 'useFactory', 'data']);
+
+function shouldIgnore(value: any): boolean {
+  return value && value.__symbolic == 'ignore';
+}
+
+/**
+ * A static reflector implements enough of the Reflector API that is necessary to compile
+ * templates statically.
+ */
+export class StaticReflector implements CompileReflector {
+  private annotationCache = new Map<StaticSymbol, any[]>();
+  private propertyCache = new Map<StaticSymbol, {[key: string]: any[]}>();
+  private parameterCache = new Map<StaticSymbol, any[]>();
+  private methodCache = new Map<StaticSymbol, {[key: string]: boolean}>();
+  private conversionMap = new Map<StaticSymbol, (context: StaticSymbol, args: any[]) => any>();
+  private injectionToken: StaticSymbol;
+  private opaqueToken: StaticSymbol;
+  private ROUTES: StaticSymbol;
+  private ANALYZE_FOR_ENTRY_COMPONENTS: StaticSymbol;
+  private annotationForParentClassWithSummaryKind =
+      new Map<CompileSummaryKind, MetadataFactory<any>[]>();
+
+  constructor(
+      private summaryResolver: SummaryResolver<StaticSymbol>,
+      private symbolResolver: StaticSymbolResolver,
+      knownMetadataClasses: {name: string, filePath: string, ctor: any}[] = [],
+      knownMetadataFunctions: {name: string, filePath: string, fn: any}[] = [],
+      private errorRecorder?: (error: any, fileName?: string) => void) {
+    this.initializeConversionMap();
+    knownMetadataClasses.forEach(
+        (kc) => this._registerDecoratorOrConstructor(
+            this.getStaticSymbol(kc.filePath, kc.name), kc.ctor));
+    knownMetadataFunctions.forEach(
+        (kf) => this._registerFunction(this.getStaticSymbol(kf.filePath, kf.name), kf.fn));
+    this.annotationForParentClassWithSummaryKind.set(
+        CompileSummaryKind.Directive, [createDirective, createComponent]);
+    this.annotationForParentClassWithSummaryKind.set(CompileSummaryKind.Pipe, [createPipe]);
+    this.annotationForParentClassWithSummaryKind.set(CompileSummaryKind.NgModule, [createNgModule]);
+    this.annotationForParentClassWithSummaryKind.set(
+        CompileSummaryKind.Injectable,
+        [createInjectable, createPipe, createDirective, createComponent, createNgModule]);
+  }
+
+  componentModuleUrl(typeOrFunc: StaticSymbol): string {
+    const staticSymbol = this.findSymbolDeclaration(typeOrFunc);
+    return this.symbolResolver.getResourcePath(staticSymbol);
+  }
+
+  resolveExternalReference(ref: o.ExternalReference): StaticSymbol {
+    const refSymbol = this.symbolResolver.getSymbolByModule(ref.moduleName !, ref.name !);
+    const declarationSymbol = this.findSymbolDeclaration(refSymbol);
+    this.symbolResolver.recordModuleNameForFileName(refSymbol.filePath, ref.moduleName !);
+    this.symbolResolver.recordImportAs(declarationSymbol, refSymbol);
+    return declarationSymbol;
+  }
+
+  findDeclaration(moduleUrl: string, name: string, containingFile?: string): StaticSymbol {
+    return this.findSymbolDeclaration(
+        this.symbolResolver.getSymbolByModule(moduleUrl, name, containingFile));
+  }
+
+  tryFindDeclaration(moduleUrl: string, name: string): StaticSymbol {
+    return this.symbolResolver.ignoreErrorsFor(() => this.findDeclaration(moduleUrl, name));
+  }
+
+  findSymbolDeclaration(symbol: StaticSymbol): StaticSymbol {
+    const resolvedSymbol = this.symbolResolver.resolveSymbol(symbol);
+    if (resolvedSymbol && resolvedSymbol.metadata instanceof StaticSymbol) {
+      return this.findSymbolDeclaration(resolvedSymbol.metadata);
+    } else {
+      return symbol;
+    }
+  }
+
+  public annotations(type: StaticSymbol): any[] {
+    let annotations = this.annotationCache.get(type);
+    if (!annotations) {
+      annotations = [];
+      const classMetadata = this.getTypeMetadata(type);
+      const parentType = this.findParentType(type, classMetadata);
+      if (parentType) {
+        const parentAnnotations = this.annotations(parentType);
+        annotations.push(...parentAnnotations);
+      }
+      let ownAnnotations: any[] = [];
+      if (classMetadata['decorators']) {
+        ownAnnotations = this.simplify(type, classMetadata['decorators']);
+        annotations.push(...ownAnnotations);
+      }
+      if (parentType && !this.summaryResolver.isLibraryFile(type.filePath) &&
+          this.summaryResolver.isLibraryFile(parentType.filePath)) {
+        const summary = this.summaryResolver.resolveSummary(parentType);
+        if (summary && summary.type) {
+          const requiredAnnotationTypes =
+              this.annotationForParentClassWithSummaryKind.get(summary.type.summaryKind !) !;
+          const typeHasRequiredAnnotation = requiredAnnotationTypes.some(
+              (requiredType) => ownAnnotations.some(ann => requiredType.isTypeOf(ann)));
+          if (!typeHasRequiredAnnotation) {
+            this.reportError(
+                syntaxError(
+                    `Class ${type.name} in ${type.filePath} extends from a ${CompileSummaryKind[summary.type.summaryKind!]} in another compilation unit without duplicating the decorator. ` +
+                    `Please add a ${requiredAnnotationTypes.map((type) => type.ngMetadataName).join(' or ')} decorator to the class.`),
+                type);
+          }
+        }
+      }
+      this.annotationCache.set(type, annotations.filter(ann => !!ann));
+    }
+    return annotations;
+  }
+
+  public propMetadata(type: StaticSymbol): {[key: string]: any[]} {
+    let propMetadata = this.propertyCache.get(type);
+    if (!propMetadata) {
+      const classMetadata = this.getTypeMetadata(type);
+      propMetadata = {};
+      const parentType = this.findParentType(type, classMetadata);
+      if (parentType) {
+        const parentPropMetadata = this.propMetadata(parentType);
+        Object.keys(parentPropMetadata).forEach((parentProp) => {
+          propMetadata ![parentProp] = parentPropMetadata[parentProp];
+        });
+      }
+
+      const members = classMetadata['members'] || {};
+      Object.keys(members).forEach((propName) => {
+        const propData = members[propName];
+        const prop = (<any[]>propData)
+                         .find(a => a['__symbolic'] == 'property' || a['__symbolic'] == 'method');
+        const decorators: any[] = [];
+        if (propMetadata ![propName]) {
+          decorators.push(...propMetadata ![propName]);
+        }
+        propMetadata ![propName] = decorators;
+        if (prop && prop['decorators']) {
+          decorators.push(...this.simplify(type, prop['decorators']));
+        }
+      });
+      this.propertyCache.set(type, propMetadata);
+    }
+    return propMetadata;
+  }
+
+  public parameters(type: StaticSymbol): any[] {
+    if (!(type instanceof StaticSymbol)) {
+      this.reportError(
+          new Error(`parameters received ${JSON.stringify(type)} which is not a StaticSymbol`),
+          type);
+      return [];
+    }
+    try {
+      let parameters = this.parameterCache.get(type);
+      if (!parameters) {
+        const classMetadata = this.getTypeMetadata(type);
+        const parentType = this.findParentType(type, classMetadata);
+        const members = classMetadata ? classMetadata['members'] : null;
+        const ctorData = members ? members['__ctor__'] : null;
+        if (ctorData) {
+          const ctor = (<any[]>ctorData).find(a => a['__symbolic'] == 'constructor');
+          const rawParameterTypes = <any[]>ctor['parameters'] || [];
+          const parameterDecorators = <any[]>this.simplify(type, ctor['parameterDecorators'] || []);
+          parameters = [];
+          rawParameterTypes.forEach((rawParamType, index) => {
+            const nestedResult: any[] = [];
+            const paramType = this.trySimplify(type, rawParamType);
+            if (paramType) nestedResult.push(paramType);
+            const decorators = parameterDecorators ? parameterDecorators[index] : null;
+            if (decorators) {
+              nestedResult.push(...decorators);
+            }
+            parameters !.push(nestedResult);
+          });
+        } else if (parentType) {
+          parameters = this.parameters(parentType);
+        }
+        if (!parameters) {
+          parameters = [];
+        }
+        this.parameterCache.set(type, parameters);
+      }
+      return parameters;
+    } catch (e) {
+      console.error(`Failed on type ${JSON.stringify(type)} with error ${e}`);
+      throw e;
+    }
+  }
+
+  private _methodNames(type: any): {[key: string]: boolean} {
+    let methodNames = this.methodCache.get(type);
+    if (!methodNames) {
+      const classMetadata = this.getTypeMetadata(type);
+      methodNames = {};
+      const parentType = this.findParentType(type, classMetadata);
+      if (parentType) {
+        const parentMethodNames = this._methodNames(parentType);
+        Object.keys(parentMethodNames).forEach((parentProp) => {
+          methodNames ![parentProp] = parentMethodNames[parentProp];
+        });
+      }
+
+      const members = classMetadata['members'] || {};
+      Object.keys(members).forEach((propName) => {
+        const propData = members[propName];
+        const isMethod = (<any[]>propData).some(a => a['__symbolic'] == 'method');
+        methodNames ![propName] = methodNames ![propName] || isMethod;
+      });
+      this.methodCache.set(type, methodNames);
+    }
+    return methodNames;
+  }
+
+  private findParentType(type: StaticSymbol, classMetadata: any): StaticSymbol|undefined {
+    const parentType = this.trySimplify(type, classMetadata['extends']);
+    if (parentType instanceof StaticSymbol) {
+      return parentType;
+    }
+  }
+
+  hasLifecycleHook(type: any, lcProperty: string): boolean {
+    if (!(type instanceof StaticSymbol)) {
+      this.reportError(
+          new Error(
+              `hasLifecycleHook received ${JSON.stringify(type)} which is not a StaticSymbol`),
+          type);
+    }
+    try {
+      return !!this._methodNames(type)[lcProperty];
+    } catch (e) {
+      console.error(`Failed on type ${JSON.stringify(type)} with error ${e}`);
+      throw e;
+    }
+  }
+
+  private _registerDecoratorOrConstructor(type: StaticSymbol, ctor: any): void {
+    this.conversionMap.set(type, (context: StaticSymbol, args: any[]) => new ctor(...args));
+  }
+
+  private _registerFunction(type: StaticSymbol, fn: any): void {
+    this.conversionMap.set(type, (context: StaticSymbol, args: any[]) => fn.apply(undefined, args));
+  }
+
+  private initializeConversionMap(): void {
+    this.injectionToken = this.findDeclaration(ANGULAR_CORE, 'InjectionToken');
+    this.opaqueToken = this.findDeclaration(ANGULAR_CORE, 'OpaqueToken');
+    this.ROUTES = this.tryFindDeclaration(ANGULAR_ROUTER, 'ROUTES');
+    this.ANALYZE_FOR_ENTRY_COMPONENTS =
+        this.findDeclaration(ANGULAR_CORE, 'ANALYZE_FOR_ENTRY_COMPONENTS');
+
+    this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Host'), createHost);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'Injectable'), createInjectable);
+    this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Self'), createSelf);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'SkipSelf'), createSkipSelf);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'Inject'), createInject);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'Optional'), createOptional);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'Attribute'), createAttribute);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'ContentChild'), createContentChild);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'ContentChildren'), createContentChildren);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'ViewChild'), createViewChild);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'ViewChildren'), createViewChildren);
+    this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Input'), createInput);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'Output'), createOutput);
+    this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Pipe'), createPipe);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'HostBinding'), createHostBinding);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'HostListener'), createHostListener);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'Directive'), createDirective);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'Component'), createComponent);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'NgModule'), createNgModule);
+
+    // Note: Some metadata classes can be used directly with Provider.deps.
+    this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Host'), createHost);
+    this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Self'), createSelf);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'SkipSelf'), createSkipSelf);
+    this._registerDecoratorOrConstructor(
+        this.findDeclaration(ANGULAR_CORE, 'Optional'), createOptional);
+  }
+
+  /**
+   * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.
+   * All types passed to the StaticResolver should be pseudo-types returned by this method.
+   *
+   * @param declarationFile the absolute path of the file where the symbol is declared
+   * @param name the name of the type.
+   */
+  getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol {
+    return this.symbolResolver.getStaticSymbol(declarationFile, name, members);
+  }
+
+  private reportError(error: Error, context: StaticSymbol, path?: string) {
+    if (this.errorRecorder) {
+      this.errorRecorder(error, (context && context.filePath) || path);
+    } else {
+      throw error;
+    }
+  }
+
+  /**
+   * Simplify but discard any errors
+   */
+  private trySimplify(context: StaticSymbol, value: any): any {
+    const originalRecorder = this.errorRecorder;
+    this.errorRecorder = (error: any, fileName: string) => {};
+    const result = this.simplify(context, value);
+    this.errorRecorder = originalRecorder;
+    return result;
+  }
+
+  /** @internal */
+  public simplify(context: StaticSymbol, value: any): any {
+    const self = this;
+    let scope = BindingScope.empty;
+    const calling = new Map<StaticSymbol, boolean>();
+
+    function simplifyInContext(
+        context: StaticSymbol, value: any, depth: number, references: number): any {
+      function resolveReferenceValue(staticSymbol: StaticSymbol): any {
+        const resolvedSymbol = self.symbolResolver.resolveSymbol(staticSymbol);
+        return resolvedSymbol ? resolvedSymbol.metadata : null;
+      }
+
+      function simplifyCall(functionSymbol: StaticSymbol, targetFunction: any, args: any[]) {
+        if (targetFunction && targetFunction['__symbolic'] == 'function') {
+          if (calling.get(functionSymbol)) {
+            throw new Error('Recursion not supported');
+          }
+          try {
+            const value = targetFunction['value'];
+            if (value && (depth != 0 || value.__symbolic != 'error')) {
+              const parameters: string[] = targetFunction['parameters'];
+              const defaults: any[] = targetFunction.defaults;
+              args = args.map(arg => simplifyInContext(context, arg, depth + 1, references))
+                         .map(arg => shouldIgnore(arg) ? undefined : arg);
+              if (defaults && defaults.length > args.length) {
+                args.push(...defaults.slice(args.length).map((value: any) => simplify(value)));
+              }
+              calling.set(functionSymbol, true);
+              const functionScope = BindingScope.build();
+              for (let i = 0; i < parameters.length; i++) {
+                functionScope.define(parameters[i], args[i]);
+              }
+              const oldScope = scope;
+              let result: any;
+              try {
+                scope = functionScope.done();
+                result = simplifyInContext(functionSymbol, value, depth + 1, references);
+              } finally {
+                scope = oldScope;
+              }
+              return result;
+            }
+          } finally {
+            calling.delete(functionSymbol);
+          }
+        }
+
+        if (depth === 0) {
+          // If depth is 0 we are evaluating the top level expression that is describing element
+          // decorator. In this case, it is a decorator we don't understand, such as a custom
+          // non-angular decorator, and we should just ignore it.
+          return IGNORE;
+        }
+        return simplify(
+            {__symbolic: 'error', message: 'Function call not supported', context: functionSymbol});
+      }
+
+      function simplify(expression: any): any {
+        if (isPrimitive(expression)) {
+          return expression;
+        }
+        if (expression instanceof Array) {
+          const result: any[] = [];
+          for (const item of (<any>expression)) {
+            // Check for a spread expression
+            if (item && item.__symbolic === 'spread') {
+              const spreadArray = simplify(item.expression);
+              if (Array.isArray(spreadArray)) {
+                for (const spreadItem of spreadArray) {
+                  result.push(spreadItem);
+                }
+                continue;
+              }
+            }
+            const value = simplify(item);
+            if (shouldIgnore(value)) {
+              continue;
+            }
+            result.push(value);
+          }
+          return result;
+        }
+        if (expression instanceof StaticSymbol) {
+          // Stop simplification at builtin symbols or if we are in a reference context
+          if (expression === self.injectionToken || expression === self.opaqueToken ||
+              self.conversionMap.has(expression) || references > 0) {
+            return expression;
+          } else {
+            const staticSymbol = expression;
+            const declarationValue = resolveReferenceValue(staticSymbol);
+            if (declarationValue) {
+              return simplifyInContext(staticSymbol, declarationValue, depth + 1, references);
+            } else {
+              return staticSymbol;
+            }
+          }
+        }
+        if (expression) {
+          if (expression['__symbolic']) {
+            let staticSymbol: StaticSymbol;
+            switch (expression['__symbolic']) {
+              case 'binop':
+                let left = simplify(expression['left']);
+                if (shouldIgnore(left)) return left;
+                let right = simplify(expression['right']);
+                if (shouldIgnore(right)) return right;
+                switch (expression['operator']) {
+                  case '&&':
+                    return left && right;
+                  case '||':
+                    return left || right;
+                  case '|':
+                    return left | right;
+                  case '^':
+                    return left ^ right;
+                  case '&':
+                    return left & right;
+                  case '==':
+                    return left == right;
+                  case '!=':
+                    return left != right;
+                  case '===':
+                    return left === right;
+                  case '!==':
+                    return left !== right;
+                  case '<':
+                    return left < right;
+                  case '>':
+                    return left > right;
+                  case '<=':
+                    return left <= right;
+                  case '>=':
+                    return left >= right;
+                  case '<<':
+                    return left << right;
+                  case '>>':
+                    return left >> right;
+                  case '+':
+                    return left + right;
+                  case '-':
+                    return left - right;
+                  case '*':
+                    return left * right;
+                  case '/':
+                    return left / right;
+                  case '%':
+                    return left % right;
+                }
+                return null;
+              case 'if':
+                let condition = simplify(expression['condition']);
+                return condition ? simplify(expression['thenExpression']) :
+                                   simplify(expression['elseExpression']);
+              case 'pre':
+                let operand = simplify(expression['operand']);
+                if (shouldIgnore(operand)) return operand;
+                switch (expression['operator']) {
+                  case '+':
+                    return operand;
+                  case '-':
+                    return -operand;
+                  case '!':
+                    return !operand;
+                  case '~':
+                    return ~operand;
+                }
+                return null;
+              case 'index':
+                let indexTarget = simplify(expression['expression']);
+                let index = simplify(expression['index']);
+                if (indexTarget && isPrimitive(index)) return indexTarget[index];
+                return null;
+              case 'select':
+                const member = expression['member'];
+                let selectContext = context;
+                let selectTarget = simplify(expression['expression']);
+                if (selectTarget instanceof StaticSymbol) {
+                  const members = selectTarget.members.concat(member);
+                  selectContext =
+                      self.getStaticSymbol(selectTarget.filePath, selectTarget.name, members);
+                  const declarationValue = resolveReferenceValue(selectContext);
+                  if (declarationValue) {
+                    return simplifyInContext(
+                        selectContext, declarationValue, depth + 1, references);
+                  } else {
+                    return selectContext;
+                  }
+                }
+                if (selectTarget && isPrimitive(member))
+                  return simplifyInContext(
+                      selectContext, selectTarget[member], depth + 1, references);
+                return null;
+              case 'reference':
+                // Note: This only has to deal with variable references,
+                // as symbol references have been converted into StaticSymbols already
+                // in the StaticSymbolResolver!
+                const name: string = expression['name'];
+                const localValue = scope.resolve(name);
+                if (localValue != BindingScope.missing) {
+                  return localValue;
+                }
+                break;
+              case 'class':
+                return context;
+              case 'function':
+                return context;
+              case 'new':
+              case 'call':
+                // Determine if the function is a built-in conversion
+                staticSymbol = simplifyInContext(
+                    context, expression['expression'], depth + 1, /* references */ 0);
+                if (staticSymbol instanceof StaticSymbol) {
+                  if (staticSymbol === self.injectionToken || staticSymbol === self.opaqueToken) {
+                    // if somebody calls new InjectionToken, don't create an InjectionToken,
+                    // but rather return the symbol to which the InjectionToken is assigned to.
+                    return context;
+                  }
+                  const argExpressions: any[] = expression['arguments'] || [];
+                  let converter = self.conversionMap.get(staticSymbol);
+                  if (converter) {
+                    const args =
+                        argExpressions
+                            .map(arg => simplifyInContext(context, arg, depth + 1, references))
+                            .map(arg => shouldIgnore(arg) ? undefined : arg);
+                    return converter(context, args);
+                  } else {
+                    // Determine if the function is one we can simplify.
+                    const targetFunction = resolveReferenceValue(staticSymbol);
+                    return simplifyCall(staticSymbol, targetFunction, argExpressions);
+                  }
+                }
+                return IGNORE;
+              case 'error':
+                let message = produceErrorMessage(expression);
+                if (expression['line']) {
+                  message =
+                      `${message} (position ${expression['line']+1}:${expression['character']+1} in the original .ts file)`;
+                  self.reportError(
+                      positionalError(
+                          message, context.filePath, expression['line'], expression['character']),
+                      context);
+                } else {
+                  self.reportError(new Error(message), context);
+                }
+                return IGNORE;
+              case 'ignore':
+                return expression;
+            }
+            return null;
+          }
+          return mapStringMap(expression, (value, name) => {
+            if (REFERENCE_SET.has(name)) {
+              if (name === USE_VALUE && PROVIDE in expression) {
+                // If this is a provider expression, check for special tokens that need the value
+                // during analysis.
+                const provide = simplify(expression.provide);
+                if (provide === self.ROUTES || provide == self.ANALYZE_FOR_ENTRY_COMPONENTS) {
+                  return simplify(value);
+                }
+              }
+              return simplifyInContext(context, value, depth, references + 1);
+            }
+            return simplify(value);
+          });
+        }
+        return IGNORE;
+      }
+
+      try {
+        return simplify(value);
+      } catch (e) {
+        const members = context.members.length ? `.${context.members.join('.')}` : '';
+        const message =
+            `${e.message}, resolving symbol ${context.name}${members} in ${context.filePath}`;
+        if (e.fileName) {
+          throw positionalError(message, e.fileName, e.line, e.column);
+        }
+        throw syntaxError(message);
+      }
+    }
+
+    const recordedSimplifyInContext = (context: StaticSymbol, value: any) => {
+      try {
+        return simplifyInContext(context, value, 0, 0);
+      } catch (e) {
+        this.reportError(e, context);
+      }
+    };
+
+    const result = this.errorRecorder ? recordedSimplifyInContext(context, value) :
+                                        simplifyInContext(context, value, 0, 0);
+    if (shouldIgnore(result)) {
+      return undefined;
+    }
+    return result;
+  }
+
+  private getTypeMetadata(type: StaticSymbol): {[key: string]: any} {
+    const resolvedSymbol = this.symbolResolver.resolveSymbol(type);
+    return resolvedSymbol && resolvedSymbol.metadata ? resolvedSymbol.metadata :
+                                                       {__symbolic: 'class'};
+  }
+}
+
+function expandedMessage(error: any): string {
+  switch (error.message) {
+    case 'Reference to non-exported class':
+      if (error.context && error.context.className) {
+        return `Reference to a non-exported class ${error.context.className}. Consider exporting the class`;
+      }
+      break;
+    case 'Variable not initialized':
+      return 'Only initialized variables and constants can be referenced because the value of this variable is needed by the template compiler';
+    case 'Destructuring not supported':
+      return 'Referencing an exported destructured variable or constant is not supported by the template compiler. Consider simplifying this to avoid destructuring';
+    case 'Could not resolve type':
+      if (error.context && error.context.typeName) {
+        return `Could not resolve type ${error.context.typeName}`;
+      }
+      break;
+    case 'Function call not supported':
+      let prefix =
+          error.context && error.context.name ? `Calling function '${error.context.name}', f` : 'F';
+      return prefix +
+          'unction calls are not supported. Consider replacing the function or lambda with a reference to an exported function';
+    case 'Reference to a local symbol':
+      if (error.context && error.context.name) {
+        return `Reference to a local (non-exported) symbol '${error.context.name}'. Consider exporting the symbol`;
+      }
+      break;
+  }
+  return error.message;
+}
+
+function produceErrorMessage(error: any): string {
+  return `Error encountered resolving symbol values statically. ${expandedMessage(error)}`;
+}
+
+function mapStringMap(input: {[key: string]: any}, transform: (value: any, key: string) => any):
+    {[key: string]: any} {
+  if (!input) return {};
+  const result: {[key: string]: any} = {};
+  Object.keys(input).forEach((key) => {
+    const value = transform(input[key], key);
+    if (!shouldIgnore(value)) {
+      if (HIDDEN_KEY.test(key)) {
+        Object.defineProperty(result, key, {enumerable: false, configurable: true, value: value});
+      } else {
+        result[key] = value;
+      }
+    }
+  });
+  return result;
+}
+
+function isPrimitive(o: any): boolean {
+  return o === null || (typeof o !== 'function' && typeof o !== 'object');
+}
+
+interface BindingScopeBuilder {
+  define(name: string, value: any): BindingScopeBuilder;
+  done(): BindingScope;
+}
+
+abstract class BindingScope {
+  abstract resolve(name: string): any;
+  public static missing = {};
+  public static empty: BindingScope = {resolve: name => BindingScope.missing};
+
+  public static build(): BindingScopeBuilder {
+    const current = new Map<string, any>();
+    return {
+      define: function(name, value) {
+        current.set(name, value);
+        return this;
+      },
+      done: function() {
+        return current.size > 0 ? new PopulatedScope(current) : BindingScope.empty;
+      }
+    };
+  }
+}
+
+class PopulatedScope extends BindingScope {
+  constructor(private bindings: Map<string, any>) { super(); }
+
+  resolve(name: string): any {
+    return this.bindings.has(name) ? this.bindings.get(name) : BindingScope.missing;
+  }
+}
+
+function positionalError(message: string, fileName: string, line: number, column: number): Error {
+  const result = new Error(message);
+  (result as any).fileName = fileName;
+  (result as any).line = line;
+  (result as any).column = column;
+  return result;
+}
\ No newline at end of file
diff --git a/angular/compiler/src/aot/static_symbol.ts b/angular/compiler/src/aot/static_symbol.ts
new file mode 100644
index 0000000..cb47dd9
--- /dev/null
+++ b/angular/compiler/src/aot/static_symbol.ts
@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * A token representing the a reference to a static type.
+ *
+ * This token is unique for a filePath and name and can be used as a hash table key.
+ */
+export class StaticSymbol {
+  constructor(public filePath: string, public name: string, public members: string[]) {}
+
+  assertNoMembers() {
+    if (this.members.length) {
+      throw new Error(
+          `Illegal state: symbol without members expected, but got ${JSON.stringify(this)}.`);
+    }
+  }
+}
+
+/**
+ * A cache of static symbol used by the StaticReflector to return the same symbol for the
+ * same symbol values.
+ */
+export class StaticSymbolCache {
+  private cache = new Map<string, StaticSymbol>();
+
+  get(declarationFile: string, name: string, members?: string[]): StaticSymbol {
+    members = members || [];
+    const memberSuffix = members.length ? `.${ members.join('.')}` : '';
+    const key = `"${declarationFile}".${name}${memberSuffix}`;
+    let result = this.cache.get(key);
+    if (!result) {
+      result = new StaticSymbol(declarationFile, name, members);
+      this.cache.set(key, result);
+    }
+    return result;
+  }
+}
\ No newline at end of file
diff --git a/angular/compiler/src/aot/static_symbol_resolver.ts b/angular/compiler/src/aot/static_symbol_resolver.ts
new file mode 100644
index 0000000..6a66d3a
--- /dev/null
+++ b/angular/compiler/src/aot/static_symbol_resolver.ts
@@ -0,0 +1,492 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {SummaryResolver} from '../summary_resolver';
+import {ValueTransformer, visitValue} from '../util';
+
+import {StaticSymbol, StaticSymbolCache} from './static_symbol';
+import {isGeneratedFile, stripSummaryForJitFileSuffix, stripSummaryForJitNameSuffix, summaryForJitFileName, summaryForJitName} from './util';
+
+export class ResolvedStaticSymbol {
+  constructor(public symbol: StaticSymbol, public metadata: any) {}
+}
+
+/**
+ * The host of the SymbolResolverHost disconnects the implementation from TypeScript / other
+ * language
+ * services and from underlying file systems.
+ */
+export interface StaticSymbolResolverHost {
+  /**
+   * Return a ModuleMetadata for the given module.
+   * Angular CLI will produce this metadata for a module whenever a .d.ts files is
+   * produced and the module has exported variables or classes with decorators. Module metadata can
+   * also be produced directly from TypeScript sources by using MetadataCollector in tools/metadata.
+   *
+   * @param modulePath is a string identifier for a module as an absolute path.
+   * @returns the metadata for the given module.
+   */
+  getMetadataFor(modulePath: string): {[key: string]: any}[]|undefined;
+
+  /**
+   * Converts a module name that is used in an `import` to a file path.
+   * I.e.
+   * `path/to/containingFile.ts` containing `import {...} from 'module-name'`.
+   */
+  moduleNameToFileName(moduleName: string, containingFile?: string): string|null;
+  /**
+   * Converts a file path to a module name that can be used as an `import.
+   * I.e. `path/to/importedFile.ts` should be imported by `path/to/containingFile.ts`.
+   *
+   * See ImportResolver.
+   */
+  fileNameToModuleName(importedFilePath: string, containingFilePath: string): string|null;
+}
+
+const SUPPORTED_SCHEMA_VERSION = 3;
+
+/**
+ * This class is responsible for loading metadata per symbol,
+ * and normalizing references between symbols.
+ *
+ * Internally, it only uses symbols without members,
+ * and deduces the values for symbols with members based
+ * on these symbols.
+ */
+export class StaticSymbolResolver {
+  private metadataCache = new Map<string, {[key: string]: any}>();
+  // Note: this will only contain StaticSymbols without members!
+  private resolvedSymbols = new Map<StaticSymbol, ResolvedStaticSymbol>();
+  private resolvedFilePaths = new Set<string>();
+  // Note: this will only contain StaticSymbols without members!
+  private importAs = new Map<StaticSymbol, StaticSymbol>();
+  private symbolResourcePaths = new Map<StaticSymbol, string>();
+  private symbolFromFile = new Map<string, StaticSymbol[]>();
+  private knownFileNameToModuleNames = new Map<string, string>();
+
+  constructor(
+      private host: StaticSymbolResolverHost, private staticSymbolCache: StaticSymbolCache,
+      private summaryResolver: SummaryResolver<StaticSymbol>,
+      private errorRecorder?: (error: any, fileName?: string) => void) {}
+
+  resolveSymbol(staticSymbol: StaticSymbol): ResolvedStaticSymbol {
+    if (staticSymbol.members.length > 0) {
+      return this._resolveSymbolMembers(staticSymbol) !;
+    }
+    let result = this.resolvedSymbols.get(staticSymbol);
+    if (result) {
+      return result;
+    }
+    result = this._resolveSymbolFromSummary(staticSymbol) !;
+    if (result) {
+      return result;
+    }
+    // Note: Some users use libraries that were not compiled with ngc, i.e. they don't
+    // have summaries, only .d.ts files. So we always need to check both, the summary
+    // and metadata.
+    this._createSymbolsOf(staticSymbol.filePath);
+    result = this.resolvedSymbols.get(staticSymbol) !;
+    return result;
+  }
+
+  /**
+   * getImportAs produces a symbol that can be used to import the given symbol.
+   * The import might be different than the symbol if the symbol is exported from
+   * a library with a summary; in which case we want to import the symbol from the
+   * ngfactory re-export instead of directly to avoid introducing a direct dependency
+   * on an otherwise indirect dependency.
+   *
+   * @param staticSymbol the symbol for which to generate a import symbol
+   */
+  getImportAs(staticSymbol: StaticSymbol): StaticSymbol|null {
+    if (staticSymbol.members.length) {
+      const baseSymbol = this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name);
+      const baseImportAs = this.getImportAs(baseSymbol);
+      return baseImportAs ?
+          this.getStaticSymbol(baseImportAs.filePath, baseImportAs.name, staticSymbol.members) :
+          null;
+    }
+    const summarizedFileName = stripSummaryForJitFileSuffix(staticSymbol.filePath);
+    if (summarizedFileName !== staticSymbol.filePath) {
+      const summarizedName = stripSummaryForJitNameSuffix(staticSymbol.name);
+      const baseSymbol =
+          this.getStaticSymbol(summarizedFileName, summarizedName, staticSymbol.members);
+      const baseImportAs = this.getImportAs(baseSymbol);
+      return baseImportAs ?
+          this.getStaticSymbol(
+              summaryForJitFileName(baseImportAs.filePath), summaryForJitName(baseImportAs.name),
+              baseSymbol.members) :
+          null;
+    }
+    let result = this.summaryResolver.getImportAs(staticSymbol);
+    if (!result) {
+      result = this.importAs.get(staticSymbol) !;
+    }
+    return result;
+  }
+
+  /**
+   * getResourcePath produces the path to the original location of the symbol and should
+   * be used to determine the relative location of resource references recorded in
+   * symbol metadata.
+   */
+  getResourcePath(staticSymbol: StaticSymbol): string {
+    return this.symbolResourcePaths.get(staticSymbol) || staticSymbol.filePath;
+  }
+
+  /**
+   * getTypeArity returns the number of generic type parameters the given symbol
+   * has. If the symbol is not a type the result is null.
+   */
+  getTypeArity(staticSymbol: StaticSymbol): number|null {
+    // If the file is a factory/ngsummary file, don't resolve the symbol as doing so would
+    // cause the metadata for an factory/ngsummary file to be loaded which doesn't exist.
+    // All references to generated classes must include the correct arity whenever
+    // generating code.
+    if (isGeneratedFile(staticSymbol.filePath)) {
+      return null;
+    }
+    let resolvedSymbol = this.resolveSymbol(staticSymbol);
+    while (resolvedSymbol && resolvedSymbol.metadata instanceof StaticSymbol) {
+      resolvedSymbol = this.resolveSymbol(resolvedSymbol.metadata);
+    }
+    return (resolvedSymbol && resolvedSymbol.metadata && resolvedSymbol.metadata.arity) || null;
+  }
+
+  /**
+   * Converts a file path to a module name that can be used as an `import`.
+   */
+  fileNameToModuleName(importedFilePath: string, containingFilePath: string): string|null {
+    return this.knownFileNameToModuleNames.get(importedFilePath) ||
+        this.host.fileNameToModuleName(importedFilePath, containingFilePath);
+  }
+
+  recordImportAs(sourceSymbol: StaticSymbol, targetSymbol: StaticSymbol) {
+    sourceSymbol.assertNoMembers();
+    targetSymbol.assertNoMembers();
+    this.importAs.set(sourceSymbol, targetSymbol);
+  }
+
+  recordModuleNameForFileName(fileName: string, moduleName: string) {
+    this.knownFileNameToModuleNames.set(fileName, moduleName);
+  }
+
+  /**
+   * Invalidate all information derived from the given file.
+   *
+   * @param fileName the file to invalidate
+   */
+  invalidateFile(fileName: string) {
+    this.metadataCache.delete(fileName);
+    this.resolvedFilePaths.delete(fileName);
+    const symbols = this.symbolFromFile.get(fileName);
+    if (symbols) {
+      this.symbolFromFile.delete(fileName);
+      for (const symbol of symbols) {
+        this.resolvedSymbols.delete(symbol);
+        this.importAs.delete(symbol);
+        this.symbolResourcePaths.delete(symbol);
+      }
+    }
+  }
+
+  /* @internal */
+  ignoreErrorsFor<T>(cb: () => T) {
+    const recorder = this.errorRecorder;
+    this.errorRecorder = () => {};
+    try {
+      return cb();
+    } finally {
+      this.errorRecorder = recorder;
+    }
+  }
+
+  private _resolveSymbolMembers(staticSymbol: StaticSymbol): ResolvedStaticSymbol|null {
+    const members = staticSymbol.members;
+    const baseResolvedSymbol =
+        this.resolveSymbol(this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name));
+    if (!baseResolvedSymbol) {
+      return null;
+    }
+    const baseMetadata = baseResolvedSymbol.metadata;
+    if (baseMetadata instanceof StaticSymbol) {
+      return new ResolvedStaticSymbol(
+          staticSymbol, this.getStaticSymbol(baseMetadata.filePath, baseMetadata.name, members));
+    } else if (baseMetadata && baseMetadata.__symbolic === 'class') {
+      if (baseMetadata.statics && members.length === 1) {
+        return new ResolvedStaticSymbol(staticSymbol, baseMetadata.statics[members[0]]);
+      }
+    } else {
+      let value = baseMetadata;
+      for (let i = 0; i < members.length && value; i++) {
+        value = value[members[i]];
+      }
+      return new ResolvedStaticSymbol(staticSymbol, value);
+    }
+    return null;
+  }
+
+  private _resolveSymbolFromSummary(staticSymbol: StaticSymbol): ResolvedStaticSymbol|null {
+    const summary = this.summaryResolver.resolveSummary(staticSymbol);
+    return summary ? new ResolvedStaticSymbol(staticSymbol, summary.metadata) : null;
+  }
+
+  /**
+   * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.
+   * All types passed to the StaticResolver should be pseudo-types returned by this method.
+   *
+   * @param declarationFile the absolute path of the file where the symbol is declared
+   * @param name the name of the type.
+   * @param members a symbol for a static member of the named type
+   */
+  getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol {
+    return this.staticSymbolCache.get(declarationFile, name, members);
+  }
+
+  getSymbolsOf(filePath: string): StaticSymbol[] {
+    // Note: Some users use libraries that were not compiled with ngc, i.e. they don't
+    // have summaries, only .d.ts files. So we always need to check both, the summary
+    // and metadata.
+    let symbols = new Set<StaticSymbol>(this.summaryResolver.getSymbolsOf(filePath));
+    this._createSymbolsOf(filePath);
+    this.resolvedSymbols.forEach((resolvedSymbol) => {
+      if (resolvedSymbol.symbol.filePath === filePath) {
+        symbols.add(resolvedSymbol.symbol);
+      }
+    });
+    return Array.from(symbols);
+  }
+
+  private _createSymbolsOf(filePath: string) {
+    if (this.resolvedFilePaths.has(filePath)) {
+      return;
+    }
+    this.resolvedFilePaths.add(filePath);
+    const resolvedSymbols: ResolvedStaticSymbol[] = [];
+    const metadata = this.getModuleMetadata(filePath);
+    if (metadata['importAs']) {
+      // Index bundle indices should use the importAs module name defined
+      // in the bundle.
+      this.knownFileNameToModuleNames.set(filePath, metadata['importAs']);
+    }
+    if (metadata['metadata']) {
+      // handle direct declarations of the symbol
+      const topLevelSymbolNames =
+          new Set<string>(Object.keys(metadata['metadata']).map(unescapeIdentifier));
+      const origins: {[index: string]: string} = metadata['origins'] || {};
+      Object.keys(metadata['metadata']).forEach((metadataKey) => {
+        const symbolMeta = metadata['metadata'][metadataKey];
+        const name = unescapeIdentifier(metadataKey);
+
+        const symbol = this.getStaticSymbol(filePath, name);
+
+        const origin = origins.hasOwnProperty(metadataKey) && origins[metadataKey];
+        if (origin) {
+          // If the symbol is from a bundled index, use the declaration location of the
+          // symbol so relative references (such as './my.html') will be calculated
+          // correctly.
+          const originFilePath = this.resolveModule(origin, filePath);
+          if (!originFilePath) {
+            this.reportError(
+                new Error(`Couldn't resolve original symbol for ${origin} from ${filePath}`));
+          } else {
+            this.symbolResourcePaths.set(symbol, originFilePath);
+          }
+        }
+        resolvedSymbols.push(
+            this.createResolvedSymbol(symbol, filePath, topLevelSymbolNames, symbolMeta));
+      });
+    }
+
+    // handle the symbols in one of the re-export location
+    if (metadata['exports']) {
+      for (const moduleExport of metadata['exports']) {
+        // handle the symbols in the list of explicitly re-exported symbols.
+        if (moduleExport.export) {
+          moduleExport.export.forEach((exportSymbol: any) => {
+            let symbolName: string;
+            if (typeof exportSymbol === 'string') {
+              symbolName = exportSymbol;
+            } else {
+              symbolName = exportSymbol.as;
+            }
+            symbolName = unescapeIdentifier(symbolName);
+            let symName = symbolName;
+            if (typeof exportSymbol !== 'string') {
+              symName = unescapeIdentifier(exportSymbol.name);
+            }
+            const resolvedModule = this.resolveModule(moduleExport.from, filePath);
+            if (resolvedModule) {
+              const targetSymbol = this.getStaticSymbol(resolvedModule, symName);
+              const sourceSymbol = this.getStaticSymbol(filePath, symbolName);
+              resolvedSymbols.push(this.createExport(sourceSymbol, targetSymbol));
+            }
+          });
+        } else {
+          // handle the symbols via export * directives.
+          const resolvedModule = this.resolveModule(moduleExport.from, filePath);
+          if (resolvedModule) {
+            const nestedExports = this.getSymbolsOf(resolvedModule);
+            nestedExports.forEach((targetSymbol) => {
+              const sourceSymbol = this.getStaticSymbol(filePath, targetSymbol.name);
+              resolvedSymbols.push(this.createExport(sourceSymbol, targetSymbol));
+            });
+          }
+        }
+      }
+    }
+    resolvedSymbols.forEach(
+        (resolvedSymbol) => this.resolvedSymbols.set(resolvedSymbol.symbol, resolvedSymbol));
+    this.symbolFromFile.set(filePath, resolvedSymbols.map(resolvedSymbol => resolvedSymbol.symbol));
+  }
+
+  private createResolvedSymbol(
+      sourceSymbol: StaticSymbol, topLevelPath: string, topLevelSymbolNames: Set<string>,
+      metadata: any): ResolvedStaticSymbol {
+    // For classes that don't have Angular summaries / metadata,
+    // we only keep their arity, but nothing else
+    // (e.g. their constructor parameters).
+    // We do this to prevent introducing deep imports
+    // as we didn't generate .ngfactory.ts files with proper reexports.
+    if (this.summaryResolver.isLibraryFile(sourceSymbol.filePath) && metadata &&
+        metadata['__symbolic'] === 'class') {
+      const transformedMeta = {__symbolic: 'class', arity: metadata.arity};
+      return new ResolvedStaticSymbol(sourceSymbol, transformedMeta);
+    }
+
+    const self = this;
+
+    class ReferenceTransformer extends ValueTransformer {
+      visitStringMap(map: {[key: string]: any}, functionParams: string[]): any {
+        const symbolic = map['__symbolic'];
+        if (symbolic === 'function') {
+          const oldLen = functionParams.length;
+          functionParams.push(...(map['parameters'] || []));
+          const result = super.visitStringMap(map, functionParams);
+          functionParams.length = oldLen;
+          return result;
+        } else if (symbolic === 'reference') {
+          const module = map['module'];
+          const name = map['name'] ? unescapeIdentifier(map['name']) : map['name'];
+          if (!name) {
+            return null;
+          }
+          let filePath: string;
+          if (module) {
+            filePath = self.resolveModule(module, sourceSymbol.filePath) !;
+            if (!filePath) {
+              return {
+                __symbolic: 'error',
+                message: `Could not resolve ${module} relative to ${sourceSymbol.filePath}.`
+              };
+            }
+            return self.getStaticSymbol(filePath, name);
+          } else if (functionParams.indexOf(name) >= 0) {
+            // reference to a function parameter
+            return {__symbolic: 'reference', name: name};
+          } else {
+            if (topLevelSymbolNames.has(name)) {
+              return self.getStaticSymbol(topLevelPath, name);
+            }
+            // ambient value
+            null;
+          }
+        } else {
+          return super.visitStringMap(map, functionParams);
+        }
+      }
+    }
+    const transformedMeta = visitValue(metadata, new ReferenceTransformer(), []);
+    if (transformedMeta instanceof StaticSymbol) {
+      return this.createExport(sourceSymbol, transformedMeta);
+    }
+    return new ResolvedStaticSymbol(sourceSymbol, transformedMeta);
+  }
+
+  private createExport(sourceSymbol: StaticSymbol, targetSymbol: StaticSymbol):
+      ResolvedStaticSymbol {
+    sourceSymbol.assertNoMembers();
+    targetSymbol.assertNoMembers();
+    if (this.summaryResolver.isLibraryFile(sourceSymbol.filePath)) {
+      // This case is for an ng library importing symbols from a plain ts library
+      // transitively.
+      // Note: We rely on the fact that we discover symbols in the direction
+      // from source files to library files
+      this.importAs.set(targetSymbol, this.getImportAs(sourceSymbol) || sourceSymbol);
+    }
+    return new ResolvedStaticSymbol(sourceSymbol, targetSymbol);
+  }
+
+  private reportError(error: Error, context?: StaticSymbol, path?: string) {
+    if (this.errorRecorder) {
+      this.errorRecorder(error, (context && context.filePath) || path);
+    } else {
+      throw error;
+    }
+  }
+
+  /**
+   * @param module an absolute path to a module file.
+   */
+  private getModuleMetadata(module: string): {[key: string]: any} {
+    let moduleMetadata = this.metadataCache.get(module);
+    if (!moduleMetadata) {
+      const moduleMetadatas = this.host.getMetadataFor(module);
+      if (moduleMetadatas) {
+        let maxVersion = -1;
+        moduleMetadatas.forEach((md) => {
+          if (md['version'] > maxVersion) {
+            maxVersion = md['version'];
+            moduleMetadata = md;
+          }
+        });
+      }
+      if (!moduleMetadata) {
+        moduleMetadata =
+            {__symbolic: 'module', version: SUPPORTED_SCHEMA_VERSION, module: module, metadata: {}};
+      }
+      if (moduleMetadata['version'] != SUPPORTED_SCHEMA_VERSION) {
+        const errorMessage = moduleMetadata['version'] == 2 ?
+            `Unsupported metadata version ${moduleMetadata['version']} for module ${module}. This module should be compiled with a newer version of ngc` :
+            `Metadata version mismatch for module ${module}, found version ${moduleMetadata['version']}, expected ${SUPPORTED_SCHEMA_VERSION}`;
+        this.reportError(new Error(errorMessage));
+      }
+      this.metadataCache.set(module, moduleMetadata);
+    }
+    return moduleMetadata;
+  }
+
+
+  getSymbolByModule(module: string, symbolName: string, containingFile?: string): StaticSymbol {
+    const filePath = this.resolveModule(module, containingFile);
+    if (!filePath) {
+      this.reportError(
+          new Error(`Could not resolve module ${module}${containingFile ? ` relative to $ {
+            containingFile
+          } `: ''}`));
+      return this.getStaticSymbol(`ERROR:${module}`, symbolName);
+    }
+    return this.getStaticSymbol(filePath, symbolName);
+  }
+
+  private resolveModule(module: string, containingFile?: string): string|null {
+    try {
+      return this.host.moduleNameToFileName(module, containingFile);
+    } catch (e) {
+      console.error(`Could not resolve module '${module}' relative to file ${containingFile}`);
+      this.reportError(e, undefined, containingFile);
+    }
+    return null;
+  }
+}
+
+// Remove extra underscore from escaped identifier.
+// See https://github.com/Microsoft/TypeScript/blob/master/src/compiler/utilities.ts
+export function unescapeIdentifier(identifier: string): string {
+  return identifier.startsWith('___') ? identifier.substr(1) : identifier;
+}
diff --git a/angular/compiler/src/aot/summary_resolver.ts b/angular/compiler/src/aot/summary_resolver.ts
new file mode 100644
index 0000000..c630675
--- /dev/null
+++ b/angular/compiler/src/aot/summary_resolver.ts
@@ -0,0 +1,114 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Summary, SummaryResolver} from '../summary_resolver';
+
+import {StaticSymbol, StaticSymbolCache} from './static_symbol';
+import {deserializeSummaries} from './summary_serializer';
+import {ngfactoryFilePath, stripGeneratedFileSuffix, summaryFileName} from './util';
+
+export interface AotSummaryResolverHost {
+  /**
+   * Loads an NgModule/Directive/Pipe summary file
+   */
+  loadSummary(filePath: string): string|null;
+
+  /**
+   * Returns whether a file is a source file or not.
+   */
+  isSourceFile(sourceFilePath: string): boolean;
+  /**
+   * Converts a file name into a representation that should be stored in a summary file.
+   * This has to include changing the suffix as well.
+   * E.g.
+   * `some_file.ts` -> `some_file.d.ts`
+   *
+   * @param referringSrcFileName the soure file that refers to fileName
+   */
+  toSummaryFileName(fileName: string, referringSrcFileName: string): string;
+
+  /**
+   * Converts a fileName that was processed by `toSummaryFileName` back into a real fileName
+   * given the fileName of the library that is referrig to it.
+   */
+  fromSummaryFileName(fileName: string, referringLibFileName: string): string;
+}
+
+export class AotSummaryResolver implements SummaryResolver<StaticSymbol> {
+  // Note: this will only contain StaticSymbols without members!
+  private summaryCache = new Map<StaticSymbol, Summary<StaticSymbol>>();
+  private loadedFilePaths = new Set<string>();
+  // Note: this will only contain StaticSymbols without members!
+  private importAs = new Map<StaticSymbol, StaticSymbol>();
+
+  constructor(private host: AotSummaryResolverHost, private staticSymbolCache: StaticSymbolCache) {}
+
+  isLibraryFile(filePath: string): boolean {
+    // Note: We need to strip the .ngfactory. file path,
+    // so this method also works for generated files
+    // (for which host.isSourceFile will always return false).
+    return !this.host.isSourceFile(stripGeneratedFileSuffix(filePath));
+  }
+
+  toSummaryFileName(filePath: string, referringSrcFileName: string) {
+    return this.host.toSummaryFileName(filePath, referringSrcFileName);
+  }
+
+  fromSummaryFileName(fileName: string, referringLibFileName: string) {
+    return this.host.fromSummaryFileName(fileName, referringLibFileName);
+  }
+
+  resolveSummary(staticSymbol: StaticSymbol): Summary<StaticSymbol> {
+    staticSymbol.assertNoMembers();
+    let summary = this.summaryCache.get(staticSymbol);
+    if (!summary) {
+      this._loadSummaryFile(staticSymbol.filePath);
+      summary = this.summaryCache.get(staticSymbol) !;
+    }
+    return summary;
+  }
+
+  getSymbolsOf(filePath: string): StaticSymbol[] {
+    this._loadSummaryFile(filePath);
+    return Array.from(this.summaryCache.keys()).filter((symbol) => symbol.filePath === filePath);
+  }
+
+  getImportAs(staticSymbol: StaticSymbol): StaticSymbol {
+    staticSymbol.assertNoMembers();
+    return this.importAs.get(staticSymbol) !;
+  }
+
+  addSummary(summary: Summary<StaticSymbol>) { this.summaryCache.set(summary.symbol, summary); }
+
+  private _loadSummaryFile(filePath: string) {
+    if (this.loadedFilePaths.has(filePath)) {
+      return;
+    }
+    this.loadedFilePaths.add(filePath);
+    if (this.isLibraryFile(filePath)) {
+      const summaryFilePath = summaryFileName(filePath);
+      let json: string|null;
+      try {
+        json = this.host.loadSummary(summaryFilePath);
+      } catch (e) {
+        console.error(`Error loading summary file ${summaryFilePath}`);
+        throw e;
+      }
+      if (json) {
+        const {summaries, importAs} =
+            deserializeSummaries(this.staticSymbolCache, this, filePath, json);
+        summaries.forEach((summary) => this.summaryCache.set(summary.symbol, summary));
+        importAs.forEach((importAs) => {
+          this.importAs.set(
+              importAs.symbol,
+              this.staticSymbolCache.get(ngfactoryFilePath(filePath), importAs.importAs));
+        });
+      }
+    }
+  }
+}
diff --git a/angular/compiler/src/aot/summary_serializer.ts b/angular/compiler/src/aot/summary_serializer.ts
new file mode 100644
index 0000000..165c803
--- /dev/null
+++ b/angular/compiler/src/aot/summary_serializer.ts
@@ -0,0 +1,354 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileNgModuleMetadata, CompileNgModuleSummary, CompilePipeMetadata, CompileProviderMetadata, CompileSummaryKind, CompileTypeMetadata, CompileTypeSummary} from '../compile_metadata';
+import * as o from '../output/output_ast';
+import {Summary, SummaryResolver} from '../summary_resolver';
+import {OutputContext, ValueTransformer, ValueVisitor, visitValue} from '../util';
+
+import {StaticSymbol, StaticSymbolCache} from './static_symbol';
+import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
+import {summaryForJitFileName, summaryForJitName} from './util';
+
+export function serializeSummaries(
+    srcFileName: string, forJitCtx: OutputContext, summaryResolver: SummaryResolver<StaticSymbol>,
+    symbolResolver: StaticSymbolResolver, symbols: ResolvedStaticSymbol[], types: {
+      summary: CompileTypeSummary,
+      metadata: CompileNgModuleMetadata | CompileDirectiveMetadata | CompilePipeMetadata |
+          CompileTypeMetadata
+    }[]): {json: string, exportAs: {symbol: StaticSymbol, exportAs: string}[]} {
+  const toJsonSerializer = new ToJsonSerializer(symbolResolver, summaryResolver);
+  const forJitSerializer = new ForJitSerializer(forJitCtx, symbolResolver);
+
+  // for symbols, we use everything except for the class metadata itself
+  // (we keep the statics though), as the class metadata is contained in the
+  // CompileTypeSummary.
+  symbols.forEach(
+      (resolvedSymbol) => toJsonSerializer.addOrMergeSummary(
+          {symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata}));
+  // Add summaries that are referenced by the given symbols (transitively)
+  // Note: the serializer.symbols array might be growing while
+  // we execute the loop!
+  for (let processedIndex = 0; processedIndex < toJsonSerializer.symbols.length; processedIndex++) {
+    const symbol = toJsonSerializer.symbols[processedIndex];
+    if (summaryResolver.isLibraryFile(symbol.filePath)) {
+      let summary = summaryResolver.resolveSummary(symbol);
+      if (!summary) {
+        // some symbols might originate from a plain typescript library
+        // that just exported .d.ts and .metadata.json files, i.e. where no summary
+        // files were created.
+        const resolvedSymbol = symbolResolver.resolveSymbol(symbol);
+        if (resolvedSymbol) {
+          summary = {symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata};
+        }
+      }
+      if (summary) {
+        if (summary.type) {
+          forJitSerializer.addLibType(summary.type);
+        }
+        toJsonSerializer.addOrMergeSummary(summary);
+      }
+    }
+  }
+
+  // Add type summaries.
+  // Note: We don't add the summaries of all referenced symbols as for the ResolvedSymbols,
+  // as the type summaries already contain the transitive data that they require
+  // (in a minimal way).
+  types.forEach(({summary, metadata}) => {
+    forJitSerializer.addSourceType(summary, metadata);
+    toJsonSerializer.addOrMergeSummary(
+        {symbol: summary.type.reference, metadata: null, type: summary});
+    if (summary.summaryKind === CompileSummaryKind.NgModule) {
+      const ngModuleSummary = <CompileNgModuleSummary>summary;
+      ngModuleSummary.exportedDirectives.concat(ngModuleSummary.exportedPipes).forEach((id) => {
+        const symbol: StaticSymbol = id.reference;
+        if (summaryResolver.isLibraryFile(symbol.filePath)) {
+          const summary = summaryResolver.resolveSummary(symbol);
+          if (summary) {
+            toJsonSerializer.addOrMergeSummary(summary);
+          }
+        }
+      });
+    }
+  });
+  const {json, exportAs} = toJsonSerializer.serialize(srcFileName);
+  forJitSerializer.serialize(exportAs);
+  return {json, exportAs};
+}
+
+export function deserializeSummaries(
+    symbolCache: StaticSymbolCache, summaryResolver: SummaryResolver<StaticSymbol>,
+    libraryFileName: string, json: string):
+    {summaries: Summary<StaticSymbol>[], importAs: {symbol: StaticSymbol, importAs: string}[]} {
+  const deserializer = new FromJsonDeserializer(symbolCache, summaryResolver);
+  return deserializer.deserialize(libraryFileName, json);
+}
+
+export function createForJitStub(outputCtx: OutputContext, reference: StaticSymbol) {
+  return createSummaryForJitFunction(outputCtx, reference, o.NULL_EXPR);
+}
+
+function createSummaryForJitFunction(
+    outputCtx: OutputContext, reference: StaticSymbol, value: o.Expression) {
+  const fnName = summaryForJitName(reference.name);
+  outputCtx.statements.push(
+      o.fn([], [new o.ReturnStatement(value)], new o.ArrayType(o.DYNAMIC_TYPE)).toDeclStmt(fnName, [
+        o.StmtModifier.Final, o.StmtModifier.Exported
+      ]));
+}
+
+class ToJsonSerializer extends ValueTransformer {
+  // Note: This only contains symbols without members.
+  symbols: StaticSymbol[] = [];
+  private indexBySymbol = new Map<StaticSymbol, number>();
+  // This now contains a `__symbol: number` in the place of
+  // StaticSymbols, but otherwise has the same shape as the original objects.
+  private processedSummaryBySymbol = new Map<StaticSymbol, any>();
+  private processedSummaries: any[] = [];
+
+  constructor(
+      private symbolResolver: StaticSymbolResolver,
+      private summaryResolver: SummaryResolver<StaticSymbol>) {
+    super();
+  }
+
+  addOrMergeSummary(summary: Summary<StaticSymbol>) {
+    let symbolMeta = summary.metadata;
+    if (symbolMeta && symbolMeta.__symbolic === 'class') {
+      // For classes, we keep everything except their class decorators.
+      // We need to keep e.g. the ctor args, method names, method decorators
+      // so that the class can be extended in another compilation unit.
+      // We don't keep the class decorators as
+      // 1) they refer to data
+      //   that should not cause a rebuild of downstream compilation units
+      //   (e.g. inline templates of @Component, or @NgModule.declarations)
+      // 2) their data is already captured in TypeSummaries, e.g. DirectiveSummary.
+      const clone: {[key: string]: any} = {};
+      Object.keys(symbolMeta).forEach((propName) => {
+        if (propName !== 'decorators') {
+          clone[propName] = symbolMeta[propName];
+        }
+      });
+      symbolMeta = clone;
+    }
+
+    let processedSummary = this.processedSummaryBySymbol.get(summary.symbol);
+    if (!processedSummary) {
+      processedSummary = this.processValue({symbol: summary.symbol});
+      this.processedSummaries.push(processedSummary);
+      this.processedSummaryBySymbol.set(summary.symbol, processedSummary);
+    }
+    // Note: == on purpose to compare with undefined!
+    if (processedSummary.metadata == null && symbolMeta != null) {
+      processedSummary.metadata = this.processValue(symbolMeta);
+    }
+    // Note: == on purpose to compare with undefined!
+    if (processedSummary.type == null && summary.type != null) {
+      processedSummary.type = this.processValue(summary.type);
+    }
+  }
+
+  serialize(srcFileName: string):
+      {json: string, exportAs: {symbol: StaticSymbol, exportAs: string}[]} {
+    const exportAs: {symbol: StaticSymbol, exportAs: string}[] = [];
+    const json = JSON.stringify({
+      summaries: this.processedSummaries,
+      symbols: this.symbols.map((symbol, index) => {
+        symbol.assertNoMembers();
+        let importAs: string = undefined !;
+        if (this.summaryResolver.isLibraryFile(symbol.filePath)) {
+          importAs = `${symbol.name}_${index}`;
+          exportAs.push({symbol, exportAs: importAs});
+        }
+        return {
+          __symbol: index,
+          name: symbol.name,
+          filePath: this.summaryResolver.toSummaryFileName(symbol.filePath, srcFileName),
+          importAs: importAs
+        };
+      })
+    });
+    return {json, exportAs};
+  }
+
+  private processValue(value: any): any { return visitValue(value, this, null); }
+
+  visitOther(value: any, context: any): any {
+    if (value instanceof StaticSymbol) {
+      const baseSymbol = this.symbolResolver.getStaticSymbol(value.filePath, value.name);
+      let index = this.indexBySymbol.get(baseSymbol);
+      // Note: == on purpose to compare with undefined!
+      if (index == null) {
+        index = this.indexBySymbol.size;
+        this.indexBySymbol.set(baseSymbol, index);
+        this.symbols.push(baseSymbol);
+      }
+      return {__symbol: index, members: value.members};
+    }
+  }
+}
+
+class ForJitSerializer {
+  private data = new Map<StaticSymbol, {
+    summary: CompileTypeSummary,
+    metadata: CompileNgModuleMetadata|CompileDirectiveMetadata|CompilePipeMetadata|
+    CompileTypeMetadata|null,
+    isLibrary: boolean
+  }>();
+
+  constructor(private outputCtx: OutputContext, private symbolResolver: StaticSymbolResolver) {}
+
+  addSourceType(
+      summary: CompileTypeSummary, metadata: CompileNgModuleMetadata|CompileDirectiveMetadata|
+      CompilePipeMetadata|CompileTypeMetadata) {
+    this.data.set(summary.type.reference, {summary, metadata, isLibrary: false});
+  }
+
+  addLibType(summary: CompileTypeSummary) {
+    this.data.set(summary.type.reference, {summary, metadata: null, isLibrary: true});
+  }
+
+  serialize(exportAs: {symbol: StaticSymbol, exportAs: string}[]): void {
+    const ngModuleSymbols = new Set<StaticSymbol>();
+
+    Array.from(this.data.values()).forEach(({summary, metadata, isLibrary}) => {
+      if (summary.summaryKind === CompileSummaryKind.NgModule) {
+        // collect the symbols that refer to NgModule classes.
+        // Note: we can't just rely on `summary.type.summaryKind` to determine this as
+        // we don't add the summaries of all referenced symbols when we serialize type summaries.
+        // See serializeSummaries for details.
+        ngModuleSymbols.add(summary.type.reference);
+        const modSummary = <CompileNgModuleSummary>summary;
+        modSummary.modules.forEach((mod) => { ngModuleSymbols.add(mod.reference); });
+      }
+      if (!isLibrary) {
+        const fnName = summaryForJitName(summary.type.reference.name);
+        createSummaryForJitFunction(
+            this.outputCtx, summary.type.reference,
+            this.serializeSummaryWithDeps(summary, metadata !));
+      }
+    });
+
+    exportAs.forEach((entry) => {
+      const symbol = entry.symbol;
+      if (ngModuleSymbols.has(symbol)) {
+        const jitExportAsName = summaryForJitName(entry.exportAs);
+        this.outputCtx.statements.push(
+            o.variable(jitExportAsName).set(this.serializeSummaryRef(symbol)).toDeclStmt(null, [
+              o.StmtModifier.Exported
+            ]));
+      }
+    });
+  }
+
+  private serializeSummaryWithDeps(
+      summary: CompileTypeSummary, metadata: CompileNgModuleMetadata|CompileDirectiveMetadata|
+      CompilePipeMetadata|CompileTypeMetadata): o.Expression {
+    const expressions: o.Expression[] = [this.serializeSummary(summary)];
+    let providers: CompileProviderMetadata[] = [];
+    if (metadata instanceof CompileNgModuleMetadata) {
+      expressions.push(...
+                       // For directives / pipes, we only add the declared ones,
+                       // and rely on transitively importing NgModules to get the transitive
+                       // summaries.
+                       metadata.declaredDirectives.concat(metadata.declaredPipes)
+                           .map(type => type.reference)
+                           // For modules,
+                           // we also add the summaries for modules
+                           // from libraries.
+                           // This is ok as we produce reexports for all transitive modules.
+                           .concat(metadata.transitiveModule.modules.map(type => type.reference)
+                                       .filter(ref => ref !== metadata.type.reference))
+                           .map((ref) => this.serializeSummaryRef(ref)));
+      // Note: We don't use `NgModuleSummary.providers`, as that one is transitive,
+      // and we already have transitive modules.
+      providers = metadata.providers;
+    } else if (summary.summaryKind === CompileSummaryKind.Directive) {
+      const dirSummary = <CompileDirectiveSummary>summary;
+      providers = dirSummary.providers.concat(dirSummary.viewProviders);
+    }
+    // Note: We can't just refer to the `ngsummary.ts` files for `useClass` providers (as we do for
+    // declaredDirectives / declaredPipes), as we allow
+    // providers without ctor arguments to skip the `@Injectable` decorator,
+    // i.e. we didn't generate .ngsummary.ts files for these.
+    expressions.push(
+        ...providers.filter(provider => !!provider.useClass).map(provider => this.serializeSummary({
+          summaryKind: CompileSummaryKind.Injectable, type: provider.useClass
+        } as CompileTypeSummary)));
+    return o.literalArr(expressions);
+  }
+
+  private serializeSummaryRef(typeSymbol: StaticSymbol): o.Expression {
+    const jitImportedSymbol = this.symbolResolver.getStaticSymbol(
+        summaryForJitFileName(typeSymbol.filePath), summaryForJitName(typeSymbol.name));
+    return this.outputCtx.importExpr(jitImportedSymbol);
+  }
+
+  private serializeSummary(data: {[key: string]: any}): o.Expression {
+    const outputCtx = this.outputCtx;
+
+    class Transformer implements ValueVisitor {
+      visitArray(arr: any[], context: any): any {
+        return o.literalArr(arr.map(entry => visitValue(entry, this, context)));
+      }
+      visitStringMap(map: {[key: string]: any}, context: any): any {
+        return new o.LiteralMapExpr(Object.keys(map).map(
+            (key) => new o.LiteralMapEntry(key, visitValue(map[key], this, context), false)));
+      }
+      visitPrimitive(value: any, context: any): any { return o.literal(value); }
+      visitOther(value: any, context: any): any {
+        if (value instanceof StaticSymbol) {
+          return outputCtx.importExpr(value);
+        } else {
+          throw new Error(`Illegal State: Encountered value ${value}`);
+        }
+      }
+    }
+
+    return visitValue(data, new Transformer(), null);
+  }
+}
+
+class FromJsonDeserializer extends ValueTransformer {
+  private symbols: StaticSymbol[];
+
+  constructor(
+      private symbolCache: StaticSymbolCache,
+      private summaryResolver: SummaryResolver<StaticSymbol>) {
+    super();
+  }
+
+  deserialize(libraryFileName: string, json: string):
+      {summaries: Summary<StaticSymbol>[], importAs: {symbol: StaticSymbol, importAs: string}[]} {
+    const data: {summaries: any[], symbols: any[]} = JSON.parse(json);
+    const importAs: {symbol: StaticSymbol, importAs: string}[] = [];
+    this.symbols = [];
+    data.symbols.forEach((serializedSymbol) => {
+      const symbol = this.symbolCache.get(
+          this.summaryResolver.fromSummaryFileName(serializedSymbol.filePath, libraryFileName),
+          serializedSymbol.name);
+      this.symbols.push(symbol);
+      if (serializedSymbol.importAs) {
+        importAs.push({symbol: symbol, importAs: serializedSymbol.importAs});
+      }
+    });
+    const summaries = visitValue(data.summaries, this, null);
+    return {summaries, importAs};
+  }
+
+  visitStringMap(map: {[key: string]: any}, context: any): any {
+    if ('__symbol' in map) {
+      const baseSymbol = this.symbols[map['__symbol']];
+      const members = map['members'];
+      return members.length ? this.symbolCache.get(baseSymbol.filePath, baseSymbol.name, members) :
+                              baseSymbol;
+    } else {
+      return super.visitStringMap(map, context);
+    }
+  }
+}
diff --git a/angular/compiler/src/aot/util.ts b/angular/compiler/src/aot/util.ts
new file mode 100644
index 0000000..1d02da8
--- /dev/null
+++ b/angular/compiler/src/aot/util.ts
@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+const STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
+const GENERATED_FILE = /\.ngfactory\.|\.ngsummary\./;
+const GENERATED_MODULE = /\.ngfactory$|\.ngsummary$/;
+const JIT_SUMMARY_FILE = /\.ngsummary\./;
+const JIT_SUMMARY_NAME = /NgSummary$/;
+
+export function ngfactoryFilePath(filePath: string, forceSourceFile = false): string {
+  const urlWithSuffix = splitTypescriptSuffix(filePath, forceSourceFile);
+  return `${urlWithSuffix[0]}.ngfactory${urlWithSuffix[1]}`;
+}
+
+export function stripGeneratedFileSuffix(filePath: string): string {
+  return filePath.replace(GENERATED_FILE, '.');
+}
+
+export function isGeneratedFile(filePath: string): boolean {
+  return GENERATED_FILE.test(filePath);
+}
+
+export function splitTypescriptSuffix(path: string, forceSourceFile = false): string[] {
+  if (path.endsWith('.d.ts')) {
+    return [path.slice(0, -5), forceSourceFile ? '.ts' : '.d.ts'];
+  }
+
+  const lastDot = path.lastIndexOf('.');
+
+  if (lastDot !== -1) {
+    return [path.substring(0, lastDot), path.substring(lastDot)];
+  }
+
+  return [path, ''];
+}
+
+export function summaryFileName(fileName: string): string {
+  const fileNameWithoutSuffix = fileName.replace(STRIP_SRC_FILE_SUFFIXES, '');
+  return `${fileNameWithoutSuffix}.ngsummary.json`;
+}
+
+export function summaryForJitFileName(fileName: string, forceSourceFile = false): string {
+  const urlWithSuffix = splitTypescriptSuffix(stripGeneratedFileSuffix(fileName), forceSourceFile);
+  return `${urlWithSuffix[0]}.ngsummary${urlWithSuffix[1]}`;
+}
+
+export function stripSummaryForJitFileSuffix(filePath: string): string {
+  return filePath.replace(JIT_SUMMARY_FILE, '.');
+}
+
+export function summaryForJitName(symbolName: string): string {
+  return `${symbolName}NgSummary`;
+}
+
+export function stripSummaryForJitNameSuffix(symbolName: string): string {
+  return symbolName.replace(JIT_SUMMARY_NAME, '');
+}
\ No newline at end of file
diff --git a/angular/compiler/src/assertions.ts b/angular/compiler/src/assertions.ts
new file mode 100644
index 0000000..2b3736e
--- /dev/null
+++ b/angular/compiler/src/assertions.ts
@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export function assertArrayOfStrings(identifier: string, value: any) {
+  if (value == null) {
+    return;
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(`Expected '${identifier}' to be an array of strings.`);
+  }
+  for (let i = 0; i < value.length; i += 1) {
+    if (typeof value[i] !== 'string') {
+      throw new Error(`Expected '${identifier}' to be an array of strings.`);
+    }
+  }
+}
+
+const INTERPOLATION_BLACKLIST_REGEXPS = [
+  /^\s*$/,        // empty
+  /[<>]/,         // html tag
+  /^[{}]$/,       // i18n expansion
+  /&(#|[a-z])/i,  // character reference,
+  /^\/\//,        // comment
+];
+
+export function assertInterpolationSymbols(identifier: string, value: any): void {
+  if (value != null && !(Array.isArray(value) && value.length == 2)) {
+    throw new Error(`Expected '${identifier}' to be an array, [start, end].`);
+  } else if (value != null) {
+    const start = value[0] as string;
+    const end = value[1] as string;
+    // black list checking
+    INTERPOLATION_BLACKLIST_REGEXPS.forEach(regexp => {
+      if (regexp.test(start) || regexp.test(end)) {
+        throw new Error(`['${start}', '${end}'] contains unusable interpolation symbol.`);
+      }
+    });
+  }
+}
diff --git a/angular/compiler/src/ast_path.ts b/angular/compiler/src/ast_path.ts
new file mode 100644
index 0000000..b899bac
--- /dev/null
+++ b/angular/compiler/src/ast_path.ts
@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * A path is an ordered set of elements. Typically a path is to  a
+ * particular offset in a source file. The head of the list is the top
+ * most node. The tail is the node that contains the offset directly.
+ *
+ * For example, the expresion `a + b + c` might have an ast that looks
+ * like:
+ *     +
+ *    / \
+ *   a   +
+ *      / \
+ *     b   c
+ *
+ * The path to the node at offset 9 would be `['+' at 1-10, '+' at 7-10,
+ * 'c' at 9-10]` and the path the node at offset 1 would be
+ * `['+' at 1-10, 'a' at 1-2]`.
+ */
+export class AstPath<T> {
+  constructor(private path: T[], public position: number = -1) {}
+
+  get empty(): boolean { return !this.path || !this.path.length; }
+  get head(): T|undefined { return this.path[0]; }
+  get tail(): T|undefined { return this.path[this.path.length - 1]; }
+
+  parentOf(node: T|undefined): T|undefined {
+    return node && this.path[this.path.indexOf(node) - 1];
+  }
+  childOf(node: T): T|undefined { return this.path[this.path.indexOf(node) + 1]; }
+
+  first<N extends T>(ctor: {new (...args: any[]): N}): N|undefined {
+    for (let i = this.path.length - 1; i >= 0; i--) {
+      let item = this.path[i];
+      if (item instanceof ctor) return <N>item;
+    }
+  }
+
+  push(node: T) { this.path.push(node); }
+
+  pop(): T { return this.path.pop() !; }
+}
diff --git a/angular/compiler/src/chars.ts b/angular/compiler/src/chars.ts
new file mode 100644
index 0000000..4e510a2
--- /dev/null
+++ b/angular/compiler/src/chars.ts
@@ -0,0 +1,89 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export const $EOF = 0;
+export const $TAB = 9;
+export const $LF = 10;
+export const $VTAB = 11;
+export const $FF = 12;
+export const $CR = 13;
+export const $SPACE = 32;
+export const $BANG = 33;
+export const $DQ = 34;
+export const $HASH = 35;
+export const $$ = 36;
+export const $PERCENT = 37;
+export const $AMPERSAND = 38;
+export const $SQ = 39;
+export const $LPAREN = 40;
+export const $RPAREN = 41;
+export const $STAR = 42;
+export const $PLUS = 43;
+export const $COMMA = 44;
+export const $MINUS = 45;
+export const $PERIOD = 46;
+export const $SLASH = 47;
+export const $COLON = 58;
+export const $SEMICOLON = 59;
+export const $LT = 60;
+export const $EQ = 61;
+export const $GT = 62;
+export const $QUESTION = 63;
+
+export const $0 = 48;
+export const $9 = 57;
+
+export const $A = 65;
+export const $E = 69;
+export const $F = 70;
+export const $X = 88;
+export const $Z = 90;
+
+export const $LBRACKET = 91;
+export const $BACKSLASH = 92;
+export const $RBRACKET = 93;
+export const $CARET = 94;
+export const $_ = 95;
+
+export const $a = 97;
+export const $e = 101;
+export const $f = 102;
+export const $n = 110;
+export const $r = 114;
+export const $t = 116;
+export const $u = 117;
+export const $v = 118;
+export const $x = 120;
+export const $z = 122;
+
+export const $LBRACE = 123;
+export const $BAR = 124;
+export const $RBRACE = 125;
+export const $NBSP = 160;
+
+export const $PIPE = 124;
+export const $TILDA = 126;
+export const $AT = 64;
+
+export const $BT = 96;
+
+export function isWhitespace(code: number): boolean {
+  return (code >= $TAB && code <= $SPACE) || (code == $NBSP);
+}
+
+export function isDigit(code: number): boolean {
+  return $0 <= code && code <= $9;
+}
+
+export function isAsciiLetter(code: number): boolean {
+  return code >= $a && code <= $z || code >= $A && code <= $Z;
+}
+
+export function isAsciiHexDigit(code: number): boolean {
+  return code >= $a && code <= $f || code >= $A && code <= $F || isDigit(code);
+}
diff --git a/angular/compiler/src/compile_metadata.ts b/angular/compiler/src/compile_metadata.ts
new file mode 100644
index 0000000..82829da
--- /dev/null
+++ b/angular/compiler/src/compile_metadata.ts
@@ -0,0 +1,794 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {StaticSymbol} from './aot/static_symbol';
+import {ChangeDetectionStrategy, SchemaMetadata, Type, ViewEncapsulation} from './core';
+import {LifecycleHooks} from './lifecycle_reflector';
+import {CssSelector} from './selector';
+import {splitAtColon, stringify} from './util';
+
+
+
+// group 0: "[prop] or (event) or @trigger"
+// group 1: "prop" from "[prop]"
+// group 2: "event" from "(event)"
+// group 3: "@trigger" from "@trigger"
+const HOST_REG_EXP = /^(?:(?:\[([^\]]+)\])|(?:\(([^\)]+)\)))|(\@[-\w]+)$/;
+
+export class CompileAnimationEntryMetadata {
+  constructor(
+      public name: string|null = null,
+      public definitions: CompileAnimationStateMetadata[]|null = null) {}
+}
+
+export abstract class CompileAnimationStateMetadata {}
+
+export class CompileAnimationStateDeclarationMetadata extends CompileAnimationStateMetadata {
+  constructor(public stateNameExpr: string, public styles: CompileAnimationStyleMetadata) {
+    super();
+  }
+}
+
+export class CompileAnimationStateTransitionMetadata extends CompileAnimationStateMetadata {
+  constructor(
+      public stateChangeExpr: string|StaticSymbol|((stateA: string, stateB: string) => boolean),
+      public steps: CompileAnimationMetadata) {
+    super();
+  }
+}
+
+export abstract class CompileAnimationMetadata {}
+
+export class CompileAnimationKeyframesSequenceMetadata extends CompileAnimationMetadata {
+  constructor(public steps: CompileAnimationStyleMetadata[] = []) { super(); }
+}
+
+export class CompileAnimationStyleMetadata extends CompileAnimationMetadata {
+  constructor(
+      public offset: number,
+      public styles: Array<string|{[key: string]: string | number}>|null = null) {
+    super();
+  }
+}
+
+export class CompileAnimationAnimateMetadata extends CompileAnimationMetadata {
+  constructor(
+      public timings: string|number = 0, public styles: CompileAnimationStyleMetadata|
+      CompileAnimationKeyframesSequenceMetadata|null = null) {
+    super();
+  }
+}
+
+export abstract class CompileAnimationWithStepsMetadata extends CompileAnimationMetadata {
+  constructor(public steps: CompileAnimationMetadata[]|null = null) { super(); }
+}
+
+export class CompileAnimationSequenceMetadata extends CompileAnimationWithStepsMetadata {
+  constructor(steps: CompileAnimationMetadata[]|null = null) { super(steps); }
+}
+
+export class CompileAnimationGroupMetadata extends CompileAnimationWithStepsMetadata {
+  constructor(steps: CompileAnimationMetadata[]|null = null) { super(steps); }
+}
+
+
+function _sanitizeIdentifier(name: string): string {
+  return name.replace(/\W/g, '_');
+}
+
+let _anonymousTypeIndex = 0;
+
+export function identifierName(compileIdentifier: CompileIdentifierMetadata | null | undefined):
+    string|null {
+  if (!compileIdentifier || !compileIdentifier.reference) {
+    return null;
+  }
+  const ref = compileIdentifier.reference;
+  if (ref instanceof StaticSymbol) {
+    return ref.name;
+  }
+  if (ref['__anonymousType']) {
+    return ref['__anonymousType'];
+  }
+  let identifier = stringify(ref);
+  if (identifier.indexOf('(') >= 0) {
+    // case: anonymous functions!
+    identifier = `anonymous_${_anonymousTypeIndex++}`;
+    ref['__anonymousType'] = identifier;
+  } else {
+    identifier = _sanitizeIdentifier(identifier);
+  }
+  return identifier;
+}
+
+export function identifierModuleUrl(compileIdentifier: CompileIdentifierMetadata): string {
+  const ref = compileIdentifier.reference;
+  if (ref instanceof StaticSymbol) {
+    return ref.filePath;
+  }
+  // Runtime type
+  return `./${stringify(ref)}`;
+}
+
+export function viewClassName(compType: any, embeddedTemplateIndex: number): string {
+  return `View_${identifierName({reference: compType})}_${embeddedTemplateIndex}`;
+}
+
+export function rendererTypeName(compType: any): string {
+  return `RenderType_${identifierName({reference: compType})}`;
+}
+
+export function hostViewClassName(compType: any): string {
+  return `HostView_${identifierName({reference: compType})}`;
+}
+
+export function componentFactoryName(compType: any): string {
+  return `${identifierName({reference: compType})}NgFactory`;
+}
+
+export interface ProxyClass { setDelegate(delegate: any): void; }
+
+export interface CompileIdentifierMetadata { reference: any; }
+
+export enum CompileSummaryKind {
+  Pipe,
+  Directive,
+  NgModule,
+  Injectable
+}
+
+/**
+ * A CompileSummary is the data needed to use a directive / pipe / module
+ * in other modules / components. However, this data is not enough to compile
+ * the directive / module itself.
+ */
+export interface CompileTypeSummary {
+  summaryKind: CompileSummaryKind|null;
+  type: CompileTypeMetadata;
+}
+
+export interface CompileDiDependencyMetadata {
+  isAttribute?: boolean;
+  isSelf?: boolean;
+  isHost?: boolean;
+  isSkipSelf?: boolean;
+  isOptional?: boolean;
+  isValue?: boolean;
+  token?: CompileTokenMetadata;
+  value?: any;
+}
+
+export interface CompileProviderMetadata {
+  token: CompileTokenMetadata;
+  useClass?: CompileTypeMetadata;
+  useValue?: any;
+  useExisting?: CompileTokenMetadata;
+  useFactory?: CompileFactoryMetadata;
+  deps?: CompileDiDependencyMetadata[];
+  multi?: boolean;
+}
+
+export interface CompileFactoryMetadata extends CompileIdentifierMetadata {
+  diDeps: CompileDiDependencyMetadata[];
+  reference: any;
+}
+
+export function tokenName(token: CompileTokenMetadata) {
+  return token.value != null ? _sanitizeIdentifier(token.value) : identifierName(token.identifier);
+}
+
+export function tokenReference(token: CompileTokenMetadata) {
+  if (token.identifier != null) {
+    return token.identifier.reference;
+  } else {
+    return token.value;
+  }
+}
+
+export interface CompileTokenMetadata {
+  value?: any;
+  identifier?: CompileIdentifierMetadata|CompileTypeMetadata;
+}
+
+/**
+ * Metadata regarding compilation of a type.
+ */
+export interface CompileTypeMetadata extends CompileIdentifierMetadata {
+  diDeps: CompileDiDependencyMetadata[];
+  lifecycleHooks: LifecycleHooks[];
+  reference: any;
+}
+
+export interface CompileQueryMetadata {
+  selectors: Array<CompileTokenMetadata>;
+  descendants: boolean;
+  first: boolean;
+  propertyName: string;
+  read: CompileTokenMetadata;
+}
+
+/**
+ * Metadata about a stylesheet
+ */
+export class CompileStylesheetMetadata {
+  moduleUrl: string|null;
+  styles: string[];
+  styleUrls: string[];
+  constructor(
+      {moduleUrl, styles,
+       styleUrls}: {moduleUrl?: string, styles?: string[], styleUrls?: string[]} = {}) {
+    this.moduleUrl = moduleUrl || null;
+    this.styles = _normalizeArray(styles);
+    this.styleUrls = _normalizeArray(styleUrls);
+  }
+}
+
+/**
+ * Summary Metadata regarding compilation of a template.
+ */
+export interface CompileTemplateSummary {
+  animations: string[]|null;
+  ngContentSelectors: string[];
+  encapsulation: ViewEncapsulation|null;
+}
+
+/**
+ * Metadata regarding compilation of a template.
+ */
+export class CompileTemplateMetadata {
+  encapsulation: ViewEncapsulation|null;
+  template: string|null;
+  templateUrl: string|null;
+  isInline: boolean;
+  styles: string[];
+  styleUrls: string[];
+  externalStylesheets: CompileStylesheetMetadata[];
+  animations: any[];
+  ngContentSelectors: string[];
+  interpolation: [string, string]|null;
+  preserveWhitespaces: boolean;
+  constructor({encapsulation, template, templateUrl, styles, styleUrls, externalStylesheets,
+               animations, ngContentSelectors, interpolation, isInline, preserveWhitespaces}: {
+    encapsulation: ViewEncapsulation | null,
+    template: string|null,
+    templateUrl: string|null,
+    styles: string[],
+    styleUrls: string[],
+    externalStylesheets: CompileStylesheetMetadata[],
+    ngContentSelectors: string[],
+    animations: any[],
+    interpolation: [string, string]|null,
+    isInline: boolean,
+    preserveWhitespaces: boolean
+  }) {
+    this.encapsulation = encapsulation;
+    this.template = template;
+    this.templateUrl = templateUrl;
+    this.styles = _normalizeArray(styles);
+    this.styleUrls = _normalizeArray(styleUrls);
+    this.externalStylesheets = _normalizeArray(externalStylesheets);
+    this.animations = animations ? flatten(animations) : [];
+    this.ngContentSelectors = ngContentSelectors || [];
+    if (interpolation && interpolation.length != 2) {
+      throw new Error(`'interpolation' should have a start and an end symbol.`);
+    }
+    this.interpolation = interpolation;
+    this.isInline = isInline;
+    this.preserveWhitespaces = preserveWhitespaces;
+  }
+
+  toSummary(): CompileTemplateSummary {
+    return {
+      animations: this.animations.map(anim => anim.name),
+      ngContentSelectors: this.ngContentSelectors,
+      encapsulation: this.encapsulation,
+    };
+  }
+}
+
+export interface CompileEntryComponentMetadata {
+  componentType: any;
+  componentFactory: StaticSymbol|object;
+}
+
+// Note: This should only use interfaces as nested data types
+// as we need to be able to serialize this from/to JSON!
+export interface CompileDirectiveSummary extends CompileTypeSummary {
+  type: CompileTypeMetadata;
+  isComponent: boolean;
+  selector: string|null;
+  exportAs: string|null;
+  inputs: {[key: string]: string};
+  outputs: {[key: string]: string};
+  hostListeners: {[key: string]: string};
+  hostProperties: {[key: string]: string};
+  hostAttributes: {[key: string]: string};
+  providers: CompileProviderMetadata[];
+  viewProviders: CompileProviderMetadata[];
+  queries: CompileQueryMetadata[];
+  viewQueries: CompileQueryMetadata[];
+  entryComponents: CompileEntryComponentMetadata[];
+  changeDetection: ChangeDetectionStrategy|null;
+  template: CompileTemplateSummary|null;
+  componentViewType: StaticSymbol|ProxyClass|null;
+  rendererType: StaticSymbol|object|null;
+  componentFactory: StaticSymbol|object|null;
+}
+
+/**
+ * Metadata regarding compilation of a directive.
+ */
+export class CompileDirectiveMetadata {
+  static create({isHost, type, isComponent, selector, exportAs, changeDetection, inputs, outputs,
+                 host, providers, viewProviders, queries, viewQueries, entryComponents, template,
+                 componentViewType, rendererType, componentFactory}: {
+    isHost: boolean,
+    type: CompileTypeMetadata,
+    isComponent: boolean,
+    selector: string|null,
+    exportAs: string|null,
+    changeDetection: ChangeDetectionStrategy|null,
+    inputs: string[],
+    outputs: string[],
+    host: {[key: string]: string},
+    providers: CompileProviderMetadata[],
+    viewProviders: CompileProviderMetadata[],
+    queries: CompileQueryMetadata[],
+    viewQueries: CompileQueryMetadata[],
+    entryComponents: CompileEntryComponentMetadata[],
+    template: CompileTemplateMetadata,
+    componentViewType: StaticSymbol|ProxyClass|null,
+    rendererType: StaticSymbol|object|null,
+    componentFactory: StaticSymbol|object|null,
+  }): CompileDirectiveMetadata {
+    const hostListeners: {[key: string]: string} = {};
+    const hostProperties: {[key: string]: string} = {};
+    const hostAttributes: {[key: string]: string} = {};
+    if (host != null) {
+      Object.keys(host).forEach(key => {
+        const value = host[key];
+        const matches = key.match(HOST_REG_EXP);
+        if (matches === null) {
+          hostAttributes[key] = value;
+        } else if (matches[1] != null) {
+          hostProperties[matches[1]] = value;
+        } else if (matches[2] != null) {
+          hostListeners[matches[2]] = value;
+        }
+      });
+    }
+    const inputsMap: {[key: string]: string} = {};
+    if (inputs != null) {
+      inputs.forEach((bindConfig: string) => {
+        // canonical syntax: `dirProp: elProp`
+        // if there is no `:`, use dirProp = elProp
+        const parts = splitAtColon(bindConfig, [bindConfig, bindConfig]);
+        inputsMap[parts[0]] = parts[1];
+      });
+    }
+    const outputsMap: {[key: string]: string} = {};
+    if (outputs != null) {
+      outputs.forEach((bindConfig: string) => {
+        // canonical syntax: `dirProp: elProp`
+        // if there is no `:`, use dirProp = elProp
+        const parts = splitAtColon(bindConfig, [bindConfig, bindConfig]);
+        outputsMap[parts[0]] = parts[1];
+      });
+    }
+
+    return new CompileDirectiveMetadata({
+      isHost,
+      type,
+      isComponent: !!isComponent, selector, exportAs, changeDetection,
+      inputs: inputsMap,
+      outputs: outputsMap,
+      hostListeners,
+      hostProperties,
+      hostAttributes,
+      providers,
+      viewProviders,
+      queries,
+      viewQueries,
+      entryComponents,
+      template,
+      componentViewType,
+      rendererType,
+      componentFactory,
+    });
+  }
+  isHost: boolean;
+  type: CompileTypeMetadata;
+  isComponent: boolean;
+  selector: string|null;
+  exportAs: string|null;
+  changeDetection: ChangeDetectionStrategy|null;
+  inputs: {[key: string]: string};
+  outputs: {[key: string]: string};
+  hostListeners: {[key: string]: string};
+  hostProperties: {[key: string]: string};
+  hostAttributes: {[key: string]: string};
+  providers: CompileProviderMetadata[];
+  viewProviders: CompileProviderMetadata[];
+  queries: CompileQueryMetadata[];
+  viewQueries: CompileQueryMetadata[];
+  entryComponents: CompileEntryComponentMetadata[];
+
+  template: CompileTemplateMetadata|null;
+
+  componentViewType: StaticSymbol|ProxyClass|null;
+  rendererType: StaticSymbol|object|null;
+  componentFactory: StaticSymbol|object|null;
+
+  constructor({isHost,          type,      isComponent,       selector,      exportAs,
+               changeDetection, inputs,    outputs,           hostListeners, hostProperties,
+               hostAttributes,  providers, viewProviders,     queries,       viewQueries,
+               entryComponents, template,  componentViewType, rendererType,  componentFactory}: {
+    isHost: boolean,
+    type: CompileTypeMetadata,
+    isComponent: boolean,
+    selector: string|null,
+    exportAs: string|null,
+    changeDetection: ChangeDetectionStrategy|null,
+    inputs: {[key: string]: string},
+    outputs: {[key: string]: string},
+    hostListeners: {[key: string]: string},
+    hostProperties: {[key: string]: string},
+    hostAttributes: {[key: string]: string},
+    providers: CompileProviderMetadata[],
+    viewProviders: CompileProviderMetadata[],
+    queries: CompileQueryMetadata[],
+    viewQueries: CompileQueryMetadata[],
+    entryComponents: CompileEntryComponentMetadata[],
+    template: CompileTemplateMetadata|null,
+    componentViewType: StaticSymbol|ProxyClass|null,
+    rendererType: StaticSymbol|object|null,
+    componentFactory: StaticSymbol|object|null,
+  }) {
+    this.isHost = !!isHost;
+    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.providers = _normalizeArray(providers);
+    this.viewProviders = _normalizeArray(viewProviders);
+    this.queries = _normalizeArray(queries);
+    this.viewQueries = _normalizeArray(viewQueries);
+    this.entryComponents = _normalizeArray(entryComponents);
+    this.template = template;
+
+    this.componentViewType = componentViewType;
+    this.rendererType = rendererType;
+    this.componentFactory = componentFactory;
+  }
+
+  toSummary(): CompileDirectiveSummary {
+    return {
+      summaryKind: CompileSummaryKind.Directive,
+      type: this.type,
+      isComponent: this.isComponent,
+      selector: this.selector,
+      exportAs: this.exportAs,
+      inputs: this.inputs,
+      outputs: this.outputs,
+      hostListeners: this.hostListeners,
+      hostProperties: this.hostProperties,
+      hostAttributes: this.hostAttributes,
+      providers: this.providers,
+      viewProviders: this.viewProviders,
+      queries: this.queries,
+      viewQueries: this.viewQueries,
+      entryComponents: this.entryComponents,
+      changeDetection: this.changeDetection,
+      template: this.template && this.template.toSummary(),
+      componentViewType: this.componentViewType,
+      rendererType: this.rendererType,
+      componentFactory: this.componentFactory
+    };
+  }
+}
+
+/**
+ * Construct {@link CompileDirectiveMetadata} from {@link ComponentTypeMetadata} and a selector.
+ */
+export function createHostComponentMeta(
+    hostTypeReference: any, compMeta: CompileDirectiveMetadata,
+    hostViewType: StaticSymbol | ProxyClass): CompileDirectiveMetadata {
+  const template = CssSelector.parse(compMeta.selector !)[0].getMatchingElementTemplate();
+  return CompileDirectiveMetadata.create({
+    isHost: true,
+    type: {reference: hostTypeReference, diDeps: [], lifecycleHooks: []},
+    template: new CompileTemplateMetadata({
+      encapsulation: ViewEncapsulation.None,
+      template: template,
+      templateUrl: '',
+      styles: [],
+      styleUrls: [],
+      ngContentSelectors: [],
+      animations: [],
+      isInline: true,
+      externalStylesheets: [],
+      interpolation: null,
+      preserveWhitespaces: false,
+    }),
+    exportAs: null,
+    changeDetection: ChangeDetectionStrategy.Default,
+    inputs: [],
+    outputs: [],
+    host: {},
+    isComponent: true,
+    selector: '*',
+    providers: [],
+    viewProviders: [],
+    queries: [],
+    viewQueries: [],
+    componentViewType: hostViewType,
+    rendererType:
+        {id: '__Host__', encapsulation: ViewEncapsulation.None, styles: [], data: {}} as object,
+    entryComponents: [],
+    componentFactory: null
+  });
+}
+
+export interface CompilePipeSummary extends CompileTypeSummary {
+  type: CompileTypeMetadata;
+  name: string;
+  pure: boolean;
+}
+
+export class CompilePipeMetadata {
+  type: CompileTypeMetadata;
+  name: string;
+  pure: boolean;
+
+  constructor({type, name, pure}: {
+    type: CompileTypeMetadata,
+    name: string,
+    pure: boolean,
+  }) {
+    this.type = type;
+    this.name = name;
+    this.pure = !!pure;
+  }
+
+  toSummary(): CompilePipeSummary {
+    return {
+      summaryKind: CompileSummaryKind.Pipe,
+      type: this.type,
+      name: this.name,
+      pure: this.pure
+    };
+  }
+}
+
+// Note: This should only use interfaces as nested data types
+// as we need to be able to serialize this from/to JSON!
+export interface CompileNgModuleSummary extends CompileTypeSummary {
+  type: CompileTypeMetadata;
+
+  // Note: This is transitive over the exported modules.
+  exportedDirectives: CompileIdentifierMetadata[];
+  // Note: This is transitive over the exported modules.
+  exportedPipes: CompileIdentifierMetadata[];
+
+  // Note: This is transitive.
+  entryComponents: CompileEntryComponentMetadata[];
+  // Note: This is transitive.
+  providers: {provider: CompileProviderMetadata, module: CompileIdentifierMetadata}[];
+  // Note: This is transitive.
+  modules: CompileTypeMetadata[];
+}
+
+/**
+ * Metadata regarding compilation of a module.
+ */
+export class CompileNgModuleMetadata {
+  type: CompileTypeMetadata;
+  declaredDirectives: CompileIdentifierMetadata[];
+  exportedDirectives: CompileIdentifierMetadata[];
+  declaredPipes: CompileIdentifierMetadata[];
+
+  exportedPipes: CompileIdentifierMetadata[];
+  entryComponents: CompileEntryComponentMetadata[];
+  bootstrapComponents: CompileIdentifierMetadata[];
+  providers: CompileProviderMetadata[];
+
+  importedModules: CompileNgModuleSummary[];
+  exportedModules: CompileNgModuleSummary[];
+  schemas: SchemaMetadata[];
+  id: string|null;
+
+  transitiveModule: TransitiveCompileNgModuleMetadata;
+
+  constructor({type, providers, declaredDirectives, exportedDirectives, declaredPipes,
+               exportedPipes, entryComponents, bootstrapComponents, importedModules,
+               exportedModules, schemas, transitiveModule, id}: {
+    type: CompileTypeMetadata,
+    providers: CompileProviderMetadata[],
+    declaredDirectives: CompileIdentifierMetadata[],
+    exportedDirectives: CompileIdentifierMetadata[],
+    declaredPipes: CompileIdentifierMetadata[],
+    exportedPipes: CompileIdentifierMetadata[],
+    entryComponents: CompileEntryComponentMetadata[],
+    bootstrapComponents: CompileIdentifierMetadata[],
+    importedModules: CompileNgModuleSummary[],
+    exportedModules: CompileNgModuleSummary[],
+    transitiveModule: TransitiveCompileNgModuleMetadata,
+    schemas: SchemaMetadata[],
+    id: string|null
+  }) {
+    this.type = type || null;
+    this.declaredDirectives = _normalizeArray(declaredDirectives);
+    this.exportedDirectives = _normalizeArray(exportedDirectives);
+    this.declaredPipes = _normalizeArray(declaredPipes);
+    this.exportedPipes = _normalizeArray(exportedPipes);
+    this.providers = _normalizeArray(providers);
+    this.entryComponents = _normalizeArray(entryComponents);
+    this.bootstrapComponents = _normalizeArray(bootstrapComponents);
+    this.importedModules = _normalizeArray(importedModules);
+    this.exportedModules = _normalizeArray(exportedModules);
+    this.schemas = _normalizeArray(schemas);
+    this.id = id || null;
+    this.transitiveModule = transitiveModule || null;
+  }
+
+  toSummary(): CompileNgModuleSummary {
+    const module = this.transitiveModule !;
+    return {
+      summaryKind: CompileSummaryKind.NgModule,
+      type: this.type,
+      entryComponents: module.entryComponents,
+      providers: module.providers,
+      modules: module.modules,
+      exportedDirectives: module.exportedDirectives,
+      exportedPipes: module.exportedPipes
+    };
+  }
+}
+
+export class TransitiveCompileNgModuleMetadata {
+  directivesSet = new Set<any>();
+  directives: CompileIdentifierMetadata[] = [];
+  exportedDirectivesSet = new Set<any>();
+  exportedDirectives: CompileIdentifierMetadata[] = [];
+  pipesSet = new Set<any>();
+  pipes: CompileIdentifierMetadata[] = [];
+  exportedPipesSet = new Set<any>();
+  exportedPipes: CompileIdentifierMetadata[] = [];
+  modulesSet = new Set<any>();
+  modules: CompileTypeMetadata[] = [];
+  entryComponentsSet = new Set<any>();
+  entryComponents: CompileEntryComponentMetadata[] = [];
+
+  providers: {provider: CompileProviderMetadata, module: CompileIdentifierMetadata}[] = [];
+
+  addProvider(provider: CompileProviderMetadata, module: CompileIdentifierMetadata) {
+    this.providers.push({provider: provider, module: module});
+  }
+
+  addDirective(id: CompileIdentifierMetadata) {
+    if (!this.directivesSet.has(id.reference)) {
+      this.directivesSet.add(id.reference);
+      this.directives.push(id);
+    }
+  }
+  addExportedDirective(id: CompileIdentifierMetadata) {
+    if (!this.exportedDirectivesSet.has(id.reference)) {
+      this.exportedDirectivesSet.add(id.reference);
+      this.exportedDirectives.push(id);
+    }
+  }
+  addPipe(id: CompileIdentifierMetadata) {
+    if (!this.pipesSet.has(id.reference)) {
+      this.pipesSet.add(id.reference);
+      this.pipes.push(id);
+    }
+  }
+  addExportedPipe(id: CompileIdentifierMetadata) {
+    if (!this.exportedPipesSet.has(id.reference)) {
+      this.exportedPipesSet.add(id.reference);
+      this.exportedPipes.push(id);
+    }
+  }
+  addModule(id: CompileTypeMetadata) {
+    if (!this.modulesSet.has(id.reference)) {
+      this.modulesSet.add(id.reference);
+      this.modules.push(id);
+    }
+  }
+  addEntryComponent(ec: CompileEntryComponentMetadata) {
+    if (!this.entryComponentsSet.has(ec.componentType)) {
+      this.entryComponentsSet.add(ec.componentType);
+      this.entryComponents.push(ec);
+    }
+  }
+}
+
+function _normalizeArray(obj: any[] | undefined | null): any[] {
+  return obj || [];
+}
+
+export class ProviderMeta {
+  token: any;
+  useClass: Type|null;
+  useValue: any;
+  useExisting: any;
+  useFactory: Function|null;
+  dependencies: Object[]|null;
+  multi: boolean;
+
+  constructor(token: any, {useClass, useValue, useExisting, useFactory, deps, multi}: {
+    useClass?: Type,
+    useValue?: any,
+    useExisting?: any,
+    useFactory?: Function|null,
+    deps?: Object[]|null,
+    multi?: boolean
+  }) {
+    this.token = token;
+    this.useClass = useClass || null;
+    this.useValue = useValue;
+    this.useExisting = useExisting;
+    this.useFactory = useFactory || null;
+    this.dependencies = deps || null;
+    this.multi = !!multi;
+  }
+}
+
+export function flatten<T>(list: Array<T|T[]>): T[] {
+  return list.reduce((flat: any[], item: T | T[]): T[] => {
+    const flatItem = Array.isArray(item) ? flatten(item) : item;
+    return (<T[]>flat).concat(flatItem);
+  }, []);
+}
+
+export function sourceUrl(url: string) {
+  // Note: We need 3 "/" so that ng shows up as a separate domain
+  // in the chrome dev tools.
+  return url.replace(/(\w+:\/\/[\w:-]+)?(\/+)?/, 'ng:///');
+}
+
+export function templateSourceUrl(
+    ngModuleType: CompileIdentifierMetadata, compMeta: {type: CompileIdentifierMetadata},
+    templateMeta: {isInline: boolean, templateUrl: string | null}) {
+  let url: string;
+  if (templateMeta.isInline) {
+    if (compMeta.type.reference instanceof StaticSymbol) {
+      // Note: a .ts file might contain multiple components with inline templates,
+      // so we need to give them unique urls, as these will be used for sourcemaps.
+      url = `${compMeta.type.reference.filePath}.${compMeta.type.reference.name}.html`;
+    } else {
+      url = `${identifierName(ngModuleType)}/${identifierName(compMeta.type)}.html`;
+    }
+  } else {
+    url = templateMeta.templateUrl !;
+  }
+  // always prepend ng:// to make angular resources easy to find and not clobber
+  // user resources.
+  return sourceUrl(url);
+}
+
+export function sharedStylesheetJitUrl(meta: CompileStylesheetMetadata, id: number) {
+  const pathParts = meta.moduleUrl !.split(/\/\\/g);
+  const baseName = pathParts[pathParts.length - 1];
+  return sourceUrl(`css/${id}${baseName}.ngstyle.js`);
+}
+
+export function ngModuleJitUrl(moduleMeta: CompileNgModuleMetadata): string {
+  return sourceUrl(`${identifierName(moduleMeta.type)}/module.ngfactory.js`);
+}
+
+export function templateJitUrl(
+    ngModuleType: CompileIdentifierMetadata, compMeta: CompileDirectiveMetadata): string {
+  return sourceUrl(`${identifierName(ngModuleType)}/${identifierName(compMeta.type)}.ngfactory.js`);
+}
diff --git a/angular/compiler/src/compile_reflector.ts b/angular/compiler/src/compile_reflector.ts
new file mode 100644
index 0000000..96cc30c
--- /dev/null
+++ b/angular/compiler/src/compile_reflector.ts
@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Component} from './core';
+import * as o from './output/output_ast';
+
+/**
+ * Provides access to reflection data about symbols that the compiler needs.
+ */
+export abstract class CompileReflector {
+  abstract parameters(typeOrFunc: /*Type*/ any): any[][];
+  abstract annotations(typeOrFunc: /*Type*/ any): any[];
+  abstract propMetadata(typeOrFunc: /*Type*/ any): {[key: string]: any[]};
+  abstract hasLifecycleHook(type: any, lcProperty: string): boolean;
+  abstract componentModuleUrl(type: /*Type*/ any, cmpMetadata: Component): string;
+  abstract resolveExternalReference(ref: o.ExternalReference): any;
+}
diff --git a/angular/compiler/src/compiler.ts b/angular/compiler/src/compiler.ts
new file mode 100644
index 0000000..8b42c8e
--- /dev/null
+++ b/angular/compiler/src/compiler.ts
@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all APIs of the compiler package.
+ *
+ * <div class="callout is-critical">
+ *   <header>Unstable APIs</header>
+ *   <p>
+ *     All compiler apis are currently considered experimental and private!
+ *   </p>
+ *   <p>
+ *     We expect the APIs in this package to keep on changing. Do not rely on them.
+ *   </p>
+ * </div>
+ */
+
+import * as core from './core';
+
+export {core};
+
+export * from './version';
+export * from './template_parser/template_ast';
+export {CompilerConfig, preserveWhitespacesDefault} from './config';
+export * from './compile_metadata';
+export * from './aot/compiler_factory';
+export * from './aot/compiler';
+export * from './aot/generated_file';
+export * from './aot/compiler_options';
+export * from './aot/compiler_host';
+export * from './aot/static_reflector';
+export * from './aot/static_symbol';
+export * from './aot/static_symbol_resolver';
+export * from './aot/summary_resolver';
+export * from './ast_path';
+export * from './summary_resolver';
+export {Identifiers} from './identifiers';
+export {JitCompiler} from './jit/compiler';
+export * from './compile_reflector';
+export * from './url_resolver';
+export * from './resource_loader';
+export {DirectiveResolver} from './directive_resolver';
+export {PipeResolver} from './pipe_resolver';
+export {NgModuleResolver} from './ng_module_resolver';
+export {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from './ml_parser/interpolation_config';
+export * from './schema/element_schema_registry';
+export * from './i18n/index';
+export * from './directive_normalizer';
+export * from './expression_parser/ast';
+export * from './expression_parser/lexer';
+export * from './expression_parser/parser';
+export * from './metadata_resolver';
+export * from './ml_parser/ast';
+export * from './ml_parser/html_parser';
+export * from './ml_parser/html_tags';
+export * from './ml_parser/interpolation_config';
+export * from './ml_parser/tags';
+export {NgModuleCompiler} from './ng_module_compiler';
+export {AssertNotNull, BinaryOperator, BinaryOperatorExpr, BuiltinMethod, BuiltinVar, CastExpr, ClassStmt, CommaExpr, CommentStmt, ConditionalExpr, DeclareFunctionStmt, DeclareVarStmt, ExpressionStatement, ExpressionVisitor, ExternalExpr, ExternalReference, FunctionExpr, IfStmt, InstantiateExpr, InvokeFunctionExpr, InvokeMethodExpr, LiteralArrayExpr, LiteralExpr, LiteralMapExpr, NotExpr, ReadKeyExpr, ReadPropExpr, ReadVarExpr, ReturnStatement, StatementVisitor, ThrowStmt, TryCatchStmt, WriteKeyExpr, WritePropExpr, WriteVarExpr, StmtModifier, Statement} from './output/output_ast';
+export {EmitterVisitorContext} from './output/abstract_emitter';
+export * from './output/ts_emitter';
+export * from './parse_util';
+export * from './schema/dom_element_schema_registry';
+export * from './selector';
+export * from './style_compiler';
+export * from './template_parser/template_parser';
+export {ViewCompiler} from './view_compiler/view_compiler';
+export {getParseErrors, isSyntaxError, syntaxError, Version} from './util';
+// This file only reexports content of the `src` folder. Keep it that way.
diff --git a/angular/compiler/src/compiler_util/expression_converter.ts b/angular/compiler/src/compiler_util/expression_converter.ts
new file mode 100644
index 0000000..a5abc8a
--- /dev/null
+++ b/angular/compiler/src/compiler_util/expression_converter.ts
@@ -0,0 +1,622 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+import * as cdAst from '../expression_parser/ast';
+import {Identifiers} from '../identifiers';
+import * as o from '../output/output_ast';
+
+export class EventHandlerVars { static event = o.variable('$event'); }
+
+export interface LocalResolver { getLocal(name: string): o.Expression|null; }
+
+export class ConvertActionBindingResult {
+  constructor(public stmts: o.Statement[], public allowDefault: o.ReadVarExpr) {}
+}
+
+/**
+ * Converts the given expression AST into an executable output AST, assuming the expression is
+ * used in an action binding (e.g. an event handler).
+ */
+export function convertActionBinding(
+    localResolver: LocalResolver | null, implicitReceiver: o.Expression, action: cdAst.AST,
+    bindingId: string): ConvertActionBindingResult {
+  if (!localResolver) {
+    localResolver = new DefaultLocalResolver();
+  }
+  const actionWithoutBuiltins = convertPropertyBindingBuiltins(
+      {
+        createLiteralArrayConverter: (argCount: number) => {
+          // Note: no caching for literal arrays in actions.
+          return (args: o.Expression[]) => o.literalArr(args);
+        },
+        createLiteralMapConverter: (keys: {key: string, quoted: boolean}[]) => {
+          // Note: no caching for literal maps in actions.
+          return (values: o.Expression[]) => {
+            const entries = keys.map((k, i) => ({
+                                       key: k.key,
+                                       value: values[i],
+                                       quoted: k.quoted,
+                                     }));
+            return o.literalMap(entries);
+          };
+        },
+        createPipeConverter: (name: string) => {
+          throw new Error(`Illegal State: Actions are not allowed to contain pipes. Pipe: ${name}`);
+        }
+      },
+      action);
+
+  const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId);
+  const actionStmts: o.Statement[] = [];
+  flattenStatements(actionWithoutBuiltins.visit(visitor, _Mode.Statement), actionStmts);
+  prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts);
+  const lastIndex = actionStmts.length - 1;
+  let preventDefaultVar: o.ReadVarExpr = null !;
+  if (lastIndex >= 0) {
+    const lastStatement = actionStmts[lastIndex];
+    const returnExpr = convertStmtIntoExpression(lastStatement);
+    if (returnExpr) {
+      // Note: We need to cast the result of the method call to dynamic,
+      // as it might be a void method!
+      preventDefaultVar = createPreventDefaultVar(bindingId);
+      actionStmts[lastIndex] =
+          preventDefaultVar.set(returnExpr.cast(o.DYNAMIC_TYPE).notIdentical(o.literal(false)))
+              .toDeclStmt(null, [o.StmtModifier.Final]);
+    }
+  }
+  return new ConvertActionBindingResult(actionStmts, preventDefaultVar);
+}
+
+export interface BuiltinConverter { (args: o.Expression[]): o.Expression; }
+
+export interface BuiltinConverterFactory {
+  createLiteralArrayConverter(argCount: number): BuiltinConverter;
+  createLiteralMapConverter(keys: {key: string, quoted: boolean}[]): BuiltinConverter;
+  createPipeConverter(name: string, argCount: number): BuiltinConverter;
+}
+
+export function convertPropertyBindingBuiltins(
+    converterFactory: BuiltinConverterFactory, ast: cdAst.AST): cdAst.AST {
+  return convertBuiltins(converterFactory, ast);
+}
+
+export class ConvertPropertyBindingResult {
+  constructor(public stmts: o.Statement[], public currValExpr: o.Expression) {}
+}
+
+/**
+ * Converts the given expression AST into an executable output AST, assuming the expression
+ * is used in property binding. The expression has to be preprocessed via
+ * `convertPropertyBindingBuiltins`.
+ */
+export function convertPropertyBinding(
+    localResolver: LocalResolver | null, implicitReceiver: o.Expression,
+    expressionWithoutBuiltins: cdAst.AST, bindingId: string): ConvertPropertyBindingResult {
+  if (!localResolver) {
+    localResolver = new DefaultLocalResolver();
+  }
+  const currValExpr = createCurrValueExpr(bindingId);
+  const stmts: o.Statement[] = [];
+  const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId);
+  const outputExpr: o.Expression = expressionWithoutBuiltins.visit(visitor, _Mode.Expression);
+
+  if (visitor.temporaryCount) {
+    for (let i = 0; i < visitor.temporaryCount; i++) {
+      stmts.push(temporaryDeclaration(bindingId, i));
+    }
+  }
+
+  stmts.push(currValExpr.set(outputExpr).toDeclStmt(null, [o.StmtModifier.Final]));
+  return new ConvertPropertyBindingResult(stmts, currValExpr);
+}
+
+function convertBuiltins(converterFactory: BuiltinConverterFactory, ast: cdAst.AST): cdAst.AST {
+  const visitor = new _BuiltinAstConverter(converterFactory);
+  return ast.visit(visitor);
+}
+
+function temporaryName(bindingId: string, temporaryNumber: number): string {
+  return `tmp_${bindingId}_${temporaryNumber}`;
+}
+
+export function temporaryDeclaration(bindingId: string, temporaryNumber: number): o.Statement {
+  return new o.DeclareVarStmt(temporaryName(bindingId, temporaryNumber), o.NULL_EXPR);
+}
+
+function prependTemporaryDecls(
+    temporaryCount: number, bindingId: string, statements: o.Statement[]) {
+  for (let i = temporaryCount - 1; i >= 0; i--) {
+    statements.unshift(temporaryDeclaration(bindingId, i));
+  }
+}
+
+enum _Mode {
+  Statement,
+  Expression
+}
+
+function ensureStatementMode(mode: _Mode, ast: cdAst.AST) {
+  if (mode !== _Mode.Statement) {
+    throw new Error(`Expected a statement, but saw ${ast}`);
+  }
+}
+
+function ensureExpressionMode(mode: _Mode, ast: cdAst.AST) {
+  if (mode !== _Mode.Expression) {
+    throw new Error(`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 _BuiltinAstConverter extends cdAst.AstTransformer {
+  constructor(private _converterFactory: BuiltinConverterFactory) { super(); }
+  visitPipe(ast: cdAst.BindingPipe, context: any): any {
+    const args = [ast.exp, ...ast.args].map(ast => ast.visit(this, context));
+    return new BuiltinFunctionCall(
+        ast.span, args, this._converterFactory.createPipeConverter(ast.name, args.length));
+  }
+  visitLiteralArray(ast: cdAst.LiteralArray, context: any): any {
+    const args = ast.expressions.map(ast => ast.visit(this, context));
+    return new BuiltinFunctionCall(
+        ast.span, args, this._converterFactory.createLiteralArrayConverter(ast.expressions.length));
+  }
+  visitLiteralMap(ast: cdAst.LiteralMap, context: any): any {
+    const args = ast.values.map(ast => ast.visit(this, context));
+
+    return new BuiltinFunctionCall(
+        ast.span, args, this._converterFactory.createLiteralMapConverter(ast.keys));
+  }
+}
+
+class _AstToIrVisitor implements cdAst.AstVisitor {
+  private _nodeMap = new Map<cdAst.AST, cdAst.AST>();
+  private _resultMap = new Map<cdAst.AST, o.Expression>();
+  private _currentTemporary: number = 0;
+  public temporaryCount: number = 0;
+
+  constructor(
+      private _localResolver: LocalResolver, private _implicitReceiver: o.Expression,
+      private bindingId: string) {}
+
+  visitBinary(ast: cdAst.Binary, mode: _Mode): any {
+    let op: o.BinaryOperator;
+    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 Error(`Unsupported operation ${ast.operation}`);
+    }
+
+    return convertToStatementIfNeeded(
+        mode,
+        new o.BinaryOperatorExpr(
+            op, this._visit(ast.left, _Mode.Expression), this._visit(ast.right, _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 {
+    const value: o.Expression = this._visit(ast.condition, _Mode.Expression);
+    return convertToStatementIfNeeded(
+        mode, value.conditional(
+                  this._visit(ast.trueExp, _Mode.Expression),
+                  this._visit(ast.falseExp, _Mode.Expression)));
+  }
+
+  visitPipe(ast: cdAst.BindingPipe, mode: _Mode): any {
+    throw new Error(
+        `Illegal state: Pipes should have been converted into functions. Pipe: ${ast.name}`);
+  }
+
+  visitFunctionCall(ast: cdAst.FunctionCall, mode: _Mode): any {
+    const convertedArgs = this.visitAll(ast.args, _Mode.Expression);
+    let fnResult: o.Expression;
+    if (ast instanceof BuiltinFunctionCall) {
+      fnResult = ast.converter(convertedArgs);
+    } else {
+      fnResult = this._visit(ast.target !, _Mode.Expression).callFn(convertedArgs);
+    }
+    return convertToStatementIfNeeded(mode, fnResult);
+  }
+
+  visitImplicitReceiver(ast: cdAst.ImplicitReceiver, mode: _Mode): any {
+    ensureExpressionMode(mode, ast);
+    return this._implicitReceiver;
+  }
+
+  visitInterpolation(ast: cdAst.Interpolation, mode: _Mode): any {
+    ensureExpressionMode(mode, ast);
+    const args = [o.literal(ast.expressions.length)];
+    for (let i = 0; i < ast.strings.length - 1; i++) {
+      args.push(o.literal(ast.strings[i]));
+      args.push(this._visit(ast.expressions[i], _Mode.Expression));
+    }
+    args.push(o.literal(ast.strings[ast.strings.length - 1]));
+
+    return ast.expressions.length <= 9 ?
+        o.importExpr(Identifiers.inlineInterpolate).callFn(args) :
+        o.importExpr(Identifiers.interpolate).callFn([args[0], o.literalArr(args.slice(1))]);
+  }
+
+  visitKeyedRead(ast: cdAst.KeyedRead, mode: _Mode): any {
+    const leftMostSafe = this.leftMostSafeNode(ast);
+    if (leftMostSafe) {
+      return this.convertSafeAccess(ast, leftMostSafe, mode);
+    } else {
+      return convertToStatementIfNeeded(
+          mode, this._visit(ast.obj, _Mode.Expression).key(this._visit(ast.key, _Mode.Expression)));
+    }
+  }
+
+  visitKeyedWrite(ast: cdAst.KeyedWrite, mode: _Mode): any {
+    const obj: o.Expression = this._visit(ast.obj, _Mode.Expression);
+    const key: o.Expression = this._visit(ast.key, _Mode.Expression);
+    const value: o.Expression = this._visit(ast.value, _Mode.Expression);
+    return convertToStatementIfNeeded(mode, obj.key(key).set(value));
+  }
+
+  visitLiteralArray(ast: cdAst.LiteralArray, mode: _Mode): any {
+    throw new Error(`Illegal State: literal arrays should have been converted into functions`);
+  }
+
+  visitLiteralMap(ast: cdAst.LiteralMap, mode: _Mode): any {
+    throw new Error(`Illegal State: literal maps should have been converted into functions`);
+  }
+
+  visitLiteralPrimitive(ast: cdAst.LiteralPrimitive, mode: _Mode): any {
+    return convertToStatementIfNeeded(mode, o.literal(ast.value));
+  }
+
+  private _getLocal(name: string): o.Expression|null { return this._localResolver.getLocal(name); }
+
+  visitMethodCall(ast: cdAst.MethodCall, mode: _Mode): any {
+    const leftMostSafe = this.leftMostSafeNode(ast);
+    if (leftMostSafe) {
+      return this.convertSafeAccess(ast, leftMostSafe, mode);
+    } else {
+      const args = this.visitAll(ast.args, _Mode.Expression);
+      let result: any = null;
+      const receiver = this._visit(ast.receiver, _Mode.Expression);
+      if (receiver === this._implicitReceiver) {
+        const varExpr = this._getLocal(ast.name);
+        if (varExpr) {
+          result = varExpr.callFn(args);
+        }
+      }
+      if (result == null) {
+        result = receiver.callMethod(ast.name, args);
+      }
+      return convertToStatementIfNeeded(mode, result);
+    }
+  }
+
+  visitPrefixNot(ast: cdAst.PrefixNot, mode: _Mode): any {
+    return convertToStatementIfNeeded(mode, o.not(this._visit(ast.expression, _Mode.Expression)));
+  }
+
+  visitNonNullAssert(ast: cdAst.NonNullAssert, mode: _Mode): any {
+    return convertToStatementIfNeeded(
+        mode, o.assertNotNull(this._visit(ast.expression, _Mode.Expression)));
+  }
+
+  visitPropertyRead(ast: cdAst.PropertyRead, mode: _Mode): any {
+    const leftMostSafe = this.leftMostSafeNode(ast);
+    if (leftMostSafe) {
+      return this.convertSafeAccess(ast, leftMostSafe, mode);
+    } else {
+      let result: any = null;
+      const receiver = this._visit(ast.receiver, _Mode.Expression);
+      if (receiver === this._implicitReceiver) {
+        result = this._getLocal(ast.name);
+      }
+      if (result == null) {
+        result = receiver.prop(ast.name);
+      }
+      return convertToStatementIfNeeded(mode, result);
+    }
+  }
+
+  visitPropertyWrite(ast: cdAst.PropertyWrite, mode: _Mode): any {
+    const receiver: o.Expression = this._visit(ast.receiver, _Mode.Expression);
+    if (receiver === this._implicitReceiver) {
+      const varExpr = this._getLocal(ast.name);
+      if (varExpr) {
+        throw new Error('Cannot assign to a reference or variable!');
+      }
+    }
+    return convertToStatementIfNeeded(
+        mode, receiver.prop(ast.name).set(this._visit(ast.value, _Mode.Expression)));
+  }
+
+  visitSafePropertyRead(ast: cdAst.SafePropertyRead, mode: _Mode): any {
+    return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
+  }
+
+  visitSafeMethodCall(ast: cdAst.SafeMethodCall, mode: _Mode): any {
+    return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
+  }
+
+  visitAll(asts: cdAst.AST[], mode: _Mode): any { return asts.map(ast => this._visit(ast, mode)); }
+
+  visitQuote(ast: cdAst.Quote, mode: _Mode): any {
+    throw new Error(`Quotes are not supported for evaluation!
+        Statement: ${ast.uninterpretedExpression} located at ${ast.location}`);
+  }
+
+  private _visit(ast: cdAst.AST, mode: _Mode): any {
+    const result = this._resultMap.get(ast);
+    if (result) return result;
+    return (this._nodeMap.get(ast) || ast).visit(this, mode);
+  }
+
+  private convertSafeAccess(
+      ast: cdAst.AST, leftMostSafe: cdAst.SafeMethodCall|cdAst.SafePropertyRead, mode: _Mode): any {
+    // If the expression contains a safe access node on the left it needs to be converted to
+    // an expression that guards the access to the member by checking the receiver for blank. As
+    // execution proceeds from left to right, the left most part of the expression must be guarded
+    // first but, because member access is left associative, the right side of the expression is at
+    // the top of the AST. The desired result requires lifting a copy of the the left part of the
+    // expression up to test it for blank before generating the unguarded version.
+
+    // Consider, for example the following expression: a?.b.c?.d.e
+
+    // This results in the ast:
+    //         .
+    //        / \
+    //       ?.   e
+    //      /  \
+    //     .    d
+    //    / \
+    //   ?.  c
+    //  /  \
+    // a    b
+
+    // The following tree should be generated:
+    //
+    //        /---- ? ----\
+    //       /      |      \
+    //     a   /--- ? ---\  null
+    //        /     |     \
+    //       .      .     null
+    //      / \    / \
+    //     .  c   .   e
+    //    / \    / \
+    //   a   b  ,   d
+    //         / \
+    //        .   c
+    //       / \
+    //      a   b
+    //
+    // Notice that the first guard condition is the left hand of the left most safe access node
+    // which comes in as leftMostSafe to this routine.
+
+    let guardedExpression = this._visit(leftMostSafe.receiver, _Mode.Expression);
+    let temporary: o.ReadVarExpr = undefined !;
+    if (this.needsTemporary(leftMostSafe.receiver)) {
+      // If the expression has method calls or pipes then we need to save the result into a
+      // temporary variable to avoid calling stateful or impure code more than once.
+      temporary = this.allocateTemporary();
+
+      // Preserve the result in the temporary variable
+      guardedExpression = temporary.set(guardedExpression);
+
+      // Ensure all further references to the guarded expression refer to the temporary instead.
+      this._resultMap.set(leftMostSafe.receiver, temporary);
+    }
+    const condition = guardedExpression.isBlank();
+
+    // Convert the ast to an unguarded access to the receiver's member. The map will substitute
+    // leftMostNode with its unguarded version in the call to `this.visit()`.
+    if (leftMostSafe instanceof cdAst.SafeMethodCall) {
+      this._nodeMap.set(
+          leftMostSafe,
+          new cdAst.MethodCall(
+              leftMostSafe.span, leftMostSafe.receiver, leftMostSafe.name, leftMostSafe.args));
+    } else {
+      this._nodeMap.set(
+          leftMostSafe,
+          new cdAst.PropertyRead(leftMostSafe.span, leftMostSafe.receiver, leftMostSafe.name));
+    }
+
+    // Recursively convert the node now without the guarded member access.
+    const access = this._visit(ast, _Mode.Expression);
+
+    // Remove the mapping. This is not strictly required as the converter only traverses each node
+    // once but is safer if the conversion is changed to traverse the nodes more than once.
+    this._nodeMap.delete(leftMostSafe);
+
+    // If we allocated a temporary, release it.
+    if (temporary) {
+      this.releaseTemporary(temporary);
+    }
+
+    // Produce the conditional
+    return convertToStatementIfNeeded(mode, condition.conditional(o.literal(null), access));
+  }
+
+  // Given a expression of the form a?.b.c?.d.e the the left most safe node is
+  // the (a?.b). The . and ?. are left associative thus can be rewritten as:
+  // ((((a?.c).b).c)?.d).e. This returns the most deeply nested safe read or
+  // safe method call as this needs be transform initially to:
+  //   a == null ? null : a.c.b.c?.d.e
+  // then to:
+  //   a == null ? null : a.b.c == null ? null : a.b.c.d.e
+  private leftMostSafeNode(ast: cdAst.AST): cdAst.SafePropertyRead|cdAst.SafeMethodCall {
+    const visit = (visitor: cdAst.AstVisitor, ast: cdAst.AST): any => {
+      return (this._nodeMap.get(ast) || ast).visit(visitor);
+    };
+    return ast.visit({
+      visitBinary(ast: cdAst.Binary) { return null; },
+      visitChain(ast: cdAst.Chain) { return null; },
+      visitConditional(ast: cdAst.Conditional) { return null; },
+      visitFunctionCall(ast: cdAst.FunctionCall) { return null; },
+      visitImplicitReceiver(ast: cdAst.ImplicitReceiver) { return null; },
+      visitInterpolation(ast: cdAst.Interpolation) { return null; },
+      visitKeyedRead(ast: cdAst.KeyedRead) { return visit(this, ast.obj); },
+      visitKeyedWrite(ast: cdAst.KeyedWrite) { return null; },
+      visitLiteralArray(ast: cdAst.LiteralArray) { return null; },
+      visitLiteralMap(ast: cdAst.LiteralMap) { return null; },
+      visitLiteralPrimitive(ast: cdAst.LiteralPrimitive) { return null; },
+      visitMethodCall(ast: cdAst.MethodCall) { return visit(this, ast.receiver); },
+      visitPipe(ast: cdAst.BindingPipe) { return null; },
+      visitPrefixNot(ast: cdAst.PrefixNot) { return null; },
+      visitNonNullAssert(ast: cdAst.NonNullAssert) { return null; },
+      visitPropertyRead(ast: cdAst.PropertyRead) { return visit(this, ast.receiver); },
+      visitPropertyWrite(ast: cdAst.PropertyWrite) { return null; },
+      visitQuote(ast: cdAst.Quote) { return null; },
+      visitSafeMethodCall(ast: cdAst.SafeMethodCall) { return visit(this, ast.receiver) || ast; },
+      visitSafePropertyRead(ast: cdAst.SafePropertyRead) {
+        return visit(this, ast.receiver) || ast;
+      }
+    });
+  }
+
+  // Returns true of the AST includes a method or a pipe indicating that, if the
+  // expression is used as the target of a safe property or method access then
+  // the expression should be stored into a temporary variable.
+  private needsTemporary(ast: cdAst.AST): boolean {
+    const visit = (visitor: cdAst.AstVisitor, ast: cdAst.AST): boolean => {
+      return ast && (this._nodeMap.get(ast) || ast).visit(visitor);
+    };
+    const visitSome = (visitor: cdAst.AstVisitor, ast: cdAst.AST[]): boolean => {
+      return ast.some(ast => visit(visitor, ast));
+    };
+    return ast.visit({
+      visitBinary(ast: cdAst.Binary):
+          boolean{return visit(this, ast.left) || visit(this, ast.right);},
+      visitChain(ast: cdAst.Chain) { return false; },
+      visitConditional(ast: cdAst.Conditional):
+          boolean{return visit(this, ast.condition) || visit(this, ast.trueExp) ||
+                      visit(this, ast.falseExp);},
+      visitFunctionCall(ast: cdAst.FunctionCall) { return true; },
+      visitImplicitReceiver(ast: cdAst.ImplicitReceiver) { return false; },
+      visitInterpolation(ast: cdAst.Interpolation) { return visitSome(this, ast.expressions); },
+      visitKeyedRead(ast: cdAst.KeyedRead) { return false; },
+      visitKeyedWrite(ast: cdAst.KeyedWrite) { return false; },
+      visitLiteralArray(ast: cdAst.LiteralArray) { return true; },
+      visitLiteralMap(ast: cdAst.LiteralMap) { return true; },
+      visitLiteralPrimitive(ast: cdAst.LiteralPrimitive) { return false; },
+      visitMethodCall(ast: cdAst.MethodCall) { return true; },
+      visitPipe(ast: cdAst.BindingPipe) { return true; },
+      visitPrefixNot(ast: cdAst.PrefixNot) { return visit(this, ast.expression); },
+      visitNonNullAssert(ast: cdAst.PrefixNot) { return visit(this, ast.expression); },
+      visitPropertyRead(ast: cdAst.PropertyRead) { return false; },
+      visitPropertyWrite(ast: cdAst.PropertyWrite) { return false; },
+      visitQuote(ast: cdAst.Quote) { return false; },
+      visitSafeMethodCall(ast: cdAst.SafeMethodCall) { return true; },
+      visitSafePropertyRead(ast: cdAst.SafePropertyRead) { return false; }
+    });
+  }
+
+  private allocateTemporary(): o.ReadVarExpr {
+    const tempNumber = this._currentTemporary++;
+    this.temporaryCount = Math.max(this._currentTemporary, this.temporaryCount);
+    return new o.ReadVarExpr(temporaryName(this.bindingId, tempNumber));
+  }
+
+  private releaseTemporary(temporary: o.ReadVarExpr) {
+    this._currentTemporary--;
+    if (temporary.name != temporaryName(this.bindingId, this._currentTemporary)) {
+      throw new Error(`Temporary ${temporary.name} released out of order`);
+    }
+  }
+}
+
+function flattenStatements(arg: any, output: o.Statement[]) {
+  if (Array.isArray(arg)) {
+    (<any[]>arg).forEach((entry) => flattenStatements(entry, output));
+  } else {
+    output.push(arg);
+  }
+}
+
+class DefaultLocalResolver implements LocalResolver {
+  getLocal(name: string): o.Expression|null {
+    if (name === EventHandlerVars.event.name) {
+      return EventHandlerVars.event;
+    }
+    return null;
+  }
+}
+
+function createCurrValueExpr(bindingId: string): o.ReadVarExpr {
+  return o.variable(`currVal_${bindingId}`);  // fix syntax highlighting: `
+}
+
+function createPreventDefaultVar(bindingId: string): o.ReadVarExpr {
+  return o.variable(`pd_${bindingId}`);
+}
+
+function convertStmtIntoExpression(stmt: o.Statement): o.Expression|null {
+  if (stmt instanceof o.ExpressionStatement) {
+    return stmt.expr;
+  } else if (stmt instanceof o.ReturnStatement) {
+    return stmt.value;
+  }
+  return null;
+}
+
+class BuiltinFunctionCall extends cdAst.FunctionCall {
+  constructor(span: cdAst.ParseSpan, public args: cdAst.AST[], public converter: BuiltinConverter) {
+    super(span, null, args);
+  }
+}
diff --git a/angular/compiler/src/config.ts b/angular/compiler/src/config.ts
new file mode 100644
index 0000000..12bab10
--- /dev/null
+++ b/angular/compiler/src/config.ts
@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileIdentifierMetadata} from './compile_metadata';
+import {MissingTranslationStrategy, ViewEncapsulation} from './core';
+import {Identifiers} from './identifiers';
+import * as o from './output/output_ast';
+import {noUndefined} from './util';
+
+export class CompilerConfig {
+  public defaultEncapsulation: ViewEncapsulation|null;
+  // Whether to support the `<template>` tag and the `template` attribute to define angular
+  // templates. They have been deprecated in 4.x, `<ng-template>` should be used instead.
+  public enableLegacyTemplate: boolean;
+  public useJit: boolean;
+  public jitDevMode: boolean;
+  public missingTranslation: MissingTranslationStrategy|null;
+  public preserveWhitespaces: boolean;
+
+  constructor(
+      {defaultEncapsulation = ViewEncapsulation.Emulated, useJit = true, jitDevMode = false,
+       missingTranslation, enableLegacyTemplate, preserveWhitespaces}: {
+        defaultEncapsulation?: ViewEncapsulation,
+        useJit?: boolean,
+        jitDevMode?: boolean,
+        missingTranslation?: MissingTranslationStrategy,
+        enableLegacyTemplate?: boolean,
+        preserveWhitespaces?: boolean
+      } = {}) {
+    this.defaultEncapsulation = defaultEncapsulation;
+    this.useJit = !!useJit;
+    this.jitDevMode = !!jitDevMode;
+    this.missingTranslation = missingTranslation || null;
+    this.enableLegacyTemplate = enableLegacyTemplate !== false;
+    this.preserveWhitespaces = preserveWhitespacesDefault(noUndefined(preserveWhitespaces));
+  }
+}
+
+export function preserveWhitespacesDefault(
+    preserveWhitespacesOption: boolean | null, defaultSetting = true): boolean {
+  return preserveWhitespacesOption === null ? defaultSetting : preserveWhitespacesOption;
+}
diff --git a/angular/compiler/src/core.ts b/angular/compiler/src/core.ts
new file mode 100644
index 0000000..032bead
--- /dev/null
+++ b/angular/compiler/src/core.ts
@@ -0,0 +1,262 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+// Attention:
+// This file duplicates types and values from @angular/core
+// so that we are able to make @angular/compiler independent of @angular/core.
+// This is important to prevent a build cycle, as @angular/core needs to
+// be compiled with the compiler.
+
+export interface Inject { token: any; }
+export const createInject = makeMetadataFactory<Inject>('Inject', (token: any) => ({token}));
+export const createInjectionToken =
+    makeMetadataFactory<object>('InjectionToken', (token: any) => token);
+
+export interface Attribute { attributeName?: string; }
+export const createAttribute =
+    makeMetadataFactory<Attribute>('Attribute', (attributeName?: string) => ({attributeName}));
+
+export interface Query {
+  descendants: boolean;
+  first: boolean;
+  read: any;
+  isViewQuery: boolean;
+  selector: any;
+}
+
+export const createContentChildren = makeMetadataFactory<Query>(
+    'ContentChildren',
+    (selector?: any, data: any = {}) =>
+        ({selector, first: false, isViewQuery: false, descendants: false, ...data}));
+export const createContentChild = makeMetadataFactory<Query>(
+    'ContentChild', (selector?: any, data: any = {}) =>
+                        ({selector, first: true, isViewQuery: false, descendants: true, ...data}));
+export const createViewChildren = makeMetadataFactory<Query>(
+    'ViewChildren', (selector?: any, data: any = {}) =>
+                        ({selector, first: false, isViewQuery: true, descendants: true, ...data}));
+export const createViewChild = makeMetadataFactory<Query>(
+    'ViewChild', (selector: any, data: any) =>
+                     ({selector, first: true, isViewQuery: true, descendants: true, ...data}));
+
+export interface Directive {
+  selector?: string;
+  inputs?: string[];
+  outputs?: string[];
+  host?: {[key: string]: string};
+  providers?: Provider[];
+  exportAs?: string;
+  queries?: {[key: string]: any};
+}
+export const createDirective =
+    makeMetadataFactory<Directive>('Directive', (dir: Directive = {}) => dir);
+
+export interface Component extends Directive {
+  changeDetection?: ChangeDetectionStrategy;
+  viewProviders?: Provider[];
+  moduleId?: string;
+  templateUrl?: string;
+  template?: string;
+  styleUrls?: string[];
+  styles?: string[];
+  animations?: any[];
+  encapsulation?: ViewEncapsulation;
+  interpolation?: [string, string];
+  entryComponents?: Array<Type|any[]>;
+  preserveWhitespaces?: boolean;
+}
+export enum ViewEncapsulation {
+  Emulated = 0,
+  Native = 1,
+  None = 2
+}
+
+export enum ChangeDetectionStrategy {
+  OnPush = 0,
+  Default = 1
+}
+
+export const createComponent = makeMetadataFactory<Component>(
+    'Component', (c: Component = {}) => ({changeDetection: ChangeDetectionStrategy.Default, ...c}));
+
+export interface Pipe {
+  name: string;
+  pure?: boolean;
+}
+export const createPipe = makeMetadataFactory<Pipe>('Pipe', (p: Pipe) => ({pure: true, ...p}));
+
+export interface Input { bindingPropertyName?: string; }
+export const createInput =
+    makeMetadataFactory<Input>('Input', (bindingPropertyName?: string) => ({bindingPropertyName}));
+
+export interface Output { bindingPropertyName?: string; }
+export const createOutput = makeMetadataFactory<Output>(
+    'Output', (bindingPropertyName?: string) => ({bindingPropertyName}));
+
+export interface HostBinding { hostPropertyName?: string; }
+export const createHostBinding = makeMetadataFactory<HostBinding>(
+    'HostBinding', (hostPropertyName?: string) => ({hostPropertyName}));
+
+export interface HostListener {
+  eventName?: string;
+  args?: string[];
+}
+export const createHostListener = makeMetadataFactory<HostListener>(
+    'HostListener', (eventName?: string, args?: string[]) => ({eventName, args}));
+
+export interface NgModule {
+  providers?: Provider[];
+  declarations?: Array<Type|any[]>;
+  imports?: Array<Type|ModuleWithProviders|any[]>;
+  exports?: Array<Type|any[]>;
+  entryComponents?: Array<Type|any[]>;
+  bootstrap?: Array<Type|any[]>;
+  schemas?: Array<SchemaMetadata|any[]>;
+  id?: string;
+}
+export const createNgModule =
+    makeMetadataFactory<NgModule>('NgModule', (ngModule: NgModule) => ngModule);
+
+export interface ModuleWithProviders {
+  ngModule: Type;
+  providers?: Provider[];
+}
+
+export interface SchemaMetadata { name: string; }
+
+export const CUSTOM_ELEMENTS_SCHEMA: SchemaMetadata = {
+  name: 'custom-elements'
+};
+
+export const NO_ERRORS_SCHEMA: SchemaMetadata = {
+  name: 'no-errors-schema'
+};
+
+export const createOptional = makeMetadataFactory('Optional');
+export const createInjectable = makeMetadataFactory('Injectable');
+export const createSelf = makeMetadataFactory('Self');
+export const createSkipSelf = makeMetadataFactory('SkipSelf');
+export const createHost = makeMetadataFactory('Host');
+
+export interface Type extends Function { new (...args: any[]): any; }
+export const Type = Function;
+
+export enum SecurityContext {
+  NONE = 0,
+  HTML = 1,
+  STYLE = 2,
+  SCRIPT = 3,
+  URL = 4,
+  RESOURCE_URL = 5,
+}
+
+export type Provider = any;
+
+export const enum NodeFlags {
+  None = 0,
+  TypeElement = 1 << 0,
+  TypeText = 1 << 1,
+  ProjectedTemplate = 1 << 2,
+  CatRenderNode = TypeElement | TypeText,
+  TypeNgContent = 1 << 3,
+  TypePipe = 1 << 4,
+  TypePureArray = 1 << 5,
+  TypePureObject = 1 << 6,
+  TypePurePipe = 1 << 7,
+  CatPureExpression = TypePureArray | TypePureObject | TypePurePipe,
+  TypeValueProvider = 1 << 8,
+  TypeClassProvider = 1 << 9,
+  TypeFactoryProvider = 1 << 10,
+  TypeUseExistingProvider = 1 << 11,
+  LazyProvider = 1 << 12,
+  PrivateProvider = 1 << 13,
+  TypeDirective = 1 << 14,
+  Component = 1 << 15,
+  CatProviderNoDirective =
+      TypeValueProvider | TypeClassProvider | TypeFactoryProvider | TypeUseExistingProvider,
+  CatProvider = CatProviderNoDirective | TypeDirective,
+  OnInit = 1 << 16,
+  OnDestroy = 1 << 17,
+  DoCheck = 1 << 18,
+  OnChanges = 1 << 19,
+  AfterContentInit = 1 << 20,
+  AfterContentChecked = 1 << 21,
+  AfterViewInit = 1 << 22,
+  AfterViewChecked = 1 << 23,
+  EmbeddedViews = 1 << 24,
+  ComponentView = 1 << 25,
+  TypeContentQuery = 1 << 26,
+  TypeViewQuery = 1 << 27,
+  StaticQuery = 1 << 28,
+  DynamicQuery = 1 << 29,
+  CatQuery = TypeContentQuery | TypeViewQuery,
+
+  // mutually exclusive values...
+  Types = CatRenderNode | TypeNgContent | TypePipe | CatPureExpression | CatProvider | CatQuery
+}
+
+export const enum DepFlags {
+  None = 0,
+  SkipSelf = 1 << 0,
+  Optional = 1 << 1,
+  Value = 2 << 2,
+}
+
+export const enum ArgumentType {Inline = 0, Dynamic = 1}
+
+export const enum BindingFlags {
+  TypeElementAttribute = 1 << 0,
+  TypeElementClass = 1 << 1,
+  TypeElementStyle = 1 << 2,
+  TypeProperty = 1 << 3,
+  SyntheticProperty = 1 << 4,
+  SyntheticHostProperty = 1 << 5,
+  CatSyntheticProperty = SyntheticProperty | SyntheticHostProperty,
+
+  // mutually exclusive values...
+  Types = TypeElementAttribute | TypeElementClass | TypeElementStyle | TypeProperty
+}
+
+export const enum QueryBindingType {First = 0, All = 1}
+
+export const enum QueryValueType {
+  ElementRef = 0,
+  RenderElement = 1,
+  TemplateRef = 2,
+  ViewContainerRef = 3,
+  Provider = 4
+}
+
+export const enum ViewFlags {
+  None = 0,
+  OnPush = 1 << 1,
+}
+
+export enum MissingTranslationStrategy {
+  Error = 0,
+  Warning = 1,
+  Ignore = 2,
+}
+
+export interface MetadataFactory<T> {
+  (...args: any[]): T;
+  isTypeOf(obj: any): obj is T;
+  ngMetadataName: string;
+}
+
+function makeMetadataFactory<T>(name: string, props?: (...args: any[]) => T): MetadataFactory<T> {
+  const factory: any = (...args: any[]) => {
+    const values = props ? props(...args) : {};
+    return {
+      ngMetadataName: name,
+      ...values,
+    };
+  };
+  factory.isTypeOf = (obj: any) => obj && obj.ngMetadataName === name;
+  factory.ngMetadataName = name;
+  return factory;
+}
diff --git a/angular/compiler/src/css_parser/css_ast.ts b/angular/compiler/src/css_parser/css_ast.ts
new file mode 100644
index 0000000..b217b08
--- /dev/null
+++ b/angular/compiler/src/css_parser/css_ast.ts
@@ -0,0 +1,248 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ParseLocation, ParseSourceSpan} from '../parse_util';
+
+import {CssToken, CssTokenType} from './css_lexer';
+
+export enum BlockType {
+  Import,
+  Charset,
+  Namespace,
+  Supports,
+  Keyframes,
+  MediaQuery,
+  Selector,
+  FontFace,
+  Page,
+  Document,
+  Viewport,
+  Unsupported
+}
+
+export interface CssAstVisitor {
+  visitCssValue(ast: CssStyleValueAst, context?: any): any;
+  visitCssInlineRule(ast: CssInlineRuleAst, context?: any): any;
+  visitCssAtRulePredicate(ast: CssAtRulePredicateAst, context?: any): any;
+  visitCssKeyframeRule(ast: CssKeyframeRuleAst, context?: any): any;
+  visitCssKeyframeDefinition(ast: CssKeyframeDefinitionAst, context?: any): any;
+  visitCssMediaQueryRule(ast: CssMediaQueryRuleAst, context?: any): any;
+  visitCssSelectorRule(ast: CssSelectorRuleAst, context?: any): any;
+  visitCssSelector(ast: CssSelectorAst, context?: any): any;
+  visitCssSimpleSelector(ast: CssSimpleSelectorAst, context?: any): any;
+  visitCssPseudoSelector(ast: CssPseudoSelectorAst, context?: any): any;
+  visitCssDefinition(ast: CssDefinitionAst, context?: any): any;
+  visitCssBlock(ast: CssBlockAst, context?: any): any;
+  visitCssStylesBlock(ast: CssStylesBlockAst, context?: any): any;
+  visitCssStyleSheet(ast: CssStyleSheetAst, context?: any): any;
+  visitCssUnknownRule(ast: CssUnknownRuleAst, context?: any): any;
+  visitCssUnknownTokenList(ast: CssUnknownTokenListAst, context?: any): any;
+}
+
+export abstract class CssAst {
+  constructor(public location: ParseSourceSpan) {}
+  get start(): ParseLocation { return this.location.start; }
+  get end(): ParseLocation { return this.location.end; }
+  abstract visit(visitor: CssAstVisitor, context?: any): any;
+}
+
+export class CssStyleValueAst extends CssAst {
+  constructor(location: ParseSourceSpan, public tokens: CssToken[], public strValue: string) {
+    super(location);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any { return visitor.visitCssValue(this); }
+}
+
+export abstract class CssRuleAst extends CssAst {
+  constructor(location: ParseSourceSpan) { super(location); }
+}
+
+export class CssBlockRuleAst extends CssRuleAst {
+  constructor(
+      public location: ParseSourceSpan, public type: BlockType, public block: CssBlockAst,
+      public name: CssToken|null = null) {
+    super(location);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssBlock(this.block, context);
+  }
+}
+
+export class CssKeyframeRuleAst extends CssBlockRuleAst {
+  constructor(location: ParseSourceSpan, name: CssToken, block: CssBlockAst) {
+    super(location, BlockType.Keyframes, block, name);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssKeyframeRule(this, context);
+  }
+}
+
+export class CssKeyframeDefinitionAst extends CssBlockRuleAst {
+  constructor(location: ParseSourceSpan, public steps: CssToken[], block: CssBlockAst) {
+    super(location, BlockType.Keyframes, block, mergeTokens(steps, ','));
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssKeyframeDefinition(this, context);
+  }
+}
+
+export class CssBlockDefinitionRuleAst extends CssBlockRuleAst {
+  constructor(
+      location: ParseSourceSpan, public strValue: string, type: BlockType,
+      public query: CssAtRulePredicateAst, block: CssBlockAst) {
+    super(location, type, block);
+    const firstCssToken: CssToken = query.tokens[0];
+    this.name = new CssToken(
+        firstCssToken.index, firstCssToken.column, firstCssToken.line, CssTokenType.Identifier,
+        this.strValue);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssBlock(this.block, context);
+  }
+}
+
+export class CssMediaQueryRuleAst extends CssBlockDefinitionRuleAst {
+  constructor(
+      location: ParseSourceSpan, strValue: string, query: CssAtRulePredicateAst,
+      block: CssBlockAst) {
+    super(location, strValue, BlockType.MediaQuery, query, block);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssMediaQueryRule(this, context);
+  }
+}
+
+export class CssAtRulePredicateAst extends CssAst {
+  constructor(location: ParseSourceSpan, public strValue: string, public tokens: CssToken[]) {
+    super(location);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssAtRulePredicate(this, context);
+  }
+}
+
+export class CssInlineRuleAst extends CssRuleAst {
+  constructor(location: ParseSourceSpan, public type: BlockType, public value: CssStyleValueAst) {
+    super(location);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssInlineRule(this, context);
+  }
+}
+
+export class CssSelectorRuleAst extends CssBlockRuleAst {
+  public strValue: string;
+
+  constructor(location: ParseSourceSpan, public selectors: CssSelectorAst[], block: CssBlockAst) {
+    super(location, BlockType.Selector, block);
+    this.strValue = selectors.map(selector => selector.strValue).join(',');
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssSelectorRule(this, context);
+  }
+}
+
+export class CssDefinitionAst extends CssAst {
+  constructor(
+      location: ParseSourceSpan, public property: CssToken, public value: CssStyleValueAst) {
+    super(location);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssDefinition(this, context);
+  }
+}
+
+export abstract class CssSelectorPartAst extends CssAst {
+  constructor(location: ParseSourceSpan) { super(location); }
+}
+
+export class CssSelectorAst extends CssSelectorPartAst {
+  public strValue: string;
+  constructor(location: ParseSourceSpan, public selectorParts: CssSimpleSelectorAst[]) {
+    super(location);
+    this.strValue = selectorParts.map(part => part.strValue).join('');
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssSelector(this, context);
+  }
+}
+
+export class CssSimpleSelectorAst extends CssSelectorPartAst {
+  constructor(
+      location: ParseSourceSpan, public tokens: CssToken[], public strValue: string,
+      public pseudoSelectors: CssPseudoSelectorAst[], public operator: CssToken) {
+    super(location);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssSimpleSelector(this, context);
+  }
+}
+
+export class CssPseudoSelectorAst extends CssSelectorPartAst {
+  constructor(
+      location: ParseSourceSpan, public strValue: string, public name: string,
+      public tokens: CssToken[], public innerSelectors: CssSelectorAst[]) {
+    super(location);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssPseudoSelector(this, context);
+  }
+}
+
+export class CssBlockAst extends CssAst {
+  constructor(location: ParseSourceSpan, public entries: CssAst[]) { super(location); }
+  visit(visitor: CssAstVisitor, context?: any): any { return visitor.visitCssBlock(this, context); }
+}
+
+/*
+ a style block is different from a standard block because it contains
+ css prop:value definitions. A regular block can contain a list of Ast entries.
+ */
+export class CssStylesBlockAst extends CssBlockAst {
+  constructor(location: ParseSourceSpan, public definitions: CssDefinitionAst[]) {
+    super(location, definitions);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssStylesBlock(this, context);
+  }
+}
+
+export class CssStyleSheetAst extends CssAst {
+  constructor(location: ParseSourceSpan, public rules: CssAst[]) { super(location); }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssStyleSheet(this, context);
+  }
+}
+
+export class CssUnknownRuleAst extends CssRuleAst {
+  constructor(location: ParseSourceSpan, public ruleName: string, public tokens: CssToken[]) {
+    super(location);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssUnknownRule(this, context);
+  }
+}
+
+export class CssUnknownTokenListAst extends CssRuleAst {
+  constructor(location: ParseSourceSpan, public name: string, public tokens: CssToken[]) {
+    super(location);
+  }
+  visit(visitor: CssAstVisitor, context?: any): any {
+    return visitor.visitCssUnknownTokenList(this, context);
+  }
+}
+
+export function mergeTokens(tokens: CssToken[], separator: string = ''): CssToken {
+  const mainToken = tokens[0];
+  let str = mainToken.strValue;
+  for (let i = 1; i < tokens.length; i++) {
+    str += separator + tokens[i].strValue;
+  }
+
+  return new CssToken(mainToken.index, mainToken.column, mainToken.line, mainToken.type, str);
+}
diff --git a/angular/compiler/src/css_parser/css_lexer.ts b/angular/compiler/src/css_parser/css_lexer.ts
new file mode 100644
index 0000000..49d84da
--- /dev/null
+++ b/angular/compiler/src/css_parser/css_lexer.ts
@@ -0,0 +1,721 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+import * as chars from '../chars';
+
+export enum CssTokenType {
+  EOF,
+  String,
+  Comment,
+  Identifier,
+  Number,
+  IdentifierOrNumber,
+  AtKeyword,
+  Character,
+  Whitespace,
+  Invalid
+}
+
+export enum CssLexerMode {
+  ALL,
+  ALL_TRACK_WS,
+  SELECTOR,
+  PSEUDO_SELECTOR,
+  PSEUDO_SELECTOR_WITH_ARGUMENTS,
+  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: Error|null, 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 {
+  let endOfProblemLine = index;
+  let current = charCode(input, index);
+  while (current > 0 && !isNewline(current)) {
+    current = charCode(input, ++endOfProblemLine);
+  }
+  const choppedString = input.substring(0, endOfProblemLine);
+  let pointerPadding = '';
+  for (let i = 0; i < column; i++) {
+    pointerPadding += ' ';
+  }
+  let pointerString = '';
+  for (let 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 function cssScannerError(token: CssToken, message: string): Error {
+  const error = Error('CssParseError: ' + message);
+  (error as any)[ERROR_RAW_MESSAGE] = message;
+  (error as any)[ERROR_TOKEN] = token;
+  return error;
+}
+
+const ERROR_TOKEN = 'ngToken';
+const ERROR_RAW_MESSAGE = 'ngRawMessage';
+
+export function getRawMessage(error: Error): string {
+  return (error as any)[ERROR_RAW_MESSAGE];
+}
+
+export function getToken(error: Error): CssToken {
+  return (error as any)[ERROR_TOKEN];
+}
+
+function _trackWhitespace(mode: CssLexerMode) {
+  switch (mode) {
+    case CssLexerMode.SELECTOR:
+    case CssLexerMode.PSEUDO_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: Error|null = 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) && !_trackWhitespace(mode)) {
+        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 ? chars.$EOF : this.input.charCodeAt(index);
+  }
+
+  consumeEmptyStatements(): void {
+    this.consumeWhitespace();
+    while (this.peek == chars.$SEMICOLON) {
+      this.advance();
+      this.consumeWhitespace();
+    }
+  }
+
+  consumeWhitespace(): void {
+    while (chars.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 == chars.$EOF) {
+            this.error('Unterminated comment');
+          }
+          this.advance();
+        }
+        this.advance();  // *
+        this.advance();  // /
+      }
+    }
+  }
+
+  consume(type: CssTokenType, value: string|null = null): LexedCssResult {
+    const mode = this._currentMode;
+
+    this.setMode(_trackWhitespace(mode) ? CssLexerMode.ALL_TRACK_WS : CssLexerMode.ALL);
+
+    const previousIndex = this.index;
+    const previousLine = this.line;
+    const previousColumn = this.column;
+
+    let next: CssToken = undefined !;
+    const output = this.scan();
+    if (output != null) {
+      // just incase the inner scan method returned an error
+      if (output.error != null) {
+        this.setMode(mode);
+        return output;
+      }
+
+      next = output.token;
+    }
+
+    if (next == null) {
+      next = new CssToken(this.index, this.column, this.line, CssTokenType.EOF, 'end of file');
+    }
+
+    let isMatchingType: boolean = false;
+    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);
+
+    let error: Error|null = null;
+    if (!isMatchingType || (value != null && value != next.strValue)) {
+      let errorMessage =
+          CssTokenType[next.type] + ' does not match expected ' + CssTokenType[type] + ' value';
+
+      if (value != null) {
+        errorMessage += ' ("' + next.strValue + '" should match "' + value + '")';
+      }
+
+      error = cssScannerError(
+          next, generateErrorMessage(
+                    this.input, errorMessage, next.strValue, previousIndex, previousLine,
+                    previousColumn));
+    }
+
+    return new LexedCssResult(error, next);
+  }
+
+
+  scan(): LexedCssResult|null {
+    const trackWS = _trackWhitespace(this._currentMode);
+    if (this.index == 0 && !trackWS) {  // first scan
+      this.consumeWhitespace();
+    }
+
+    const token = this._scan();
+    if (token == null) return null;
+
+    const error = this._currentError !;
+    this._currentError = null;
+
+    if (!trackWS) {
+      this.consumeWhitespace();
+    }
+    return new LexedCssResult(error, token);
+  }
+
+  /** @internal */
+  _scan(): CssToken|null {
+    let peek = this.peek;
+    let peekPeek = this.peekPeek;
+    if (peek == chars.$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
+      const commentToken = this.scanComment();
+      if (this._trackComments) {
+        return commentToken;
+      }
+    }
+
+    if (_trackWhitespace(this._currentMode) && (chars.isWhitespace(peek) || isNewline(peek))) {
+      return this.scanWhitespace();
+    }
+
+    peek = this.peek;
+    peekPeek = this.peekPeek;
+    if (peek == chars.$EOF) return null;
+
+    if (isStringStart(peek, peekPeek)) {
+      return this.scanString();
+    }
+
+    // something like url(cool)
+    if (this._currentMode == CssLexerMode.STYLE_VALUE_FUNCTION) {
+      return this.scanCssValueFunction();
+    }
+
+    const isModifier = peek == chars.$PLUS || peek == chars.$MINUS;
+    const digitA = isModifier ? false : chars.isDigit(peek);
+    const digitB = chars.isDigit(peekPeek);
+    if (digitA || (isModifier && (peekPeek == chars.$PERIOD || digitB)) ||
+        (peek == chars.$PERIOD && digitB)) {
+      return this.scanNumber();
+    }
+
+    if (peek == chars.$AT) {
+      return this.scanAtExpression();
+    }
+
+    if (isIdentifierStart(peek, peekPeek)) {
+      return this.scanIdentifier();
+    }
+
+    if (isValidCssCharacter(peek, this._currentMode)) {
+      return this.scanCharacter();
+    }
+
+    return this.error(`Unexpected character [${String.fromCharCode(peek)}]`);
+  }
+
+  scanComment(): CssToken|null {
+    if (this.assertCondition(
+            isCommentStart(this.peek, this.peekPeek), 'Expected comment start value')) {
+      return null;
+    }
+
+    const start = this.index;
+    const startingColumn = this.column;
+    const startingLine = this.line;
+
+    this.advance();  // /
+    this.advance();  // *
+
+    while (!isCommentEnd(this.peek, this.peekPeek)) {
+      if (this.peek == chars.$EOF) {
+        this.error('Unterminated comment');
+      }
+      this.advance();
+    }
+
+    this.advance();  // *
+    this.advance();  // /
+
+    const str = this.input.substring(start, this.index);
+    return new CssToken(start, startingColumn, startingLine, CssTokenType.Comment, str);
+  }
+
+  scanWhitespace(): CssToken {
+    const start = this.index;
+    const startingColumn = this.column;
+    const startingLine = this.line;
+    while (chars.isWhitespace(this.peek) && this.peek != chars.$EOF) {
+      this.advance();
+    }
+    const str = this.input.substring(start, this.index);
+    return new CssToken(start, startingColumn, startingLine, CssTokenType.Whitespace, str);
+  }
+
+  scanString(): CssToken|null {
+    if (this.assertCondition(
+            isStringStart(this.peek, this.peekPeek), 'Unexpected non-string starting value')) {
+      return null;
+    }
+
+    const target = this.peek;
+    const start = this.index;
+    const startingColumn = this.column;
+    const startingLine = this.line;
+    let previous = target;
+    this.advance();
+
+    while (!isCharMatch(target, previous, this.peek)) {
+      if (this.peek == chars.$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();
+
+    const str = this.input.substring(start, this.index);
+    return new CssToken(start, startingColumn, startingLine, CssTokenType.String, str);
+  }
+
+  scanNumber(): CssToken {
+    const start = this.index;
+    const startingColumn = this.column;
+    if (this.peek == chars.$PLUS || this.peek == chars.$MINUS) {
+      this.advance();
+    }
+    let periodUsed = false;
+    while (chars.isDigit(this.peek) || this.peek == chars.$PERIOD) {
+      if (this.peek == chars.$PERIOD) {
+        if (periodUsed) {
+          this.error('Unexpected use of a second period value');
+        }
+        periodUsed = true;
+      }
+      this.advance();
+    }
+    const strValue = this.input.substring(start, this.index);
+    return new CssToken(start, startingColumn, this.line, CssTokenType.Number, strValue);
+  }
+
+  scanIdentifier(): CssToken|null {
+    if (this.assertCondition(
+            isIdentifierStart(this.peek, this.peekPeek), 'Expected identifier starting value')) {
+      return null;
+    }
+
+    const start = this.index;
+    const startingColumn = this.column;
+    while (isIdentifierPart(this.peek)) {
+      this.advance();
+    }
+    const strValue = this.input.substring(start, this.index);
+    return new CssToken(start, startingColumn, this.line, CssTokenType.Identifier, strValue);
+  }
+
+  scanCssValueFunction(): CssToken {
+    const start = this.index;
+    const startingColumn = this.column;
+    let parenBalance = 1;
+    while (this.peek != chars.$EOF && parenBalance > 0) {
+      this.advance();
+      if (this.peek == chars.$LPAREN) {
+        parenBalance++;
+      } else if (this.peek == chars.$RPAREN) {
+        parenBalance--;
+      }
+    }
+    const strValue = this.input.substring(start, this.index);
+    return new CssToken(start, startingColumn, this.line, CssTokenType.Identifier, strValue);
+  }
+
+  scanCharacter(): CssToken|null {
+    const start = this.index;
+    const startingColumn = this.column;
+    if (this.assertCondition(
+            isValidCssCharacter(this.peek, this._currentMode),
+            charStr(this.peek) + ' is not a valid CSS character')) {
+      return null;
+    }
+
+    const c = this.input.substring(start, start + 1);
+    this.advance();
+
+    return new CssToken(start, startingColumn, this.line, CssTokenType.Character, c);
+  }
+
+  scanAtExpression(): CssToken|null {
+    if (this.assertCondition(this.peek == chars.$AT, 'Expected @ value')) {
+      return null;
+    }
+
+    const start = this.index;
+    const startingColumn = this.column;
+    this.advance();
+    if (isIdentifierStart(this.peek, this.peekPeek)) {
+      const ident = this.scanIdentifier() !;
+      const 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 = null, doNotAdvance: boolean = false):
+      CssToken {
+    const index: number = this.index;
+    const column: number = this.column;
+    const line: number = this.line;
+    errorTokenValue = errorTokenValue || String.fromCharCode(this.peek);
+    const invalidToken = new CssToken(index, column, line, CssTokenType.Invalid, errorTokenValue);
+    const errorMessage =
+        generateErrorMessage(this.input, message, errorTokenValue, index, line, column);
+    if (!doNotAdvance) {
+      this.advance();
+    }
+    this._currentError = cssScannerError(invalidToken, errorMessage);
+    return invalidToken;
+  }
+}
+
+function isCharMatch(target: number, previous: number, code: number): boolean {
+  return code == target && previous != chars.$BACKSLASH;
+}
+
+function isCommentStart(code: number, next: number): boolean {
+  return code == chars.$SLASH && next == chars.$STAR;
+}
+
+function isCommentEnd(code: number, next: number): boolean {
+  return code == chars.$STAR && next == chars.$SLASH;
+}
+
+function isStringStart(code: number, next: number): boolean {
+  let target = code;
+  if (target == chars.$BACKSLASH) {
+    target = next;
+  }
+  return target == chars.$DQ || target == chars.$SQ;
+}
+
+function isIdentifierStart(code: number, next: number): boolean {
+  let target = code;
+  if (target == chars.$MINUS) {
+    target = next;
+  }
+
+  return chars.isAsciiLetter(target) || target == chars.$BACKSLASH || target == chars.$MINUS ||
+      target == chars.$_;
+}
+
+function isIdentifierPart(target: number): boolean {
+  return chars.isAsciiLetter(target) || target == chars.$BACKSLASH || target == chars.$MINUS ||
+      target == chars.$_ || chars.isDigit(target);
+}
+
+function isValidPseudoSelectorCharacter(code: number): boolean {
+  switch (code) {
+    case chars.$LPAREN:
+    case chars.$RPAREN:
+      return true;
+    default:
+      return false;
+  }
+}
+
+function isValidKeyframeBlockCharacter(code: number): boolean {
+  return code == chars.$PERCENT;
+}
+
+function isValidAttributeSelectorCharacter(code: number): boolean {
+  // value^*|$~=something
+  switch (code) {
+    case chars.$$:
+    case chars.$PIPE:
+    case chars.$CARET:
+    case chars.$TILDA:
+    case chars.$STAR:
+    case chars.$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 chars.$HASH:
+    case chars.$PERIOD:
+    case chars.$TILDA:
+    case chars.$STAR:
+    case chars.$PLUS:
+    case chars.$GT:
+    case chars.$COLON:
+    case chars.$PIPE:
+    case chars.$COMMA:
+    case chars.$LBRACKET:
+    case chars.$RBRACKET:
+      return true;
+    default:
+      return false;
+  }
+}
+
+function isValidStyleBlockCharacter(code: number): boolean {
+  // key:value;
+  // key:calc(something ... )
+  switch (code) {
+    case chars.$HASH:
+    case chars.$SEMICOLON:
+    case chars.$COLON:
+    case chars.$PERCENT:
+    case chars.$SLASH:
+    case chars.$BACKSLASH:
+    case chars.$BANG:
+    case chars.$PERIOD:
+    case chars.$LPAREN:
+    case chars.$RPAREN:
+      return true;
+    default:
+      return false;
+  }
+}
+
+function isValidMediaQueryRuleCharacter(code: number): boolean {
+  // (min-width: 7.5em) and (orientation: landscape)
+  switch (code) {
+    case chars.$LPAREN:
+    case chars.$RPAREN:
+    case chars.$COLON:
+    case chars.$PERCENT:
+    case chars.$PERIOD:
+      return true;
+    default:
+      return false;
+  }
+}
+
+function isValidAtRuleCharacter(code: number): boolean {
+  // @document url(http://www.w3.org/page?something=on#hash),
+  switch (code) {
+    case chars.$LPAREN:
+    case chars.$RPAREN:
+    case chars.$COLON:
+    case chars.$PERCENT:
+    case chars.$PERIOD:
+    case chars.$SLASH:
+    case chars.$BACKSLASH:
+    case chars.$HASH:
+    case chars.$EQ:
+    case chars.$QUESTION:
+    case chars.$AMPERSAND:
+    case chars.$STAR:
+    case chars.$COMMA:
+    case chars.$MINUS:
+    case chars.$PLUS:
+      return true;
+    default:
+      return false;
+  }
+}
+
+function isValidStyleFunctionCharacter(code: number): boolean {
+  switch (code) {
+    case chars.$PERIOD:
+    case chars.$MINUS:
+    case chars.$PLUS:
+    case chars.$STAR:
+    case chars.$SLASH:
+    case chars.$LPAREN:
+    case chars.$RPAREN:
+    case chars.$COMMA:
+      return true;
+    default:
+      return false;
+  }
+}
+
+function isValidBlockCharacter(code: number): boolean {
+  // @something { }
+  // IDENT
+  return code == chars.$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_WITH_ARGUMENTS:
+      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: string, index: number): number {
+  return index >= input.length ? chars.$EOF : input.charCodeAt(index);
+}
+
+function charStr(code: number): string {
+  return String.fromCharCode(code);
+}
+
+export function isNewline(code: number): boolean {
+  switch (code) {
+    case chars.$FF:
+    case chars.$CR:
+    case chars.$LF:
+    case chars.$VTAB:
+      return true;
+
+    default:
+      return false;
+  }
+}
diff --git a/angular/compiler/src/css_parser/css_parser.ts b/angular/compiler/src/css_parser/css_parser.ts
new file mode 100644
index 0000000..cf283a6
--- /dev/null
+++ b/angular/compiler/src/css_parser/css_parser.ts
@@ -0,0 +1,900 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as chars from '../chars';
+import {ParseError, ParseLocation, ParseSourceFile, ParseSourceSpan} from '../parse_util';
+
+import {BlockType, CssAst, CssAtRulePredicateAst, CssBlockAst, CssBlockDefinitionRuleAst, CssBlockRuleAst, CssDefinitionAst, CssInlineRuleAst, CssKeyframeDefinitionAst, CssKeyframeRuleAst, CssMediaQueryRuleAst, CssPseudoSelectorAst, CssRuleAst, CssSelectorAst, CssSelectorRuleAst, CssSimpleSelectorAst, CssStyleSheetAst, CssStyleValueAst, CssStylesBlockAst, CssUnknownRuleAst, CssUnknownTokenListAst, mergeTokens} from './css_ast';
+import {CssLexer, CssLexerMode, CssScanner, CssToken, CssTokenType, generateErrorMessage, getRawMessage, isNewline} from './css_lexer';
+
+const SPACE_OPERATOR = ' ';
+
+export {CssToken} from './css_lexer';
+export {BlockType} from './css_ast';
+
+const SLASH_CHARACTER = '/';
+const GT_CHARACTER = '>';
+const TRIPLE_GT_OPERATOR_STR = '>>>';
+const DEEP_OPERATOR_STR = '/deep/';
+
+const EOF_DELIM_FLAG = 1;
+const RBRACE_DELIM_FLAG = 2;
+const LBRACE_DELIM_FLAG = 4;
+const COMMA_DELIM_FLAG = 8;
+const COLON_DELIM_FLAG = 16;
+const SEMICOLON_DELIM_FLAG = 32;
+const NEWLINE_DELIM_FLAG = 64;
+const RPAREN_DELIM_FLAG = 128;
+const LPAREN_DELIM_FLAG = 256;
+const SPACE_DELIM_FLAG = 512;
+
+function _pseudoSelectorSupportsInnerSelectors(name: string): boolean {
+  return ['not', 'host', 'host-context'].indexOf(name) >= 0;
+}
+
+function isSelectorOperatorCharacter(code: number): boolean {
+  switch (code) {
+    case chars.$SLASH:
+    case chars.$TILDA:
+    case chars.$PLUS:
+    case chars.$GT:
+      return true;
+    default:
+      return chars.isWhitespace(code);
+  }
+}
+
+function getDelimFromCharacter(code: number): number {
+  switch (code) {
+    case chars.$EOF:
+      return EOF_DELIM_FLAG;
+    case chars.$COMMA:
+      return COMMA_DELIM_FLAG;
+    case chars.$COLON:
+      return COLON_DELIM_FLAG;
+    case chars.$SEMICOLON:
+      return SEMICOLON_DELIM_FLAG;
+    case chars.$RBRACE:
+      return RBRACE_DELIM_FLAG;
+    case chars.$LBRACE:
+      return LBRACE_DELIM_FLAG;
+    case chars.$RPAREN:
+      return RPAREN_DELIM_FLAG;
+    case chars.$SPACE:
+    case chars.$TAB:
+      return SPACE_DELIM_FLAG;
+    default:
+      return isNewline(code) ? NEWLINE_DELIM_FLAG : 0;
+  }
+}
+
+function characterContainsDelimiter(code: number, delimiters: number): boolean {
+  return (getDelimFromCharacter(code) & delimiters) > 0;
+}
+
+export class ParsedCssResult {
+  constructor(public errors: CssParseError[], public ast: CssStyleSheetAst) {}
+}
+
+export class CssParser {
+  private _errors: CssParseError[] = [];
+  private _file: ParseSourceFile;
+  private _scanner: CssScanner;
+  private _lastToken: CssToken;
+
+  /**
+   * @param css the CSS code that will be parsed
+   * @param url the name of the CSS file containing the CSS source code
+   */
+  parse(css: string, url: string): ParsedCssResult {
+    const lexer = new CssLexer();
+    this._file = new ParseSourceFile(css, url);
+    this._scanner = lexer.scan(css, false);
+
+    const ast = this._parseStyleSheet(EOF_DELIM_FLAG);
+
+    const errors = this._errors;
+    this._errors = [];
+
+    const result = new ParsedCssResult(errors, ast);
+    this._file = null as any;
+    this._scanner = null as any;
+    return result;
+  }
+
+  /** @internal */
+  _parseStyleSheet(delimiters: number): CssStyleSheetAst {
+    const results: CssRuleAst[] = [];
+    this._scanner.consumeEmptyStatements();
+    while (this._scanner.peek != chars.$EOF) {
+      this._scanner.setMode(CssLexerMode.BLOCK);
+      results.push(this._parseRule(delimiters));
+    }
+    let span: ParseSourceSpan|null = null;
+    if (results.length > 0) {
+      const firstRule = results[0];
+      // we collect the last token like so incase there was an
+      // EOF token that was emitted sometime during the lexing
+      span = this._generateSourceSpan(firstRule, this._lastToken);
+    }
+    return new CssStyleSheetAst(span !, results);
+  }
+
+  /** @internal */
+  _getSourceContent(): string { return this._scanner != null ? this._scanner.input : ''; }
+
+  /** @internal */
+  _extractSourceContent(start: number, end: number): string {
+    return this._getSourceContent().substring(start, end + 1);
+  }
+
+  /** @internal */
+  _generateSourceSpan(start: CssToken|CssAst, end: CssToken|CssAst|null = null): ParseSourceSpan {
+    let startLoc: ParseLocation;
+    if (start instanceof CssAst) {
+      startLoc = start.location.start;
+    } else {
+      let token = start;
+      if (token == null) {
+        // the data here is invalid, however, if and when this does
+        // occur, any other errors associated with this will be collected
+        token = this._lastToken;
+      }
+      startLoc = new ParseLocation(this._file, token.index, token.line, token.column);
+    }
+
+    if (end == null) {
+      end = this._lastToken;
+    }
+
+    let endLine: number = -1;
+    let endColumn: number = -1;
+    let endIndex: number = -1;
+    if (end instanceof CssAst) {
+      endLine = end.location.end.line !;
+      endColumn = end.location.end.col !;
+      endIndex = end.location.end.offset !;
+    } else if (end instanceof CssToken) {
+      endLine = end.line;
+      endColumn = end.column;
+      endIndex = end.index;
+    }
+
+    const endLoc = new ParseLocation(this._file, endIndex, endLine, endColumn);
+    return new ParseSourceSpan(startLoc, endLoc);
+  }
+
+  /** @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;
+    }
+  }
+
+  /** @internal */
+  _parseRule(delimiters: number): CssRuleAst {
+    if (this._scanner.peek == chars.$AT) {
+      return this._parseAtRule(delimiters);
+    }
+    return this._parseSelectorRule(delimiters);
+  }
+
+  /** @internal */
+  _parseAtRule(delimiters: number): CssRuleAst {
+    const start = this._getScannerIndex();
+
+    this._scanner.setMode(CssLexerMode.BLOCK);
+    const token = this._scan();
+    const startToken = token;
+
+    this._assertCondition(
+        token.type == CssTokenType.AtKeyword,
+        `The CSS Rule ${token.strValue} is not a valid [@] rule.`, token);
+
+    let block: CssBlockAst;
+    const type = this._resolveBlockType(token);
+    let span: ParseSourceSpan;
+    let tokens: CssToken[];
+    let endToken: CssToken;
+    let end: number;
+    let strValue: string;
+    let query: CssAtRulePredicateAst;
+    switch (type) {
+      case BlockType.Charset:
+      case BlockType.Namespace:
+      case BlockType.Import:
+        let value = this._parseValue(delimiters);
+        this._scanner.setMode(CssLexerMode.BLOCK);
+        this._scanner.consumeEmptyStatements();
+        span = this._generateSourceSpan(startToken, value);
+        return new CssInlineRuleAst(span, type, value);
+
+      case BlockType.Viewport:
+      case BlockType.FontFace:
+        block = this._parseStyleBlock(delimiters) !;
+        span = this._generateSourceSpan(startToken, block);
+        return new CssBlockRuleAst(span, type, block);
+
+      case BlockType.Keyframes:
+        tokens = this._collectUntilDelim(delimiters | RBRACE_DELIM_FLAG | LBRACE_DELIM_FLAG);
+        // keyframes only have one identifier name
+        let name = tokens[0];
+        block = this._parseKeyframeBlock(delimiters);
+        span = this._generateSourceSpan(startToken, block);
+        return new CssKeyframeRuleAst(span, name, block);
+
+      case BlockType.MediaQuery:
+        this._scanner.setMode(CssLexerMode.MEDIA_QUERY);
+        tokens = this._collectUntilDelim(delimiters | RBRACE_DELIM_FLAG | LBRACE_DELIM_FLAG);
+        endToken = tokens[tokens.length - 1];
+        // we do not track the whitespace after the mediaQuery predicate ends
+        // so we have to calculate the end string value on our own
+        end = endToken.index + endToken.strValue.length - 1;
+        strValue = this._extractSourceContent(start, end);
+        span = this._generateSourceSpan(startToken, endToken);
+        query = new CssAtRulePredicateAst(span, strValue, tokens);
+        block = this._parseBlock(delimiters);
+        strValue = this._extractSourceContent(start, this._getScannerIndex() - 1);
+        span = this._generateSourceSpan(startToken, block);
+        return new CssMediaQueryRuleAst(span, strValue, query, block);
+
+      case BlockType.Document:
+      case BlockType.Supports:
+      case BlockType.Page:
+        this._scanner.setMode(CssLexerMode.AT_RULE_QUERY);
+        tokens = this._collectUntilDelim(delimiters | RBRACE_DELIM_FLAG | LBRACE_DELIM_FLAG);
+        endToken = tokens[tokens.length - 1];
+        // we do not track the whitespace after this block rule predicate ends
+        // so we have to calculate the end string value on our own
+        end = endToken.index + endToken.strValue.length - 1;
+        strValue = this._extractSourceContent(start, end);
+        span = this._generateSourceSpan(startToken, tokens[tokens.length - 1]);
+        query = new CssAtRulePredicateAst(span, strValue, tokens);
+        block = this._parseBlock(delimiters);
+        strValue = this._extractSourceContent(start, block.end.offset !);
+        span = this._generateSourceSpan(startToken, block);
+        return new CssBlockDefinitionRuleAst(span, strValue, type, query, block);
+
+      // if a custom @rule { ... } is used it should still tokenize the insides
+      default:
+        let listOfTokens: CssToken[] = [];
+        let tokenName = token.strValue;
+        this._scanner.setMode(CssLexerMode.ALL);
+        this._error(
+            generateErrorMessage(
+                this._getSourceContent(),
+                `The CSS "at" rule "${tokenName}" is not allowed to used here`, token.strValue,
+                token.index, token.line, token.column),
+            token);
+
+        this._collectUntilDelim(delimiters | LBRACE_DELIM_FLAG | SEMICOLON_DELIM_FLAG)
+            .forEach((token) => { listOfTokens.push(token); });
+        if (this._scanner.peek == chars.$LBRACE) {
+          listOfTokens.push(this._consume(CssTokenType.Character, '{'));
+          this._collectUntilDelim(delimiters | RBRACE_DELIM_FLAG | LBRACE_DELIM_FLAG)
+              .forEach((token) => { listOfTokens.push(token); });
+          listOfTokens.push(this._consume(CssTokenType.Character, '}'));
+        }
+        endToken = listOfTokens[listOfTokens.length - 1];
+        span = this._generateSourceSpan(startToken, endToken);
+        return new CssUnknownRuleAst(span, tokenName, listOfTokens);
+    }
+  }
+
+  /** @internal */
+  _parseSelectorRule(delimiters: number): CssRuleAst {
+    const start = this._getScannerIndex();
+    const selectors = this._parseSelectors(delimiters);
+    const block = this._parseStyleBlock(delimiters);
+    let ruleAst: CssRuleAst;
+    let span: ParseSourceSpan;
+    const startSelector = selectors[0];
+    if (block != null) {
+      span = this._generateSourceSpan(startSelector, block);
+      ruleAst = new CssSelectorRuleAst(span, selectors, block);
+    } else {
+      const name = this._extractSourceContent(start, this._getScannerIndex() - 1);
+      const innerTokens: CssToken[] = [];
+      selectors.forEach((selector: CssSelectorAst) => {
+        selector.selectorParts.forEach((part: CssSimpleSelectorAst) => {
+          part.tokens.forEach((token: CssToken) => { innerTokens.push(token); });
+        });
+      });
+      const endToken = innerTokens[innerTokens.length - 1];
+      span = this._generateSourceSpan(startSelector, endToken);
+      ruleAst = new CssUnknownTokenListAst(span, name, innerTokens);
+    }
+    this._scanner.setMode(CssLexerMode.BLOCK);
+    this._scanner.consumeEmptyStatements();
+    return ruleAst;
+  }
+
+  /** @internal */
+  _parseSelectors(delimiters: number): CssSelectorAst[] {
+    delimiters |= LBRACE_DELIM_FLAG | SEMICOLON_DELIM_FLAG;
+
+    const selectors: CssSelectorAst[] = [];
+    let 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);
+        if (isParsingSelectors) {
+          this._scanner.consumeWhitespace();
+        }
+      }
+    }
+
+    return selectors;
+  }
+
+  /** @internal */
+  _scan(): CssToken {
+    const output = this._scanner.scan() !;
+    const token = output.token;
+    const error = output.error;
+    if (error != null) {
+      this._error(getRawMessage(error), token);
+    }
+    this._lastToken = token;
+    return token;
+  }
+
+  /** @internal */
+  _getScannerIndex(): number { return this._scanner.index; }
+
+  /** @internal */
+  _consume(type: CssTokenType, value: string|null = null): CssToken {
+    const output = this._scanner.consume(type, value);
+    const token = output.token;
+    const error = output.error;
+    if (error != null) {
+      this._error(getRawMessage(error), token);
+    }
+    this._lastToken = token;
+    return token;
+  }
+
+  /** @internal */
+  _parseKeyframeBlock(delimiters: number): CssBlockAst {
+    delimiters |= RBRACE_DELIM_FLAG;
+    this._scanner.setMode(CssLexerMode.KEYFRAME_BLOCK);
+
+    const startToken = this._consume(CssTokenType.Character, '{');
+
+    const definitions: CssKeyframeDefinitionAst[] = [];
+    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
+      definitions.push(this._parseKeyframeDefinition(delimiters));
+    }
+
+    const endToken = this._consume(CssTokenType.Character, '}');
+
+    const span = this._generateSourceSpan(startToken, endToken);
+    return new CssBlockAst(span, definitions);
+  }
+
+  /** @internal */
+  _parseKeyframeDefinition(delimiters: number): CssKeyframeDefinitionAst {
+    const start = this._getScannerIndex();
+    const stepTokens: CssToken[] = [];
+    delimiters |= LBRACE_DELIM_FLAG;
+    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
+      stepTokens.push(this._parseKeyframeLabel(delimiters | COMMA_DELIM_FLAG));
+      if (this._scanner.peek != chars.$LBRACE) {
+        this._consume(CssTokenType.Character, ',');
+      }
+    }
+    const stylesBlock = this._parseStyleBlock(delimiters | RBRACE_DELIM_FLAG);
+    const span = this._generateSourceSpan(stepTokens[0], stylesBlock);
+    const ast = new CssKeyframeDefinitionAst(span, stepTokens, stylesBlock !);
+
+    this._scanner.setMode(CssLexerMode.BLOCK);
+    return ast;
+  }
+
+  /** @internal */
+  _parseKeyframeLabel(delimiters: number): CssToken {
+    this._scanner.setMode(CssLexerMode.KEYFRAME_BLOCK);
+    return mergeTokens(this._collectUntilDelim(delimiters));
+  }
+
+  /** @internal */
+  _parsePseudoSelector(delimiters: number): CssPseudoSelectorAst {
+    const start = this._getScannerIndex();
+
+    delimiters &= ~COMMA_DELIM_FLAG;
+
+    // we keep the original value since we may use it to recurse when :not, :host are used
+    const startingDelims = delimiters;
+
+    const startToken = this._consume(CssTokenType.Character, ':');
+    const tokens = [startToken];
+
+    if (this._scanner.peek == chars.$COLON) {  // ::something
+      tokens.push(this._consume(CssTokenType.Character, ':'));
+    }
+
+    const innerSelectors: CssSelectorAst[] = [];
+
+    this._scanner.setMode(CssLexerMode.PSEUDO_SELECTOR);
+
+    // host, host-context, lang, not, nth-child are all identifiers
+    const pseudoSelectorToken = this._consume(CssTokenType.Identifier);
+    const pseudoSelectorName = pseudoSelectorToken.strValue;
+    tokens.push(pseudoSelectorToken);
+
+    // host(), lang(), nth-child(), etc...
+    if (this._scanner.peek == chars.$LPAREN) {
+      this._scanner.setMode(CssLexerMode.PSEUDO_SELECTOR_WITH_ARGUMENTS);
+
+      const openParenToken = this._consume(CssTokenType.Character, '(');
+      tokens.push(openParenToken);
+
+      // :host(innerSelector(s)), :not(selector), etc...
+      if (_pseudoSelectorSupportsInnerSelectors(pseudoSelectorName)) {
+        let innerDelims = startingDelims | LPAREN_DELIM_FLAG | RPAREN_DELIM_FLAG;
+        if (pseudoSelectorName == 'not') {
+          // the inner selector inside of :not(...) can only be one
+          // CSS selector (no commas allowed) ... This is according
+          // to the CSS specification
+          innerDelims |= COMMA_DELIM_FLAG;
+        }
+
+        // :host(a, b, c) {
+        this._parseSelectors(innerDelims).forEach((selector, index) => {
+          innerSelectors.push(selector);
+        });
+      } else {
+        // this branch is for things like "en-us, 2k + 1, etc..."
+        // which all end up in pseudoSelectors like :lang, :nth-child, etc..
+        const innerValueDelims = delimiters | LBRACE_DELIM_FLAG | COLON_DELIM_FLAG |
+            RPAREN_DELIM_FLAG | LPAREN_DELIM_FLAG;
+        while (!characterContainsDelimiter(this._scanner.peek, innerValueDelims)) {
+          const token = this._scan();
+          tokens.push(token);
+        }
+      }
+
+      const closeParenToken = this._consume(CssTokenType.Character, ')');
+      tokens.push(closeParenToken);
+    }
+
+    const end = this._getScannerIndex() - 1;
+    const strValue = this._extractSourceContent(start, end);
+
+    const endToken = tokens[tokens.length - 1];
+    const span = this._generateSourceSpan(startToken, endToken);
+    return new CssPseudoSelectorAst(span, strValue, pseudoSelectorName, tokens, innerSelectors);
+  }
+
+  /** @internal */
+  _parseSimpleSelector(delimiters: number): CssSimpleSelectorAst {
+    const start = this._getScannerIndex();
+
+    delimiters |= COMMA_DELIM_FLAG;
+
+    this._scanner.setMode(CssLexerMode.SELECTOR);
+    const selectorCssTokens: CssToken[] = [];
+    const pseudoSelectors: CssPseudoSelectorAst[] = [];
+
+    let previousToken: CssToken = undefined !;
+
+    const selectorPartDelimiters = delimiters | SPACE_DELIM_FLAG;
+    let loopOverSelector = !characterContainsDelimiter(this._scanner.peek, selectorPartDelimiters);
+
+    let hasAttributeError = false;
+    while (loopOverSelector) {
+      const peek = this._scanner.peek;
+
+      switch (peek) {
+        case chars.$COLON:
+          let innerPseudo = this._parsePseudoSelector(delimiters);
+          pseudoSelectors.push(innerPseudo);
+          this._scanner.setMode(CssLexerMode.SELECTOR);
+          break;
+
+        case chars.$LBRACKET:
+          // we set the mode after the scan because attribute mode does not
+          // allow attribute [] values. And this also will catch any errors
+          // if an extra "[" is used inside.
+          selectorCssTokens.push(this._scan());
+          this._scanner.setMode(CssLexerMode.ATTRIBUTE_SELECTOR);
+          break;
+
+        case chars.$RBRACKET:
+          if (this._scanner.getMode() != CssLexerMode.ATTRIBUTE_SELECTOR) {
+            hasAttributeError = true;
+          }
+          // we set the mode early because attribute mode does not
+          // allow attribute [] values
+          this._scanner.setMode(CssLexerMode.SELECTOR);
+          selectorCssTokens.push(this._scan());
+          break;
+
+        default:
+          if (isSelectorOperatorCharacter(peek)) {
+            loopOverSelector = false;
+            continue;
+          }
+
+          let token = this._scan();
+          previousToken = token;
+          selectorCssTokens.push(token);
+          break;
+      }
+
+      loopOverSelector = !characterContainsDelimiter(this._scanner.peek, selectorPartDelimiters);
+    }
+
+    hasAttributeError =
+        hasAttributeError || this._scanner.getMode() == CssLexerMode.ATTRIBUTE_SELECTOR;
+    if (hasAttributeError) {
+      this._error(
+          `Unbalanced CSS attribute selector at column ${previousToken.line}:${previousToken.column}`,
+          previousToken);
+    }
+
+    let end = this._getScannerIndex() - 1;
+
+    // this happens if the selector is not directly followed by
+    // a comma or curly brace without a space in between
+    let operator: CssToken|null = null;
+    let operatorScanCount = 0;
+    let lastOperatorToken: CssToken|null = null;
+    if (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
+      while (operator == null && !characterContainsDelimiter(this._scanner.peek, delimiters) &&
+             isSelectorOperatorCharacter(this._scanner.peek)) {
+        let token = this._scan();
+        const tokenOperator = token.strValue;
+        operatorScanCount++;
+        lastOperatorToken = token;
+        if (tokenOperator != SPACE_OPERATOR) {
+          switch (tokenOperator) {
+            case SLASH_CHARACTER:
+              // /deep/ operator
+              let deepToken = this._consume(CssTokenType.Identifier);
+              let deepSlash = this._consume(CssTokenType.Character);
+              let index = lastOperatorToken.index;
+              let line = lastOperatorToken.line;
+              let column = lastOperatorToken.column;
+              if (deepToken != null && deepToken.strValue.toLowerCase() == 'deep' &&
+                  deepSlash.strValue == SLASH_CHARACTER) {
+                token = new CssToken(
+                    lastOperatorToken.index, lastOperatorToken.column, lastOperatorToken.line,
+                    CssTokenType.Identifier, DEEP_OPERATOR_STR);
+              } else {
+                const text = SLASH_CHARACTER + deepToken.strValue + deepSlash.strValue;
+                this._error(
+                    generateErrorMessage(
+                        this._getSourceContent(), `${text} is an invalid CSS operator`, text, index,
+                        line, column),
+                    lastOperatorToken);
+                token = new CssToken(index, column, line, CssTokenType.Invalid, text);
+              }
+              break;
+
+            case GT_CHARACTER:
+              // >>> operator
+              if (this._scanner.peek == chars.$GT && this._scanner.peekPeek == chars.$GT) {
+                this._consume(CssTokenType.Character, GT_CHARACTER);
+                this._consume(CssTokenType.Character, GT_CHARACTER);
+                token = new CssToken(
+                    lastOperatorToken.index, lastOperatorToken.column, lastOperatorToken.line,
+                    CssTokenType.Identifier, TRIPLE_GT_OPERATOR_STR);
+              }
+              break;
+          }
+
+          operator = token;
+        }
+      }
+
+      // so long as there is an operator then we can have an
+      // ending value that is beyond the selector value ...
+      // otherwise it's just a bunch of trailing whitespace
+      if (operator != null) {
+        end = operator.index;
+      }
+    }
+
+    this._scanner.consumeWhitespace();
+
+    const strValue = this._extractSourceContent(start, end);
+
+    // if we do come across one or more spaces inside of
+    // the operators loop then an empty space is still a
+    // valid operator to use if something else was not found
+    if (operator == null && operatorScanCount > 0 && this._scanner.peek != chars.$LBRACE) {
+      operator = lastOperatorToken;
+    }
+
+    // please note that `endToken` is reassigned multiple times below
+    // so please do not optimize the if statements into if/elseif
+    let startTokenOrAst: CssToken|CssAst|null = null;
+    let endTokenOrAst: CssToken|CssAst|null = null;
+    if (selectorCssTokens.length > 0) {
+      startTokenOrAst = startTokenOrAst || selectorCssTokens[0];
+      endTokenOrAst = selectorCssTokens[selectorCssTokens.length - 1];
+    }
+    if (pseudoSelectors.length > 0) {
+      startTokenOrAst = startTokenOrAst || pseudoSelectors[0];
+      endTokenOrAst = pseudoSelectors[pseudoSelectors.length - 1];
+    }
+    if (operator != null) {
+      startTokenOrAst = startTokenOrAst || operator;
+      endTokenOrAst = operator;
+    }
+
+    const span = this._generateSourceSpan(startTokenOrAst !, endTokenOrAst);
+    return new CssSimpleSelectorAst(span, selectorCssTokens, strValue, pseudoSelectors, operator !);
+  }
+
+  /** @internal */
+  _parseSelector(delimiters: number): CssSelectorAst {
+    delimiters |= COMMA_DELIM_FLAG;
+    this._scanner.setMode(CssLexerMode.SELECTOR);
+
+    const simpleSelectors: CssSimpleSelectorAst[] = [];
+    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
+      simpleSelectors.push(this._parseSimpleSelector(delimiters));
+      this._scanner.consumeWhitespace();
+    }
+
+    const firstSelector = simpleSelectors[0];
+    const lastSelector = simpleSelectors[simpleSelectors.length - 1];
+    const span = this._generateSourceSpan(firstSelector, lastSelector);
+    return new CssSelectorAst(span, simpleSelectors);
+  }
+
+  /** @internal */
+  _parseValue(delimiters: number): CssStyleValueAst {
+    delimiters |= RBRACE_DELIM_FLAG | SEMICOLON_DELIM_FLAG | NEWLINE_DELIM_FLAG;
+
+    this._scanner.setMode(CssLexerMode.STYLE_VALUE);
+    const start = this._getScannerIndex();
+
+    const tokens: CssToken[] = [];
+    let wsStr = '';
+    let previous: CssToken = undefined !;
+    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
+      let token: CssToken;
+      if (previous != null && previous.type == CssTokenType.Identifier &&
+          this._scanner.peek == chars.$LPAREN) {
+        token = this._consume(CssTokenType.Character, '(');
+        tokens.push(token);
+
+        this._scanner.setMode(CssLexerMode.STYLE_VALUE_FUNCTION);
+
+        token = this._scan();
+        tokens.push(token);
+
+        this._scanner.setMode(CssLexerMode.STYLE_VALUE);
+
+        token = this._consume(CssTokenType.Character, ')');
+        tokens.push(token);
+      } else {
+        token = this._scan();
+        if (token.type == CssTokenType.Whitespace) {
+          wsStr += token.strValue;
+        } else {
+          wsStr = '';
+          tokens.push(token);
+        }
+      }
+      previous = token;
+    }
+
+    const end = this._getScannerIndex() - 1;
+    this._scanner.consumeWhitespace();
+
+    const code = this._scanner.peek;
+    if (code == chars.$SEMICOLON) {
+      this._consume(CssTokenType.Character, ';');
+    } else if (code != chars.$RBRACE) {
+      this._error(
+          generateErrorMessage(
+              this._getSourceContent(), `The CSS key/value definition did not end with a semicolon`,
+              previous.strValue, previous.index, previous.line, previous.column),
+          previous);
+    }
+
+    const strValue = this._extractSourceContent(start, end);
+    const startToken = tokens[0];
+    const endToken = tokens[tokens.length - 1];
+    const span = this._generateSourceSpan(startToken, endToken);
+    return new CssStyleValueAst(span, tokens, strValue);
+  }
+
+  /** @internal */
+  _collectUntilDelim(delimiters: number, assertType: CssTokenType|null = null): CssToken[] {
+    const tokens: CssToken[] = [];
+    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
+      const val = assertType != null ? this._consume(assertType) : this._scan();
+      tokens.push(val);
+    }
+    return tokens;
+  }
+
+  /** @internal */
+  _parseBlock(delimiters: number): CssBlockAst {
+    delimiters |= RBRACE_DELIM_FLAG;
+
+    this._scanner.setMode(CssLexerMode.BLOCK);
+
+    const startToken = this._consume(CssTokenType.Character, '{');
+    this._scanner.consumeEmptyStatements();
+
+    const results: CssRuleAst[] = [];
+    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
+      results.push(this._parseRule(delimiters));
+    }
+
+    const endToken = this._consume(CssTokenType.Character, '}');
+
+    this._scanner.setMode(CssLexerMode.BLOCK);
+    this._scanner.consumeEmptyStatements();
+
+    const span = this._generateSourceSpan(startToken, endToken);
+    return new CssBlockAst(span, results);
+  }
+
+  /** @internal */
+  _parseStyleBlock(delimiters: number): CssStylesBlockAst|null {
+    delimiters |= RBRACE_DELIM_FLAG | LBRACE_DELIM_FLAG;
+
+    this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
+
+    const startToken = this._consume(CssTokenType.Character, '{');
+    if (startToken.numValue != chars.$LBRACE) {
+      return null;
+    }
+
+    const definitions: CssDefinitionAst[] = [];
+    this._scanner.consumeEmptyStatements();
+
+    while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
+      definitions.push(this._parseDefinition(delimiters));
+      this._scanner.consumeEmptyStatements();
+    }
+
+    const endToken = this._consume(CssTokenType.Character, '}');
+
+    this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
+    this._scanner.consumeEmptyStatements();
+
+    const span = this._generateSourceSpan(startToken, endToken);
+    return new CssStylesBlockAst(span, definitions);
+  }
+
+  /** @internal */
+  _parseDefinition(delimiters: number): CssDefinitionAst {
+    this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
+
+    let prop = this._consume(CssTokenType.Identifier);
+    let parseValue: boolean = false;
+    let value: CssStyleValueAst|null = null;
+    let endToken: CssToken|CssStyleValueAst = prop;
+
+    // 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 chars.$SEMICOLON:
+      case chars.$RBRACE:
+      case chars.$EOF:
+        parseValue = false;
+        break;
+
+      default:
+        let propStr = [prop.strValue];
+        if (this._scanner.peek != chars.$COLON) {
+          // this will throw the error
+          const nextValue = this._consume(CssTokenType.Character, ':');
+          propStr.push(nextValue.strValue);
+
+          const remainingTokens = this._collectUntilDelim(
+              delimiters | COLON_DELIM_FLAG | SEMICOLON_DELIM_FLAG, CssTokenType.Identifier);
+          if (remainingTokens.length > 0) {
+            remainingTokens.forEach((token) => { propStr.push(token.strValue); });
+          }
+
+          endToken = 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 == chars.$COLON) {
+          this._consume(CssTokenType.Character, ':');
+          parseValue = true;
+        }
+        break;
+    }
+
+    if (parseValue) {
+      value = this._parseValue(delimiters);
+      endToken = value;
+    } else {
+      this._error(
+          generateErrorMessage(
+              this._getSourceContent(), `The CSS property was not paired with a style value`,
+              prop.strValue, prop.index, prop.line, prop.column),
+          prop);
+    }
+
+    const span = this._generateSourceSpan(prop, endToken);
+    return new CssDefinitionAst(span, 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) {
+    const length = problemToken.strValue.length;
+    const error = CssParseError.create(
+        this._file, 0, problemToken.line, problemToken.column, length, message);
+    this._errors.push(error);
+  }
+}
+
+export class CssParseError extends ParseError {
+  static create(
+      file: ParseSourceFile, offset: number, line: number, col: number, length: number,
+      errMsg: string): CssParseError {
+    const start = new ParseLocation(file, offset, line, col);
+    const end = new ParseLocation(file, offset, line, col + length);
+    const span = new ParseSourceSpan(start, end);
+    return new CssParseError(span, 'CSS Parse Error: ' + errMsg);
+  }
+
+  constructor(span: ParseSourceSpan, message: string) { super(span, message); }
+}
diff --git a/angular/compiler/src/directive_normalizer.ts b/angular/compiler/src/directive_normalizer.ts
new file mode 100644
index 0000000..2ac66f6
--- /dev/null
+++ b/angular/compiler/src/directive_normalizer.ts
@@ -0,0 +1,267 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileAnimationEntryMetadata, CompileDirectiveMetadata, CompileStylesheetMetadata, CompileTemplateMetadata, templateSourceUrl} from './compile_metadata';
+import {CompilerConfig, preserveWhitespacesDefault} from './config';
+import {ViewEncapsulation} from './core';
+import * as html from './ml_parser/ast';
+import {HtmlParser} from './ml_parser/html_parser';
+import {InterpolationConfig} from './ml_parser/interpolation_config';
+import {ResourceLoader} from './resource_loader';
+import {extractStyleUrls, isStyleUrlResolvable} from './style_url_resolver';
+import {PreparsedElementType, preparseElement} from './template_parser/template_preparser';
+import {UrlResolver} from './url_resolver';
+import {SyncAsync, isDefined, stringify, syntaxError} from './util';
+
+export interface PrenormalizedTemplateMetadata {
+  ngModuleType: any;
+  componentType: any;
+  moduleUrl: string;
+  template: string|null;
+  templateUrl: string|null;
+  styles: string[];
+  styleUrls: string[];
+  interpolation: [string, string]|null;
+  encapsulation: ViewEncapsulation|null;
+  animations: CompileAnimationEntryMetadata[];
+  preserveWhitespaces: boolean|null;
+}
+
+export class DirectiveNormalizer {
+  private _resourceLoaderCache = new Map<string, SyncAsync<string>>();
+
+  constructor(
+      private _resourceLoader: ResourceLoader, private _urlResolver: UrlResolver,
+      private _htmlParser: HtmlParser, private _config: CompilerConfig) {}
+
+  clearCache(): void { this._resourceLoaderCache.clear(); }
+
+  clearCacheFor(normalizedDirective: CompileDirectiveMetadata): void {
+    if (!normalizedDirective.isComponent) {
+      return;
+    }
+    const template = normalizedDirective.template !;
+    this._resourceLoaderCache.delete(template.templateUrl !);
+    template.externalStylesheets.forEach(
+        (stylesheet) => { this._resourceLoaderCache.delete(stylesheet.moduleUrl !); });
+  }
+
+  private _fetch(url: string): SyncAsync<string> {
+    let result = this._resourceLoaderCache.get(url);
+    if (!result) {
+      result = this._resourceLoader.get(url);
+      this._resourceLoaderCache.set(url, result);
+    }
+    return result;
+  }
+
+  normalizeTemplate(prenormData: PrenormalizedTemplateMetadata):
+      SyncAsync<CompileTemplateMetadata> {
+    if (isDefined(prenormData.template)) {
+      if (isDefined(prenormData.templateUrl)) {
+        throw syntaxError(
+            `'${stringify(prenormData.componentType)}' component cannot define both template and templateUrl`);
+      }
+      if (typeof prenormData.template !== 'string') {
+        throw syntaxError(
+            `The template specified for component ${stringify(prenormData.componentType)} is not a string`);
+      }
+    } else if (isDefined(prenormData.templateUrl)) {
+      if (typeof prenormData.templateUrl !== 'string') {
+        throw syntaxError(
+            `The templateUrl specified for component ${stringify(prenormData.componentType)} is not a string`);
+      }
+    } else {
+      throw syntaxError(
+          `No template specified for component ${stringify(prenormData.componentType)}`);
+    }
+
+    if (isDefined(prenormData.preserveWhitespaces) &&
+        typeof prenormData.preserveWhitespaces !== 'boolean') {
+      throw syntaxError(
+          `The preserveWhitespaces option for component ${stringify(prenormData.componentType)} must be a boolean`);
+    }
+
+    return SyncAsync.then(
+        this.normalizeTemplateOnly(prenormData),
+        (result: CompileTemplateMetadata) => this.normalizeExternalStylesheets(result));
+  }
+
+  normalizeTemplateOnly(prenomData: PrenormalizedTemplateMetadata):
+      SyncAsync<CompileTemplateMetadata> {
+    let template: SyncAsync<string>;
+    let templateUrl: string;
+    if (prenomData.template != null) {
+      template = prenomData.template;
+      templateUrl = prenomData.moduleUrl;
+    } else {
+      templateUrl = this._urlResolver.resolve(prenomData.moduleUrl, prenomData.templateUrl !);
+      template = this._fetch(templateUrl);
+    }
+    return SyncAsync.then(
+        template, (template) => this.normalizeLoadedTemplate(prenomData, template, templateUrl));
+  }
+
+  normalizeLoadedTemplate(
+      prenormData: PrenormalizedTemplateMetadata, template: string,
+      templateAbsUrl: string): CompileTemplateMetadata {
+    const isInline = !!prenormData.template;
+    const interpolationConfig = InterpolationConfig.fromArray(prenormData.interpolation !);
+    const rootNodesAndErrors = this._htmlParser.parse(
+        template,
+        templateSourceUrl(
+            {reference: prenormData.ngModuleType}, {type: {reference: prenormData.componentType}},
+            {isInline, templateUrl: templateAbsUrl}),
+        true, interpolationConfig);
+    if (rootNodesAndErrors.errors.length > 0) {
+      const errorString = rootNodesAndErrors.errors.join('\n');
+      throw syntaxError(`Template parse errors:\n${errorString}`);
+    }
+
+    const templateMetadataStyles = this.normalizeStylesheet(new CompileStylesheetMetadata({
+      styles: prenormData.styles,
+      styleUrls: prenormData.styleUrls,
+      moduleUrl: prenormData.moduleUrl
+    }));
+
+    const visitor = new TemplatePreparseVisitor();
+    html.visitAll(visitor, rootNodesAndErrors.rootNodes);
+    const templateStyles = this.normalizeStylesheet(new CompileStylesheetMetadata(
+        {styles: visitor.styles, styleUrls: visitor.styleUrls, moduleUrl: templateAbsUrl}));
+
+    let encapsulation = prenormData.encapsulation;
+    if (encapsulation == null) {
+      encapsulation = this._config.defaultEncapsulation;
+    }
+
+    const styles = templateMetadataStyles.styles.concat(templateStyles.styles);
+    const styleUrls = templateMetadataStyles.styleUrls.concat(templateStyles.styleUrls);
+
+    if (encapsulation === ViewEncapsulation.Emulated && styles.length === 0 &&
+        styleUrls.length === 0) {
+      encapsulation = ViewEncapsulation.None;
+    }
+
+    return new CompileTemplateMetadata({
+      encapsulation,
+      template,
+      templateUrl: templateAbsUrl, styles, styleUrls,
+      ngContentSelectors: visitor.ngContentSelectors,
+      animations: prenormData.animations,
+      interpolation: prenormData.interpolation, isInline,
+      externalStylesheets: [],
+      preserveWhitespaces: preserveWhitespacesDefault(
+          prenormData.preserveWhitespaces, this._config.preserveWhitespaces),
+    });
+  }
+
+  normalizeExternalStylesheets(templateMeta: CompileTemplateMetadata):
+      SyncAsync<CompileTemplateMetadata> {
+    return SyncAsync.then(
+        this._loadMissingExternalStylesheets(templateMeta.styleUrls),
+        (externalStylesheets) => new CompileTemplateMetadata({
+          encapsulation: templateMeta.encapsulation,
+          template: templateMeta.template,
+          templateUrl: templateMeta.templateUrl,
+          styles: templateMeta.styles,
+          styleUrls: templateMeta.styleUrls,
+          externalStylesheets: externalStylesheets,
+          ngContentSelectors: templateMeta.ngContentSelectors,
+          animations: templateMeta.animations,
+          interpolation: templateMeta.interpolation,
+          isInline: templateMeta.isInline,
+          preserveWhitespaces: templateMeta.preserveWhitespaces,
+        }));
+  }
+
+  private _loadMissingExternalStylesheets(
+      styleUrls: string[],
+      loadedStylesheets:
+          Map<string, CompileStylesheetMetadata> = new Map<string, CompileStylesheetMetadata>()):
+      SyncAsync<CompileStylesheetMetadata[]> {
+    return SyncAsync.then(
+        SyncAsync.all(styleUrls.filter((styleUrl) => !loadedStylesheets.has(styleUrl))
+                          .map(
+                              styleUrl => SyncAsync.then(
+                                  this._fetch(styleUrl),
+                                  (loadedStyle) => {
+                                    const stylesheet =
+                                        this.normalizeStylesheet(new CompileStylesheetMetadata(
+                                            {styles: [loadedStyle], moduleUrl: styleUrl}));
+                                    loadedStylesheets.set(styleUrl, stylesheet);
+                                    return this._loadMissingExternalStylesheets(
+                                        stylesheet.styleUrls, loadedStylesheets);
+                                  }))),
+        (_) => Array.from(loadedStylesheets.values()));
+  }
+
+  normalizeStylesheet(stylesheet: CompileStylesheetMetadata): CompileStylesheetMetadata {
+    const moduleUrl = stylesheet.moduleUrl !;
+    const allStyleUrls = stylesheet.styleUrls.filter(isStyleUrlResolvable)
+                             .map(url => this._urlResolver.resolve(moduleUrl, url));
+
+    const allStyles = stylesheet.styles.map(style => {
+      const styleWithImports = extractStyleUrls(this._urlResolver, moduleUrl, style);
+      allStyleUrls.push(...styleWithImports.styleUrls);
+      return styleWithImports.style;
+    });
+
+    return new CompileStylesheetMetadata(
+        {styles: allStyles, styleUrls: allStyleUrls, moduleUrl: moduleUrl});
+  }
+}
+
+class TemplatePreparseVisitor implements html.Visitor {
+  ngContentSelectors: string[] = [];
+  styles: string[] = [];
+  styleUrls: string[] = [];
+  ngNonBindableStackCount: number = 0;
+
+  visitElement(ast: html.Element, context: any): any {
+    const preparsedElement = preparseElement(ast);
+    switch (preparsedElement.type) {
+      case PreparsedElementType.NG_CONTENT:
+        if (this.ngNonBindableStackCount === 0) {
+          this.ngContentSelectors.push(preparsedElement.selectAttr);
+        }
+        break;
+      case PreparsedElementType.STYLE:
+        let textContent = '';
+        ast.children.forEach(child => {
+          if (child instanceof html.Text) {
+            textContent += child.value;
+          }
+        });
+        this.styles.push(textContent);
+        break;
+      case PreparsedElementType.STYLESHEET:
+        this.styleUrls.push(preparsedElement.hrefAttr);
+        break;
+      default:
+        break;
+    }
+    if (preparsedElement.nonBindable) {
+      this.ngNonBindableStackCount++;
+    }
+    html.visitAll(this, ast.children);
+    if (preparsedElement.nonBindable) {
+      this.ngNonBindableStackCount--;
+    }
+    return null;
+  }
+
+  visitExpansion(ast: html.Expansion, context: any): any { html.visitAll(this, ast.cases); }
+
+  visitExpansionCase(ast: html.ExpansionCase, context: any): any {
+    html.visitAll(this, ast.expression);
+  }
+
+  visitComment(ast: html.Comment, context: any): any { return null; }
+  visitAttribute(ast: html.Attribute, context: any): any { return null; }
+  visitText(ast: html.Text, context: any): any { return null; }
+}
diff --git a/angular/compiler/src/directive_resolver.ts b/angular/compiler/src/directive_resolver.ts
new file mode 100644
index 0000000..c32f328
--- /dev/null
+++ b/angular/compiler/src/directive_resolver.ts
@@ -0,0 +1,186 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileReflector} from './compile_reflector';
+import {Component, Directive, Type, createComponent, createContentChild, createContentChildren, createDirective, createHostBinding, createHostListener, createInput, createOutput, createViewChild, createViewChildren} from './core';
+import {resolveForwardRef, splitAtColon, stringify} from './util';
+
+const QUERY_METADATA_IDENTIFIERS = [
+  createViewChild,
+  createViewChildren,
+  createContentChild,
+  createContentChildren,
+];
+
+/*
+ * Resolve a `Type` for {@link Directive}.
+ *
+ * This interface can be overridden by the application developer to create custom behavior.
+ *
+ * See {@link Compiler}
+ */
+export class DirectiveResolver {
+  constructor(private _reflector: CompileReflector) {}
+
+  isDirective(type: Type) {
+    const typeMetadata = this._reflector.annotations(resolveForwardRef(type));
+    return typeMetadata && typeMetadata.some(isDirectiveMetadata);
+  }
+
+  /**
+   * Return {@link Directive} for a given `Type`.
+   */
+  resolve(type: Type): Directive;
+  resolve(type: Type, throwIfNotFound: true): Directive;
+  resolve(type: Type, throwIfNotFound: boolean): Directive|null;
+  resolve(type: Type, throwIfNotFound = true): Directive|null {
+    const typeMetadata = this._reflector.annotations(resolveForwardRef(type));
+    if (typeMetadata) {
+      const metadata = findLast(typeMetadata, isDirectiveMetadata);
+      if (metadata) {
+        const propertyMetadata = this._reflector.propMetadata(type);
+        return this._mergeWithPropertyMetadata(metadata, propertyMetadata, type);
+      }
+    }
+
+    if (throwIfNotFound) {
+      throw new Error(`No Directive annotation found on ${stringify(type)}`);
+    }
+
+    return null;
+  }
+
+  private _mergeWithPropertyMetadata(
+      dm: Directive, propertyMetadata: {[key: string]: any[]}, directiveType: Type): Directive {
+    const inputs: string[] = [];
+    const outputs: string[] = [];
+    const host: {[key: string]: string} = {};
+    const queries: {[key: string]: any} = {};
+
+    Object.keys(propertyMetadata).forEach((propName: string) => {
+      const input = findLast(propertyMetadata[propName], (a) => createInput.isTypeOf(a));
+      if (input) {
+        if (input.bindingPropertyName) {
+          inputs.push(`${propName}: ${input.bindingPropertyName}`);
+        } else {
+          inputs.push(propName);
+        }
+      }
+      const output = findLast(propertyMetadata[propName], (a) => createOutput.isTypeOf(a));
+      if (output) {
+        if (output.bindingPropertyName) {
+          outputs.push(`${propName}: ${output.bindingPropertyName}`);
+        } else {
+          outputs.push(propName);
+        }
+      }
+      const hostBindings = propertyMetadata[propName].filter(a => createHostBinding.isTypeOf(a));
+      hostBindings.forEach(hostBinding => {
+        if (hostBinding.hostPropertyName) {
+          const startWith = hostBinding.hostPropertyName[0];
+          if (startWith === '(') {
+            throw new Error(`@HostBinding can not bind to events. Use @HostListener instead.`);
+          } else if (startWith === '[') {
+            throw new Error(
+                `@HostBinding parameter should be a property name, 'class.<name>', or 'attr.<name>'.`);
+          }
+          host[`[${hostBinding.hostPropertyName}]`] = propName;
+        } else {
+          host[`[${propName}]`] = propName;
+        }
+      });
+      const hostListeners = propertyMetadata[propName].filter(a => createHostListener.isTypeOf(a));
+      hostListeners.forEach(hostListener => {
+        const args = hostListener.args || [];
+        host[`(${hostListener.eventName})`] = `${propName}(${args.join(',')})`;
+      });
+      const query = findLast(
+          propertyMetadata[propName], (a) => QUERY_METADATA_IDENTIFIERS.some(i => i.isTypeOf(a)));
+      if (query) {
+        queries[propName] = query;
+      }
+    });
+    return this._merge(dm, inputs, outputs, host, queries, directiveType);
+  }
+
+  private _extractPublicName(def: string) { return splitAtColon(def, [null !, def])[1].trim(); }
+
+  private _dedupeBindings(bindings: string[]): string[] {
+    const names = new Set<string>();
+    const reversedResult: string[] = [];
+    // go last to first to allow later entries to overwrite previous entries
+    for (let i = bindings.length - 1; i >= 0; i--) {
+      const binding = bindings[i];
+      const name = this._extractPublicName(binding);
+      if (!names.has(name)) {
+        names.add(name);
+        reversedResult.push(binding);
+      }
+    }
+    return reversedResult.reverse();
+  }
+
+  private _merge(
+      directive: Directive, inputs: string[], outputs: string[], host: {[key: string]: string},
+      queries: {[key: string]: any}, directiveType: Type): Directive {
+    const mergedInputs =
+        this._dedupeBindings(directive.inputs ? directive.inputs.concat(inputs) : inputs);
+    const mergedOutputs =
+        this._dedupeBindings(directive.outputs ? directive.outputs.concat(outputs) : outputs);
+    const mergedHost = directive.host ? {...directive.host, ...host} : host;
+    const mergedQueries = directive.queries ? {...directive.queries, ...queries} : queries;
+
+    if (createComponent.isTypeOf(directive)) {
+      const comp = directive as Component;
+      return createComponent({
+        selector: comp.selector,
+        inputs: mergedInputs,
+        outputs: mergedOutputs,
+        host: mergedHost,
+        exportAs: comp.exportAs,
+        moduleId: comp.moduleId,
+        queries: mergedQueries,
+        changeDetection: comp.changeDetection,
+        providers: comp.providers,
+        viewProviders: comp.viewProviders,
+        entryComponents: comp.entryComponents,
+        template: comp.template,
+        templateUrl: comp.templateUrl,
+        styles: comp.styles,
+        styleUrls: comp.styleUrls,
+        encapsulation: comp.encapsulation,
+        animations: comp.animations,
+        interpolation: comp.interpolation,
+        preserveWhitespaces: directive.preserveWhitespaces,
+      });
+    } else {
+      return createDirective({
+        selector: directive.selector,
+        inputs: mergedInputs,
+        outputs: mergedOutputs,
+        host: mergedHost,
+        exportAs: directive.exportAs,
+        queries: mergedQueries,
+        providers: directive.providers
+      });
+    }
+  }
+}
+
+function isDirectiveMetadata(type: any): type is Directive {
+  return createDirective.isTypeOf(type) || createComponent.isTypeOf(type);
+}
+
+export function findLast<T>(arr: T[], condition: (value: T) => boolean): T|null {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (condition(arr[i])) {
+      return arr[i];
+    }
+  }
+  return null;
+}
diff --git a/angular/compiler/src/expression_parser/ast.ts b/angular/compiler/src/expression_parser/ast.ts
new file mode 100644
index 0000000..b6b1b03
--- /dev/null
+++ b/angular/compiler/src/expression_parser/ast.ts
@@ -0,0 +1,498 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+
+export class ParserError {
+  public message: string;
+  constructor(
+      message: string, public input: string, public errLocation: string, public ctxLocation?: any) {
+    this.message = `Parser Error: ${message} ${errLocation} [${input}] in ${ctxLocation}`;
+  }
+}
+
+export class ParseSpan {
+  constructor(public start: number, public end: number) {}
+}
+
+export class AST {
+  constructor(public span: ParseSpan) {}
+  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(
+      span: ParseSpan, public prefix: string, public uninterpretedExpression: string,
+      public location: any) {
+    super(span);
+  }
+  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(span: ParseSpan, public expressions: any[]) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any { return visitor.visitChain(this, context); }
+}
+
+export class Conditional extends AST {
+  constructor(span: ParseSpan, public condition: AST, public trueExp: AST, public falseExp: AST) {
+    super(span);
+  }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitConditional(this, context);
+  }
+}
+
+export class PropertyRead extends AST {
+  constructor(span: ParseSpan, public receiver: AST, public name: string) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitPropertyRead(this, context);
+  }
+}
+
+export class PropertyWrite extends AST {
+  constructor(span: ParseSpan, public receiver: AST, public name: string, public value: AST) {
+    super(span);
+  }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitPropertyWrite(this, context);
+  }
+}
+
+export class SafePropertyRead extends AST {
+  constructor(span: ParseSpan, public receiver: AST, public name: string) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitSafePropertyRead(this, context);
+  }
+}
+
+export class KeyedRead extends AST {
+  constructor(span: ParseSpan, public obj: AST, public key: AST) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitKeyedRead(this, context);
+  }
+}
+
+export class KeyedWrite extends AST {
+  constructor(span: ParseSpan, public obj: AST, public key: AST, public value: AST) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitKeyedWrite(this, context);
+  }
+}
+
+export class BindingPipe extends AST {
+  constructor(span: ParseSpan, public exp: AST, public name: string, public args: any[]) {
+    super(span);
+  }
+  visit(visitor: AstVisitor, context: any = null): any { return visitor.visitPipe(this, context); }
+}
+
+export class LiteralPrimitive extends AST {
+  constructor(span: ParseSpan, public value: any) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitLiteralPrimitive(this, context);
+  }
+}
+
+export class LiteralArray extends AST {
+  constructor(span: ParseSpan, public expressions: any[]) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitLiteralArray(this, context);
+  }
+}
+
+export type LiteralMapKey = {
+  key: string; quoted: boolean;
+};
+
+export class LiteralMap extends AST {
+  constructor(span: ParseSpan, public keys: LiteralMapKey[], public values: any[]) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitLiteralMap(this, context);
+  }
+}
+
+export class Interpolation extends AST {
+  constructor(span: ParseSpan, public strings: any[], public expressions: any[]) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitInterpolation(this, context);
+  }
+}
+
+export class Binary extends AST {
+  constructor(span: ParseSpan, public operation: string, public left: AST, public right: AST) {
+    super(span);
+  }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitBinary(this, context);
+  }
+}
+
+export class PrefixNot extends AST {
+  constructor(span: ParseSpan, public expression: AST) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitPrefixNot(this, context);
+  }
+}
+
+export class NonNullAssert extends AST {
+  constructor(span: ParseSpan, public expression: AST) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitNonNullAssert(this, context);
+  }
+}
+
+export class MethodCall extends AST {
+  constructor(span: ParseSpan, public receiver: AST, public name: string, public args: any[]) {
+    super(span);
+  }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitMethodCall(this, context);
+  }
+}
+
+export class SafeMethodCall extends AST {
+  constructor(span: ParseSpan, public receiver: AST, public name: string, public args: any[]) {
+    super(span);
+  }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitSafeMethodCall(this, context);
+  }
+}
+
+export class FunctionCall extends AST {
+  constructor(span: ParseSpan, public target: AST|null, public args: any[]) { super(span); }
+  visit(visitor: AstVisitor, context: any = null): any {
+    return visitor.visitFunctionCall(this, context);
+  }
+}
+
+export class ASTWithSource extends AST {
+  constructor(
+      public ast: AST, public source: string|null, public location: string,
+      public errors: ParserError[]) {
+    super(new ParseSpan(0, source == null ? 0 : source.length));
+  }
+  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 span: ParseSpan, 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;
+  visitNonNullAssert(ast: NonNullAssert, 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;
+  visit?(ast: AST, context?: any): any;
+}
+
+export class NullAstVisitor implements 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 {}
+  visitNonNullAssert(ast: NonNullAssert, 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;
+  }
+  visitNonNullAssert(ast: NonNullAssert, 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.span, ast.strings, this.visitAll(ast.expressions));
+  }
+
+  visitLiteralPrimitive(ast: LiteralPrimitive, context: any): AST {
+    return new LiteralPrimitive(ast.span, ast.value);
+  }
+
+  visitPropertyRead(ast: PropertyRead, context: any): AST {
+    return new PropertyRead(ast.span, ast.receiver.visit(this), ast.name);
+  }
+
+  visitPropertyWrite(ast: PropertyWrite, context: any): AST {
+    return new PropertyWrite(ast.span, ast.receiver.visit(this), ast.name, ast.value.visit(this));
+  }
+
+  visitSafePropertyRead(ast: SafePropertyRead, context: any): AST {
+    return new SafePropertyRead(ast.span, ast.receiver.visit(this), ast.name);
+  }
+
+  visitMethodCall(ast: MethodCall, context: any): AST {
+    return new MethodCall(ast.span, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
+  }
+
+  visitSafeMethodCall(ast: SafeMethodCall, context: any): AST {
+    return new SafeMethodCall(
+        ast.span, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
+  }
+
+  visitFunctionCall(ast: FunctionCall, context: any): AST {
+    return new FunctionCall(ast.span, ast.target !.visit(this), this.visitAll(ast.args));
+  }
+
+  visitLiteralArray(ast: LiteralArray, context: any): AST {
+    return new LiteralArray(ast.span, this.visitAll(ast.expressions));
+  }
+
+  visitLiteralMap(ast: LiteralMap, context: any): AST {
+    return new LiteralMap(ast.span, ast.keys, this.visitAll(ast.values));
+  }
+
+  visitBinary(ast: Binary, context: any): AST {
+    return new Binary(ast.span, ast.operation, ast.left.visit(this), ast.right.visit(this));
+  }
+
+  visitPrefixNot(ast: PrefixNot, context: any): AST {
+    return new PrefixNot(ast.span, ast.expression.visit(this));
+  }
+
+  visitNonNullAssert(ast: NonNullAssert, context: any): AST {
+    return new NonNullAssert(ast.span, ast.expression.visit(this));
+  }
+
+  visitConditional(ast: Conditional, context: any): AST {
+    return new Conditional(
+        ast.span, ast.condition.visit(this), ast.trueExp.visit(this), ast.falseExp.visit(this));
+  }
+
+  visitPipe(ast: BindingPipe, context: any): AST {
+    return new BindingPipe(ast.span, ast.exp.visit(this), ast.name, this.visitAll(ast.args));
+  }
+
+  visitKeyedRead(ast: KeyedRead, context: any): AST {
+    return new KeyedRead(ast.span, ast.obj.visit(this), ast.key.visit(this));
+  }
+
+  visitKeyedWrite(ast: KeyedWrite, context: any): AST {
+    return new KeyedWrite(
+        ast.span, ast.obj.visit(this), ast.key.visit(this), ast.value.visit(this));
+  }
+
+  visitAll(asts: any[]): any[] {
+    const res = new Array(asts.length);
+    for (let i = 0; i < asts.length; ++i) {
+      res[i] = asts[i].visit(this);
+    }
+    return res;
+  }
+
+  visitChain(ast: Chain, context: any): AST {
+    return new Chain(ast.span, this.visitAll(ast.expressions));
+  }
+
+  visitQuote(ast: Quote, context: any): AST {
+    return new Quote(ast.span, ast.prefix, ast.uninterpretedExpression, ast.location);
+  }
+}
+
+export function visitAstChildren(ast: AST, visitor: AstVisitor, context?: any) {
+  function visit(ast: AST) {
+    visitor.visit && visitor.visit(ast, context) || ast.visit(visitor, context);
+  }
+
+  function visitAll<T extends AST>(asts: T[]) { asts.forEach(visit); }
+
+  ast.visit({
+    visitBinary(ast) {
+      visit(ast.left);
+      visit(ast.right);
+    },
+    visitChain(ast) { visitAll(ast.expressions); },
+    visitConditional(ast) {
+      visit(ast.condition);
+      visit(ast.trueExp);
+      visit(ast.falseExp);
+    },
+    visitFunctionCall(ast) {
+      if (ast.target) {
+        visit(ast.target);
+      }
+      visitAll(ast.args);
+    },
+    visitImplicitReceiver(ast) {},
+    visitInterpolation(ast) { visitAll(ast.expressions); },
+    visitKeyedRead(ast) {
+      visit(ast.obj);
+      visit(ast.key);
+    },
+    visitKeyedWrite(ast) {
+      visit(ast.obj);
+      visit(ast.key);
+      visit(ast.obj);
+    },
+    visitLiteralArray(ast) { visitAll(ast.expressions); },
+    visitLiteralMap(ast) {},
+    visitLiteralPrimitive(ast) {},
+    visitMethodCall(ast) {
+      visit(ast.receiver);
+      visitAll(ast.args);
+    },
+    visitPipe(ast) {
+      visit(ast.exp);
+      visitAll(ast.args);
+    },
+    visitPrefixNot(ast) { visit(ast.expression); },
+    visitNonNullAssert(ast) { visit(ast.expression); },
+    visitPropertyRead(ast) { visit(ast.receiver); },
+    visitPropertyWrite(ast) {
+      visit(ast.receiver);
+      visit(ast.value);
+    },
+    visitQuote(ast) {},
+    visitSafeMethodCall(ast) {
+      visit(ast.receiver);
+      visitAll(ast.args);
+    },
+    visitSafePropertyRead(ast) { visit(ast.receiver); },
+  });
+}
diff --git a/angular/compiler/src/expression_parser/lexer.ts b/angular/compiler/src/expression_parser/lexer.ts
new file mode 100644
index 0000000..cc485ea
--- /dev/null
+++ b/angular/compiler/src/expression_parser/lexer.ts
@@ -0,0 +1,391 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as chars from '../chars';
+
+export enum TokenType {
+  Character,
+  Identifier,
+  Keyword,
+  String,
+  Operator,
+  Number,
+  Error
+}
+
+const KEYWORDS = ['var', 'let', 'as', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];
+
+export class Lexer {
+  tokenize(text: string): Token[] {
+    const scanner = new _Scanner(text);
+    const tokens: Token[] = [];
+    let token = scanner.scanToken();
+    while (token != null) {
+      tokens.push(token);
+      token = scanner.scanToken();
+    }
+    return tokens;
+  }
+}
+
+export class Token {
+  constructor(
+      public index: number, public type: TokenType, public numValue: number,
+      public strValue: string) {}
+
+  isCharacter(code: number): boolean {
+    return this.type == TokenType.Character && this.numValue == code;
+  }
+
+  isNumber(): boolean { return this.type == TokenType.Number; }
+
+  isString(): boolean { return this.type == TokenType.String; }
+
+  isOperator(operater: string): boolean {
+    return this.type == TokenType.Operator && this.strValue == operater;
+  }
+
+  isIdentifier(): boolean { return this.type == TokenType.Identifier; }
+
+  isKeyword(): boolean { return this.type == TokenType.Keyword; }
+
+  isKeywordLet(): boolean { return this.type == TokenType.Keyword && this.strValue == 'let'; }
+
+  isKeywordAs(): boolean { return this.type == TokenType.Keyword && this.strValue == 'as'; }
+
+  isKeywordNull(): boolean { return this.type == TokenType.Keyword && this.strValue == 'null'; }
+
+  isKeywordUndefined(): boolean {
+    return this.type == TokenType.Keyword && this.strValue == 'undefined';
+  }
+
+  isKeywordTrue(): boolean { return this.type == TokenType.Keyword && this.strValue == 'true'; }
+
+  isKeywordFalse(): boolean { return this.type == TokenType.Keyword && this.strValue == 'false'; }
+
+  isKeywordThis(): boolean { return this.type == TokenType.Keyword && this.strValue == 'this'; }
+
+  isError(): boolean { return this.type == TokenType.Error; }
+
+  toNumber(): number { return this.type == TokenType.Number ? this.numValue : -1; }
+
+  toString(): string|null {
+    switch (this.type) {
+      case TokenType.Character:
+      case TokenType.Identifier:
+      case TokenType.Keyword:
+      case TokenType.Operator:
+      case TokenType.String:
+      case TokenType.Error:
+        return this.strValue;
+      case TokenType.Number:
+        return this.numValue.toString();
+      default:
+        return null;
+    }
+  }
+}
+
+function newCharacterToken(index: number, code: number): Token {
+  return new Token(index, TokenType.Character, code, String.fromCharCode(code));
+}
+
+function newIdentifierToken(index: number, text: string): Token {
+  return new Token(index, TokenType.Identifier, 0, text);
+}
+
+function newKeywordToken(index: number, text: string): Token {
+  return new Token(index, TokenType.Keyword, 0, text);
+}
+
+function newOperatorToken(index: number, text: string): Token {
+  return new Token(index, TokenType.Operator, 0, text);
+}
+
+function newStringToken(index: number, text: string): Token {
+  return new Token(index, TokenType.String, 0, text);
+}
+
+function newNumberToken(index: number, n: number): Token {
+  return new Token(index, TokenType.Number, n, '');
+}
+
+function newErrorToken(index: number, message: string): Token {
+  return new Token(index, TokenType.Error, 0, message);
+}
+
+export const EOF: Token = new Token(-1, TokenType.Character, 0, '');
+
+class _Scanner {
+  length: number;
+  peek: number = 0;
+  index: number = -1;
+
+  constructor(public input: string) {
+    this.length = input.length;
+    this.advance();
+  }
+
+  advance() {
+    this.peek = ++this.index >= this.length ? chars.$EOF : this.input.charCodeAt(this.index);
+  }
+
+  scanToken(): Token|null {
+    const input = this.input, length = this.length;
+    let peek = this.peek, index = this.index;
+
+    // Skip whitespace.
+    while (peek <= chars.$SPACE) {
+      if (++index >= length) {
+        peek = chars.$EOF;
+        break;
+      } else {
+        peek = input.charCodeAt(index);
+      }
+    }
+
+    this.peek = peek;
+    this.index = index;
+
+    if (index >= length) {
+      return null;
+    }
+
+    // Handle identifiers and numbers.
+    if (isIdentifierStart(peek)) return this.scanIdentifier();
+    if (chars.isDigit(peek)) return this.scanNumber(index);
+
+    const start: number = index;
+    switch (peek) {
+      case chars.$PERIOD:
+        this.advance();
+        return chars.isDigit(this.peek) ? this.scanNumber(start) :
+                                          newCharacterToken(start, chars.$PERIOD);
+      case chars.$LPAREN:
+      case chars.$RPAREN:
+      case chars.$LBRACE:
+      case chars.$RBRACE:
+      case chars.$LBRACKET:
+      case chars.$RBRACKET:
+      case chars.$COMMA:
+      case chars.$COLON:
+      case chars.$SEMICOLON:
+        return this.scanCharacter(start, peek);
+      case chars.$SQ:
+      case chars.$DQ:
+        return this.scanString();
+      case chars.$HASH:
+      case chars.$PLUS:
+      case chars.$MINUS:
+      case chars.$STAR:
+      case chars.$SLASH:
+      case chars.$PERCENT:
+      case chars.$CARET:
+        return this.scanOperator(start, String.fromCharCode(peek));
+      case chars.$QUESTION:
+        return this.scanComplexOperator(start, '?', chars.$PERIOD, '.');
+      case chars.$LT:
+      case chars.$GT:
+        return this.scanComplexOperator(start, String.fromCharCode(peek), chars.$EQ, '=');
+      case chars.$BANG:
+      case chars.$EQ:
+        return this.scanComplexOperator(
+            start, String.fromCharCode(peek), chars.$EQ, '=', chars.$EQ, '=');
+      case chars.$AMPERSAND:
+        return this.scanComplexOperator(start, '&', chars.$AMPERSAND, '&');
+      case chars.$BAR:
+        return this.scanComplexOperator(start, '|', chars.$BAR, '|');
+      case chars.$NBSP:
+        while (chars.isWhitespace(this.peek)) this.advance();
+        return this.scanToken();
+    }
+
+    this.advance();
+    return this.error(`Unexpected character [${String.fromCharCode(peek)}]`, 0);
+  }
+
+  scanCharacter(start: number, code: number): Token {
+    this.advance();
+    return newCharacterToken(start, code);
+  }
+
+
+  scanOperator(start: number, str: string): Token {
+    this.advance();
+    return newOperatorToken(start, str);
+  }
+
+  /**
+   * Tokenize a 2/3 char long operator
+   *
+   * @param start start index in the expression
+   * @param one first symbol (always part of the operator)
+   * @param twoCode code point for the second symbol
+   * @param two second symbol (part of the operator when the second code point matches)
+   * @param threeCode code point for the third symbol
+   * @param three third symbol (part of the operator when provided and matches source expression)
+   */
+  scanComplexOperator(
+      start: number, one: string, twoCode: number, two: string, threeCode?: number,
+      three?: string): Token {
+    this.advance();
+    let str: string = one;
+    if (this.peek == twoCode) {
+      this.advance();
+      str += two;
+    }
+    if (threeCode != null && this.peek == threeCode) {
+      this.advance();
+      str += three;
+    }
+    return newOperatorToken(start, str);
+  }
+
+  scanIdentifier(): Token {
+    const start: number = this.index;
+    this.advance();
+    while (isIdentifierPart(this.peek)) this.advance();
+    const str: string = this.input.substring(start, this.index);
+    return KEYWORDS.indexOf(str) > -1 ? newKeywordToken(start, str) :
+                                        newIdentifierToken(start, str);
+  }
+
+  scanNumber(start: number): Token {
+    let simple: boolean = (this.index === start);
+    this.advance();  // Skip initial digit.
+    while (true) {
+      if (chars.isDigit(this.peek)) {
+        // Do nothing.
+      } else if (this.peek == chars.$PERIOD) {
+        simple = false;
+      } else if (isExponentStart(this.peek)) {
+        this.advance();
+        if (isExponentSign(this.peek)) this.advance();
+        if (!chars.isDigit(this.peek)) return this.error('Invalid exponent', -1);
+        simple = false;
+      } else {
+        break;
+      }
+      this.advance();
+    }
+    const str: string = this.input.substring(start, this.index);
+    const value: number = simple ? parseIntAutoRadix(str) : parseFloat(str);
+    return newNumberToken(start, value);
+  }
+
+  scanString(): Token {
+    const start: number = this.index;
+    const quote: number = this.peek;
+    this.advance();  // Skip initial quote.
+
+    let buffer: string = '';
+    let marker: number = this.index;
+    const input: string = this.input;
+
+    while (this.peek != quote) {
+      if (this.peek == chars.$BACKSLASH) {
+        buffer += input.substring(marker, this.index);
+        this.advance();
+        let unescapedCode: number;
+        // Workaround for TS2.1-introduced type strictness
+        this.peek = this.peek;
+        if (this.peek == chars.$u) {
+          // 4 character hex code for unicode character.
+          const hex: string = input.substring(this.index + 1, this.index + 5);
+          if (/^[0-9a-f]+$/i.test(hex)) {
+            unescapedCode = parseInt(hex, 16);
+          } else {
+            return this.error(`Invalid unicode escape [\\u${hex}]`, 0);
+          }
+          for (let i: number = 0; i < 5; i++) {
+            this.advance();
+          }
+        } else {
+          unescapedCode = unescape(this.peek);
+          this.advance();
+        }
+        buffer += String.fromCharCode(unescapedCode);
+        marker = this.index;
+      } else if (this.peek == chars.$EOF) {
+        return this.error('Unterminated quote', 0);
+      } else {
+        this.advance();
+      }
+    }
+
+    const last: string = input.substring(marker, this.index);
+    this.advance();  // Skip terminating quote.
+
+    return newStringToken(start, buffer + last);
+  }
+
+  error(message: string, offset: number): Token {
+    const position: number = this.index + offset;
+    return newErrorToken(
+        position, `Lexer Error: ${message} at column ${position} in expression [${this.input}]`);
+  }
+}
+
+function isIdentifierStart(code: number): boolean {
+  return (chars.$a <= code && code <= chars.$z) || (chars.$A <= code && code <= chars.$Z) ||
+      (code == chars.$_) || (code == chars.$$);
+}
+
+export function isIdentifier(input: string): boolean {
+  if (input.length == 0) return false;
+  const scanner = new _Scanner(input);
+  if (!isIdentifierStart(scanner.peek)) return false;
+  scanner.advance();
+  while (scanner.peek !== chars.$EOF) {
+    if (!isIdentifierPart(scanner.peek)) return false;
+    scanner.advance();
+  }
+  return true;
+}
+
+function isIdentifierPart(code: number): boolean {
+  return chars.isAsciiLetter(code) || chars.isDigit(code) || (code == chars.$_) ||
+      (code == chars.$$);
+}
+
+function isExponentStart(code: number): boolean {
+  return code == chars.$e || code == chars.$E;
+}
+
+function isExponentSign(code: number): boolean {
+  return code == chars.$MINUS || code == chars.$PLUS;
+}
+
+export function isQuote(code: number): boolean {
+  return code === chars.$SQ || code === chars.$DQ || code === chars.$BT;
+}
+
+function unescape(code: number): number {
+  switch (code) {
+    case chars.$n:
+      return chars.$LF;
+    case chars.$f:
+      return chars.$FF;
+    case chars.$r:
+      return chars.$CR;
+    case chars.$t:
+      return chars.$TAB;
+    case chars.$v:
+      return chars.$VTAB;
+    default:
+      return code;
+  }
+}
+
+function parseIntAutoRadix(text: string): number {
+  const result: number = parseInt(text);
+  if (isNaN(result)) {
+    throw new Error('Invalid integer literal when parsing ' + text);
+  }
+  return result;
+}
diff --git a/angular/compiler/src/expression_parser/parser.ts b/angular/compiler/src/expression_parser/parser.ts
new file mode 100644
index 0000000..93d2362
--- /dev/null
+++ b/angular/compiler/src/expression_parser/parser.ts
@@ -0,0 +1,831 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as chars from '../chars';
+import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from '../ml_parser/interpolation_config';
+import {escapeRegExp} from '../util';
+
+import {AST, ASTWithSource, AstVisitor, Binary, BindingPipe, Chain, Conditional, EmptyExpr, FunctionCall, ImplicitReceiver, Interpolation, KeyedRead, KeyedWrite, LiteralArray, LiteralMap, LiteralMapKey, LiteralPrimitive, MethodCall, NonNullAssert, ParseSpan, ParserError, PrefixNot, PropertyRead, PropertyWrite, Quote, SafeMethodCall, SafePropertyRead, TemplateBinding} from './ast';
+import {EOF, Lexer, Token, TokenType, isIdentifier, isQuote} from './lexer';
+
+export class SplitInterpolation {
+  constructor(public strings: string[], public expressions: string[], public offsets: number[]) {}
+}
+
+export class TemplateBindingParseResult {
+  constructor(
+      public templateBindings: TemplateBinding[], public warnings: string[],
+      public errors: ParserError[]) {}
+}
+
+function _createInterpolateRegExp(config: InterpolationConfig): RegExp {
+  const pattern = escapeRegExp(config.start) + '([\\s\\S]*?)' + escapeRegExp(config.end);
+  return new RegExp(pattern, 'g');
+}
+
+export class Parser {
+  private errors: ParserError[] = [];
+
+  constructor(private _lexer: Lexer) {}
+
+  parseAction(
+      input: string, location: any,
+      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource {
+    this._checkNoInterpolation(input, location, interpolationConfig);
+    const sourceToLex = this._stripComments(input);
+    const tokens = this._lexer.tokenize(this._stripComments(input));
+    const ast = new _ParseAST(
+                    input, location, tokens, sourceToLex.length, true, this.errors,
+                    input.length - sourceToLex.length)
+                    .parseChain();
+    return new ASTWithSource(ast, input, location, this.errors);
+  }
+
+  parseBinding(
+      input: string, location: any,
+      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource {
+    const ast = this._parseBindingAst(input, location, interpolationConfig);
+    return new ASTWithSource(ast, input, location, this.errors);
+  }
+
+  parseSimpleBinding(
+      input: string, location: string,
+      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource {
+    const ast = this._parseBindingAst(input, location, interpolationConfig);
+    const errors = SimpleExpressionChecker.check(ast);
+    if (errors.length > 0) {
+      this._reportError(
+          `Host binding expression cannot contain ${errors.join(' ')}`, input, location);
+    }
+    return new ASTWithSource(ast, input, location, this.errors);
+  }
+
+  private _reportError(message: string, input: string, errLocation: string, ctxLocation?: any) {
+    this.errors.push(new ParserError(message, input, errLocation, ctxLocation));
+  }
+
+  private _parseBindingAst(
+      input: string, location: string, interpolationConfig: InterpolationConfig): AST {
+    // Quotes expressions use 3rd-party expression language. We don't want to use
+    // our lexer or parser for that, so we check for that ahead of time.
+    const quote = this._parseQuote(input, location);
+
+    if (quote != null) {
+      return quote;
+    }
+
+    this._checkNoInterpolation(input, location, interpolationConfig);
+    const sourceToLex = this._stripComments(input);
+    const tokens = this._lexer.tokenize(sourceToLex);
+    return new _ParseAST(
+               input, location, tokens, sourceToLex.length, false, this.errors,
+               input.length - sourceToLex.length)
+        .parseChain();
+  }
+
+  private _parseQuote(input: string|null, location: any): AST|null {
+    if (input == null) return null;
+    const prefixSeparatorIndex = input.indexOf(':');
+    if (prefixSeparatorIndex == -1) return null;
+    const prefix = input.substring(0, prefixSeparatorIndex).trim();
+    if (!isIdentifier(prefix)) return null;
+    const uninterpretedExpression = input.substring(prefixSeparatorIndex + 1);
+    return new Quote(new ParseSpan(0, input.length), prefix, uninterpretedExpression, location);
+  }
+
+  parseTemplateBindings(prefixToken: string|null, input: string, location: any):
+      TemplateBindingParseResult {
+    const tokens = this._lexer.tokenize(input);
+    if (prefixToken) {
+      // Prefix the tokens with the tokens from prefixToken but have them take no space (0 index).
+      const prefixTokens = this._lexer.tokenize(prefixToken).map(t => {
+        t.index = 0;
+        return t;
+      });
+      tokens.unshift(...prefixTokens);
+    }
+    return new _ParseAST(input, location, tokens, input.length, false, this.errors, 0)
+        .parseTemplateBindings();
+  }
+
+  parseInterpolation(
+      input: string, location: any,
+      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource|null {
+    const split = this.splitInterpolation(input, location, interpolationConfig);
+    if (split == null) return null;
+
+    const expressions: AST[] = [];
+
+    for (let i = 0; i < split.expressions.length; ++i) {
+      const expressionText = split.expressions[i];
+      const sourceToLex = this._stripComments(expressionText);
+      const tokens = this._lexer.tokenize(sourceToLex);
+      const ast = new _ParseAST(
+                      input, location, tokens, sourceToLex.length, false, this.errors,
+                      split.offsets[i] + (expressionText.length - sourceToLex.length))
+                      .parseChain();
+      expressions.push(ast);
+    }
+
+    return new ASTWithSource(
+        new Interpolation(
+            new ParseSpan(0, input == null ? 0 : input.length), split.strings, expressions),
+        input, location, this.errors);
+  }
+
+  splitInterpolation(
+      input: string, location: string,
+      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): SplitInterpolation
+      |null {
+    const regexp = _createInterpolateRegExp(interpolationConfig);
+    const parts = input.split(regexp);
+    if (parts.length <= 1) {
+      return null;
+    }
+    const strings: string[] = [];
+    const expressions: string[] = [];
+    const offsets: number[] = [];
+    let offset = 0;
+    for (let i = 0; i < parts.length; i++) {
+      const part: string = parts[i];
+      if (i % 2 === 0) {
+        // fixed string
+        strings.push(part);
+        offset += part.length;
+      } else if (part.trim().length > 0) {
+        offset += interpolationConfig.start.length;
+        expressions.push(part);
+        offsets.push(offset);
+        offset += part.length + interpolationConfig.end.length;
+      } else {
+        this._reportError(
+            'Blank expressions are not allowed in interpolated strings', input,
+            `at column ${this._findInterpolationErrorColumn(parts, i, interpolationConfig)} in`,
+            location);
+        expressions.push('$implict');
+        offsets.push(offset);
+      }
+    }
+    return new SplitInterpolation(strings, expressions, offsets);
+  }
+
+  wrapLiteralPrimitive(input: string|null, location: any): ASTWithSource {
+    return new ASTWithSource(
+        new LiteralPrimitive(new ParseSpan(0, input == null ? 0 : input.length), input), input,
+        location, this.errors);
+  }
+
+  private _stripComments(input: string): string {
+    const i = this._commentStart(input);
+    return i != null ? input.substring(0, i).trim() : input;
+  }
+
+  private _commentStart(input: string): number|null {
+    let outerQuote: number|null = null;
+    for (let i = 0; i < input.length - 1; i++) {
+      const char = input.charCodeAt(i);
+      const nextChar = input.charCodeAt(i + 1);
+
+      if (char === chars.$SLASH && nextChar == chars.$SLASH && outerQuote == null) return i;
+
+      if (outerQuote === char) {
+        outerQuote = null;
+      } else if (outerQuote == null && isQuote(char)) {
+        outerQuote = char;
+      }
+    }
+    return null;
+  }
+
+  private _checkNoInterpolation(
+      input: string, location: any, interpolationConfig: InterpolationConfig): void {
+    const regexp = _createInterpolateRegExp(interpolationConfig);
+    const parts = input.split(regexp);
+    if (parts.length > 1) {
+      this._reportError(
+          `Got interpolation (${interpolationConfig.start}${interpolationConfig.end}) where expression was expected`,
+          input,
+          `at column ${this._findInterpolationErrorColumn(parts, 1, interpolationConfig)} in`,
+          location);
+    }
+  }
+
+  private _findInterpolationErrorColumn(
+      parts: string[], partInErrIdx: number, interpolationConfig: InterpolationConfig): number {
+    let errLocation = '';
+    for (let j = 0; j < partInErrIdx; j++) {
+      errLocation += j % 2 === 0 ?
+          parts[j] :
+          `${interpolationConfig.start}${parts[j]}${interpolationConfig.end}`;
+    }
+
+    return errLocation.length;
+  }
+}
+
+export class _ParseAST {
+  private rparensExpected = 0;
+  private rbracketsExpected = 0;
+  private rbracesExpected = 0;
+
+  index: number = 0;
+
+  constructor(
+      public input: string, public location: any, public tokens: Token[],
+      public inputLength: number, public parseAction: boolean, private errors: ParserError[],
+      private offset: number) {}
+
+  peek(offset: number): Token {
+    const i = this.index + offset;
+    return i < this.tokens.length ? this.tokens[i] : EOF;
+  }
+
+  get next(): Token { return this.peek(0); }
+
+  get inputIndex(): number {
+    return (this.index < this.tokens.length) ? this.next.index + this.offset :
+                                               this.inputLength + this.offset;
+  }
+
+  span(start: number) { return new ParseSpan(start, this.inputIndex); }
+
+  advance() { this.index++; }
+
+  optionalCharacter(code: number): boolean {
+    if (this.next.isCharacter(code)) {
+      this.advance();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  peekKeywordLet(): boolean { return this.next.isKeywordLet(); }
+  peekKeywordAs(): boolean { return this.next.isKeywordAs(); }
+
+  expectCharacter(code: number) {
+    if (this.optionalCharacter(code)) return;
+    this.error(`Missing expected ${String.fromCharCode(code)}`);
+  }
+
+  optionalOperator(op: string): boolean {
+    if (this.next.isOperator(op)) {
+      this.advance();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  expectOperator(operator: string) {
+    if (this.optionalOperator(operator)) return;
+    this.error(`Missing expected operator ${operator}`);
+  }
+
+  expectIdentifierOrKeyword(): string {
+    const n = this.next;
+    if (!n.isIdentifier() && !n.isKeyword()) {
+      this.error(`Unexpected token ${n}, expected identifier or keyword`);
+      return '';
+    }
+    this.advance();
+    return n.toString() as string;
+  }
+
+  expectIdentifierOrKeywordOrString(): string {
+    const n = this.next;
+    if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) {
+      this.error(`Unexpected token ${n}, expected identifier, keyword, or string`);
+      return '';
+    }
+    this.advance();
+    return n.toString() as string;
+  }
+
+  parseChain(): AST {
+    const exprs: AST[] = [];
+    const start = this.inputIndex;
+    while (this.index < this.tokens.length) {
+      const expr = this.parsePipe();
+      exprs.push(expr);
+
+      if (this.optionalCharacter(chars.$SEMICOLON)) {
+        if (!this.parseAction) {
+          this.error('Binding expression cannot contain chained expression');
+        }
+        while (this.optionalCharacter(chars.$SEMICOLON)) {
+        }  // read all semicolons
+      } else if (this.index < this.tokens.length) {
+        this.error(`Unexpected token '${this.next}'`);
+      }
+    }
+    if (exprs.length == 0) return new EmptyExpr(this.span(start));
+    if (exprs.length == 1) return exprs[0];
+    return new Chain(this.span(start), exprs);
+  }
+
+  parsePipe(): AST {
+    let result = this.parseExpression();
+    if (this.optionalOperator('|')) {
+      if (this.parseAction) {
+        this.error('Cannot have a pipe in an action expression');
+      }
+
+      do {
+        const name = this.expectIdentifierOrKeyword();
+        const args: AST[] = [];
+        while (this.optionalCharacter(chars.$COLON)) {
+          args.push(this.parseExpression());
+        }
+        result = new BindingPipe(this.span(result.span.start), result, name, args);
+      } while (this.optionalOperator('|'));
+    }
+
+    return result;
+  }
+
+  parseExpression(): AST { return this.parseConditional(); }
+
+  parseConditional(): AST {
+    const start = this.inputIndex;
+    const result = this.parseLogicalOr();
+
+    if (this.optionalOperator('?')) {
+      const yes = this.parsePipe();
+      let no: AST;
+      if (!this.optionalCharacter(chars.$COLON)) {
+        const end = this.inputIndex;
+        const expression = this.input.substring(start, end);
+        this.error(`Conditional expression ${expression} requires all 3 expressions`);
+        no = new EmptyExpr(this.span(start));
+      } else {
+        no = this.parsePipe();
+      }
+      return new Conditional(this.span(start), result, yes, no);
+    } else {
+      return result;
+    }
+  }
+
+  parseLogicalOr(): AST {
+    // '||'
+    let result = this.parseLogicalAnd();
+    while (this.optionalOperator('||')) {
+      const right = this.parseLogicalAnd();
+      result = new Binary(this.span(result.span.start), '||', result, right);
+    }
+    return result;
+  }
+
+  parseLogicalAnd(): AST {
+    // '&&'
+    let result = this.parseEquality();
+    while (this.optionalOperator('&&')) {
+      const right = this.parseEquality();
+      result = new Binary(this.span(result.span.start), '&&', result, right);
+    }
+    return result;
+  }
+
+  parseEquality(): AST {
+    // '==','!=','===','!=='
+    let result = this.parseRelational();
+    while (this.next.type == TokenType.Operator) {
+      const operator = this.next.strValue;
+      switch (operator) {
+        case '==':
+        case '===':
+        case '!=':
+        case '!==':
+          this.advance();
+          const right = this.parseRelational();
+          result = new Binary(this.span(result.span.start), operator, result, right);
+          continue;
+      }
+      break;
+    }
+    return result;
+  }
+
+  parseRelational(): AST {
+    // '<', '>', '<=', '>='
+    let result = this.parseAdditive();
+    while (this.next.type == TokenType.Operator) {
+      const operator = this.next.strValue;
+      switch (operator) {
+        case '<':
+        case '>':
+        case '<=':
+        case '>=':
+          this.advance();
+          const right = this.parseAdditive();
+          result = new Binary(this.span(result.span.start), operator, result, right);
+          continue;
+      }
+      break;
+    }
+    return result;
+  }
+
+  parseAdditive(): AST {
+    // '+', '-'
+    let result = this.parseMultiplicative();
+    while (this.next.type == TokenType.Operator) {
+      const operator = this.next.strValue;
+      switch (operator) {
+        case '+':
+        case '-':
+          this.advance();
+          let right = this.parseMultiplicative();
+          result = new Binary(this.span(result.span.start), operator, result, right);
+          continue;
+      }
+      break;
+    }
+    return result;
+  }
+
+  parseMultiplicative(): AST {
+    // '*', '%', '/'
+    let result = this.parsePrefix();
+    while (this.next.type == TokenType.Operator) {
+      const operator = this.next.strValue;
+      switch (operator) {
+        case '*':
+        case '%':
+        case '/':
+          this.advance();
+          let right = this.parsePrefix();
+          result = new Binary(this.span(result.span.start), operator, result, right);
+          continue;
+      }
+      break;
+    }
+    return result;
+  }
+
+  parsePrefix(): AST {
+    if (this.next.type == TokenType.Operator) {
+      const start = this.inputIndex;
+      const operator = this.next.strValue;
+      let result: AST;
+      switch (operator) {
+        case '+':
+          this.advance();
+          return this.parsePrefix();
+        case '-':
+          this.advance();
+          result = this.parsePrefix();
+          return new Binary(
+              this.span(start), operator, new LiteralPrimitive(new ParseSpan(start, start), 0),
+              result);
+        case '!':
+          this.advance();
+          result = this.parsePrefix();
+          return new PrefixNot(this.span(start), result);
+      }
+    }
+    return this.parseCallChain();
+  }
+
+  parseCallChain(): AST {
+    let result = this.parsePrimary();
+    while (true) {
+      if (this.optionalCharacter(chars.$PERIOD)) {
+        result = this.parseAccessMemberOrMethodCall(result, false);
+
+      } else if (this.optionalOperator('?.')) {
+        result = this.parseAccessMemberOrMethodCall(result, true);
+
+      } else if (this.optionalCharacter(chars.$LBRACKET)) {
+        this.rbracketsExpected++;
+        const key = this.parsePipe();
+        this.rbracketsExpected--;
+        this.expectCharacter(chars.$RBRACKET);
+        if (this.optionalOperator('=')) {
+          const value = this.parseConditional();
+          result = new KeyedWrite(this.span(result.span.start), result, key, value);
+        } else {
+          result = new KeyedRead(this.span(result.span.start), result, key);
+        }
+
+      } else if (this.optionalCharacter(chars.$LPAREN)) {
+        this.rparensExpected++;
+        const args = this.parseCallArguments();
+        this.rparensExpected--;
+        this.expectCharacter(chars.$RPAREN);
+        result = new FunctionCall(this.span(result.span.start), result, args);
+
+      } else if (this.optionalOperator('!')) {
+        result = new NonNullAssert(this.span(result.span.start), result);
+
+      } else {
+        return result;
+      }
+    }
+  }
+
+  parsePrimary(): AST {
+    const start = this.inputIndex;
+    if (this.optionalCharacter(chars.$LPAREN)) {
+      this.rparensExpected++;
+      const result = this.parsePipe();
+      this.rparensExpected--;
+      this.expectCharacter(chars.$RPAREN);
+      return result;
+
+    } else if (this.next.isKeywordNull()) {
+      this.advance();
+      return new LiteralPrimitive(this.span(start), null);
+
+    } else if (this.next.isKeywordUndefined()) {
+      this.advance();
+      return new LiteralPrimitive(this.span(start), void 0);
+
+    } else if (this.next.isKeywordTrue()) {
+      this.advance();
+      return new LiteralPrimitive(this.span(start), true);
+
+    } else if (this.next.isKeywordFalse()) {
+      this.advance();
+      return new LiteralPrimitive(this.span(start), false);
+
+    } else if (this.next.isKeywordThis()) {
+      this.advance();
+      return new ImplicitReceiver(this.span(start));
+
+    } else if (this.optionalCharacter(chars.$LBRACKET)) {
+      this.rbracketsExpected++;
+      const elements = this.parseExpressionList(chars.$RBRACKET);
+      this.rbracketsExpected--;
+      this.expectCharacter(chars.$RBRACKET);
+      return new LiteralArray(this.span(start), elements);
+
+    } else if (this.next.isCharacter(chars.$LBRACE)) {
+      return this.parseLiteralMap();
+
+    } else if (this.next.isIdentifier()) {
+      return this.parseAccessMemberOrMethodCall(new ImplicitReceiver(this.span(start)), false);
+
+    } else if (this.next.isNumber()) {
+      const value = this.next.toNumber();
+      this.advance();
+      return new LiteralPrimitive(this.span(start), value);
+
+    } else if (this.next.isString()) {
+      const literalValue = this.next.toString();
+      this.advance();
+      return new LiteralPrimitive(this.span(start), literalValue);
+
+    } else if (this.index >= this.tokens.length) {
+      this.error(`Unexpected end of expression: ${this.input}`);
+      return new EmptyExpr(this.span(start));
+    } else {
+      this.error(`Unexpected token ${this.next}`);
+      return new EmptyExpr(this.span(start));
+    }
+  }
+
+  parseExpressionList(terminator: number): AST[] {
+    const result: AST[] = [];
+    if (!this.next.isCharacter(terminator)) {
+      do {
+        result.push(this.parsePipe());
+      } while (this.optionalCharacter(chars.$COMMA));
+    }
+    return result;
+  }
+
+  parseLiteralMap(): LiteralMap {
+    const keys: LiteralMapKey[] = [];
+    const values: AST[] = [];
+    const start = this.inputIndex;
+    this.expectCharacter(chars.$LBRACE);
+    if (!this.optionalCharacter(chars.$RBRACE)) {
+      this.rbracesExpected++;
+      do {
+        const quoted = this.next.isString();
+        const key = this.expectIdentifierOrKeywordOrString();
+        keys.push({key, quoted});
+        this.expectCharacter(chars.$COLON);
+        values.push(this.parsePipe());
+      } while (this.optionalCharacter(chars.$COMMA));
+      this.rbracesExpected--;
+      this.expectCharacter(chars.$RBRACE);
+    }
+    return new LiteralMap(this.span(start), keys, values);
+  }
+
+  parseAccessMemberOrMethodCall(receiver: AST, isSafe: boolean = false): AST {
+    const start = receiver.span.start;
+    const id = this.expectIdentifierOrKeyword();
+
+    if (this.optionalCharacter(chars.$LPAREN)) {
+      this.rparensExpected++;
+      const args = this.parseCallArguments();
+      this.expectCharacter(chars.$RPAREN);
+      this.rparensExpected--;
+      const span = this.span(start);
+      return isSafe ? new SafeMethodCall(span, receiver, id, args) :
+                      new MethodCall(span, receiver, id, args);
+
+    } else {
+      if (isSafe) {
+        if (this.optionalOperator('=')) {
+          this.error('The \'?.\' operator cannot be used in the assignment');
+          return new EmptyExpr(this.span(start));
+        } else {
+          return new SafePropertyRead(this.span(start), receiver, id);
+        }
+      } else {
+        if (this.optionalOperator('=')) {
+          if (!this.parseAction) {
+            this.error('Bindings cannot contain assignments');
+            return new EmptyExpr(this.span(start));
+          }
+
+          const value = this.parseConditional();
+          return new PropertyWrite(this.span(start), receiver, id, value);
+        } else {
+          return new PropertyRead(this.span(start), receiver, id);
+        }
+      }
+    }
+  }
+
+  parseCallArguments(): BindingPipe[] {
+    if (this.next.isCharacter(chars.$RPAREN)) return [];
+    const positionals: AST[] = [];
+    do {
+      positionals.push(this.parsePipe());
+    } while (this.optionalCharacter(chars.$COMMA));
+    return positionals as BindingPipe[];
+  }
+
+  /**
+   * An identifier, a keyword, a string with an optional `-` inbetween.
+   */
+  expectTemplateBindingKey(): string {
+    let result = '';
+    let operatorFound = false;
+    do {
+      result += this.expectIdentifierOrKeywordOrString();
+      operatorFound = this.optionalOperator('-');
+      if (operatorFound) {
+        result += '-';
+      }
+    } while (operatorFound);
+
+    return result.toString();
+  }
+
+  parseTemplateBindings(): TemplateBindingParseResult {
+    const bindings: TemplateBinding[] = [];
+    let prefix: string = null !;
+    const warnings: string[] = [];
+    while (this.index < this.tokens.length) {
+      const start = this.inputIndex;
+      let keyIsVar: boolean = this.peekKeywordLet();
+      if (keyIsVar) {
+        this.advance();
+      }
+      let rawKey = this.expectTemplateBindingKey();
+      let key = rawKey;
+      if (!keyIsVar) {
+        if (prefix == null) {
+          prefix = key;
+        } else {
+          key = prefix + key[0].toUpperCase() + key.substring(1);
+        }
+      }
+      this.optionalCharacter(chars.$COLON);
+      let name: string = null !;
+      let expression: ASTWithSource = null !;
+      if (keyIsVar) {
+        if (this.optionalOperator('=')) {
+          name = this.expectTemplateBindingKey();
+        } else {
+          name = '\$implicit';
+        }
+      } else if (this.peekKeywordAs()) {
+        const letStart = this.inputIndex;
+        this.advance();  // consume `as`
+        name = rawKey;
+        key = this.expectTemplateBindingKey();  // read local var name
+        keyIsVar = true;
+      } else if (this.next !== EOF && !this.peekKeywordLet()) {
+        const start = this.inputIndex;
+        const ast = this.parsePipe();
+        const source = this.input.substring(start - this.offset, this.inputIndex - this.offset);
+        expression = new ASTWithSource(ast, source, this.location, this.errors);
+      }
+      bindings.push(new TemplateBinding(this.span(start), key, keyIsVar, name, expression));
+      if (this.peekKeywordAs() && !keyIsVar) {
+        const letStart = this.inputIndex;
+        this.advance();                                   // consume `as`
+        const letName = this.expectTemplateBindingKey();  // read local var name
+        bindings.push(new TemplateBinding(this.span(letStart), letName, true, key, null !));
+      }
+      if (!this.optionalCharacter(chars.$SEMICOLON)) {
+        this.optionalCharacter(chars.$COMMA);
+      }
+    }
+    return new TemplateBindingParseResult(bindings, warnings, this.errors);
+  }
+
+  error(message: string, index: number|null = null) {
+    this.errors.push(new ParserError(message, this.input, this.locationText(index), this.location));
+    this.skip();
+  }
+
+  private locationText(index: number|null = null) {
+    if (index == null) index = this.index;
+    return (index < this.tokens.length) ? `at column ${this.tokens[index].index + 1} in` :
+                                          `at the end of the expression`;
+  }
+
+  // Error recovery should skip tokens until it encounters a recovery point. skip() treats
+  // the end of input and a ';' as unconditionally a recovery point. It also treats ')',
+  // '}' and ']' as conditional recovery points if one of calling productions is expecting
+  // one of these symbols. This allows skip() to recover from errors such as '(a.) + 1' allowing
+  // more of the AST to be retained (it doesn't skip any tokens as the ')' is retained because
+  // of the '(' begins an '(' <expr> ')' production). The recovery points of grouping symbols
+  // must be conditional as they must be skipped if none of the calling productions are not
+  // expecting the closing token else we will never make progress in the case of an
+  // extraneous group closing symbol (such as a stray ')'). This is not the case for ';' because
+  // parseChain() is always the root production and it expects a ';'.
+
+  // If a production expects one of these token it increments the corresponding nesting count,
+  // and then decrements it just prior to checking if the token is in the input.
+  private skip() {
+    let n = this.next;
+    while (this.index < this.tokens.length && !n.isCharacter(chars.$SEMICOLON) &&
+           (this.rparensExpected <= 0 || !n.isCharacter(chars.$RPAREN)) &&
+           (this.rbracesExpected <= 0 || !n.isCharacter(chars.$RBRACE)) &&
+           (this.rbracketsExpected <= 0 || !n.isCharacter(chars.$RBRACKET))) {
+      if (this.next.isError()) {
+        this.errors.push(new ParserError(
+            this.next.toString() !, this.input, this.locationText(), this.location));
+      }
+      this.advance();
+      n = this.next;
+    }
+  }
+}
+
+class SimpleExpressionChecker implements AstVisitor {
+  static check(ast: AST): string[] {
+    const s = new SimpleExpressionChecker();
+    ast.visit(s);
+    return s.errors;
+  }
+
+  errors: string[] = [];
+
+  visitImplicitReceiver(ast: ImplicitReceiver, context: any) {}
+
+  visitInterpolation(ast: Interpolation, context: any) {}
+
+  visitLiteralPrimitive(ast: LiteralPrimitive, context: any) {}
+
+  visitPropertyRead(ast: PropertyRead, context: any) {}
+
+  visitPropertyWrite(ast: PropertyWrite, context: any) {}
+
+  visitSafePropertyRead(ast: SafePropertyRead, context: any) {}
+
+  visitMethodCall(ast: MethodCall, context: any) {}
+
+  visitSafeMethodCall(ast: SafeMethodCall, context: any) {}
+
+  visitFunctionCall(ast: FunctionCall, context: any) {}
+
+  visitLiteralArray(ast: LiteralArray, context: any) { this.visitAll(ast.expressions); }
+
+  visitLiteralMap(ast: LiteralMap, context: any) { this.visitAll(ast.values); }
+
+  visitBinary(ast: Binary, context: any) {}
+
+  visitPrefixNot(ast: PrefixNot, context: any) {}
+
+  visitNonNullAssert(ast: NonNullAssert, context: any) {}
+
+  visitConditional(ast: Conditional, context: any) {}
+
+  visitPipe(ast: BindingPipe, context: any) { this.errors.push('pipes'); }
+
+  visitKeyedRead(ast: KeyedRead, context: any) {}
+
+  visitKeyedWrite(ast: KeyedWrite, context: any) {}
+
+  visitAll(asts: any[]): any[] { return asts.map(node => node.visit(this)); }
+
+  visitChain(ast: Chain, context: any) {}
+
+  visitQuote(ast: Quote, context: any) {}
+}
diff --git a/angular/compiler/src/i18n/digest.ts b/angular/compiler/src/i18n/digest.ts
new file mode 100644
index 0000000..c60b853
--- /dev/null
+++ b/angular/compiler/src/i18n/digest.ts
@@ -0,0 +1,337 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {utf8Encode} from '../util';
+
+import * as i18n from './i18n_ast';
+
+export function digest(message: i18n.Message): string {
+  return message.id || sha1(serializeNodes(message.nodes).join('') + `[${message.meaning}]`);
+}
+
+export function decimalDigest(message: i18n.Message): string {
+  if (message.id) {
+    return message.id;
+  }
+
+  const visitor = new _SerializerIgnoreIcuExpVisitor();
+  const parts = message.nodes.map(a => a.visit(visitor, null));
+  return computeMsgId(parts.join(''), message.meaning);
+}
+
+/**
+ * Serialize the i18n ast to something xml-like in order to generate an UID.
+ *
+ * The visitor is also used in the i18n parser tests
+ *
+ * @internal
+ */
+class _SerializerVisitor implements i18n.Visitor {
+  visitText(text: i18n.Text, context: any): any { return text.value; }
+
+  visitContainer(container: i18n.Container, context: any): any {
+    return `[${container.children.map(child => child.visit(this)).join(', ')}]`;
+  }
+
+  visitIcu(icu: i18n.Icu, context: any): any {
+    const strCases =
+        Object.keys(icu.cases).map((k: string) => `${k} {${icu.cases[k].visit(this)}}`);
+    return `{${icu.expression}, ${icu.type}, ${strCases.join(', ')}}`;
+  }
+
+  visitTagPlaceholder(ph: i18n.TagPlaceholder, context: any): any {
+    return ph.isVoid ?
+        `<ph tag name="${ph.startName}"/>` :
+        `<ph tag name="${ph.startName}">${ph.children.map(child => child.visit(this)).join(', ')}</ph name="${ph.closeName}">`;
+  }
+
+  visitPlaceholder(ph: i18n.Placeholder, context: any): any {
+    return ph.value ? `<ph name="${ph.name}">${ph.value}</ph>` : `<ph name="${ph.name}"/>`;
+  }
+
+  visitIcuPlaceholder(ph: i18n.IcuPlaceholder, context?: any): any {
+    return `<ph icu name="${ph.name}">${ph.value.visit(this)}</ph>`;
+  }
+}
+
+const serializerVisitor = new _SerializerVisitor();
+
+export function serializeNodes(nodes: i18n.Node[]): string[] {
+  return nodes.map(a => a.visit(serializerVisitor, null));
+}
+
+/**
+ * Serialize the i18n ast to something xml-like in order to generate an UID.
+ *
+ * Ignore the ICU expressions so that message IDs stays identical if only the expression changes.
+ *
+ * @internal
+ */
+class _SerializerIgnoreIcuExpVisitor extends _SerializerVisitor {
+  visitIcu(icu: i18n.Icu, context: any): any {
+    let strCases = Object.keys(icu.cases).map((k: string) => `${k} {${icu.cases[k].visit(this)}}`);
+    // Do not take the expression into account
+    return `{${icu.type}, ${strCases.join(', ')}}`;
+  }
+}
+
+/**
+ * Compute the SHA1 of the given string
+ *
+ * see http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf
+ *
+ * WARNING: this function has not been designed not tested with security in mind.
+ *          DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.
+ */
+export function sha1(str: string): string {
+  const utf8 = utf8Encode(str);
+  const words32 = stringToWords32(utf8, Endian.Big);
+  const len = utf8.length * 8;
+
+  const w = new Array(80);
+  let [a, b, c, d, e]: number[] = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+
+  words32[len >> 5] |= 0x80 << (24 - len % 32);
+  words32[((len + 64 >> 9) << 4) + 15] = len;
+
+  for (let i = 0; i < words32.length; i += 16) {
+    const [h0, h1, h2, h3, h4]: number[] = [a, b, c, d, e];
+
+    for (let j = 0; j < 80; j++) {
+      if (j < 16) {
+        w[j] = words32[i + j];
+      } else {
+        w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
+      }
+
+      const [f, k] = fk(j, b, c, d);
+      const temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32);
+      [e, d, c, b, a] = [d, c, rol32(b, 30), a, temp];
+    }
+
+    [a, b, c, d, e] = [add32(a, h0), add32(b, h1), add32(c, h2), add32(d, h3), add32(e, h4)];
+  }
+
+  return byteStringToHexString(words32ToByteString([a, b, c, d, e]));
+}
+
+function fk(index: number, b: number, c: number, d: number): [number, number] {
+  if (index < 20) {
+    return [(b & c) | (~b & d), 0x5a827999];
+  }
+
+  if (index < 40) {
+    return [b ^ c ^ d, 0x6ed9eba1];
+  }
+
+  if (index < 60) {
+    return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc];
+  }
+
+  return [b ^ c ^ d, 0xca62c1d6];
+}
+
+/**
+ * Compute the fingerprint of the given string
+ *
+ * The output is 64 bit number encoded as a decimal string
+ *
+ * based on:
+ * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java
+ */
+export function fingerprint(str: string): [number, number] {
+  const utf8 = utf8Encode(str);
+
+  let [hi, lo] = [hash32(utf8, 0), hash32(utf8, 102072)];
+
+  if (hi == 0 && (lo == 0 || lo == 1)) {
+    hi = hi ^ 0x130f9bef;
+    lo = lo ^ -0x6b5f56d8;
+  }
+
+  return [hi, lo];
+}
+
+export function computeMsgId(msg: string, meaning: string): string {
+  let [hi, lo] = fingerprint(msg);
+
+  if (meaning) {
+    const [him, lom] = fingerprint(meaning);
+    [hi, lo] = add64(rol64([hi, lo], 1), [him, lom]);
+  }
+
+  return byteStringToDecString(words32ToByteString([hi & 0x7fffffff, lo]));
+}
+
+function hash32(str: string, c: number): number {
+  let [a, b] = [0x9e3779b9, 0x9e3779b9];
+  let i: number;
+
+  const len = str.length;
+
+  for (i = 0; i + 12 <= len; i += 12) {
+    a = add32(a, wordAt(str, i, Endian.Little));
+    b = add32(b, wordAt(str, i + 4, Endian.Little));
+    c = add32(c, wordAt(str, i + 8, Endian.Little));
+    [a, b, c] = mix([a, b, c]);
+  }
+
+  a = add32(a, wordAt(str, i, Endian.Little));
+  b = add32(b, wordAt(str, i + 4, Endian.Little));
+  // the first byte of c is reserved for the length
+  c = add32(c, len);
+  c = add32(c, wordAt(str, i + 8, Endian.Little) << 8);
+
+  return mix([a, b, c])[2];
+}
+
+// clang-format off
+function mix([a, b, c]: [number, number, number]): [number, number, number] {
+  a = sub32(a, b); a = sub32(a, c); a ^= c >>> 13;
+  b = sub32(b, c); b = sub32(b, a); b ^= a << 8;
+  c = sub32(c, a); c = sub32(c, b); c ^= b >>> 13;
+  a = sub32(a, b); a = sub32(a, c); a ^= c >>> 12;
+  b = sub32(b, c); b = sub32(b, a); b ^= a << 16;
+  c = sub32(c, a); c = sub32(c, b); c ^= b >>> 5;
+  a = sub32(a, b); a = sub32(a, c); a ^= c >>> 3;
+  b = sub32(b, c); b = sub32(b, a); b ^= a << 10;
+  c = sub32(c, a); c = sub32(c, b); c ^= b >>> 15;
+  return [a, b, c];
+}
+// clang-format on
+
+// Utils
+
+enum Endian {
+  Little,
+  Big,
+}
+
+function add32(a: number, b: number): number {
+  return add32to64(a, b)[1];
+}
+
+function add32to64(a: number, b: number): [number, number] {
+  const low = (a & 0xffff) + (b & 0xffff);
+  const high = (a >>> 16) + (b >>> 16) + (low >>> 16);
+  return [high >>> 16, (high << 16) | (low & 0xffff)];
+}
+
+function add64([ah, al]: [number, number], [bh, bl]: [number, number]): [number, number] {
+  const [carry, l] = add32to64(al, bl);
+  const h = add32(add32(ah, bh), carry);
+  return [h, l];
+}
+
+function sub32(a: number, b: number): number {
+  const low = (a & 0xffff) - (b & 0xffff);
+  const high = (a >> 16) - (b >> 16) + (low >> 16);
+  return (high << 16) | (low & 0xffff);
+}
+
+// Rotate a 32b number left `count` position
+function rol32(a: number, count: number): number {
+  return (a << count) | (a >>> (32 - count));
+}
+
+// Rotate a 64b number left `count` position
+function rol64([hi, lo]: [number, number], count: number): [number, number] {
+  const h = (hi << count) | (lo >>> (32 - count));
+  const l = (lo << count) | (hi >>> (32 - count));
+  return [h, l];
+}
+
+function stringToWords32(str: string, endian: Endian): number[] {
+  const words32 = Array((str.length + 3) >>> 2);
+
+  for (let i = 0; i < words32.length; i++) {
+    words32[i] = wordAt(str, i * 4, endian);
+  }
+
+  return words32;
+}
+
+function byteAt(str: string, index: number): number {
+  return index >= str.length ? 0 : str.charCodeAt(index) & 0xff;
+}
+
+function wordAt(str: string, index: number, endian: Endian): number {
+  let word = 0;
+  if (endian === Endian.Big) {
+    for (let i = 0; i < 4; i++) {
+      word += byteAt(str, index + i) << (24 - 8 * i);
+    }
+  } else {
+    for (let i = 0; i < 4; i++) {
+      word += byteAt(str, index + i) << 8 * i;
+    }
+  }
+  return word;
+}
+
+function words32ToByteString(words32: number[]): string {
+  return words32.reduce((str, word) => str + word32ToByteString(word), '');
+}
+
+function word32ToByteString(word: number): string {
+  let str = '';
+  for (let i = 0; i < 4; i++) {
+    str += String.fromCharCode((word >>> 8 * (3 - i)) & 0xff);
+  }
+  return str;
+}
+
+function byteStringToHexString(str: string): string {
+  let hex: string = '';
+  for (let i = 0; i < str.length; i++) {
+    const b = byteAt(str, i);
+    hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16);
+  }
+  return hex.toLowerCase();
+}
+
+// based on http://www.danvk.org/hex2dec.html (JS can not handle more than 56b)
+function byteStringToDecString(str: string): string {
+  let decimal = '';
+  let toThePower = '1';
+
+  for (let i = str.length - 1; i >= 0; i--) {
+    decimal = addBigInt(decimal, numberTimesBigInt(byteAt(str, i), toThePower));
+    toThePower = numberTimesBigInt(256, toThePower);
+  }
+
+  return decimal.split('').reverse().join('');
+}
+
+// x and y decimal, lowest significant digit first
+function addBigInt(x: string, y: string): string {
+  let sum = '';
+  const len = Math.max(x.length, y.length);
+  for (let i = 0, carry = 0; i < len || carry; i++) {
+    const tmpSum = carry + +(x[i] || 0) + +(y[i] || 0);
+    if (tmpSum >= 10) {
+      carry = 1;
+      sum += tmpSum - 10;
+    } else {
+      carry = 0;
+      sum += tmpSum;
+    }
+  }
+
+  return sum;
+}
+
+function numberTimesBigInt(num: number, b: string): string {
+  let product = '';
+  let bToThePower = b;
+  for (; num !== 0; num = num >>> 1) {
+    if (num & 1) product = addBigInt(product, bToThePower);
+    bToThePower = addBigInt(bToThePower, bToThePower);
+  }
+  return product;
+}
diff --git a/angular/compiler/src/i18n/extractor.ts b/angular/compiler/src/i18n/extractor.ts
new file mode 100644
index 0000000..3b573e7
--- /dev/null
+++ b/angular/compiler/src/i18n/extractor.ts
@@ -0,0 +1,121 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+/**
+ * Extract i18n messages from source code
+ */
+import {analyzeAndValidateNgModules, extractProgramSymbols} from '../aot/compiler';
+import {createAotUrlResolver} from '../aot/compiler_factory';
+import {StaticReflector} from '../aot/static_reflector';
+import {StaticSymbolCache} from '../aot/static_symbol';
+import {StaticSymbolResolver, StaticSymbolResolverHost} from '../aot/static_symbol_resolver';
+import {AotSummaryResolver, AotSummaryResolverHost} from '../aot/summary_resolver';
+import {CompileDirectiveMetadata} from '../compile_metadata';
+import {CompilerConfig} from '../config';
+import {ViewEncapsulation} from '../core';
+import {DirectiveNormalizer} from '../directive_normalizer';
+import {DirectiveResolver} from '../directive_resolver';
+import {CompileMetadataResolver} from '../metadata_resolver';
+import {HtmlParser} from '../ml_parser/html_parser';
+import {InterpolationConfig} from '../ml_parser/interpolation_config';
+import {NgModuleResolver} from '../ng_module_resolver';
+import {ParseError} from '../parse_util';
+import {PipeResolver} from '../pipe_resolver';
+import {DomElementSchemaRegistry} from '../schema/dom_element_schema_registry';
+import {syntaxError} from '../util';
+
+import {MessageBundle} from './message_bundle';
+
+
+
+/**
+ * The host of the Extractor disconnects the implementation from TypeScript / other language
+ * services and from underlying file systems.
+ */
+export interface ExtractorHost extends StaticSymbolResolverHost, AotSummaryResolverHost {
+  /**
+   * Converts a path that refers to a resource into an absolute filePath
+   * that can be lateron used for loading the resource via `loadResource.
+   */
+  resourceNameToFileName(path: string, containingFile: string): string|null;
+  /**
+   * Loads a resource (e.g. html / css)
+   */
+  loadResource(path: string): Promise<string>|string;
+}
+
+export class Extractor {
+  constructor(
+      public host: ExtractorHost, private staticSymbolResolver: StaticSymbolResolver,
+      private messageBundle: MessageBundle, private metadataResolver: CompileMetadataResolver) {}
+
+  extract(rootFiles: string[]): Promise<MessageBundle> {
+    const programSymbols = extractProgramSymbols(this.staticSymbolResolver, rootFiles, this.host);
+    const {files, ngModules} =
+        analyzeAndValidateNgModules(programSymbols, this.host, this.metadataResolver);
+    return Promise
+        .all(ngModules.map(
+            ngModule => this.metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
+                ngModule.type.reference, false)))
+        .then(() => {
+          const errors: ParseError[] = [];
+
+          files.forEach(file => {
+            const compMetas: CompileDirectiveMetadata[] = [];
+            file.directives.forEach(directiveType => {
+              const dirMeta = this.metadataResolver.getDirectiveMetadata(directiveType);
+              if (dirMeta && dirMeta.isComponent) {
+                compMetas.push(dirMeta);
+              }
+            });
+            compMetas.forEach(compMeta => {
+              const html = compMeta.template !.template !;
+              const interpolationConfig =
+                  InterpolationConfig.fromArray(compMeta.template !.interpolation);
+              errors.push(...this.messageBundle.updateFromTemplate(
+                  html, file.srcUrl, interpolationConfig) !);
+            });
+          });
+
+          if (errors.length) {
+            throw new Error(errors.map(e => e.toString()).join('\n'));
+          }
+
+          return this.messageBundle;
+        });
+  }
+
+  static create(host: ExtractorHost, locale: string|null):
+      {extractor: Extractor, staticReflector: StaticReflector} {
+    const htmlParser = new HtmlParser();
+
+    const urlResolver = createAotUrlResolver(host);
+    const symbolCache = new StaticSymbolCache();
+    const summaryResolver = new AotSummaryResolver(host, symbolCache);
+    const staticSymbolResolver = new StaticSymbolResolver(host, symbolCache, summaryResolver);
+    const staticReflector = new StaticReflector(summaryResolver, staticSymbolResolver);
+
+    const config =
+        new CompilerConfig({defaultEncapsulation: ViewEncapsulation.Emulated, useJit: false});
+
+    const normalizer = new DirectiveNormalizer(
+        {get: (url: string) => host.loadResource(url)}, urlResolver, htmlParser, config);
+    const elementSchemaRegistry = new DomElementSchemaRegistry();
+    const resolver = new CompileMetadataResolver(
+        config, new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
+        new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer,
+        console, symbolCache, staticReflector);
+
+    // TODO(vicb): implicit tags & attributes
+    const messageBundle = new MessageBundle(htmlParser, [], {}, locale);
+
+    const extractor = new Extractor(host, staticSymbolResolver, messageBundle, resolver);
+    return {extractor, staticReflector};
+  }
+}
diff --git a/angular/compiler/src/i18n/extractor_merger.ts b/angular/compiler/src/i18n/extractor_merger.ts
new file mode 100644
index 0000000..1cae8b9
--- /dev/null
+++ b/angular/compiler/src/i18n/extractor_merger.ts
@@ -0,0 +1,500 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as html from '../ml_parser/ast';
+import {InterpolationConfig} from '../ml_parser/interpolation_config';
+import {ParseTreeResult} from '../ml_parser/parser';
+
+import * as i18n from './i18n_ast';
+import {createI18nMessageFactory} from './i18n_parser';
+import {I18nError} from './parse_util';
+import {TranslationBundle} from './translation_bundle';
+
+const _I18N_ATTR = 'i18n';
+const _I18N_ATTR_PREFIX = 'i18n-';
+const _I18N_COMMENT_PREFIX_REGEXP = /^i18n:?/;
+const MEANING_SEPARATOR = '|';
+const ID_SEPARATOR = '@@';
+
+/**
+ * Extract translatable messages from an html AST
+ */
+export function extractMessages(
+    nodes: html.Node[], interpolationConfig: InterpolationConfig, implicitTags: string[],
+    implicitAttrs: {[k: string]: string[]}): ExtractionResult {
+  const visitor = new _Visitor(implicitTags, implicitAttrs);
+  return visitor.extract(nodes, interpolationConfig);
+}
+
+export function mergeTranslations(
+    nodes: html.Node[], translations: TranslationBundle, interpolationConfig: InterpolationConfig,
+    implicitTags: string[], implicitAttrs: {[k: string]: string[]}): ParseTreeResult {
+  const visitor = new _Visitor(implicitTags, implicitAttrs);
+  return visitor.merge(nodes, translations, interpolationConfig);
+}
+
+export class ExtractionResult {
+  constructor(public messages: i18n.Message[], public errors: I18nError[]) {}
+}
+
+enum _VisitorMode {
+  Extract,
+  Merge
+}
+
+/**
+ * This Visitor is used:
+ * 1. to extract all the translatable strings from an html AST (see `extract()`),
+ * 2. to replace the translatable strings with the actual translations (see `merge()`)
+ *
+ * @internal
+ */
+class _Visitor implements html.Visitor {
+  private _depth: number;
+
+  // <el i18n>...</el>
+  private _inI18nNode: boolean;
+  private _inImplicitNode: boolean;
+
+  // <!--i18n-->...<!--/i18n-->
+  private _inI18nBlock: boolean;
+  private _blockMeaningAndDesc: string;
+  private _blockChildren: html.Node[];
+  private _blockStartDepth: number;
+
+  // {<icu message>}
+  private _inIcu: boolean;
+
+  // set to void 0 when not in a section
+  private _msgCountAtSectionStart: number|undefined;
+  private _errors: I18nError[];
+  private _mode: _VisitorMode;
+
+  // _VisitorMode.Extract only
+  private _messages: i18n.Message[];
+
+  // _VisitorMode.Merge only
+  private _translations: TranslationBundle;
+  private _createI18nMessage:
+      (msg: html.Node[], meaning: string, description: string, id: string) => i18n.Message;
+
+
+  constructor(private _implicitTags: string[], private _implicitAttrs: {[k: string]: string[]}) {}
+
+  /**
+   * Extracts the messages from the tree
+   */
+  extract(nodes: html.Node[], interpolationConfig: InterpolationConfig): ExtractionResult {
+    this._init(_VisitorMode.Extract, interpolationConfig);
+
+    nodes.forEach(node => node.visit(this, null));
+
+    if (this._inI18nBlock) {
+      this._reportError(nodes[nodes.length - 1], 'Unclosed block');
+    }
+
+    return new ExtractionResult(this._messages, this._errors);
+  }
+
+  /**
+   * Returns a tree where all translatable nodes are translated
+   */
+  merge(
+      nodes: html.Node[], translations: TranslationBundle,
+      interpolationConfig: InterpolationConfig): ParseTreeResult {
+    this._init(_VisitorMode.Merge, interpolationConfig);
+    this._translations = translations;
+
+    // Construct a single fake root element
+    const wrapper = new html.Element('wrapper', [], nodes, undefined !, undefined, undefined);
+
+    const translatedNode = wrapper.visit(this, null);
+
+    if (this._inI18nBlock) {
+      this._reportError(nodes[nodes.length - 1], 'Unclosed block');
+    }
+
+    return new ParseTreeResult(translatedNode.children, this._errors);
+  }
+
+  visitExpansionCase(icuCase: html.ExpansionCase, context: any): any {
+    // Parse cases for translatable html attributes
+    const expression = html.visitAll(this, icuCase.expression, context);
+
+    if (this._mode === _VisitorMode.Merge) {
+      return new html.ExpansionCase(
+          icuCase.value, expression, icuCase.sourceSpan, icuCase.valueSourceSpan,
+          icuCase.expSourceSpan);
+    }
+  }
+
+  visitExpansion(icu: html.Expansion, context: any): html.Expansion {
+    this._mayBeAddBlockChildren(icu);
+
+    const wasInIcu = this._inIcu;
+
+    if (!this._inIcu) {
+      // nested ICU messages should not be extracted but top-level translated as a whole
+      if (this._isInTranslatableSection) {
+        this._addMessage([icu]);
+      }
+      this._inIcu = true;
+    }
+
+    const cases = html.visitAll(this, icu.cases, context);
+
+    if (this._mode === _VisitorMode.Merge) {
+      icu = new html.Expansion(
+          icu.switchValue, icu.type, cases, icu.sourceSpan, icu.switchValueSourceSpan);
+    }
+
+    this._inIcu = wasInIcu;
+
+    return icu;
+  }
+
+  visitComment(comment: html.Comment, context: any): any {
+    const isOpening = _isOpeningComment(comment);
+
+    if (isOpening && this._isInTranslatableSection) {
+      this._reportError(comment, 'Could not start a block inside a translatable section');
+      return;
+    }
+
+    const isClosing = _isClosingComment(comment);
+
+    if (isClosing && !this._inI18nBlock) {
+      this._reportError(comment, 'Trying to close an unopened block');
+      return;
+    }
+
+    if (!this._inI18nNode && !this._inIcu) {
+      if (!this._inI18nBlock) {
+        if (isOpening) {
+          this._inI18nBlock = true;
+          this._blockStartDepth = this._depth;
+          this._blockChildren = [];
+          this._blockMeaningAndDesc =
+              comment.value !.replace(_I18N_COMMENT_PREFIX_REGEXP, '').trim();
+          this._openTranslatableSection(comment);
+        }
+      } else {
+        if (isClosing) {
+          if (this._depth == this._blockStartDepth) {
+            this._closeTranslatableSection(comment, this._blockChildren);
+            this._inI18nBlock = false;
+            const message = this._addMessage(this._blockChildren, this._blockMeaningAndDesc) !;
+            // merge attributes in sections
+            const nodes = this._translateMessage(comment, message);
+            return html.visitAll(this, nodes);
+          } else {
+            this._reportError(comment, 'I18N blocks should not cross element boundaries');
+            return;
+          }
+        }
+      }
+    }
+  }
+
+  visitText(text: html.Text, context: any): html.Text {
+    if (this._isInTranslatableSection) {
+      this._mayBeAddBlockChildren(text);
+    }
+    return text;
+  }
+
+  visitElement(el: html.Element, context: any): html.Element|null {
+    this._mayBeAddBlockChildren(el);
+    this._depth++;
+    const wasInI18nNode = this._inI18nNode;
+    const wasInImplicitNode = this._inImplicitNode;
+    let childNodes: html.Node[] = [];
+    let translatedChildNodes: html.Node[] = undefined !;
+
+    // Extract:
+    // - top level nodes with the (implicit) "i18n" attribute if not already in a section
+    // - ICU messages
+    const i18nAttr = _getI18nAttr(el);
+    const i18nMeta = i18nAttr ? i18nAttr.value : '';
+    const isImplicit = this._implicitTags.some(tag => el.name === tag) && !this._inIcu &&
+        !this._isInTranslatableSection;
+    const isTopLevelImplicit = !wasInImplicitNode && isImplicit;
+    this._inImplicitNode = wasInImplicitNode || isImplicit;
+
+    if (!this._isInTranslatableSection && !this._inIcu) {
+      if (i18nAttr || isTopLevelImplicit) {
+        this._inI18nNode = true;
+        const message = this._addMessage(el.children, i18nMeta) !;
+        translatedChildNodes = this._translateMessage(el, message);
+      }
+
+      if (this._mode == _VisitorMode.Extract) {
+        const isTranslatable = i18nAttr || isTopLevelImplicit;
+        if (isTranslatable) this._openTranslatableSection(el);
+        html.visitAll(this, el.children);
+        if (isTranslatable) this._closeTranslatableSection(el, el.children);
+      }
+    } else {
+      if (i18nAttr || isTopLevelImplicit) {
+        this._reportError(
+            el, 'Could not mark an element as translatable inside a translatable section');
+      }
+
+      if (this._mode == _VisitorMode.Extract) {
+        // Descend into child nodes for extraction
+        html.visitAll(this, el.children);
+      }
+    }
+
+    if (this._mode === _VisitorMode.Merge) {
+      const visitNodes = translatedChildNodes || el.children;
+      visitNodes.forEach(child => {
+        const visited = child.visit(this, context);
+        if (visited && !this._isInTranslatableSection) {
+          // Do not add the children from translatable sections (= i18n blocks here)
+          // They will be added later in this loop when the block closes (i.e. on `<!-- /i18n -->`)
+          childNodes = childNodes.concat(visited);
+        }
+      });
+    }
+
+    this._visitAttributesOf(el);
+
+    this._depth--;
+    this._inI18nNode = wasInI18nNode;
+    this._inImplicitNode = wasInImplicitNode;
+
+    if (this._mode === _VisitorMode.Merge) {
+      const translatedAttrs = this._translateAttributes(el);
+      return new html.Element(
+          el.name, translatedAttrs, childNodes, el.sourceSpan, el.startSourceSpan,
+          el.endSourceSpan);
+    }
+    return null;
+  }
+
+  visitAttribute(attribute: html.Attribute, context: any): any {
+    throw new Error('unreachable code');
+  }
+
+  private _init(mode: _VisitorMode, interpolationConfig: InterpolationConfig): void {
+    this._mode = mode;
+    this._inI18nBlock = false;
+    this._inI18nNode = false;
+    this._depth = 0;
+    this._inIcu = false;
+    this._msgCountAtSectionStart = undefined;
+    this._errors = [];
+    this._messages = [];
+    this._inImplicitNode = false;
+    this._createI18nMessage = createI18nMessageFactory(interpolationConfig);
+  }
+
+  // looks for translatable attributes
+  private _visitAttributesOf(el: html.Element): void {
+    const explicitAttrNameToValue: {[k: string]: string} = {};
+    const implicitAttrNames: string[] = this._implicitAttrs[el.name] || [];
+
+    el.attrs.filter(attr => attr.name.startsWith(_I18N_ATTR_PREFIX))
+        .forEach(
+            attr => explicitAttrNameToValue[attr.name.slice(_I18N_ATTR_PREFIX.length)] =
+                attr.value);
+
+    el.attrs.forEach(attr => {
+      if (attr.name in explicitAttrNameToValue) {
+        this._addMessage([attr], explicitAttrNameToValue[attr.name]);
+      } else if (implicitAttrNames.some(name => attr.name === name)) {
+        this._addMessage([attr]);
+      }
+    });
+  }
+
+  // add a translatable message
+  private _addMessage(ast: html.Node[], msgMeta?: string): i18n.Message|null {
+    if (ast.length == 0 ||
+        ast.length == 1 && ast[0] instanceof html.Attribute && !(<html.Attribute>ast[0]).value) {
+      // Do not create empty messages
+      return null;
+    }
+
+    const {meaning, description, id} = _parseMessageMeta(msgMeta);
+    const message = this._createI18nMessage(ast, meaning, description, id);
+    this._messages.push(message);
+    return message;
+  }
+
+  // Translates the given message given the `TranslationBundle`
+  // This is used for translating elements / blocks - see `_translateAttributes` for attributes
+  // no-op when called in extraction mode (returns [])
+  private _translateMessage(el: html.Node, message: i18n.Message): html.Node[] {
+    if (message && this._mode === _VisitorMode.Merge) {
+      const nodes = this._translations.get(message);
+
+      if (nodes) {
+        return nodes;
+      }
+
+      this._reportError(
+          el, `Translation unavailable for message id="${this._translations.digest(message)}"`);
+    }
+
+    return [];
+  }
+
+  // translate the attributes of an element and remove i18n specific attributes
+  private _translateAttributes(el: html.Element): html.Attribute[] {
+    const attributes = el.attrs;
+    const i18nParsedMessageMeta:
+        {[name: string]: {meaning: string, description: string, id: string}} = {};
+
+    attributes.forEach(attr => {
+      if (attr.name.startsWith(_I18N_ATTR_PREFIX)) {
+        i18nParsedMessageMeta[attr.name.slice(_I18N_ATTR_PREFIX.length)] =
+            _parseMessageMeta(attr.value);
+      }
+    });
+
+    const translatedAttributes: html.Attribute[] = [];
+
+    attributes.forEach((attr) => {
+      if (attr.name === _I18N_ATTR || attr.name.startsWith(_I18N_ATTR_PREFIX)) {
+        // strip i18n specific attributes
+        return;
+      }
+
+      if (attr.value && attr.value != '' && i18nParsedMessageMeta.hasOwnProperty(attr.name)) {
+        const {meaning, description, id} = i18nParsedMessageMeta[attr.name];
+        const message: i18n.Message = this._createI18nMessage([attr], meaning, description, id);
+        const nodes = this._translations.get(message);
+        if (nodes) {
+          if (nodes.length == 0) {
+            translatedAttributes.push(new html.Attribute(attr.name, '', attr.sourceSpan));
+          } else if (nodes[0] instanceof html.Text) {
+            const value = (nodes[0] as html.Text).value;
+            translatedAttributes.push(new html.Attribute(attr.name, value, attr.sourceSpan));
+          } else {
+            this._reportError(
+                el,
+                `Unexpected translation for attribute "${attr.name}" (id="${id || this._translations.digest(message)}")`);
+          }
+        } else {
+          this._reportError(
+              el,
+              `Translation unavailable for attribute "${attr.name}" (id="${id || this._translations.digest(message)}")`);
+        }
+      } else {
+        translatedAttributes.push(attr);
+      }
+    });
+
+    return translatedAttributes;
+  }
+
+
+  /**
+   * Add the node as a child of the block when:
+   * - we are in a block,
+   * - we are not inside a ICU message (those are handled separately),
+   * - the node is a "direct child" of the block
+   */
+  private _mayBeAddBlockChildren(node: html.Node): void {
+    if (this._inI18nBlock && !this._inIcu && this._depth == this._blockStartDepth) {
+      this._blockChildren.push(node);
+    }
+  }
+
+  /**
+   * Marks the start of a section, see `_closeTranslatableSection`
+   */
+  private _openTranslatableSection(node: html.Node): void {
+    if (this._isInTranslatableSection) {
+      this._reportError(node, 'Unexpected section start');
+    } else {
+      this._msgCountAtSectionStart = this._messages.length;
+    }
+  }
+
+  /**
+   * A translatable section could be:
+   * - the content of translatable element,
+   * - nodes between `<!-- i18n -->` and `<!-- /i18n -->` comments
+   */
+  private get _isInTranslatableSection(): boolean {
+    return this._msgCountAtSectionStart !== void 0;
+  }
+
+  /**
+   * Terminates a section.
+   *
+   * If a section has only one significant children (comments not significant) then we should not
+   * keep the message from this children:
+   *
+   * `<p i18n="meaning|description">{ICU message}</p>` would produce two messages:
+   * - one for the <p> content with meaning and description,
+   * - another one for the ICU message.
+   *
+   * In this case the last message is discarded as it contains less information (the AST is
+   * otherwise identical).
+   *
+   * Note that we should still keep messages extracted from attributes inside the section (ie in the
+   * ICU message here)
+   */
+  private _closeTranslatableSection(node: html.Node, directChildren: html.Node[]): void {
+    if (!this._isInTranslatableSection) {
+      this._reportError(node, 'Unexpected section end');
+      return;
+    }
+
+    const startIndex = this._msgCountAtSectionStart;
+    const significantChildren: number = directChildren.reduce(
+        (count: number, node: html.Node): number => count + (node instanceof html.Comment ? 0 : 1),
+        0);
+
+    if (significantChildren == 1) {
+      for (let i = this._messages.length - 1; i >= startIndex !; i--) {
+        const ast = this._messages[i].nodes;
+        if (!(ast.length == 1 && ast[0] instanceof i18n.Text)) {
+          this._messages.splice(i, 1);
+          break;
+        }
+      }
+    }
+
+    this._msgCountAtSectionStart = undefined;
+  }
+
+  private _reportError(node: html.Node, msg: string): void {
+    this._errors.push(new I18nError(node.sourceSpan !, msg));
+  }
+}
+
+function _isOpeningComment(n: html.Node): boolean {
+  return !!(n instanceof html.Comment && n.value && n.value.startsWith('i18n'));
+}
+
+function _isClosingComment(n: html.Node): boolean {
+  return !!(n instanceof html.Comment && n.value && n.value === '/i18n');
+}
+
+function _getI18nAttr(p: html.Element): html.Attribute|null {
+  return p.attrs.find(attr => attr.name === _I18N_ATTR) || null;
+}
+
+function _parseMessageMeta(i18n?: string): {meaning: string, description: string, id: string} {
+  if (!i18n) return {meaning: '', description: '', id: ''};
+
+  const idIndex = i18n.indexOf(ID_SEPARATOR);
+  const descIndex = i18n.indexOf(MEANING_SEPARATOR);
+  const [meaningAndDesc, id] =
+      (idIndex > -1) ? [i18n.slice(0, idIndex), i18n.slice(idIndex + 2)] : [i18n, ''];
+  const [meaning, description] = (descIndex > -1) ?
+      [meaningAndDesc.slice(0, descIndex), meaningAndDesc.slice(descIndex + 1)] :
+      ['', meaningAndDesc];
+
+  return {meaning, description, id};
+}
diff --git a/angular/compiler/src/i18n/i18n_ast.ts b/angular/compiler/src/i18n/i18n_ast.ts
new file mode 100644
index 0000000..c2d1864
--- /dev/null
+++ b/angular/compiler/src/i18n/i18n_ast.ts
@@ -0,0 +1,157 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ParseSourceSpan} from '../parse_util';
+
+export class Message {
+  sources: MessageSpan[];
+
+  /**
+   * @param nodes message AST
+   * @param placeholders maps placeholder names to static content
+   * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)
+   * @param meaning
+   * @param description
+   * @param id
+   */
+  constructor(
+      public nodes: Node[], public placeholders: {[phName: string]: string},
+      public placeholderToMessage: {[phName: string]: Message}, public meaning: string,
+      public description: string, public id: string) {
+    if (nodes.length) {
+      this.sources = [{
+        filePath: nodes[0].sourceSpan.start.file.url,
+        startLine: nodes[0].sourceSpan.start.line + 1,
+        startCol: nodes[0].sourceSpan.start.col + 1,
+        endLine: nodes[nodes.length - 1].sourceSpan.end.line + 1,
+        endCol: nodes[0].sourceSpan.start.col + 1
+      }];
+    } else {
+      this.sources = [];
+    }
+  }
+}
+
+// line and columns indexes are 1 based
+export interface MessageSpan {
+  filePath: string;
+  startLine: number;
+  startCol: number;
+  endLine: number;
+  endCol: number;
+}
+
+export interface Node {
+  sourceSpan: ParseSourceSpan;
+  visit(visitor: Visitor, context?: any): any;
+}
+
+export class Text implements Node {
+  constructor(public value: string, public sourceSpan: ParseSourceSpan) {}
+
+  visit(visitor: Visitor, context?: any): any { return visitor.visitText(this, context); }
+}
+
+// TODO(vicb): do we really need this node (vs an array) ?
+export class Container implements Node {
+  constructor(public children: Node[], public sourceSpan: ParseSourceSpan) {}
+
+  visit(visitor: Visitor, context?: any): any { return visitor.visitContainer(this, context); }
+}
+
+export class Icu implements Node {
+  public expressionPlaceholder: string;
+  constructor(
+      public expression: string, public type: string, public cases: {[k: string]: Node},
+      public sourceSpan: ParseSourceSpan) {}
+
+  visit(visitor: Visitor, context?: any): any { return visitor.visitIcu(this, context); }
+}
+
+export class TagPlaceholder implements Node {
+  constructor(
+      public tag: string, public attrs: {[k: string]: string}, public startName: string,
+      public closeName: string, public children: Node[], public isVoid: boolean,
+      public sourceSpan: ParseSourceSpan) {}
+
+  visit(visitor: Visitor, context?: any): any { return visitor.visitTagPlaceholder(this, context); }
+}
+
+export class Placeholder implements Node {
+  constructor(public value: string, public name: string, public sourceSpan: ParseSourceSpan) {}
+
+  visit(visitor: Visitor, context?: any): any { return visitor.visitPlaceholder(this, context); }
+}
+
+export class IcuPlaceholder implements Node {
+  constructor(public value: Icu, public name: string, public sourceSpan: ParseSourceSpan) {}
+
+  visit(visitor: Visitor, context?: any): any { return visitor.visitIcuPlaceholder(this, context); }
+}
+
+export interface Visitor {
+  visitText(text: Text, context?: any): any;
+  visitContainer(container: Container, context?: any): any;
+  visitIcu(icu: Icu, context?: any): any;
+  visitTagPlaceholder(ph: TagPlaceholder, context?: any): any;
+  visitPlaceholder(ph: Placeholder, context?: any): any;
+  visitIcuPlaceholder(ph: IcuPlaceholder, context?: any): any;
+}
+
+// Clone the AST
+export class CloneVisitor implements Visitor {
+  visitText(text: Text, context?: any): Text { return new Text(text.value, text.sourceSpan); }
+
+  visitContainer(container: Container, context?: any): Container {
+    const children = container.children.map(n => n.visit(this, context));
+    return new Container(children, container.sourceSpan);
+  }
+
+  visitIcu(icu: Icu, context?: any): Icu {
+    const cases: {[k: string]: Node} = {};
+    Object.keys(icu.cases).forEach(key => cases[key] = icu.cases[key].visit(this, context));
+    const msg = new Icu(icu.expression, icu.type, cases, icu.sourceSpan);
+    msg.expressionPlaceholder = icu.expressionPlaceholder;
+    return msg;
+  }
+
+  visitTagPlaceholder(ph: TagPlaceholder, context?: any): TagPlaceholder {
+    const children = ph.children.map(n => n.visit(this, context));
+    return new TagPlaceholder(
+        ph.tag, ph.attrs, ph.startName, ph.closeName, children, ph.isVoid, ph.sourceSpan);
+  }
+
+  visitPlaceholder(ph: Placeholder, context?: any): Placeholder {
+    return new Placeholder(ph.value, ph.name, ph.sourceSpan);
+  }
+
+  visitIcuPlaceholder(ph: IcuPlaceholder, context?: any): IcuPlaceholder {
+    return new IcuPlaceholder(ph.value, ph.name, ph.sourceSpan);
+  }
+}
+
+// Visit all the nodes recursively
+export class RecurseVisitor implements Visitor {
+  visitText(text: Text, context?: any): any{};
+
+  visitContainer(container: Container, context?: any): any {
+    container.children.forEach(child => child.visit(this));
+  }
+
+  visitIcu(icu: Icu, context?: any): any {
+    Object.keys(icu.cases).forEach(k => { icu.cases[k].visit(this); });
+  }
+
+  visitTagPlaceholder(ph: TagPlaceholder, context?: any): any {
+    ph.children.forEach(child => child.visit(this));
+  }
+
+  visitPlaceholder(ph: Placeholder, context?: any): any{};
+
+  visitIcuPlaceholder(ph: IcuPlaceholder, context?: any): any{};
+}
diff --git a/angular/compiler/src/i18n/i18n_html_parser.ts b/angular/compiler/src/i18n/i18n_html_parser.ts
new file mode 100644
index 0000000..b0c3397
--- /dev/null
+++ b/angular/compiler/src/i18n/i18n_html_parser.ts
@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {MissingTranslationStrategy} from '../core';
+import {HtmlParser} from '../ml_parser/html_parser';
+import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from '../ml_parser/interpolation_config';
+import {ParseTreeResult} from '../ml_parser/parser';
+import {Console} from '../util';
+
+import {digest} from './digest';
+import {mergeTranslations} from './extractor_merger';
+import {Serializer} from './serializers/serializer';
+import {Xliff} from './serializers/xliff';
+import {Xliff2} from './serializers/xliff2';
+import {Xmb} from './serializers/xmb';
+import {Xtb} from './serializers/xtb';
+import {TranslationBundle} from './translation_bundle';
+
+export class I18NHtmlParser implements HtmlParser {
+  // @override
+  getTagDefinition: any;
+
+  private _translationBundle: TranslationBundle;
+
+  constructor(
+      private _htmlParser: HtmlParser, translations?: string, translationsFormat?: string,
+      missingTranslation: MissingTranslationStrategy = MissingTranslationStrategy.Warning,
+      console?: Console) {
+    if (translations) {
+      const serializer = createSerializer(translationsFormat);
+      this._translationBundle =
+          TranslationBundle.load(translations, 'i18n', serializer, missingTranslation, console);
+    } else {
+      this._translationBundle =
+          new TranslationBundle({}, null, digest, undefined, missingTranslation, console);
+    }
+  }
+
+  parse(
+      source: string, url: string, parseExpansionForms: boolean = false,
+      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ParseTreeResult {
+    const parseResult =
+        this._htmlParser.parse(source, url, parseExpansionForms, interpolationConfig);
+
+    if (parseResult.errors.length) {
+      return new ParseTreeResult(parseResult.rootNodes, parseResult.errors);
+    }
+
+    return mergeTranslations(
+        parseResult.rootNodes, this._translationBundle, interpolationConfig, [], {});
+  }
+}
+
+function createSerializer(format?: string): Serializer {
+  format = (format || 'xlf').toLowerCase();
+
+  switch (format) {
+    case 'xmb':
+      return new Xmb();
+    case 'xtb':
+      return new Xtb();
+    case 'xliff2':
+    case 'xlf2':
+      return new Xliff2();
+    case 'xliff':
+    case 'xlf':
+    default:
+      return new Xliff();
+  }
+}
diff --git a/angular/compiler/src/i18n/i18n_parser.ts b/angular/compiler/src/i18n/i18n_parser.ts
new file mode 100644
index 0000000..708a8e8
--- /dev/null
+++ b/angular/compiler/src/i18n/i18n_parser.ts
@@ -0,0 +1,169 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Lexer as ExpressionLexer} from '../expression_parser/lexer';
+import {Parser as ExpressionParser} from '../expression_parser/parser';
+import * as html from '../ml_parser/ast';
+import {getHtmlTagDefinition} from '../ml_parser/html_tags';
+import {InterpolationConfig} from '../ml_parser/interpolation_config';
+import {ParseSourceSpan} from '../parse_util';
+
+import * as i18n from './i18n_ast';
+import {PlaceholderRegistry} from './serializers/placeholder';
+
+const _expParser = new ExpressionParser(new ExpressionLexer());
+
+/**
+ * Returns a function converting html nodes to an i18n Message given an interpolationConfig
+ */
+export function createI18nMessageFactory(interpolationConfig: InterpolationConfig): (
+    nodes: html.Node[], meaning: string, description: string, id: string) => i18n.Message {
+  const visitor = new _I18nVisitor(_expParser, interpolationConfig);
+
+  return (nodes: html.Node[], meaning: string, description: string, id: string) =>
+             visitor.toI18nMessage(nodes, meaning, description, id);
+}
+
+class _I18nVisitor implements html.Visitor {
+  private _isIcu: boolean;
+  private _icuDepth: number;
+  private _placeholderRegistry: PlaceholderRegistry;
+  private _placeholderToContent: {[phName: string]: string};
+  private _placeholderToMessage: {[phName: string]: i18n.Message};
+
+  constructor(
+      private _expressionParser: ExpressionParser,
+      private _interpolationConfig: InterpolationConfig) {}
+
+  public toI18nMessage(nodes: html.Node[], meaning: string, description: string, id: string):
+      i18n.Message {
+    this._isIcu = nodes.length == 1 && nodes[0] instanceof html.Expansion;
+    this._icuDepth = 0;
+    this._placeholderRegistry = new PlaceholderRegistry();
+    this._placeholderToContent = {};
+    this._placeholderToMessage = {};
+
+    const i18nodes: i18n.Node[] = html.visitAll(this, nodes, {});
+
+    return new i18n.Message(
+        i18nodes, this._placeholderToContent, this._placeholderToMessage, meaning, description, id);
+  }
+
+  visitElement(el: html.Element, context: any): i18n.Node {
+    const children = html.visitAll(this, el.children);
+    const attrs: {[k: string]: string} = {};
+    el.attrs.forEach(attr => {
+      // Do not visit the attributes, translatable ones are top-level ASTs
+      attrs[attr.name] = attr.value;
+    });
+
+    const isVoid: boolean = getHtmlTagDefinition(el.name).isVoid;
+    const startPhName =
+        this._placeholderRegistry.getStartTagPlaceholderName(el.name, attrs, isVoid);
+    this._placeholderToContent[startPhName] = el.sourceSpan !.toString();
+
+    let closePhName = '';
+
+    if (!isVoid) {
+      closePhName = this._placeholderRegistry.getCloseTagPlaceholderName(el.name);
+      this._placeholderToContent[closePhName] = `</${el.name}>`;
+    }
+
+    return new i18n.TagPlaceholder(
+        el.name, attrs, startPhName, closePhName, children, isVoid, el.sourceSpan !);
+  }
+
+  visitAttribute(attribute: html.Attribute, context: any): i18n.Node {
+    return this._visitTextWithInterpolation(attribute.value, attribute.sourceSpan);
+  }
+
+  visitText(text: html.Text, context: any): i18n.Node {
+    return this._visitTextWithInterpolation(text.value, text.sourceSpan !);
+  }
+
+  visitComment(comment: html.Comment, context: any): i18n.Node|null { return null; }
+
+  visitExpansion(icu: html.Expansion, context: any): i18n.Node {
+    this._icuDepth++;
+    const i18nIcuCases: {[k: string]: i18n.Node} = {};
+    const i18nIcu = new i18n.Icu(icu.switchValue, icu.type, i18nIcuCases, icu.sourceSpan);
+    icu.cases.forEach((caze): void => {
+      i18nIcuCases[caze.value] = new i18n.Container(
+          caze.expression.map((node) => node.visit(this, {})), caze.expSourceSpan);
+    });
+    this._icuDepth--;
+
+    if (this._isIcu || this._icuDepth > 0) {
+      // Returns an ICU node when:
+      // - the message (vs a part of the message) is an ICU message, or
+      // - the ICU message is nested.
+      const expPh = this._placeholderRegistry.getUniquePlaceholder(`VAR_${icu.type}`);
+      i18nIcu.expressionPlaceholder = expPh;
+      this._placeholderToContent[expPh] = icu.switchValue;
+
+      return i18nIcu;
+    }
+
+    // Else returns a placeholder
+    // ICU placeholders should not be replaced with their original content but with the their
+    // translations. We need to create a new visitor (they are not re-entrant) to compute the
+    // message id.
+    // TODO(vicb): add a html.Node -> i18n.Message cache to avoid having to re-create the msg
+    const phName = this._placeholderRegistry.getPlaceholderName('ICU', icu.sourceSpan.toString());
+    const visitor = new _I18nVisitor(this._expressionParser, this._interpolationConfig);
+    this._placeholderToMessage[phName] = visitor.toI18nMessage([icu], '', '', '');
+    return new i18n.IcuPlaceholder(i18nIcu, phName, icu.sourceSpan);
+  }
+
+  visitExpansionCase(icuCase: html.ExpansionCase, context: any): i18n.Node {
+    throw new Error('Unreachable code');
+  }
+
+  private _visitTextWithInterpolation(text: string, sourceSpan: ParseSourceSpan): i18n.Node {
+    const splitInterpolation = this._expressionParser.splitInterpolation(
+        text, sourceSpan.start.toString(), this._interpolationConfig);
+
+    if (!splitInterpolation) {
+      // No expression, return a single text
+      return new i18n.Text(text, sourceSpan);
+    }
+
+    // Return a group of text + expressions
+    const nodes: i18n.Node[] = [];
+    const container = new i18n.Container(nodes, sourceSpan);
+    const {start: sDelimiter, end: eDelimiter} = this._interpolationConfig;
+
+    for (let i = 0; i < splitInterpolation.strings.length - 1; i++) {
+      const expression = splitInterpolation.expressions[i];
+      const baseName = _extractPlaceholderName(expression) || 'INTERPOLATION';
+      const phName = this._placeholderRegistry.getPlaceholderName(baseName, expression);
+
+      if (splitInterpolation.strings[i].length) {
+        // No need to add empty strings
+        nodes.push(new i18n.Text(splitInterpolation.strings[i], sourceSpan));
+      }
+
+      nodes.push(new i18n.Placeholder(expression, phName, sourceSpan));
+      this._placeholderToContent[phName] = sDelimiter + expression + eDelimiter;
+    }
+
+    // The last index contains no expression
+    const lastStringIdx = splitInterpolation.strings.length - 1;
+    if (splitInterpolation.strings[lastStringIdx].length) {
+      nodes.push(new i18n.Text(splitInterpolation.strings[lastStringIdx], sourceSpan));
+    }
+    return container;
+  }
+}
+
+const _CUSTOM_PH_EXP =
+    /\/\/[\s\S]*i18n[\s\S]*\([\s\S]*ph[\s\S]*=[\s\S]*("|')([\s\S]*?)\1[\s\S]*\)/g;
+
+function _extractPlaceholderName(input: string): string {
+  return input.split(_CUSTOM_PH_EXP)[2];
+}
diff --git a/angular/compiler/src/i18n/index.ts b/angular/compiler/src/i18n/index.ts
new file mode 100644
index 0000000..f47e971
--- /dev/null
+++ b/angular/compiler/src/i18n/index.ts
@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export {Extractor, ExtractorHost} from './extractor';
+export {I18NHtmlParser} from './i18n_html_parser';
+export {MessageBundle} from './message_bundle';
+export {Serializer} from './serializers/serializer';
+export {Xliff} from './serializers/xliff';
+export {Xliff2} from './serializers/xliff2';
+export {Xmb} from './serializers/xmb';
+export {Xtb} from './serializers/xtb';
diff --git a/angular/compiler/src/i18n/message_bundle.ts b/angular/compiler/src/i18n/message_bundle.ts
new file mode 100644
index 0000000..e685478
--- /dev/null
+++ b/angular/compiler/src/i18n/message_bundle.ts
@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {HtmlParser} from '../ml_parser/html_parser';
+import {InterpolationConfig} from '../ml_parser/interpolation_config';
+import {ParseError} from '../parse_util';
+
+import {extractMessages} from './extractor_merger';
+import * as i18n from './i18n_ast';
+import {PlaceholderMapper, Serializer} from './serializers/serializer';
+
+
+/**
+ * A container for message extracted from the templates.
+ */
+export class MessageBundle {
+  private _messages: i18n.Message[] = [];
+
+  constructor(
+      private _htmlParser: HtmlParser, private _implicitTags: string[],
+      private _implicitAttrs: {[k: string]: string[]}, private _locale: string|null = null) {}
+
+  updateFromTemplate(html: string, url: string, interpolationConfig: InterpolationConfig):
+      ParseError[] {
+    const htmlParserResult = this._htmlParser.parse(html, url, true, interpolationConfig);
+
+    if (htmlParserResult.errors.length) {
+      return htmlParserResult.errors;
+    }
+
+    const i18nParserResult = extractMessages(
+        htmlParserResult.rootNodes, interpolationConfig, this._implicitTags, this._implicitAttrs);
+
+    if (i18nParserResult.errors.length) {
+      return i18nParserResult.errors;
+    }
+
+    this._messages.push(...i18nParserResult.messages);
+    return [];
+  }
+
+  // Return the message in the internal format
+  // The public (serialized) format might be different, see the `write` method.
+  getMessages(): i18n.Message[] { return this._messages; }
+
+  write(serializer: Serializer, filterSources?: (path: string) => string): string {
+    const messages: {[id: string]: i18n.Message} = {};
+    const mapperVisitor = new MapPlaceholderNames();
+
+    // Deduplicate messages based on their ID
+    this._messages.forEach(message => {
+      const id = serializer.digest(message);
+      if (!messages.hasOwnProperty(id)) {
+        messages[id] = message;
+      } else {
+        messages[id].sources.push(...message.sources);
+      }
+    });
+
+    // Transform placeholder names using the serializer mapping
+    const msgList = Object.keys(messages).map(id => {
+      const mapper = serializer.createNameMapper(messages[id]);
+      const src = messages[id];
+      const nodes = mapper ? mapperVisitor.convert(src.nodes, mapper) : src.nodes;
+      let transformedMessage = new i18n.Message(nodes, {}, {}, src.meaning, src.description, id);
+      transformedMessage.sources = src.sources;
+      if (filterSources) {
+        transformedMessage.sources.forEach(
+            (source: i18n.MessageSpan) => source.filePath = filterSources(source.filePath));
+      }
+      return transformedMessage;
+    });
+
+    return serializer.write(msgList, this._locale);
+  }
+}
+
+// Transform an i18n AST by renaming the placeholder nodes with the given mapper
+class MapPlaceholderNames extends i18n.CloneVisitor {
+  convert(nodes: i18n.Node[], mapper: PlaceholderMapper): i18n.Node[] {
+    return mapper ? nodes.map(n => n.visit(this, mapper)) : nodes;
+  }
+
+  visitTagPlaceholder(ph: i18n.TagPlaceholder, mapper: PlaceholderMapper): i18n.TagPlaceholder {
+    const startName = mapper.toPublicName(ph.startName) !;
+    const closeName = ph.closeName ? mapper.toPublicName(ph.closeName) ! : ph.closeName;
+    const children = ph.children.map(n => n.visit(this, mapper));
+    return new i18n.TagPlaceholder(
+        ph.tag, ph.attrs, startName, closeName, children, ph.isVoid, ph.sourceSpan);
+  }
+
+  visitPlaceholder(ph: i18n.Placeholder, mapper: PlaceholderMapper): i18n.Placeholder {
+    return new i18n.Placeholder(ph.value, mapper.toPublicName(ph.name) !, ph.sourceSpan);
+  }
+
+  visitIcuPlaceholder(ph: i18n.IcuPlaceholder, mapper: PlaceholderMapper): i18n.IcuPlaceholder {
+    return new i18n.IcuPlaceholder(ph.value, mapper.toPublicName(ph.name) !, ph.sourceSpan);
+  }
+}
diff --git a/angular/compiler/src/i18n/parse_util.ts b/angular/compiler/src/i18n/parse_util.ts
new file mode 100644
index 0000000..37acd85
--- /dev/null
+++ b/angular/compiler/src/i18n/parse_util.ts
@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ParseError, ParseSourceSpan} from '../parse_util';
+
+/**
+ * An i18n error.
+ */
+export class I18nError extends ParseError {
+  constructor(span: ParseSourceSpan, msg: string) { super(span, msg); }
+}
diff --git a/angular/compiler/src/i18n/serializers/placeholder.ts b/angular/compiler/src/i18n/serializers/placeholder.ts
new file mode 100644
index 0000000..02fb3c9
--- /dev/null
+++ b/angular/compiler/src/i18n/serializers/placeholder.ts
@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+const TAG_TO_PLACEHOLDER_NAMES: {[k: string]: string} = {
+  'A': 'LINK',
+  'B': 'BOLD_TEXT',
+  'BR': 'LINE_BREAK',
+  'EM': 'EMPHASISED_TEXT',
+  'H1': 'HEADING_LEVEL1',
+  'H2': 'HEADING_LEVEL2',
+  'H3': 'HEADING_LEVEL3',
+  'H4': 'HEADING_LEVEL4',
+  'H5': 'HEADING_LEVEL5',
+  'H6': 'HEADING_LEVEL6',
+  'HR': 'HORIZONTAL_RULE',
+  'I': 'ITALIC_TEXT',
+  'LI': 'LIST_ITEM',
+  'LINK': 'MEDIA_LINK',
+  'OL': 'ORDERED_LIST',
+  'P': 'PARAGRAPH',
+  'Q': 'QUOTATION',
+  'S': 'STRIKETHROUGH_TEXT',
+  'SMALL': 'SMALL_TEXT',
+  'SUB': 'SUBSTRIPT',
+  'SUP': 'SUPERSCRIPT',
+  'TBODY': 'TABLE_BODY',
+  'TD': 'TABLE_CELL',
+  'TFOOT': 'TABLE_FOOTER',
+  'TH': 'TABLE_HEADER_CELL',
+  'THEAD': 'TABLE_HEADER',
+  'TR': 'TABLE_ROW',
+  'TT': 'MONOSPACED_TEXT',
+  'U': 'UNDERLINED_TEXT',
+  'UL': 'UNORDERED_LIST',
+};
+
+/**
+ * Creates unique names for placeholder with different content.
+ *
+ * Returns the same placeholder name when the content is identical.
+ *
+ * @internal
+ */
+export class PlaceholderRegistry {
+  // Count the occurrence of the base name top generate a unique name
+  private _placeHolderNameCounts: {[k: string]: number} = {};
+  // Maps signature to placeholder names
+  private _signatureToName: {[k: string]: string} = {};
+
+  getStartTagPlaceholderName(tag: string, attrs: {[k: string]: string}, isVoid: boolean): string {
+    const signature = this._hashTag(tag, attrs, isVoid);
+    if (this._signatureToName[signature]) {
+      return this._signatureToName[signature];
+    }
+
+    const upperTag = tag.toUpperCase();
+    const baseName = TAG_TO_PLACEHOLDER_NAMES[upperTag] || `TAG_${upperTag}`;
+    const name = this._generateUniqueName(isVoid ? baseName : `START_${baseName}`);
+
+    this._signatureToName[signature] = name;
+
+    return name;
+  }
+
+  getCloseTagPlaceholderName(tag: string): string {
+    const signature = this._hashClosingTag(tag);
+    if (this._signatureToName[signature]) {
+      return this._signatureToName[signature];
+    }
+
+    const upperTag = tag.toUpperCase();
+    const baseName = TAG_TO_PLACEHOLDER_NAMES[upperTag] || `TAG_${upperTag}`;
+    const name = this._generateUniqueName(`CLOSE_${baseName}`);
+
+    this._signatureToName[signature] = name;
+
+    return name;
+  }
+
+  getPlaceholderName(name: string, content: string): string {
+    const upperName = name.toUpperCase();
+    const signature = `PH: ${upperName}=${content}`;
+    if (this._signatureToName[signature]) {
+      return this._signatureToName[signature];
+    }
+
+    const uniqueName = this._generateUniqueName(upperName);
+    this._signatureToName[signature] = uniqueName;
+
+    return uniqueName;
+  }
+
+  getUniquePlaceholder(name: string): string {
+    return this._generateUniqueName(name.toUpperCase());
+  }
+
+  // Generate a hash for a tag - does not take attribute order into account
+  private _hashTag(tag: string, attrs: {[k: string]: string}, isVoid: boolean): string {
+    const start = `<${tag}`;
+    const strAttrs = Object.keys(attrs).sort().map((name) => ` ${name}=${attrs[name]}`).join('');
+    const end = isVoid ? '/>' : `></${tag}>`;
+
+    return start + strAttrs + end;
+  }
+
+  private _hashClosingTag(tag: string): string { return this._hashTag(`/${tag}`, {}, false); }
+
+  private _generateUniqueName(base: string): string {
+    const seen = this._placeHolderNameCounts.hasOwnProperty(base);
+    if (!seen) {
+      this._placeHolderNameCounts[base] = 1;
+      return base;
+    }
+
+    const id = this._placeHolderNameCounts[base];
+    this._placeHolderNameCounts[base] = id + 1;
+    return `${base}_${id}`;
+  }
+}
diff --git a/angular/compiler/src/i18n/serializers/serializer.ts b/angular/compiler/src/i18n/serializers/serializer.ts
new file mode 100644
index 0000000..4fb7dc8
--- /dev/null
+++ b/angular/compiler/src/i18n/serializers/serializer.ts
@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as i18n from '../i18n_ast';
+
+export abstract class Serializer {
+  // - The `placeholders` and `placeholderToMessage` properties are irrelevant in the input messages
+  // - The `id` contains the message id that the serializer is expected to use
+  // - Placeholder names are already map to public names using the provided mapper
+  abstract write(messages: i18n.Message[], locale: string|null): string;
+
+  abstract load(content: string, url: string):
+      {locale: string | null, i18nNodesByMsgId: {[msgId: string]: i18n.Node[]}};
+
+  abstract digest(message: i18n.Message): string;
+
+  // Creates a name mapper, see `PlaceholderMapper`
+  // Returning `null` means that no name mapping is used.
+  createNameMapper(message: i18n.Message): PlaceholderMapper|null { return null; }
+}
+
+/**
+ * A `PlaceholderMapper` converts placeholder names from internal to serialized representation and
+ * back.
+ *
+ * It should be used for serialization format that put constraints on the placeholder names.
+ */
+export interface PlaceholderMapper {
+  toPublicName(internalName: string): string|null;
+
+  toInternalName(publicName: string): string|null;
+}
+
+/**
+ * A simple mapper that take a function to transform an internal name to a public name
+ */
+export class SimplePlaceholderMapper extends i18n.RecurseVisitor implements PlaceholderMapper {
+  private internalToPublic: {[k: string]: string} = {};
+  private publicToNextId: {[k: string]: number} = {};
+  private publicToInternal: {[k: string]: string} = {};
+
+  // create a mapping from the message
+  constructor(message: i18n.Message, private mapName: (name: string) => string) {
+    super();
+    message.nodes.forEach(node => node.visit(this));
+  }
+
+  toPublicName(internalName: string): string|null {
+    return this.internalToPublic.hasOwnProperty(internalName) ?
+        this.internalToPublic[internalName] :
+        null;
+  }
+
+  toInternalName(publicName: string): string|null {
+    return this.publicToInternal.hasOwnProperty(publicName) ? this.publicToInternal[publicName] :
+                                                              null;
+  }
+
+  visitText(text: i18n.Text, context?: any): any { return null; }
+
+  visitTagPlaceholder(ph: i18n.TagPlaceholder, context?: any): any {
+    this.visitPlaceholderName(ph.startName);
+    super.visitTagPlaceholder(ph, context);
+    this.visitPlaceholderName(ph.closeName);
+  }
+
+  visitPlaceholder(ph: i18n.Placeholder, context?: any): any { this.visitPlaceholderName(ph.name); }
+
+  visitIcuPlaceholder(ph: i18n.IcuPlaceholder, context?: any): any {
+    this.visitPlaceholderName(ph.name);
+  }
+
+  // XMB placeholders could only contains A-Z, 0-9 and _
+  private visitPlaceholderName(internalName: string): void {
+    if (!internalName || this.internalToPublic.hasOwnProperty(internalName)) {
+      return;
+    }
+
+    let publicName = this.mapName(internalName);
+
+    if (this.publicToInternal.hasOwnProperty(publicName)) {
+      // Create a new XMB when it has already been used
+      const nextId = this.publicToNextId[publicName];
+      this.publicToNextId[publicName] = nextId + 1;
+      publicName = `${publicName}_${nextId}`;
+    } else {
+      this.publicToNextId[publicName] = 1;
+    }
+
+    this.internalToPublic[internalName] = publicName;
+    this.publicToInternal[publicName] = internalName;
+  }
+}
diff --git a/angular/compiler/src/i18n/serializers/xliff.ts b/angular/compiler/src/i18n/serializers/xliff.ts
new file mode 100644
index 0000000..11a5944
--- /dev/null
+++ b/angular/compiler/src/i18n/serializers/xliff.ts
@@ -0,0 +1,328 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as ml from '../../ml_parser/ast';
+import {XmlParser} from '../../ml_parser/xml_parser';
+import {digest} from '../digest';
+import * as i18n from '../i18n_ast';
+import {I18nError} from '../parse_util';
+
+import {Serializer} from './serializer';
+import * as xml from './xml_helper';
+
+const _VERSION = '1.2';
+const _XMLNS = 'urn:oasis:names:tc:xliff:document:1.2';
+// TODO(vicb): make this a param (s/_/-/)
+const _DEFAULT_SOURCE_LANG = 'en';
+const _PLACEHOLDER_TAG = 'x';
+
+const _FILE_TAG = 'file';
+const _SOURCE_TAG = 'source';
+const _TARGET_TAG = 'target';
+const _UNIT_TAG = 'trans-unit';
+const _CONTEXT_GROUP_TAG = 'context-group';
+const _CONTEXT_TAG = 'context';
+
+// http://docs.oasis-open.org/xliff/v1.2/os/xliff-core.html
+// http://docs.oasis-open.org/xliff/v1.2/xliff-profile-html/xliff-profile-html-1.2.html
+export class Xliff extends Serializer {
+  write(messages: i18n.Message[], locale: string|null): string {
+    const visitor = new _WriteVisitor();
+    const transUnits: xml.Node[] = [];
+
+    messages.forEach(message => {
+      let contextTags: xml.Node[] = [];
+      message.sources.forEach((source: i18n.MessageSpan) => {
+        let contextGroupTag = new xml.Tag(_CONTEXT_GROUP_TAG, {purpose: 'location'});
+        contextGroupTag.children.push(
+            new xml.CR(10),
+            new xml.Tag(
+                _CONTEXT_TAG, {'context-type': 'sourcefile'}, [new xml.Text(source.filePath)]),
+            new xml.CR(10), new xml.Tag(
+                                _CONTEXT_TAG, {'context-type': 'linenumber'},
+                                [new xml.Text(`${source.startLine}`)]),
+            new xml.CR(8));
+        contextTags.push(new xml.CR(8), contextGroupTag);
+      });
+
+      const transUnit = new xml.Tag(_UNIT_TAG, {id: message.id, datatype: 'html'});
+      transUnit.children.push(
+          new xml.CR(8), new xml.Tag(_SOURCE_TAG, {}, visitor.serialize(message.nodes)),
+          ...contextTags);
+
+      if (message.description) {
+        transUnit.children.push(
+            new xml.CR(8),
+            new xml.Tag(
+                'note', {priority: '1', from: 'description'}, [new xml.Text(message.description)]));
+      }
+
+      if (message.meaning) {
+        transUnit.children.push(
+            new xml.CR(8),
+            new xml.Tag('note', {priority: '1', from: 'meaning'}, [new xml.Text(message.meaning)]));
+      }
+
+      transUnit.children.push(new xml.CR(6));
+
+      transUnits.push(new xml.CR(6), transUnit);
+    });
+
+    const body = new xml.Tag('body', {}, [...transUnits, new xml.CR(4)]);
+    const file = new xml.Tag(
+        'file', {
+          'source-language': locale || _DEFAULT_SOURCE_LANG,
+          datatype: 'plaintext',
+          original: 'ng2.template',
+        },
+        [new xml.CR(4), body, new xml.CR(2)]);
+    const xliff = new xml.Tag(
+        'xliff', {version: _VERSION, xmlns: _XMLNS}, [new xml.CR(2), file, new xml.CR()]);
+
+    return xml.serialize([
+      new xml.Declaration({version: '1.0', encoding: 'UTF-8'}), new xml.CR(), xliff, new xml.CR()
+    ]);
+  }
+
+  load(content: string, url: string):
+      {locale: string, i18nNodesByMsgId: {[msgId: string]: i18n.Node[]}} {
+    // xliff to xml nodes
+    const xliffParser = new XliffParser();
+    const {locale, msgIdToHtml, errors} = xliffParser.parse(content, url);
+
+    // xml nodes to i18n nodes
+    const i18nNodesByMsgId: {[msgId: string]: i18n.Node[]} = {};
+    const converter = new XmlToI18n();
+
+    Object.keys(msgIdToHtml).forEach(msgId => {
+      const {i18nNodes, errors: e} = converter.convert(msgIdToHtml[msgId], url);
+      errors.push(...e);
+      i18nNodesByMsgId[msgId] = i18nNodes;
+    });
+
+    if (errors.length) {
+      throw new Error(`xliff parse errors:\n${errors.join('\n')}`);
+    }
+
+    return {locale: locale !, i18nNodesByMsgId};
+  }
+
+  digest(message: i18n.Message): string { return digest(message); }
+}
+
+class _WriteVisitor implements i18n.Visitor {
+  visitText(text: i18n.Text, context?: any): xml.Node[] { return [new xml.Text(text.value)]; }
+
+  visitContainer(container: i18n.Container, context?: any): xml.Node[] {
+    const nodes: xml.Node[] = [];
+    container.children.forEach((node: i18n.Node) => nodes.push(...node.visit(this)));
+    return nodes;
+  }
+
+  visitIcu(icu: i18n.Icu, context?: any): xml.Node[] {
+    const nodes = [new xml.Text(`{${icu.expressionPlaceholder}, ${icu.type}, `)];
+
+    Object.keys(icu.cases).forEach((c: string) => {
+      nodes.push(new xml.Text(`${c} {`), ...icu.cases[c].visit(this), new xml.Text(`} `));
+    });
+
+    nodes.push(new xml.Text(`}`));
+
+    return nodes;
+  }
+
+  visitTagPlaceholder(ph: i18n.TagPlaceholder, context?: any): xml.Node[] {
+    const ctype = getCtypeForTag(ph.tag);
+
+    if (ph.isVoid) {
+      // void tags have no children nor closing tags
+      return [new xml.Tag(
+          _PLACEHOLDER_TAG, {id: ph.startName, ctype, 'equiv-text': `<${ph.tag}/>`})];
+    }
+
+    const startTagPh =
+        new xml.Tag(_PLACEHOLDER_TAG, {id: ph.startName, ctype, 'equiv-text': `<${ph.tag}>`});
+    const closeTagPh =
+        new xml.Tag(_PLACEHOLDER_TAG, {id: ph.closeName, ctype, 'equiv-text': `</${ph.tag}>`});
+
+    return [startTagPh, ...this.serialize(ph.children), closeTagPh];
+  }
+
+  visitPlaceholder(ph: i18n.Placeholder, context?: any): xml.Node[] {
+    return [new xml.Tag(_PLACEHOLDER_TAG, {id: ph.name, 'equiv-text': `{{${ph.value}}}`})];
+  }
+
+  visitIcuPlaceholder(ph: i18n.IcuPlaceholder, context?: any): xml.Node[] {
+    const equivText =
+        `{${ph.value.expression}, ${ph.value.type}, ${Object.keys(ph.value.cases).map((value: string) => value + ' {...}').join(' ')}}`;
+    return [new xml.Tag(_PLACEHOLDER_TAG, {id: ph.name, 'equiv-text': equivText})];
+  }
+
+  serialize(nodes: i18n.Node[]): xml.Node[] {
+    return [].concat(...nodes.map(node => node.visit(this)));
+  }
+}
+
+// TODO(vicb): add error management (structure)
+// Extract messages as xml nodes from the xliff file
+class XliffParser implements ml.Visitor {
+  private _unitMlString: string|null;
+  private _errors: I18nError[];
+  private _msgIdToHtml: {[msgId: string]: string};
+  private _locale: string|null = null;
+
+  parse(xliff: string, url: string) {
+    this._unitMlString = null;
+    this._msgIdToHtml = {};
+
+    const xml = new XmlParser().parse(xliff, url, false);
+
+    this._errors = xml.errors;
+    ml.visitAll(this, xml.rootNodes, null);
+
+    return {
+      msgIdToHtml: this._msgIdToHtml,
+      errors: this._errors,
+      locale: this._locale,
+    };
+  }
+
+  visitElement(element: ml.Element, context: any): any {
+    switch (element.name) {
+      case _UNIT_TAG:
+        this._unitMlString = null !;
+        const idAttr = element.attrs.find((attr) => attr.name === 'id');
+        if (!idAttr) {
+          this._addError(element, `<${_UNIT_TAG}> misses the "id" attribute`);
+        } else {
+          const id = idAttr.value;
+          if (this._msgIdToHtml.hasOwnProperty(id)) {
+            this._addError(element, `Duplicated translations for msg ${id}`);
+          } else {
+            ml.visitAll(this, element.children, null);
+            if (typeof this._unitMlString === 'string') {
+              this._msgIdToHtml[id] = this._unitMlString;
+            } else {
+              this._addError(element, `Message ${id} misses a translation`);
+            }
+          }
+        }
+        break;
+
+      case _SOURCE_TAG:
+        // ignore source message
+        break;
+
+      case _TARGET_TAG:
+        const innerTextStart = element.startSourceSpan !.end.offset;
+        const innerTextEnd = element.endSourceSpan !.start.offset;
+        const content = element.startSourceSpan !.start.file.content;
+        const innerText = content.slice(innerTextStart, innerTextEnd);
+        this._unitMlString = innerText;
+        break;
+
+      case _FILE_TAG:
+        const localeAttr = element.attrs.find((attr) => attr.name === 'target-language');
+        if (localeAttr) {
+          this._locale = localeAttr.value;
+        }
+        ml.visitAll(this, element.children, null);
+        break;
+
+      default:
+        // TODO(vicb): assert file structure, xliff version
+        // For now only recurse on unhandled nodes
+        ml.visitAll(this, element.children, null);
+    }
+  }
+
+  visitAttribute(attribute: ml.Attribute, context: any): any {}
+
+  visitText(text: ml.Text, context: any): any {}
+
+  visitComment(comment: ml.Comment, context: any): any {}
+
+  visitExpansion(expansion: ml.Expansion, context: any): any {}
+
+  visitExpansionCase(expansionCase: ml.ExpansionCase, context: any): any {}
+
+  private _addError(node: ml.Node, message: string): void {
+    this._errors.push(new I18nError(node.sourceSpan !, message));
+  }
+}
+
+// Convert ml nodes (xliff syntax) to i18n nodes
+class XmlToI18n implements ml.Visitor {
+  private _errors: I18nError[];
+
+  convert(message: string, url: string) {
+    const xmlIcu = new XmlParser().parse(message, url, true);
+    this._errors = xmlIcu.errors;
+
+    const i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ?
+        [] :
+        ml.visitAll(this, xmlIcu.rootNodes);
+
+    return {
+      i18nNodes: i18nNodes,
+      errors: this._errors,
+    };
+  }
+
+  visitText(text: ml.Text, context: any) { return new i18n.Text(text.value, text.sourceSpan !); }
+
+  visitElement(el: ml.Element, context: any): i18n.Placeholder|null {
+    if (el.name === _PLACEHOLDER_TAG) {
+      const nameAttr = el.attrs.find((attr) => attr.name === 'id');
+      if (nameAttr) {
+        return new i18n.Placeholder('', nameAttr.value, el.sourceSpan !);
+      }
+
+      this._addError(el, `<${_PLACEHOLDER_TAG}> misses the "id" attribute`);
+    } else {
+      this._addError(el, `Unexpected tag`);
+    }
+    return null;
+  }
+
+  visitExpansion(icu: ml.Expansion, context: any) {
+    const caseMap: {[value: string]: i18n.Node} = {};
+
+    ml.visitAll(this, icu.cases).forEach((c: any) => {
+      caseMap[c.value] = new i18n.Container(c.nodes, icu.sourceSpan);
+    });
+
+    return new i18n.Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);
+  }
+
+  visitExpansionCase(icuCase: ml.ExpansionCase, context: any): any {
+    return {
+      value: icuCase.value,
+      nodes: ml.visitAll(this, icuCase.expression),
+    };
+  }
+
+  visitComment(comment: ml.Comment, context: any) {}
+
+  visitAttribute(attribute: ml.Attribute, context: any) {}
+
+  private _addError(node: ml.Node, message: string): void {
+    this._errors.push(new I18nError(node.sourceSpan !, message));
+  }
+}
+
+function getCtypeForTag(tag: string): string {
+  switch (tag.toLowerCase()) {
+    case 'br':
+      return 'lb';
+    case 'img':
+      return 'image';
+    default:
+      return `x-${tag}`;
+  }
+}
diff --git a/angular/compiler/src/i18n/serializers/xliff2.ts b/angular/compiler/src/i18n/serializers/xliff2.ts
new file mode 100644
index 0000000..ea754b3
--- /dev/null
+++ b/angular/compiler/src/i18n/serializers/xliff2.ts
@@ -0,0 +1,382 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as ml from '../../ml_parser/ast';
+import {XmlParser} from '../../ml_parser/xml_parser';
+import {decimalDigest} from '../digest';
+import * as i18n from '../i18n_ast';
+import {I18nError} from '../parse_util';
+
+import {Serializer} from './serializer';
+import * as xml from './xml_helper';
+
+const _VERSION = '2.0';
+const _XMLNS = 'urn:oasis:names:tc:xliff:document:2.0';
+// TODO(vicb): make this a param (s/_/-/)
+const _DEFAULT_SOURCE_LANG = 'en';
+const _PLACEHOLDER_TAG = 'ph';
+const _PLACEHOLDER_SPANNING_TAG = 'pc';
+
+const _XLIFF_TAG = 'xliff';
+const _SOURCE_TAG = 'source';
+const _TARGET_TAG = 'target';
+const _UNIT_TAG = 'unit';
+
+// http://docs.oasis-open.org/xliff/xliff-core/v2.0/os/xliff-core-v2.0-os.html
+export class Xliff2 extends Serializer {
+  write(messages: i18n.Message[], locale: string|null): string {
+    const visitor = new _WriteVisitor();
+    const units: xml.Node[] = [];
+
+    messages.forEach(message => {
+      const unit = new xml.Tag(_UNIT_TAG, {id: message.id});
+      const notes = new xml.Tag('notes');
+
+      if (message.description || message.meaning) {
+        if (message.description) {
+          notes.children.push(
+              new xml.CR(8),
+              new xml.Tag('note', {category: 'description'}, [new xml.Text(message.description)]));
+        }
+
+        if (message.meaning) {
+          notes.children.push(
+              new xml.CR(8),
+              new xml.Tag('note', {category: 'meaning'}, [new xml.Text(message.meaning)]));
+        }
+      }
+
+      message.sources.forEach((source: i18n.MessageSpan) => {
+        notes.children.push(new xml.CR(8), new xml.Tag('note', {category: 'location'}, [
+          new xml.Text(
+              `${source.filePath}:${source.startLine}${source.endLine !== source.startLine ? ',' + source.endLine : ''}`)
+        ]));
+      });
+
+      notes.children.push(new xml.CR(6));
+      unit.children.push(new xml.CR(6), notes);
+
+      const segment = new xml.Tag('segment');
+
+      segment.children.push(
+          new xml.CR(8), new xml.Tag(_SOURCE_TAG, {}, visitor.serialize(message.nodes)),
+          new xml.CR(6));
+
+      unit.children.push(new xml.CR(6), segment, new xml.CR(4));
+
+      units.push(new xml.CR(4), unit);
+    });
+
+    const file =
+        new xml.Tag('file', {'original': 'ng.template', id: 'ngi18n'}, [...units, new xml.CR(2)]);
+
+    const xliff = new xml.Tag(
+        _XLIFF_TAG, {version: _VERSION, xmlns: _XMLNS, srcLang: locale || _DEFAULT_SOURCE_LANG},
+        [new xml.CR(2), file, new xml.CR()]);
+
+    return xml.serialize([
+      new xml.Declaration({version: '1.0', encoding: 'UTF-8'}), new xml.CR(), xliff, new xml.CR()
+    ]);
+  }
+
+  load(content: string, url: string):
+      {locale: string, i18nNodesByMsgId: {[msgId: string]: i18n.Node[]}} {
+    // xliff to xml nodes
+    const xliff2Parser = new Xliff2Parser();
+    const {locale, msgIdToHtml, errors} = xliff2Parser.parse(content, url);
+
+    // xml nodes to i18n nodes
+    const i18nNodesByMsgId: {[msgId: string]: i18n.Node[]} = {};
+    const converter = new XmlToI18n();
+
+    Object.keys(msgIdToHtml).forEach(msgId => {
+      const {i18nNodes, errors: e} = converter.convert(msgIdToHtml[msgId], url);
+      errors.push(...e);
+      i18nNodesByMsgId[msgId] = i18nNodes;
+    });
+
+    if (errors.length) {
+      throw new Error(`xliff2 parse errors:\n${errors.join('\n')}`);
+    }
+
+    return {locale: locale !, i18nNodesByMsgId};
+  }
+
+  digest(message: i18n.Message): string { return decimalDigest(message); }
+}
+
+class _WriteVisitor implements i18n.Visitor {
+  private _nextPlaceholderId: number;
+
+  visitText(text: i18n.Text, context?: any): xml.Node[] { return [new xml.Text(text.value)]; }
+
+  visitContainer(container: i18n.Container, context?: any): xml.Node[] {
+    const nodes: xml.Node[] = [];
+    container.children.forEach((node: i18n.Node) => nodes.push(...node.visit(this)));
+    return nodes;
+  }
+
+  visitIcu(icu: i18n.Icu, context?: any): xml.Node[] {
+    const nodes = [new xml.Text(`{${icu.expressionPlaceholder}, ${icu.type}, `)];
+
+    Object.keys(icu.cases).forEach((c: string) => {
+      nodes.push(new xml.Text(`${c} {`), ...icu.cases[c].visit(this), new xml.Text(`} `));
+    });
+
+    nodes.push(new xml.Text(`}`));
+
+    return nodes;
+  }
+
+  visitTagPlaceholder(ph: i18n.TagPlaceholder, context?: any): xml.Node[] {
+    const type = getTypeForTag(ph.tag);
+
+    if (ph.isVoid) {
+      const tagPh = new xml.Tag(_PLACEHOLDER_TAG, {
+        id: (this._nextPlaceholderId++).toString(),
+        equiv: ph.startName,
+        type: type,
+        disp: `<${ph.tag}/>`,
+      });
+      return [tagPh];
+    }
+
+    const tagPc = new xml.Tag(_PLACEHOLDER_SPANNING_TAG, {
+      id: (this._nextPlaceholderId++).toString(),
+      equivStart: ph.startName,
+      equivEnd: ph.closeName,
+      type: type,
+      dispStart: `<${ph.tag}>`,
+      dispEnd: `</${ph.tag}>`,
+    });
+    const nodes: xml.Node[] = [].concat(...ph.children.map(node => node.visit(this)));
+    if (nodes.length) {
+      nodes.forEach((node: xml.Node) => tagPc.children.push(node));
+    } else {
+      tagPc.children.push(new xml.Text(''));
+    }
+
+    return [tagPc];
+  }
+
+  visitPlaceholder(ph: i18n.Placeholder, context?: any): xml.Node[] {
+    const idStr = (this._nextPlaceholderId++).toString();
+    return [new xml.Tag(_PLACEHOLDER_TAG, {
+      id: idStr,
+      equiv: ph.name,
+      disp: `{{${ph.value}}}`,
+    })];
+  }
+
+  visitIcuPlaceholder(ph: i18n.IcuPlaceholder, context?: any): xml.Node[] {
+    const cases = Object.keys(ph.value.cases).map((value: string) => value + ' {...}').join(' ');
+    const idStr = (this._nextPlaceholderId++).toString();
+    return [new xml.Tag(
+        _PLACEHOLDER_TAG,
+        {id: idStr, equiv: ph.name, disp: `{${ph.value.expression}, ${ph.value.type}, ${cases}}`})];
+  }
+
+  serialize(nodes: i18n.Node[]): xml.Node[] {
+    this._nextPlaceholderId = 0;
+    return [].concat(...nodes.map(node => node.visit(this)));
+  }
+}
+
+// Extract messages as xml nodes from the xliff file
+class Xliff2Parser implements ml.Visitor {
+  private _unitMlString: string|null;
+  private _errors: I18nError[];
+  private _msgIdToHtml: {[msgId: string]: string};
+  private _locale: string|null = null;
+
+  parse(xliff: string, url: string) {
+    this._unitMlString = null;
+    this._msgIdToHtml = {};
+
+    const xml = new XmlParser().parse(xliff, url, false);
+
+    this._errors = xml.errors;
+    ml.visitAll(this, xml.rootNodes, null);
+
+    return {
+      msgIdToHtml: this._msgIdToHtml,
+      errors: this._errors,
+      locale: this._locale,
+    };
+  }
+
+  visitElement(element: ml.Element, context: any): any {
+    switch (element.name) {
+      case _UNIT_TAG:
+        this._unitMlString = null;
+        const idAttr = element.attrs.find((attr) => attr.name === 'id');
+        if (!idAttr) {
+          this._addError(element, `<${_UNIT_TAG}> misses the "id" attribute`);
+        } else {
+          const id = idAttr.value;
+          if (this._msgIdToHtml.hasOwnProperty(id)) {
+            this._addError(element, `Duplicated translations for msg ${id}`);
+          } else {
+            ml.visitAll(this, element.children, null);
+            if (typeof this._unitMlString === 'string') {
+              this._msgIdToHtml[id] = this._unitMlString;
+            } else {
+              this._addError(element, `Message ${id} misses a translation`);
+            }
+          }
+        }
+        break;
+
+      case _SOURCE_TAG:
+        // ignore source message
+        break;
+
+      case _TARGET_TAG:
+        const innerTextStart = element.startSourceSpan !.end.offset;
+        const innerTextEnd = element.endSourceSpan !.start.offset;
+        const content = element.startSourceSpan !.start.file.content;
+        const innerText = content.slice(innerTextStart, innerTextEnd);
+        this._unitMlString = innerText;
+        break;
+
+      case _XLIFF_TAG:
+        const localeAttr = element.attrs.find((attr) => attr.name === 'trgLang');
+        if (localeAttr) {
+          this._locale = localeAttr.value;
+        }
+
+        const versionAttr = element.attrs.find((attr) => attr.name === 'version');
+        if (versionAttr) {
+          const version = versionAttr.value;
+          if (version !== '2.0') {
+            this._addError(
+                element,
+                `The XLIFF file version ${version} is not compatible with XLIFF 2.0 serializer`);
+          } else {
+            ml.visitAll(this, element.children, null);
+          }
+        }
+        break;
+      default:
+        ml.visitAll(this, element.children, null);
+    }
+  }
+
+  visitAttribute(attribute: ml.Attribute, context: any): any {}
+
+  visitText(text: ml.Text, context: any): any {}
+
+  visitComment(comment: ml.Comment, context: any): any {}
+
+  visitExpansion(expansion: ml.Expansion, context: any): any {}
+
+  visitExpansionCase(expansionCase: ml.ExpansionCase, context: any): any {}
+
+  private _addError(node: ml.Node, message: string): void {
+    this._errors.push(new I18nError(node.sourceSpan, message));
+  }
+}
+
+// Convert ml nodes (xliff syntax) to i18n nodes
+class XmlToI18n implements ml.Visitor {
+  private _errors: I18nError[];
+
+  convert(message: string, url: string) {
+    const xmlIcu = new XmlParser().parse(message, url, true);
+    this._errors = xmlIcu.errors;
+
+    const i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ?
+        [] :
+        [].concat(...ml.visitAll(this, xmlIcu.rootNodes));
+
+    return {
+      i18nNodes,
+      errors: this._errors,
+    };
+  }
+
+  visitText(text: ml.Text, context: any) { return new i18n.Text(text.value, text.sourceSpan); }
+
+  visitElement(el: ml.Element, context: any): i18n.Node[]|null {
+    switch (el.name) {
+      case _PLACEHOLDER_TAG:
+        const nameAttr = el.attrs.find((attr) => attr.name === 'equiv');
+        if (nameAttr) {
+          return [new i18n.Placeholder('', nameAttr.value, el.sourceSpan)];
+        }
+
+        this._addError(el, `<${_PLACEHOLDER_TAG}> misses the "equiv" attribute`);
+        break;
+      case _PLACEHOLDER_SPANNING_TAG:
+        const startAttr = el.attrs.find((attr) => attr.name === 'equivStart');
+        const endAttr = el.attrs.find((attr) => attr.name === 'equivEnd');
+
+        if (!startAttr) {
+          this._addError(el, `<${_PLACEHOLDER_TAG}> misses the "equivStart" attribute`);
+        } else if (!endAttr) {
+          this._addError(el, `<${_PLACEHOLDER_TAG}> misses the "equivEnd" attribute`);
+        } else {
+          const startId = startAttr.value;
+          const endId = endAttr.value;
+
+          const nodes: i18n.Node[] = [];
+
+          return nodes.concat(
+              new i18n.Placeholder('', startId, el.sourceSpan),
+              ...el.children.map(node => node.visit(this, null)),
+              new i18n.Placeholder('', endId, el.sourceSpan));
+        }
+        break;
+      default:
+        this._addError(el, `Unexpected tag`);
+    }
+
+    return null;
+  }
+
+  visitExpansion(icu: ml.Expansion, context: any) {
+    const caseMap: {[value: string]: i18n.Node} = {};
+
+    ml.visitAll(this, icu.cases).forEach((c: any) => {
+      caseMap[c.value] = new i18n.Container(c.nodes, icu.sourceSpan);
+    });
+
+    return new i18n.Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);
+  }
+
+  visitExpansionCase(icuCase: ml.ExpansionCase, context: any): any {
+    return {
+      value: icuCase.value,
+      nodes: [].concat(...ml.visitAll(this, icuCase.expression)),
+    };
+  }
+
+  visitComment(comment: ml.Comment, context: any) {}
+
+  visitAttribute(attribute: ml.Attribute, context: any) {}
+
+  private _addError(node: ml.Node, message: string): void {
+    this._errors.push(new I18nError(node.sourceSpan, message));
+  }
+}
+
+function getTypeForTag(tag: string): string {
+  switch (tag.toLowerCase()) {
+    case 'br':
+    case 'b':
+    case 'i':
+    case 'u':
+      return 'fmt';
+    case 'img':
+      return 'image';
+    case 'a':
+      return 'link';
+    default:
+      return 'other';
+  }
+}
diff --git a/angular/compiler/src/i18n/serializers/xmb.ts b/angular/compiler/src/i18n/serializers/xmb.ts
new file mode 100644
index 0000000..dde588f
--- /dev/null
+++ b/angular/compiler/src/i18n/serializers/xmb.ts
@@ -0,0 +1,179 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {decimalDigest} from '../digest';
+import * as i18n from '../i18n_ast';
+
+import {PlaceholderMapper, Serializer, SimplePlaceholderMapper} from './serializer';
+import * as xml from './xml_helper';
+
+const _MESSAGES_TAG = 'messagebundle';
+const _MESSAGE_TAG = 'msg';
+const _PLACEHOLDER_TAG = 'ph';
+const _EXEMPLE_TAG = 'ex';
+const _SOURCE_TAG = 'source';
+
+const _DOCTYPE = `<!ELEMENT messagebundle (msg)*>
+<!ATTLIST messagebundle class CDATA #IMPLIED>
+
+<!ELEMENT msg (#PCDATA|ph|source)*>
+<!ATTLIST msg id CDATA #IMPLIED>
+<!ATTLIST msg seq CDATA #IMPLIED>
+<!ATTLIST msg name CDATA #IMPLIED>
+<!ATTLIST msg desc CDATA #IMPLIED>
+<!ATTLIST msg meaning CDATA #IMPLIED>
+<!ATTLIST msg obsolete (obsolete) #IMPLIED>
+<!ATTLIST msg xml:space (default|preserve) "default">
+<!ATTLIST msg is_hidden CDATA #IMPLIED>
+
+<!ELEMENT source (#PCDATA)>
+
+<!ELEMENT ph (#PCDATA|ex)*>
+<!ATTLIST ph name CDATA #REQUIRED>
+
+<!ELEMENT ex (#PCDATA)>`;
+
+export class Xmb extends Serializer {
+  write(messages: i18n.Message[], locale: string|null): string {
+    const exampleVisitor = new ExampleVisitor();
+    const visitor = new _Visitor();
+    let rootNode = new xml.Tag(_MESSAGES_TAG);
+
+    messages.forEach(message => {
+      const attrs: {[k: string]: string} = {id: message.id};
+
+      if (message.description) {
+        attrs['desc'] = message.description;
+      }
+
+      if (message.meaning) {
+        attrs['meaning'] = message.meaning;
+      }
+
+      let sourceTags: xml.Tag[] = [];
+      message.sources.forEach((source: i18n.MessageSpan) => {
+        sourceTags.push(new xml.Tag(_SOURCE_TAG, {}, [
+          new xml.Text(
+              `${source.filePath}:${source.startLine}${source.endLine !== source.startLine ? ',' + source.endLine : ''}`)
+        ]));
+      });
+
+      rootNode.children.push(
+          new xml.CR(2),
+          new xml.Tag(_MESSAGE_TAG, attrs, [...sourceTags, ...visitor.serialize(message.nodes)]));
+    });
+
+    rootNode.children.push(new xml.CR());
+
+    return xml.serialize([
+      new xml.Declaration({version: '1.0', encoding: 'UTF-8'}),
+      new xml.CR(),
+      new xml.Doctype(_MESSAGES_TAG, _DOCTYPE),
+      new xml.CR(),
+      exampleVisitor.addDefaultExamples(rootNode),
+      new xml.CR(),
+    ]);
+  }
+
+  load(content: string, url: string):
+      {locale: string, i18nNodesByMsgId: {[msgId: string]: i18n.Node[]}} {
+    throw new Error('Unsupported');
+  }
+
+  digest(message: i18n.Message): string { return digest(message); }
+
+
+  createNameMapper(message: i18n.Message): PlaceholderMapper {
+    return new SimplePlaceholderMapper(message, toPublicName);
+  }
+}
+
+class _Visitor implements i18n.Visitor {
+  visitText(text: i18n.Text, context?: any): xml.Node[] { return [new xml.Text(text.value)]; }
+
+  visitContainer(container: i18n.Container, context: any): xml.Node[] {
+    const nodes: xml.Node[] = [];
+    container.children.forEach((node: i18n.Node) => nodes.push(...node.visit(this)));
+    return nodes;
+  }
+
+  visitIcu(icu: i18n.Icu, context?: any): xml.Node[] {
+    const nodes = [new xml.Text(`{${icu.expressionPlaceholder}, ${icu.type}, `)];
+
+    Object.keys(icu.cases).forEach((c: string) => {
+      nodes.push(new xml.Text(`${c} {`), ...icu.cases[c].visit(this), new xml.Text(`} `));
+    });
+
+    nodes.push(new xml.Text(`}`));
+
+    return nodes;
+  }
+
+  visitTagPlaceholder(ph: i18n.TagPlaceholder, context?: any): xml.Node[] {
+    const startEx = new xml.Tag(_EXEMPLE_TAG, {}, [new xml.Text(`<${ph.tag}>`)]);
+    const startTagPh = new xml.Tag(_PLACEHOLDER_TAG, {name: ph.startName}, [startEx]);
+    if (ph.isVoid) {
+      // void tags have no children nor closing tags
+      return [startTagPh];
+    }
+
+    const closeEx = new xml.Tag(_EXEMPLE_TAG, {}, [new xml.Text(`</${ph.tag}>`)]);
+    const closeTagPh = new xml.Tag(_PLACEHOLDER_TAG, {name: ph.closeName}, [closeEx]);
+
+    return [startTagPh, ...this.serialize(ph.children), closeTagPh];
+  }
+
+  visitPlaceholder(ph: i18n.Placeholder, context?: any): xml.Node[] {
+    const exTag = new xml.Tag(_EXEMPLE_TAG, {}, [new xml.Text(`{{${ph.value}}}`)]);
+    return [new xml.Tag(_PLACEHOLDER_TAG, {name: ph.name}, [exTag])];
+  }
+
+  visitIcuPlaceholder(ph: i18n.IcuPlaceholder, context?: any): xml.Node[] {
+    const exTag = new xml.Tag(_EXEMPLE_TAG, {}, [
+      new xml.Text(
+          `{${ph.value.expression}, ${ph.value.type}, ${Object.keys(ph.value.cases).map((value: string) => value + ' {...}').join(' ')}}`)
+    ]);
+    return [new xml.Tag(_PLACEHOLDER_TAG, {name: ph.name}, [exTag])];
+  }
+
+  serialize(nodes: i18n.Node[]): xml.Node[] {
+    return [].concat(...nodes.map(node => node.visit(this)));
+  }
+}
+
+export function digest(message: i18n.Message): string {
+  return decimalDigest(message);
+}
+
+// TC requires at least one non-empty example on placeholders
+class ExampleVisitor implements xml.IVisitor {
+  addDefaultExamples(node: xml.Node): xml.Node {
+    node.visit(this);
+    return node;
+  }
+
+  visitTag(tag: xml.Tag): void {
+    if (tag.name === _PLACEHOLDER_TAG) {
+      if (!tag.children || tag.children.length == 0) {
+        const exText = new xml.Text(tag.attrs['name'] || '...');
+        tag.children = [new xml.Tag(_EXEMPLE_TAG, {}, [exText])];
+      }
+    } else if (tag.children) {
+      tag.children.forEach(node => node.visit(this));
+    }
+  }
+
+  visitText(text: xml.Text): void {}
+  visitDeclaration(decl: xml.Declaration): void {}
+  visitDoctype(doctype: xml.Doctype): void {}
+}
+
+// XMB/XTB placeholders can only contain A-Z, 0-9 and _
+export function toPublicName(internalName: string): string {
+  return internalName.toUpperCase().replace(/[^A-Z0-9_]/g, '_');
+}
diff --git a/angular/compiler/src/i18n/serializers/xml_helper.ts b/angular/compiler/src/i18n/serializers/xml_helper.ts
new file mode 100644
index 0000000..e7cbc8b
--- /dev/null
+++ b/angular/compiler/src/i18n/serializers/xml_helper.ts
@@ -0,0 +1,106 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export interface IVisitor {
+  visitTag(tag: Tag): any;
+  visitText(text: Text): any;
+  visitDeclaration(decl: Declaration): any;
+  visitDoctype(doctype: Doctype): any;
+}
+
+class _Visitor implements IVisitor {
+  visitTag(tag: Tag): string {
+    const strAttrs = this._serializeAttributes(tag.attrs);
+
+    if (tag.children.length == 0) {
+      return `<${tag.name}${strAttrs}/>`;
+    }
+
+    const strChildren = tag.children.map(node => node.visit(this));
+    return `<${tag.name}${strAttrs}>${strChildren.join('')}</${tag.name}>`;
+  }
+
+  visitText(text: Text): string { return text.value; }
+
+  visitDeclaration(decl: Declaration): string {
+    return `<?xml${this._serializeAttributes(decl.attrs)} ?>`;
+  }
+
+  private _serializeAttributes(attrs: {[k: string]: string}) {
+    const strAttrs = Object.keys(attrs).map((name: string) => `${name}="${attrs[name]}"`).join(' ');
+    return strAttrs.length > 0 ? ' ' + strAttrs : '';
+  }
+
+  visitDoctype(doctype: Doctype): any {
+    return `<!DOCTYPE ${doctype.rootTag} [\n${doctype.dtd}\n]>`;
+  }
+}
+
+const _visitor = new _Visitor();
+
+export function serialize(nodes: Node[]): string {
+  return nodes.map((node: Node): string => node.visit(_visitor)).join('');
+}
+
+export interface Node { visit(visitor: IVisitor): any; }
+
+export class Declaration implements Node {
+  public attrs: {[k: string]: string} = {};
+
+  constructor(unescapedAttrs: {[k: string]: string}) {
+    Object.keys(unescapedAttrs).forEach((k: string) => {
+      this.attrs[k] = _escapeXml(unescapedAttrs[k]);
+    });
+  }
+
+  visit(visitor: IVisitor): any { return visitor.visitDeclaration(this); }
+}
+
+export class Doctype implements Node {
+  constructor(public rootTag: string, public dtd: string){};
+
+  visit(visitor: IVisitor): any { return visitor.visitDoctype(this); }
+}
+
+export class Tag implements Node {
+  public attrs: {[k: string]: string} = {};
+
+  constructor(
+      public name: string, unescapedAttrs: {[k: string]: string} = {},
+      public children: Node[] = []) {
+    Object.keys(unescapedAttrs).forEach((k: string) => {
+      this.attrs[k] = _escapeXml(unescapedAttrs[k]);
+    });
+  }
+
+  visit(visitor: IVisitor): any { return visitor.visitTag(this); }
+}
+
+export class Text implements Node {
+  value: string;
+  constructor(unescapedValue: string) { this.value = _escapeXml(unescapedValue); };
+
+  visit(visitor: IVisitor): any { return visitor.visitText(this); }
+}
+
+export class CR extends Text {
+  constructor(ws: number = 0) { super(`\n${new Array(ws + 1).join(' ')}`); }
+}
+
+const _ESCAPED_CHARS: [RegExp, string][] = [
+  [/&/g, '&amp;'],
+  [/"/g, '&quot;'],
+  [/'/g, '&apos;'],
+  [/</g, '&lt;'],
+  [/>/g, '&gt;'],
+];
+
+function _escapeXml(text: string): string {
+  return _ESCAPED_CHARS.reduce(
+      (text: string, entry: [RegExp, string]) => text.replace(entry[0], entry[1]), text);
+}
diff --git a/angular/compiler/src/i18n/serializers/xtb.ts b/angular/compiler/src/i18n/serializers/xtb.ts
new file mode 100644
index 0000000..c0259d6
--- /dev/null
+++ b/angular/compiler/src/i18n/serializers/xtb.ts
@@ -0,0 +1,211 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as ml from '../../ml_parser/ast';
+import {XmlParser} from '../../ml_parser/xml_parser';
+import * as i18n from '../i18n_ast';
+import {I18nError} from '../parse_util';
+
+import {PlaceholderMapper, Serializer, SimplePlaceholderMapper} from './serializer';
+import {digest, toPublicName} from './xmb';
+
+const _TRANSLATIONS_TAG = 'translationbundle';
+const _TRANSLATION_TAG = 'translation';
+const _PLACEHOLDER_TAG = 'ph';
+
+export class Xtb extends Serializer {
+  write(messages: i18n.Message[], locale: string|null): string { throw new Error('Unsupported'); }
+
+  load(content: string, url: string):
+      {locale: string, i18nNodesByMsgId: {[msgId: string]: i18n.Node[]}} {
+    // xtb to xml nodes
+    const xtbParser = new XtbParser();
+    const {locale, msgIdToHtml, errors} = xtbParser.parse(content, url);
+
+    // xml nodes to i18n nodes
+    const i18nNodesByMsgId: {[msgId: string]: i18n.Node[]} = {};
+    const converter = new XmlToI18n();
+
+    // Because we should be able to load xtb files that rely on features not supported by angular,
+    // we need to delay the conversion of html to i18n nodes so that non angular messages are not
+    // converted
+    Object.keys(msgIdToHtml).forEach(msgId => {
+      const valueFn = function() {
+        const {i18nNodes, errors} = converter.convert(msgIdToHtml[msgId], url);
+        if (errors.length) {
+          throw new Error(`xtb parse errors:\n${errors.join('\n')}`);
+        }
+        return i18nNodes;
+      };
+      createLazyProperty(i18nNodesByMsgId, msgId, valueFn);
+    });
+
+    if (errors.length) {
+      throw new Error(`xtb parse errors:\n${errors.join('\n')}`);
+    }
+
+    return {locale: locale !, i18nNodesByMsgId};
+  }
+
+  digest(message: i18n.Message): string { return digest(message); }
+
+  createNameMapper(message: i18n.Message): PlaceholderMapper {
+    return new SimplePlaceholderMapper(message, toPublicName);
+  }
+}
+
+function createLazyProperty(messages: any, id: string, valueFn: () => any) {
+  Object.defineProperty(messages, id, {
+    configurable: true,
+    enumerable: true,
+    get: function() {
+      const value = valueFn();
+      Object.defineProperty(messages, id, {enumerable: true, value});
+      return value;
+    },
+    set: _ => { throw new Error('Could not overwrite an XTB translation'); },
+  });
+}
+
+// Extract messages as xml nodes from the xtb file
+class XtbParser implements ml.Visitor {
+  private _bundleDepth: number;
+  private _errors: I18nError[];
+  private _msgIdToHtml: {[msgId: string]: string};
+  private _locale: string|null = null;
+
+  parse(xtb: string, url: string) {
+    this._bundleDepth = 0;
+    this._msgIdToHtml = {};
+
+    // We can not parse the ICU messages at this point as some messages might not originate
+    // from Angular that could not be lex'd.
+    const xml = new XmlParser().parse(xtb, url, false);
+
+    this._errors = xml.errors;
+    ml.visitAll(this, xml.rootNodes);
+
+    return {
+      msgIdToHtml: this._msgIdToHtml,
+      errors: this._errors,
+      locale: this._locale,
+    };
+  }
+
+  visitElement(element: ml.Element, context: any): any {
+    switch (element.name) {
+      case _TRANSLATIONS_TAG:
+        this._bundleDepth++;
+        if (this._bundleDepth > 1) {
+          this._addError(element, `<${_TRANSLATIONS_TAG}> elements can not be nested`);
+        }
+        const langAttr = element.attrs.find((attr) => attr.name === 'lang');
+        if (langAttr) {
+          this._locale = langAttr.value;
+        }
+        ml.visitAll(this, element.children, null);
+        this._bundleDepth--;
+        break;
+
+      case _TRANSLATION_TAG:
+        const idAttr = element.attrs.find((attr) => attr.name === 'id');
+        if (!idAttr) {
+          this._addError(element, `<${_TRANSLATION_TAG}> misses the "id" attribute`);
+        } else {
+          const id = idAttr.value;
+          if (this._msgIdToHtml.hasOwnProperty(id)) {
+            this._addError(element, `Duplicated translations for msg ${id}`);
+          } else {
+            const innerTextStart = element.startSourceSpan !.end.offset;
+            const innerTextEnd = element.endSourceSpan !.start.offset;
+            const content = element.startSourceSpan !.start.file.content;
+            const innerText = content.slice(innerTextStart !, innerTextEnd !);
+            this._msgIdToHtml[id] = innerText;
+          }
+        }
+        break;
+
+      default:
+        this._addError(element, 'Unexpected tag');
+    }
+  }
+
+  visitAttribute(attribute: ml.Attribute, context: any): any {}
+
+  visitText(text: ml.Text, context: any): any {}
+
+  visitComment(comment: ml.Comment, context: any): any {}
+
+  visitExpansion(expansion: ml.Expansion, context: any): any {}
+
+  visitExpansionCase(expansionCase: ml.ExpansionCase, context: any): any {}
+
+  private _addError(node: ml.Node, message: string): void {
+    this._errors.push(new I18nError(node.sourceSpan !, message));
+  }
+}
+
+// Convert ml nodes (xtb syntax) to i18n nodes
+class XmlToI18n implements ml.Visitor {
+  private _errors: I18nError[];
+
+  convert(message: string, url: string) {
+    const xmlIcu = new XmlParser().parse(message, url, true);
+    this._errors = xmlIcu.errors;
+
+    const i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ?
+        [] :
+        ml.visitAll(this, xmlIcu.rootNodes);
+
+    return {
+      i18nNodes,
+      errors: this._errors,
+    };
+  }
+
+  visitText(text: ml.Text, context: any) { return new i18n.Text(text.value, text.sourceSpan !); }
+
+  visitExpansion(icu: ml.Expansion, context: any) {
+    const caseMap: {[value: string]: i18n.Node} = {};
+
+    ml.visitAll(this, icu.cases).forEach(c => {
+      caseMap[c.value] = new i18n.Container(c.nodes, icu.sourceSpan);
+    });
+
+    return new i18n.Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);
+  }
+
+  visitExpansionCase(icuCase: ml.ExpansionCase, context: any): any {
+    return {
+      value: icuCase.value,
+      nodes: ml.visitAll(this, icuCase.expression),
+    };
+  }
+
+  visitElement(el: ml.Element, context: any): i18n.Placeholder|null {
+    if (el.name === _PLACEHOLDER_TAG) {
+      const nameAttr = el.attrs.find((attr) => attr.name === 'name');
+      if (nameAttr) {
+        return new i18n.Placeholder('', nameAttr.value, el.sourceSpan !);
+      }
+
+      this._addError(el, `<${_PLACEHOLDER_TAG}> misses the "name" attribute`);
+    } else {
+      this._addError(el, `Unexpected tag`);
+    }
+    return null;
+  }
+
+  visitComment(comment: ml.Comment, context: any) {}
+
+  visitAttribute(attribute: ml.Attribute, context: any) {}
+
+  private _addError(node: ml.Node, message: string): void {
+    this._errors.push(new I18nError(node.sourceSpan !, message));
+  }
+}
diff --git a/angular/compiler/src/i18n/translation_bundle.ts b/angular/compiler/src/i18n/translation_bundle.ts
new file mode 100644
index 0000000..c1c5daf
--- /dev/null
+++ b/angular/compiler/src/i18n/translation_bundle.ts
@@ -0,0 +1,190 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {MissingTranslationStrategy} from '../core';
+import * as html from '../ml_parser/ast';
+import {HtmlParser} from '../ml_parser/html_parser';
+import {Console} from '../util';
+
+import * as i18n from './i18n_ast';
+import {I18nError} from './parse_util';
+import {PlaceholderMapper, Serializer} from './serializers/serializer';
+
+
+/**
+ * A container for translated messages
+ */
+export class TranslationBundle {
+  private _i18nToHtml: I18nToHtmlVisitor;
+
+  constructor(
+      private _i18nNodesByMsgId: {[msgId: string]: i18n.Node[]} = {}, locale: string|null,
+      public digest: (m: i18n.Message) => string,
+      public mapperFactory?: (m: i18n.Message) => PlaceholderMapper,
+      missingTranslationStrategy: MissingTranslationStrategy = MissingTranslationStrategy.Warning,
+      console?: Console) {
+    this._i18nToHtml = new I18nToHtmlVisitor(
+        _i18nNodesByMsgId, locale, digest, mapperFactory !, missingTranslationStrategy, console);
+  }
+
+  // Creates a `TranslationBundle` by parsing the given `content` with the `serializer`.
+  static load(
+      content: string, url: string, serializer: Serializer,
+      missingTranslationStrategy: MissingTranslationStrategy,
+      console?: Console): TranslationBundle {
+    const {locale, i18nNodesByMsgId} = serializer.load(content, url);
+    const digestFn = (m: i18n.Message) => serializer.digest(m);
+    const mapperFactory = (m: i18n.Message) => serializer.createNameMapper(m) !;
+    return new TranslationBundle(
+        i18nNodesByMsgId, locale, digestFn, mapperFactory, missingTranslationStrategy, console);
+  }
+
+  // Returns the translation as HTML nodes from the given source message.
+  get(srcMsg: i18n.Message): html.Node[] {
+    const html = this._i18nToHtml.convert(srcMsg);
+
+    if (html.errors.length) {
+      throw new Error(html.errors.join('\n'));
+    }
+
+    return html.nodes;
+  }
+
+  has(srcMsg: i18n.Message): boolean { return this.digest(srcMsg) in this._i18nNodesByMsgId; }
+}
+
+class I18nToHtmlVisitor implements i18n.Visitor {
+  private _srcMsg: i18n.Message;
+  private _contextStack: {msg: i18n.Message, mapper: (name: string) => string}[] = [];
+  private _errors: I18nError[] = [];
+  private _mapper: (name: string) => string;
+
+  constructor(
+      private _i18nNodesByMsgId: {[msgId: string]: i18n.Node[]} = {}, private _locale: string|null,
+      private _digest: (m: i18n.Message) => string,
+      private _mapperFactory: (m: i18n.Message) => PlaceholderMapper,
+      private _missingTranslationStrategy: MissingTranslationStrategy, private _console?: Console) {
+  }
+
+  convert(srcMsg: i18n.Message): {nodes: html.Node[], errors: I18nError[]} {
+    this._contextStack.length = 0;
+    this._errors.length = 0;
+
+    // i18n to text
+    const text = this._convertToText(srcMsg);
+
+    // text to html
+    const url = srcMsg.nodes[0].sourceSpan.start.file.url;
+    const html = new HtmlParser().parse(text, url, true);
+
+    return {
+      nodes: html.rootNodes,
+      errors: [...this._errors, ...html.errors],
+    };
+  }
+
+  visitText(text: i18n.Text, context?: any): string { return text.value; }
+
+  visitContainer(container: i18n.Container, context?: any): any {
+    return container.children.map(n => n.visit(this)).join('');
+  }
+
+  visitIcu(icu: i18n.Icu, context?: any): any {
+    const cases = Object.keys(icu.cases).map(k => `${k} {${icu.cases[k].visit(this)}}`);
+
+    // TODO(vicb): Once all format switch to using expression placeholders
+    // we should throw when the placeholder is not in the source message
+    const exp = this._srcMsg.placeholders.hasOwnProperty(icu.expression) ?
+        this._srcMsg.placeholders[icu.expression] :
+        icu.expression;
+
+    return `{${exp}, ${icu.type}, ${cases.join(' ')}}`;
+  }
+
+  visitPlaceholder(ph: i18n.Placeholder, context?: any): string {
+    const phName = this._mapper(ph.name);
+    if (this._srcMsg.placeholders.hasOwnProperty(phName)) {
+      return this._srcMsg.placeholders[phName];
+    }
+
+    if (this._srcMsg.placeholderToMessage.hasOwnProperty(phName)) {
+      return this._convertToText(this._srcMsg.placeholderToMessage[phName]);
+    }
+
+    this._addError(ph, `Unknown placeholder "${ph.name}"`);
+    return '';
+  }
+
+  // Loaded message contains only placeholders (vs tag and icu placeholders).
+  // However when a translation can not be found, we need to serialize the source message
+  // which can contain tag placeholders
+  visitTagPlaceholder(ph: i18n.TagPlaceholder, context?: any): string {
+    const tag = `${ph.tag}`;
+    const attrs = Object.keys(ph.attrs).map(name => `${name}="${ph.attrs[name]}"`).join(' ');
+    if (ph.isVoid) {
+      return `<${tag} ${attrs}/>`;
+    }
+    const children = ph.children.map((c: i18n.Node) => c.visit(this)).join('');
+    return `<${tag} ${attrs}>${children}</${tag}>`;
+  }
+
+  // Loaded message contains only placeholders (vs tag and icu placeholders).
+  // However when a translation can not be found, we need to serialize the source message
+  // which can contain tag placeholders
+  visitIcuPlaceholder(ph: i18n.IcuPlaceholder, context?: any): string {
+    // An ICU placeholder references the source message to be serialized
+    return this._convertToText(this._srcMsg.placeholderToMessage[ph.name]);
+  }
+
+  /**
+   * Convert a source message to a translated text string:
+   * - text nodes are replaced with their translation,
+   * - placeholders are replaced with their content,
+   * - ICU nodes are converted to ICU expressions.
+   */
+  private _convertToText(srcMsg: i18n.Message): string {
+    const id = this._digest(srcMsg);
+    const mapper = this._mapperFactory ? this._mapperFactory(srcMsg) : null;
+    let nodes: i18n.Node[];
+
+    this._contextStack.push({msg: this._srcMsg, mapper: this._mapper});
+    this._srcMsg = srcMsg;
+
+    if (this._i18nNodesByMsgId.hasOwnProperty(id)) {
+      // When there is a translation use its nodes as the source
+      // And create a mapper to convert serialized placeholder names to internal names
+      nodes = this._i18nNodesByMsgId[id];
+      this._mapper = (name: string) => mapper ? mapper.toInternalName(name) ! : name;
+    } else {
+      // When no translation has been found
+      // - report an error / a warning / nothing,
+      // - use the nodes from the original message
+      // - placeholders are already internal and need no mapper
+      if (this._missingTranslationStrategy === MissingTranslationStrategy.Error) {
+        const ctx = this._locale ? ` for locale "${this._locale}"` : '';
+        this._addError(srcMsg.nodes[0], `Missing translation for message "${id}"${ctx}`);
+      } else if (
+          this._console &&
+          this._missingTranslationStrategy === MissingTranslationStrategy.Warning) {
+        const ctx = this._locale ? ` for locale "${this._locale}"` : '';
+        this._console.warn(`Missing translation for message "${id}"${ctx}`);
+      }
+      nodes = srcMsg.nodes;
+      this._mapper = (name: string) => name;
+    }
+    const text = nodes.map(node => node.visit(this)).join('');
+    const context = this._contextStack.pop() !;
+    this._srcMsg = context.msg;
+    this._mapper = context.mapper;
+    return text;
+  }
+
+  private _addError(el: i18n.Node, msg: string) {
+    this._errors.push(new I18nError(el.sourceSpan, msg));
+  }
+}
diff --git a/angular/compiler/src/identifiers.ts b/angular/compiler/src/identifiers.ts
new file mode 100644
index 0000000..598aff3
--- /dev/null
+++ b/angular/compiler/src/identifiers.ts
@@ -0,0 +1,132 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileIdentifierMetadata, CompileTokenMetadata} from './compile_metadata';
+import {CompileReflector} from './compile_reflector';
+import {Attribute, Component, Directive, HostBinding, HostListener, Inject, Input, NgModule, Output, Pipe, Query} from './core';
+import * as o from './output/output_ast';
+
+const CORE = '@angular/core';
+
+export class Identifiers {
+  static ANALYZE_FOR_ENTRY_COMPONENTS: o.ExternalReference = {
+    name: 'ANALYZE_FOR_ENTRY_COMPONENTS',
+    moduleName: CORE,
+
+  };
+  static ElementRef: o.ExternalReference = {name: 'ElementRef', moduleName: CORE};
+  static NgModuleRef: o.ExternalReference = {name: 'NgModuleRef', moduleName: CORE};
+  static ViewContainerRef: o.ExternalReference = {name: 'ViewContainerRef', moduleName: CORE};
+  static ChangeDetectorRef: o.ExternalReference = {
+    name: 'ChangeDetectorRef',
+    moduleName: CORE,
+
+  };
+  static QueryList: o.ExternalReference = {name: 'QueryList', moduleName: CORE};
+  static TemplateRef: o.ExternalReference = {name: 'TemplateRef', moduleName: CORE};
+  static CodegenComponentFactoryResolver: o.ExternalReference = {
+    name: 'ɵCodegenComponentFactoryResolver',
+    moduleName: CORE,
+
+  };
+  static ComponentFactoryResolver: o.ExternalReference = {
+    name: 'ComponentFactoryResolver',
+    moduleName: CORE,
+
+  };
+  static ComponentFactory: o.ExternalReference = {name: 'ComponentFactory', moduleName: CORE};
+  static ComponentRef: o.ExternalReference = {name: 'ComponentRef', moduleName: CORE};
+  static NgModuleFactory: o.ExternalReference = {name: 'NgModuleFactory', moduleName: CORE};
+  static createModuleFactory: o.ExternalReference = {
+    name: 'ɵcmf',
+    moduleName: CORE,
+
+  };
+  static moduleDef: o.ExternalReference = {
+    name: 'ɵmod',
+    moduleName: CORE,
+
+  };
+  static moduleProviderDef: o.ExternalReference = {
+    name: 'ɵmpd',
+    moduleName: CORE,
+
+  };
+  static RegisterModuleFactoryFn: o.ExternalReference = {
+    name: 'ɵregisterModuleFactory',
+    moduleName: CORE,
+
+  };
+  static Injector: o.ExternalReference = {name: 'Injector', moduleName: CORE};
+  static ViewEncapsulation: o.ExternalReference = {
+    name: 'ViewEncapsulation',
+    moduleName: CORE,
+
+  };
+  static ChangeDetectionStrategy: o.ExternalReference = {
+    name: 'ChangeDetectionStrategy',
+    moduleName: CORE,
+
+  };
+  static SecurityContext: o.ExternalReference = {
+    name: 'SecurityContext',
+    moduleName: CORE,
+
+  };
+  static LOCALE_ID: o.ExternalReference = {name: 'LOCALE_ID', moduleName: CORE};
+  static TRANSLATIONS_FORMAT: o.ExternalReference = {
+    name: 'TRANSLATIONS_FORMAT',
+    moduleName: CORE,
+
+  };
+  static inlineInterpolate: o.ExternalReference = {
+    name: 'ɵinlineInterpolate',
+    moduleName: CORE,
+
+  };
+  static interpolate: o.ExternalReference = {name: 'ɵinterpolate', moduleName: CORE};
+  static EMPTY_ARRAY: o.ExternalReference = {name: 'ɵEMPTY_ARRAY', moduleName: CORE};
+  static EMPTY_MAP: o.ExternalReference = {name: 'ɵEMPTY_MAP', moduleName: CORE};
+  static Renderer: o.ExternalReference = {name: 'Renderer', moduleName: CORE};
+  static viewDef: o.ExternalReference = {name: 'ɵvid', moduleName: CORE};
+  static elementDef: o.ExternalReference = {name: 'ɵeld', moduleName: CORE};
+  static anchorDef: o.ExternalReference = {name: 'ɵand', moduleName: CORE};
+  static textDef: o.ExternalReference = {name: 'ɵted', moduleName: CORE};
+  static directiveDef: o.ExternalReference = {name: 'ɵdid', moduleName: CORE};
+  static providerDef: o.ExternalReference = {name: 'ɵprd', moduleName: CORE};
+  static queryDef: o.ExternalReference = {name: 'ɵqud', moduleName: CORE};
+  static pureArrayDef: o.ExternalReference = {name: 'ɵpad', moduleName: CORE};
+  static pureObjectDef: o.ExternalReference = {name: 'ɵpod', moduleName: CORE};
+  static purePipeDef: o.ExternalReference = {name: 'ɵppd', moduleName: CORE};
+  static pipeDef: o.ExternalReference = {name: 'ɵpid', moduleName: CORE};
+  static nodeValue: o.ExternalReference = {name: 'ɵnov', moduleName: CORE};
+  static ngContentDef: o.ExternalReference = {name: 'ɵncd', moduleName: CORE};
+  static unwrapValue: o.ExternalReference = {name: 'ɵunv', moduleName: CORE};
+  static createRendererType2: o.ExternalReference = {name: 'ɵcrt', moduleName: CORE};
+  // type only
+  static RendererType2: o.ExternalReference = {
+    name: 'RendererType2',
+    moduleName: CORE,
+
+  };
+  // type only
+  static ViewDefinition: o.ExternalReference = {
+    name: 'ɵViewDefinition',
+    moduleName: CORE,
+  };
+  static createComponentFactory: o.ExternalReference = {name: 'ɵccf', moduleName: CORE};
+}
+
+export function createTokenForReference(reference: any): CompileTokenMetadata {
+  return {identifier: {reference: reference}};
+}
+
+export function createTokenForExternalReference(
+    reflector: CompileReflector, reference: o.ExternalReference): CompileTokenMetadata {
+  return createTokenForReference(reflector.resolveExternalReference(reference));
+}
diff --git a/angular/compiler/src/jit/compiler.ts b/angular/compiler/src/jit/compiler.ts
new file mode 100644
index 0000000..dfc508a
--- /dev/null
+++ b/angular/compiler/src/jit/compiler.ts
@@ -0,0 +1,353 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileProviderMetadata, CompileStylesheetMetadata, CompileTypeSummary, ProviderMeta, ProxyClass, createHostComponentMeta, identifierName, ngModuleJitUrl, sharedStylesheetJitUrl, templateJitUrl, templateSourceUrl} from '../compile_metadata';
+import {CompileReflector} from '../compile_reflector';
+import {CompilerConfig} from '../config';
+import {Type} from '../core';
+import {CompileMetadataResolver} from '../metadata_resolver';
+import {NgModuleCompiler} from '../ng_module_compiler';
+import * as ir from '../output/output_ast';
+import {interpretStatements} from '../output/output_interpreter';
+import {jitStatements} from '../output/output_jit';
+import {CompiledStylesheet, StyleCompiler} from '../style_compiler';
+import {SummaryResolver} from '../summary_resolver';
+import {TemplateParser} from '../template_parser/template_parser';
+import {Console, OutputContext, SyncAsync, stringify} from '../util';
+import {ViewCompiler} from '../view_compiler/view_compiler';
+
+export interface ModuleWithComponentFactories {
+  ngModuleFactory: object;
+  componentFactories: object[];
+}
+
+/**
+ * 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.
+ *
+ * @security  When compiling templates at runtime, you must ensure that the entire template comes
+ * from a trusted source. Attacker-controlled data introduced by a template could expose your
+ * application to XSS risks.  For more detail, see the [Security Guide](http://g.co/ng/security).
+ */
+export class JitCompiler {
+  private _compiledTemplateCache = new Map<Type, CompiledTemplate>();
+  private _compiledHostTemplateCache = new Map<Type, CompiledTemplate>();
+  private _compiledDirectiveWrapperCache = new Map<Type, Type>();
+  private _compiledNgModuleCache = new Map<Type, object>();
+  private _sharedStylesheetCount = 0;
+
+  constructor(
+      private _metadataResolver: CompileMetadataResolver, private _templateParser: TemplateParser,
+      private _styleCompiler: StyleCompiler, private _viewCompiler: ViewCompiler,
+      private _ngModuleCompiler: NgModuleCompiler, private _summaryResolver: SummaryResolver<Type>,
+      private _reflector: CompileReflector, private _compilerConfig: CompilerConfig,
+      private _console: Console,
+      private getExtraNgModuleProviders: (ngModule: any) => CompileProviderMetadata[]) {}
+
+  compileModuleSync(moduleType: Type): object {
+    return SyncAsync.assertSync(this._compileModuleAndComponents(moduleType, true));
+  }
+
+  compileModuleAsync(moduleType: Type): Promise<object> {
+    return Promise.resolve(this._compileModuleAndComponents(moduleType, false));
+  }
+
+  compileModuleAndAllComponentsSync(moduleType: Type): ModuleWithComponentFactories {
+    return SyncAsync.assertSync(this._compileModuleAndAllComponents(moduleType, true));
+  }
+
+  compileModuleAndAllComponentsAsync(moduleType: Type): Promise<ModuleWithComponentFactories> {
+    return Promise.resolve(this._compileModuleAndAllComponents(moduleType, false));
+  }
+
+  getNgContentSelectors(component: Type): string[] {
+    this._console.warn(
+        'Compiler.getNgContentSelectors is deprecated. Use ComponentFactory.ngContentSelectors instead!');
+    const template = this._compiledTemplateCache.get(component);
+    if (!template) {
+      throw new Error(`The component ${stringify(component)} is not yet compiled!`);
+    }
+    return template.compMeta.template !.ngContentSelectors;
+  }
+
+  getComponentFactory(component: Type): object {
+    const summary = this._metadataResolver.getDirectiveSummary(component);
+    return summary.componentFactory as object;
+  }
+
+  loadAotSummaries(summaries: () => any[]) {
+    this.clearCache();
+    flattenSummaries(summaries).forEach((summary) => {
+      this._summaryResolver.addSummary(
+          {symbol: summary.type.reference, metadata: null, type: summary});
+    });
+  }
+
+  hasAotSummary(ref: Type) { return !!this._summaryResolver.resolveSummary(ref); }
+
+  private _filterJitIdentifiers(ids: CompileIdentifierMetadata[]): any[] {
+    return ids.map(mod => mod.reference).filter((ref) => !this.hasAotSummary(ref));
+  }
+
+  private _compileModuleAndComponents(moduleType: Type, isSync: boolean): SyncAsync<object> {
+    return SyncAsync.then(this._loadModules(moduleType, isSync), () => {
+      this._compileComponents(moduleType, null);
+      return this._compileModule(moduleType);
+    });
+  }
+
+  private _compileModuleAndAllComponents(moduleType: Type, isSync: boolean):
+      SyncAsync<ModuleWithComponentFactories> {
+    return SyncAsync.then(this._loadModules(moduleType, isSync), () => {
+      const componentFactories: object[] = [];
+      this._compileComponents(moduleType, componentFactories);
+      return {
+        ngModuleFactory: this._compileModule(moduleType),
+        componentFactories: componentFactories
+      };
+    });
+  }
+
+  private _loadModules(mainModule: any, isSync: boolean): SyncAsync<any> {
+    const loading: Promise<any>[] = [];
+    const mainNgModule = this._metadataResolver.getNgModuleMetadata(mainModule) !;
+    // Note: for runtime compilation, we want to transitively compile all modules,
+    // so we also need to load the declared directives / pipes for all nested modules.
+    this._filterJitIdentifiers(mainNgModule.transitiveModule.modules).forEach((nestedNgModule) => {
+      // getNgModuleMetadata only returns null if the value passed in is not an NgModule
+      const moduleMeta = this._metadataResolver.getNgModuleMetadata(nestedNgModule) !;
+      this._filterJitIdentifiers(moduleMeta.declaredDirectives).forEach((ref) => {
+        const promise =
+            this._metadataResolver.loadDirectiveMetadata(moduleMeta.type.reference, ref, isSync);
+        if (promise) {
+          loading.push(promise);
+        }
+      });
+      this._filterJitIdentifiers(moduleMeta.declaredPipes)
+          .forEach((ref) => this._metadataResolver.getOrLoadPipeMetadata(ref));
+    });
+    return SyncAsync.all(loading);
+  }
+
+  private _compileModule(moduleType: Type): object {
+    let ngModuleFactory = this._compiledNgModuleCache.get(moduleType) !;
+    if (!ngModuleFactory) {
+      const moduleMeta = this._metadataResolver.getNgModuleMetadata(moduleType) !;
+      // Always provide a bound Compiler
+      const extraProviders = this.getExtraNgModuleProviders(moduleMeta.type.reference);
+      const outputCtx = createOutputContext();
+      const compileResult = this._ngModuleCompiler.compile(outputCtx, moduleMeta, extraProviders);
+      ngModuleFactory = this._interpretOrJit(
+          ngModuleJitUrl(moduleMeta), outputCtx.statements)[compileResult.ngModuleFactoryVar];
+      this._compiledNgModuleCache.set(moduleMeta.type.reference, ngModuleFactory);
+    }
+    return ngModuleFactory;
+  }
+
+  /**
+   * @internal
+   */
+  _compileComponents(mainModule: Type, allComponentFactories: object[]|null) {
+    const ngModule = this._metadataResolver.getNgModuleMetadata(mainModule) !;
+    const moduleByJitDirective = new Map<any, CompileNgModuleMetadata>();
+    const templates = new Set<CompiledTemplate>();
+
+    const transJitModules = this._filterJitIdentifiers(ngModule.transitiveModule.modules);
+    transJitModules.forEach((localMod) => {
+      const localModuleMeta = this._metadataResolver.getNgModuleMetadata(localMod) !;
+      this._filterJitIdentifiers(localModuleMeta.declaredDirectives).forEach((dirRef) => {
+        moduleByJitDirective.set(dirRef, localModuleMeta);
+        const dirMeta = this._metadataResolver.getDirectiveMetadata(dirRef);
+        if (dirMeta.isComponent) {
+          templates.add(this._createCompiledTemplate(dirMeta, localModuleMeta));
+          if (allComponentFactories) {
+            const template =
+                this._createCompiledHostTemplate(dirMeta.type.reference, localModuleMeta);
+            templates.add(template);
+            allComponentFactories.push(dirMeta.componentFactory as object);
+          }
+        }
+      });
+    });
+    transJitModules.forEach((localMod) => {
+      const localModuleMeta = this._metadataResolver.getNgModuleMetadata(localMod) !;
+      this._filterJitIdentifiers(localModuleMeta.declaredDirectives).forEach((dirRef) => {
+        const dirMeta = this._metadataResolver.getDirectiveMetadata(dirRef);
+        if (dirMeta.isComponent) {
+          dirMeta.entryComponents.forEach((entryComponentType) => {
+            const moduleMeta = moduleByJitDirective.get(entryComponentType.componentType) !;
+            templates.add(
+                this._createCompiledHostTemplate(entryComponentType.componentType, moduleMeta));
+          });
+        }
+      });
+      localModuleMeta.entryComponents.forEach((entryComponentType) => {
+        if (!this.hasAotSummary(entryComponentType.componentType.reference)) {
+          const moduleMeta = moduleByJitDirective.get(entryComponentType.componentType) !;
+          templates.add(
+              this._createCompiledHostTemplate(entryComponentType.componentType, moduleMeta));
+        }
+      });
+    });
+    templates.forEach((template) => this._compileTemplate(template));
+  }
+
+  clearCacheFor(type: Type) {
+    this._compiledNgModuleCache.delete(type);
+    this._metadataResolver.clearCacheFor(type);
+    this._compiledHostTemplateCache.delete(type);
+    const compiledTemplate = this._compiledTemplateCache.get(type);
+    if (compiledTemplate) {
+      this._compiledTemplateCache.delete(type);
+    }
+  }
+
+  clearCache(): void {
+    this._metadataResolver.clearCache();
+    this._compiledTemplateCache.clear();
+    this._compiledHostTemplateCache.clear();
+    this._compiledNgModuleCache.clear();
+  }
+
+  private _createCompiledHostTemplate(compType: Type, ngModule: CompileNgModuleMetadata):
+      CompiledTemplate {
+    if (!ngModule) {
+      throw new Error(
+          `Component ${stringify(compType)} is not part of any NgModule or the module has not been imported into your module.`);
+    }
+    let compiledTemplate = this._compiledHostTemplateCache.get(compType);
+    if (!compiledTemplate) {
+      const compMeta = this._metadataResolver.getDirectiveMetadata(compType);
+      assertComponent(compMeta);
+
+      const hostClass = this._metadataResolver.getHostComponentType(compType);
+      const hostMeta = createHostComponentMeta(
+          hostClass, compMeta, (compMeta.componentFactory as any).viewDefFactory);
+      compiledTemplate =
+          new CompiledTemplate(true, compMeta.type, hostMeta, ngModule, [compMeta.type]);
+      this._compiledHostTemplateCache.set(compType, compiledTemplate);
+    }
+    return compiledTemplate;
+  }
+
+  private _createCompiledTemplate(
+      compMeta: CompileDirectiveMetadata, ngModule: CompileNgModuleMetadata): CompiledTemplate {
+    let compiledTemplate = this._compiledTemplateCache.get(compMeta.type.reference);
+    if (!compiledTemplate) {
+      assertComponent(compMeta);
+      compiledTemplate = new CompiledTemplate(
+          false, compMeta.type, compMeta, ngModule, ngModule.transitiveModule.directives);
+      this._compiledTemplateCache.set(compMeta.type.reference, compiledTemplate);
+    }
+    return compiledTemplate;
+  }
+
+  private _compileTemplate(template: CompiledTemplate) {
+    if (template.isCompiled) {
+      return;
+    }
+    const compMeta = template.compMeta;
+    const externalStylesheetsByModuleUrl = new Map<string, CompiledStylesheet>();
+    const outputContext = createOutputContext();
+    const componentStylesheet = this._styleCompiler.compileComponent(outputContext, compMeta);
+    const preserveWhitespaces = compMeta !.template !.preserveWhitespaces;
+    compMeta.template !.externalStylesheets.forEach((stylesheetMeta) => {
+      const compiledStylesheet =
+          this._styleCompiler.compileStyles(createOutputContext(), compMeta, stylesheetMeta);
+      externalStylesheetsByModuleUrl.set(stylesheetMeta.moduleUrl !, compiledStylesheet);
+    });
+    this._resolveStylesCompileResult(componentStylesheet, externalStylesheetsByModuleUrl);
+    const directives =
+        template.directives.map(dir => this._metadataResolver.getDirectiveSummary(dir.reference));
+    const pipes = template.ngModule.transitiveModule.pipes.map(
+        pipe => this._metadataResolver.getPipeSummary(pipe.reference));
+    const {template: parsedTemplate, pipes: usedPipes} = this._templateParser.parse(
+        compMeta, compMeta.template !.template !, directives, pipes, template.ngModule.schemas,
+        templateSourceUrl(template.ngModule.type, template.compMeta, template.compMeta.template !),
+        preserveWhitespaces);
+    const compileResult = this._viewCompiler.compileComponent(
+        outputContext, compMeta, parsedTemplate, ir.variable(componentStylesheet.stylesVar),
+        usedPipes);
+    const evalResult = this._interpretOrJit(
+        templateJitUrl(template.ngModule.type, template.compMeta), outputContext.statements);
+    const viewClass = evalResult[compileResult.viewClassVar];
+    const rendererType = evalResult[compileResult.rendererTypeVar];
+    template.compiled(viewClass, rendererType);
+  }
+
+  private _resolveStylesCompileResult(
+      result: CompiledStylesheet, externalStylesheetsByModuleUrl: Map<string, CompiledStylesheet>) {
+    result.dependencies.forEach((dep, i) => {
+      const nestedCompileResult = externalStylesheetsByModuleUrl.get(dep.moduleUrl) !;
+      const nestedStylesArr = this._resolveAndEvalStylesCompileResult(
+          nestedCompileResult, externalStylesheetsByModuleUrl);
+      dep.setValue(nestedStylesArr);
+    });
+  }
+
+  private _resolveAndEvalStylesCompileResult(
+      result: CompiledStylesheet,
+      externalStylesheetsByModuleUrl: Map<string, CompiledStylesheet>): string[] {
+    this._resolveStylesCompileResult(result, externalStylesheetsByModuleUrl);
+    return this._interpretOrJit(
+        sharedStylesheetJitUrl(result.meta, this._sharedStylesheetCount++),
+        result.outputCtx.statements)[result.stylesVar];
+  }
+
+  private _interpretOrJit(sourceUrl: string, statements: ir.Statement[]): any {
+    if (!this._compilerConfig.useJit) {
+      return interpretStatements(statements, this._reflector);
+    } else {
+      return jitStatements(sourceUrl, statements, this._reflector, this._compilerConfig.jitDevMode);
+    }
+  }
+}
+
+class CompiledTemplate {
+  private _viewClass: Function = null !;
+  isCompiled = false;
+
+  constructor(
+      public isHost: boolean, public compType: CompileIdentifierMetadata,
+      public compMeta: CompileDirectiveMetadata, public ngModule: CompileNgModuleMetadata,
+      public directives: CompileIdentifierMetadata[]) {}
+
+  compiled(viewClass: Function, rendererType: any) {
+    this._viewClass = viewClass;
+    (<ProxyClass>this.compMeta.componentViewType).setDelegate(viewClass);
+    for (let prop in rendererType) {
+      (<any>this.compMeta.rendererType)[prop] = rendererType[prop];
+    }
+    this.isCompiled = true;
+  }
+}
+
+function assertComponent(meta: CompileDirectiveMetadata) {
+  if (!meta.isComponent) {
+    throw new Error(
+        `Could not compile '${identifierName(meta.type)}' because it is not a component.`);
+  }
+}
+
+function flattenSummaries(fn: () => any[], out: CompileTypeSummary[] = []): CompileTypeSummary[] {
+  fn().forEach((entry) => {
+    if (typeof entry === 'function') {
+      flattenSummaries(entry, out);
+    } else {
+      out.push(entry);
+    }
+  });
+  return out;
+}
+
+function createOutputContext(): OutputContext {
+  const importExpr = (symbol: any) =>
+      ir.importExpr({name: identifierName(symbol), moduleName: null, runtime: symbol});
+  return {statements: [], genFilePath: '', importExpr};
+}
diff --git a/angular/compiler/src/lifecycle_reflector.ts b/angular/compiler/src/lifecycle_reflector.ts
new file mode 100644
index 0000000..738e699
--- /dev/null
+++ b/angular/compiler/src/lifecycle_reflector.ts
@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileReflector} from './compile_reflector';
+
+export enum LifecycleHooks {
+  OnInit,
+  OnDestroy,
+  DoCheck,
+  OnChanges,
+  AfterContentInit,
+  AfterContentChecked,
+  AfterViewInit,
+  AfterViewChecked
+}
+
+export const LIFECYCLE_HOOKS_VALUES = [
+  LifecycleHooks.OnInit, LifecycleHooks.OnDestroy, LifecycleHooks.DoCheck, LifecycleHooks.OnChanges,
+  LifecycleHooks.AfterContentInit, LifecycleHooks.AfterContentChecked, LifecycleHooks.AfterViewInit,
+  LifecycleHooks.AfterViewChecked
+];
+
+export function hasLifecycleHook(
+    reflector: CompileReflector, hook: LifecycleHooks, token: any): boolean {
+  return reflector.hasLifecycleHook(token, getHookName(hook));
+}
+
+export function getAllLifecycleHooks(reflector: CompileReflector, token: any): LifecycleHooks[] {
+  return LIFECYCLE_HOOKS_VALUES.filter(hook => hasLifecycleHook(reflector, hook, token));
+}
+
+function getHookName(hook: LifecycleHooks): string {
+  switch (hook) {
+    case LifecycleHooks.OnInit:
+      return 'ngOnInit';
+    case LifecycleHooks.OnDestroy:
+      return 'ngOnDestroy';
+    case LifecycleHooks.DoCheck:
+      return 'ngDoCheck';
+    case LifecycleHooks.OnChanges:
+      return 'ngOnChanges';
+    case LifecycleHooks.AfterContentInit:
+      return 'ngAfterContentInit';
+    case LifecycleHooks.AfterContentChecked:
+      return 'ngAfterContentChecked';
+    case LifecycleHooks.AfterViewInit:
+      return 'ngAfterViewInit';
+    case LifecycleHooks.AfterViewChecked:
+      return 'ngAfterViewChecked';
+  }
+}
diff --git a/angular/compiler/src/metadata_resolver.ts b/angular/compiler/src/metadata_resolver.ts
new file mode 100644
index 0000000..3392966
--- /dev/null
+++ b/angular/compiler/src/metadata_resolver.ts
@@ -0,0 +1,1104 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {StaticSymbol, StaticSymbolCache} from './aot/static_symbol';
+import {ngfactoryFilePath} from './aot/util';
+import {assertArrayOfStrings, assertInterpolationSymbols} from './assertions';
+import * as cpl from './compile_metadata';
+import {CompileReflector} from './compile_reflector';
+import {CompilerConfig} from './config';
+import {ChangeDetectionStrategy, Component, Directive, ModuleWithProviders, Provider, Query, SchemaMetadata, Type, createAttribute, createComponent, createHost, createInject, createInjectable, createInjectionToken, createOptional, createSelf, createSkipSelf} from './core';
+import {DirectiveNormalizer} from './directive_normalizer';
+import {DirectiveResolver} from './directive_resolver';
+import {Identifiers} from './identifiers';
+import {getAllLifecycleHooks} from './lifecycle_reflector';
+import {NgModuleResolver} from './ng_module_resolver';
+import {PipeResolver} from './pipe_resolver';
+import {ElementSchemaRegistry} from './schema/element_schema_registry';
+import {SummaryResolver} from './summary_resolver';
+import {Console, SyncAsync, ValueTransformer, isPromise, noUndefined, resolveForwardRef, stringify, syntaxError, visitValue} from './util';
+
+export type ErrorCollector = (error: any, type?: any) => void;
+
+export const ERROR_COMPONENT_TYPE = 'ngComponentType';
+
+// Design notes:
+// - don't lazily create metadata:
+//   For some metadata, we need to do async work sometimes,
+//   so the user has to kick off this loading.
+//   But we want to report errors even when the async work is
+//   not required to check that the user would have been able
+//   to wait correctly.
+export class CompileMetadataResolver {
+  private _nonNormalizedDirectiveCache =
+      new Map<Type, {annotation: Directive, metadata: cpl.CompileDirectiveMetadata}>();
+  private _directiveCache = new Map<Type, cpl.CompileDirectiveMetadata>();
+  private _summaryCache = new Map<Type, cpl.CompileTypeSummary|null>();
+  private _pipeCache = new Map<Type, cpl.CompilePipeMetadata>();
+  private _ngModuleCache = new Map<Type, cpl.CompileNgModuleMetadata>();
+  private _ngModuleOfTypes = new Map<Type, Type>();
+
+  constructor(
+      private _config: CompilerConfig, private _ngModuleResolver: NgModuleResolver,
+      private _directiveResolver: DirectiveResolver, private _pipeResolver: PipeResolver,
+      private _summaryResolver: SummaryResolver<any>,
+      private _schemaRegistry: ElementSchemaRegistry,
+      private _directiveNormalizer: DirectiveNormalizer, private _console: Console,
+      private _staticSymbolCache: StaticSymbolCache, private _reflector: CompileReflector,
+      private _errorCollector?: ErrorCollector) {}
+
+  getReflector(): CompileReflector { return this._reflector; }
+
+  clearCacheFor(type: Type) {
+    const dirMeta = this._directiveCache.get(type);
+    this._directiveCache.delete(type);
+    this._nonNormalizedDirectiveCache.delete(type);
+    this._summaryCache.delete(type);
+    this._pipeCache.delete(type);
+    this._ngModuleOfTypes.delete(type);
+    // Clear all of the NgModule as they contain transitive information!
+    this._ngModuleCache.clear();
+    if (dirMeta) {
+      this._directiveNormalizer.clearCacheFor(dirMeta);
+    }
+  }
+
+  clearCache(): void {
+    this._directiveCache.clear();
+    this._nonNormalizedDirectiveCache.clear();
+    this._summaryCache.clear();
+    this._pipeCache.clear();
+    this._ngModuleCache.clear();
+    this._ngModuleOfTypes.clear();
+    this._directiveNormalizer.clearCache();
+  }
+
+  private _createProxyClass(baseType: any, name: string): cpl.ProxyClass {
+    let delegate: any = null;
+    const proxyClass: cpl.ProxyClass = <any>function() {
+      if (!delegate) {
+        throw new Error(
+            `Illegal state: Class ${name} for type ${stringify(baseType)} is not compiled yet!`);
+      }
+      return delegate.apply(this, arguments);
+    };
+    proxyClass.setDelegate = (d) => {
+      delegate = d;
+      (<any>proxyClass).prototype = d.prototype;
+    };
+    // Make stringify work correctly
+    (<any>proxyClass).overriddenName = name;
+    return proxyClass;
+  }
+
+  private getGeneratedClass(dirType: any, name: string): StaticSymbol|cpl.ProxyClass {
+    if (dirType instanceof StaticSymbol) {
+      return this._staticSymbolCache.get(ngfactoryFilePath(dirType.filePath), name);
+    } else {
+      return this._createProxyClass(dirType, name);
+    }
+  }
+
+  private getComponentViewClass(dirType: any): StaticSymbol|cpl.ProxyClass {
+    return this.getGeneratedClass(dirType, cpl.viewClassName(dirType, 0));
+  }
+
+  getHostComponentViewClass(dirType: any): StaticSymbol|cpl.ProxyClass {
+    return this.getGeneratedClass(dirType, cpl.hostViewClassName(dirType));
+  }
+
+  getHostComponentType(dirType: any): StaticSymbol|Type {
+    const name = `${cpl.identifierName({reference: dirType})}_Host`;
+    if (dirType instanceof StaticSymbol) {
+      return this._staticSymbolCache.get(dirType.filePath, name);
+    } else {
+      const HostClass = <any>function HostClass() {};
+      HostClass.overriddenName = name;
+
+      return HostClass;
+    }
+  }
+
+  private getRendererType(dirType: any): StaticSymbol|object {
+    if (dirType instanceof StaticSymbol) {
+      return this._staticSymbolCache.get(
+          ngfactoryFilePath(dirType.filePath), cpl.rendererTypeName(dirType));
+    } else {
+      // returning an object as proxy,
+      // that we fill later during runtime compilation.
+      return <any>{};
+    }
+  }
+
+  private getComponentFactory(
+      selector: string, dirType: any, inputs: {[key: string]: string}|null,
+      outputs: {[key: string]: string}): StaticSymbol|object {
+    if (dirType instanceof StaticSymbol) {
+      return this._staticSymbolCache.get(
+          ngfactoryFilePath(dirType.filePath), cpl.componentFactoryName(dirType));
+    } else {
+      const hostView = this.getHostComponentViewClass(dirType);
+      // Note: ngContentSelectors will be filled later once the template is
+      // loaded.
+      const createComponentFactory =
+          this._reflector.resolveExternalReference(Identifiers.createComponentFactory);
+      return createComponentFactory(selector, dirType, <any>hostView, inputs, outputs, []);
+    }
+  }
+
+  private initComponentFactory(factory: StaticSymbol|object, ngContentSelectors: string[]) {
+    if (!(factory instanceof StaticSymbol)) {
+      (factory as any).ngContentSelectors.push(...ngContentSelectors);
+    }
+  }
+
+  private _loadSummary(type: any, kind: cpl.CompileSummaryKind): cpl.CompileTypeSummary|null {
+    let typeSummary = this._summaryCache.get(type);
+    if (!typeSummary) {
+      const summary = this._summaryResolver.resolveSummary(type);
+      typeSummary = summary ? summary.type : null;
+      this._summaryCache.set(type, typeSummary || null);
+    }
+    return typeSummary && typeSummary.summaryKind === kind ? typeSummary : null;
+  }
+
+  loadDirectiveMetadata(ngModuleType: any, directiveType: any, isSync: boolean): SyncAsync<null> {
+    if (this._directiveCache.has(directiveType)) {
+      return null;
+    }
+    directiveType = resolveForwardRef(directiveType);
+    const {annotation, metadata} = this.getNonNormalizedDirectiveMetadata(directiveType) !;
+
+    const createDirectiveMetadata = (templateMetadata: cpl.CompileTemplateMetadata | null) => {
+      const normalizedDirMeta = new cpl.CompileDirectiveMetadata({
+        isHost: false,
+        type: metadata.type,
+        isComponent: metadata.isComponent,
+        selector: metadata.selector,
+        exportAs: metadata.exportAs,
+        changeDetection: metadata.changeDetection,
+        inputs: metadata.inputs,
+        outputs: metadata.outputs,
+        hostListeners: metadata.hostListeners,
+        hostProperties: metadata.hostProperties,
+        hostAttributes: metadata.hostAttributes,
+        providers: metadata.providers,
+        viewProviders: metadata.viewProviders,
+        queries: metadata.queries,
+        viewQueries: metadata.viewQueries,
+        entryComponents: metadata.entryComponents,
+        componentViewType: metadata.componentViewType,
+        rendererType: metadata.rendererType,
+        componentFactory: metadata.componentFactory,
+        template: templateMetadata
+      });
+      if (templateMetadata) {
+        this.initComponentFactory(metadata.componentFactory !, templateMetadata.ngContentSelectors);
+      }
+      this._directiveCache.set(directiveType, normalizedDirMeta);
+      this._summaryCache.set(directiveType, normalizedDirMeta.toSummary());
+      return null;
+    };
+
+    if (metadata.isComponent) {
+      const template = metadata.template !;
+      const templateMeta = this._directiveNormalizer.normalizeTemplate({
+        ngModuleType,
+        componentType: directiveType,
+        moduleUrl: this._reflector.componentModuleUrl(directiveType, annotation),
+        encapsulation: template.encapsulation,
+        template: template.template,
+        templateUrl: template.templateUrl,
+        styles: template.styles,
+        styleUrls: template.styleUrls,
+        animations: template.animations,
+        interpolation: template.interpolation,
+        preserveWhitespaces: template.preserveWhitespaces
+      });
+      if (isPromise(templateMeta) && isSync) {
+        this._reportError(componentStillLoadingError(directiveType), directiveType);
+        return null;
+      }
+      return SyncAsync.then(templateMeta, createDirectiveMetadata);
+    } else {
+      // directive
+      createDirectiveMetadata(null);
+      return null;
+    }
+  }
+
+  getNonNormalizedDirectiveMetadata(directiveType: any):
+      {annotation: Directive, metadata: cpl.CompileDirectiveMetadata}|null {
+    directiveType = resolveForwardRef(directiveType);
+    if (!directiveType) {
+      return null;
+    }
+    let cacheEntry = this._nonNormalizedDirectiveCache.get(directiveType);
+    if (cacheEntry) {
+      return cacheEntry;
+    }
+    const dirMeta = this._directiveResolver.resolve(directiveType, false);
+    if (!dirMeta) {
+      return null;
+    }
+    let nonNormalizedTemplateMetadata: cpl.CompileTemplateMetadata = undefined !;
+
+    if (createComponent.isTypeOf(dirMeta)) {
+      // component
+      const compMeta = dirMeta as Component;
+      assertArrayOfStrings('styles', compMeta.styles);
+      assertArrayOfStrings('styleUrls', compMeta.styleUrls);
+      assertInterpolationSymbols('interpolation', compMeta.interpolation);
+
+      const animations = compMeta.animations;
+
+      nonNormalizedTemplateMetadata = new cpl.CompileTemplateMetadata({
+        encapsulation: noUndefined(compMeta.encapsulation),
+        template: noUndefined(compMeta.template),
+        templateUrl: noUndefined(compMeta.templateUrl),
+        styles: compMeta.styles || [],
+        styleUrls: compMeta.styleUrls || [],
+        animations: animations || [],
+        interpolation: noUndefined(compMeta.interpolation),
+        isInline: !!compMeta.template,
+        externalStylesheets: [],
+        ngContentSelectors: [],
+        preserveWhitespaces: noUndefined(dirMeta.preserveWhitespaces),
+      });
+    }
+
+    let changeDetectionStrategy: ChangeDetectionStrategy = null !;
+    let viewProviders: cpl.CompileProviderMetadata[] = [];
+    let entryComponentMetadata: cpl.CompileEntryComponentMetadata[] = [];
+    let selector = dirMeta.selector;
+
+    if (createComponent.isTypeOf(dirMeta)) {
+      // Component
+      const compMeta = dirMeta as Component;
+      changeDetectionStrategy = compMeta.changeDetection !;
+      if (compMeta.viewProviders) {
+        viewProviders = this._getProvidersMetadata(
+            compMeta.viewProviders, entryComponentMetadata,
+            `viewProviders for "${stringifyType(directiveType)}"`, [], directiveType);
+      }
+      if (compMeta.entryComponents) {
+        entryComponentMetadata = flattenAndDedupeArray(compMeta.entryComponents)
+                                     .map((type) => this._getEntryComponentMetadata(type) !)
+                                     .concat(entryComponentMetadata);
+      }
+      if (!selector) {
+        selector = this._schemaRegistry.getDefaultComponentElementName();
+      }
+    } else {
+      // Directive
+      if (!selector) {
+        this._reportError(
+            syntaxError(
+                `Directive ${stringifyType(directiveType)} has no selector, please add it!`),
+            directiveType);
+        selector = 'error';
+      }
+    }
+
+    let providers: cpl.CompileProviderMetadata[] = [];
+    if (dirMeta.providers != null) {
+      providers = this._getProvidersMetadata(
+          dirMeta.providers, entryComponentMetadata,
+          `providers for "${stringifyType(directiveType)}"`, [], directiveType);
+    }
+    let queries: cpl.CompileQueryMetadata[] = [];
+    let viewQueries: cpl.CompileQueryMetadata[] = [];
+    if (dirMeta.queries != null) {
+      queries = this._getQueriesMetadata(dirMeta.queries, false, directiveType);
+      viewQueries = this._getQueriesMetadata(dirMeta.queries, true, directiveType);
+    }
+
+    const metadata = cpl.CompileDirectiveMetadata.create({
+      isHost: false,
+      selector: selector,
+      exportAs: noUndefined(dirMeta.exportAs),
+      isComponent: !!nonNormalizedTemplateMetadata,
+      type: this._getTypeMetadata(directiveType),
+      template: nonNormalizedTemplateMetadata,
+      changeDetection: changeDetectionStrategy,
+      inputs: dirMeta.inputs || [],
+      outputs: dirMeta.outputs || [],
+      host: dirMeta.host || {},
+      providers: providers || [],
+      viewProviders: viewProviders || [],
+      queries: queries || [],
+      viewQueries: viewQueries || [],
+      entryComponents: entryComponentMetadata,
+      componentViewType: nonNormalizedTemplateMetadata ? this.getComponentViewClass(directiveType) :
+                                                         null,
+      rendererType: nonNormalizedTemplateMetadata ? this.getRendererType(directiveType) : null,
+      componentFactory: null
+    });
+    if (nonNormalizedTemplateMetadata) {
+      metadata.componentFactory =
+          this.getComponentFactory(selector, directiveType, metadata.inputs, metadata.outputs);
+    }
+    cacheEntry = {metadata, annotation: dirMeta};
+    this._nonNormalizedDirectiveCache.set(directiveType, cacheEntry);
+    return cacheEntry;
+  }
+
+  /**
+   * Gets the metadata for the given directive.
+   * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first.
+   */
+  getDirectiveMetadata(directiveType: any): cpl.CompileDirectiveMetadata {
+    const dirMeta = this._directiveCache.get(directiveType) !;
+    if (!dirMeta) {
+      this._reportError(
+          syntaxError(
+              `Illegal state: getDirectiveMetadata can only be called after loadNgModuleDirectiveAndPipeMetadata for a module that declares it. Directive ${stringifyType(directiveType)}.`),
+          directiveType);
+    }
+    return dirMeta;
+  }
+
+  getDirectiveSummary(dirType: any): cpl.CompileDirectiveSummary {
+    const dirSummary =
+        <cpl.CompileDirectiveSummary>this._loadSummary(dirType, cpl.CompileSummaryKind.Directive);
+    if (!dirSummary) {
+      this._reportError(
+          syntaxError(
+              `Illegal state: Could not load the summary for directive ${stringifyType(dirType)}.`),
+          dirType);
+    }
+    return dirSummary;
+  }
+
+  isDirective(type: any) {
+    return !!this._loadSummary(type, cpl.CompileSummaryKind.Directive) ||
+        this._directiveResolver.isDirective(type);
+  }
+
+  isPipe(type: any) {
+    return !!this._loadSummary(type, cpl.CompileSummaryKind.Pipe) ||
+        this._pipeResolver.isPipe(type);
+  }
+
+  isNgModule(type: any) {
+    return !!this._loadSummary(type, cpl.CompileSummaryKind.NgModule) ||
+        this._ngModuleResolver.isNgModule(type);
+  }
+
+  getNgModuleSummary(moduleType: any): cpl.CompileNgModuleSummary|null {
+    let moduleSummary: cpl.CompileNgModuleSummary|null =
+        <cpl.CompileNgModuleSummary>this._loadSummary(moduleType, cpl.CompileSummaryKind.NgModule);
+    if (!moduleSummary) {
+      const moduleMeta = this.getNgModuleMetadata(moduleType, false);
+      moduleSummary = moduleMeta ? moduleMeta.toSummary() : null;
+      if (moduleSummary) {
+        this._summaryCache.set(moduleType, moduleSummary);
+      }
+    }
+    return moduleSummary;
+  }
+
+  /**
+   * Loads the declared directives and pipes of an NgModule.
+   */
+  loadNgModuleDirectiveAndPipeMetadata(moduleType: any, isSync: boolean, throwIfNotFound = true):
+      Promise<any> {
+    const ngModule = this.getNgModuleMetadata(moduleType, throwIfNotFound);
+    const loading: Promise<any>[] = [];
+    if (ngModule) {
+      ngModule.declaredDirectives.forEach((id) => {
+        const promise = this.loadDirectiveMetadata(moduleType, id.reference, isSync);
+        if (promise) {
+          loading.push(promise);
+        }
+      });
+      ngModule.declaredPipes.forEach((id) => this._loadPipeMetadata(id.reference));
+    }
+    return Promise.all(loading);
+  }
+
+  getNgModuleMetadata(moduleType: any, throwIfNotFound = true): cpl.CompileNgModuleMetadata|null {
+    moduleType = resolveForwardRef(moduleType);
+    let compileMeta = this._ngModuleCache.get(moduleType);
+    if (compileMeta) {
+      return compileMeta;
+    }
+    const meta = this._ngModuleResolver.resolve(moduleType, throwIfNotFound);
+    if (!meta) {
+      return null;
+    }
+    const declaredDirectives: cpl.CompileIdentifierMetadata[] = [];
+    const exportedNonModuleIdentifiers: cpl.CompileIdentifierMetadata[] = [];
+    const declaredPipes: cpl.CompileIdentifierMetadata[] = [];
+    const importedModules: cpl.CompileNgModuleSummary[] = [];
+    const exportedModules: cpl.CompileNgModuleSummary[] = [];
+    const providers: cpl.CompileProviderMetadata[] = [];
+    const entryComponents: cpl.CompileEntryComponentMetadata[] = [];
+    const bootstrapComponents: cpl.CompileIdentifierMetadata[] = [];
+    const schemas: SchemaMetadata[] = [];
+
+    if (meta.imports) {
+      flattenAndDedupeArray(meta.imports).forEach((importedType) => {
+        let importedModuleType: Type = undefined !;
+        if (isValidType(importedType)) {
+          importedModuleType = importedType;
+        } else if (importedType && importedType.ngModule) {
+          const moduleWithProviders: ModuleWithProviders = importedType;
+          importedModuleType = moduleWithProviders.ngModule;
+          if (moduleWithProviders.providers) {
+            providers.push(...this._getProvidersMetadata(
+                moduleWithProviders.providers, entryComponents,
+                `provider for the NgModule '${stringifyType(importedModuleType)}'`, [],
+                importedType));
+          }
+        }
+
+        if (importedModuleType) {
+          if (this._checkSelfImport(moduleType, importedModuleType)) return;
+          const importedModuleSummary = this.getNgModuleSummary(importedModuleType);
+          if (!importedModuleSummary) {
+            this._reportError(
+                syntaxError(
+                    `Unexpected ${this._getTypeDescriptor(importedType)} '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'. Please add a @NgModule annotation.`),
+                moduleType);
+            return;
+          }
+          importedModules.push(importedModuleSummary);
+        } else {
+          this._reportError(
+              syntaxError(
+                  `Unexpected value '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'`),
+              moduleType);
+          return;
+        }
+      });
+    }
+
+    if (meta.exports) {
+      flattenAndDedupeArray(meta.exports).forEach((exportedType) => {
+        if (!isValidType(exportedType)) {
+          this._reportError(
+              syntaxError(
+                  `Unexpected value '${stringifyType(exportedType)}' exported by the module '${stringifyType(moduleType)}'`),
+              moduleType);
+          return;
+        }
+        const exportedModuleSummary = this.getNgModuleSummary(exportedType);
+        if (exportedModuleSummary) {
+          exportedModules.push(exportedModuleSummary);
+        } else {
+          exportedNonModuleIdentifiers.push(this._getIdentifierMetadata(exportedType));
+        }
+      });
+    }
+
+    // Note: This will be modified later, so we rely on
+    // getting a new instance every time!
+    const transitiveModule = this._getTransitiveNgModuleMetadata(importedModules, exportedModules);
+    if (meta.declarations) {
+      flattenAndDedupeArray(meta.declarations).forEach((declaredType) => {
+        if (!isValidType(declaredType)) {
+          this._reportError(
+              syntaxError(
+                  `Unexpected value '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'`),
+              moduleType);
+          return;
+        }
+        const declaredIdentifier = this._getIdentifierMetadata(declaredType);
+        if (this.isDirective(declaredType)) {
+          transitiveModule.addDirective(declaredIdentifier);
+          declaredDirectives.push(declaredIdentifier);
+          this._addTypeToModule(declaredType, moduleType);
+        } else if (this.isPipe(declaredType)) {
+          transitiveModule.addPipe(declaredIdentifier);
+          transitiveModule.pipes.push(declaredIdentifier);
+          declaredPipes.push(declaredIdentifier);
+          this._addTypeToModule(declaredType, moduleType);
+        } else {
+          this._reportError(
+              syntaxError(
+                  `Unexpected ${this._getTypeDescriptor(declaredType)} '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'. Please add a @Pipe/@Directive/@Component annotation.`),
+              moduleType);
+          return;
+        }
+      });
+    }
+
+    const exportedDirectives: cpl.CompileIdentifierMetadata[] = [];
+    const exportedPipes: cpl.CompileIdentifierMetadata[] = [];
+    exportedNonModuleIdentifiers.forEach((exportedId) => {
+      if (transitiveModule.directivesSet.has(exportedId.reference)) {
+        exportedDirectives.push(exportedId);
+        transitiveModule.addExportedDirective(exportedId);
+      } else if (transitiveModule.pipesSet.has(exportedId.reference)) {
+        exportedPipes.push(exportedId);
+        transitiveModule.addExportedPipe(exportedId);
+      } else {
+        this._reportError(
+            syntaxError(
+                `Can't export ${this._getTypeDescriptor(exportedId.reference)} ${stringifyType(exportedId.reference)} from ${stringifyType(moduleType)} as it was neither declared nor imported!`),
+            moduleType);
+        return;
+      }
+    });
+
+    // The providers of the module have to go last
+    // so that they overwrite any other provider we already added.
+    if (meta.providers) {
+      providers.push(...this._getProvidersMetadata(
+          meta.providers, entryComponents,
+          `provider for the NgModule '${stringifyType(moduleType)}'`, [], moduleType));
+    }
+
+    if (meta.entryComponents) {
+      entryComponents.push(...flattenAndDedupeArray(meta.entryComponents)
+                               .map(type => this._getEntryComponentMetadata(type) !));
+    }
+
+    if (meta.bootstrap) {
+      flattenAndDedupeArray(meta.bootstrap).forEach(type => {
+        if (!isValidType(type)) {
+          this._reportError(
+              syntaxError(
+                  `Unexpected value '${stringifyType(type)}' used in the bootstrap property of module '${stringifyType(moduleType)}'`),
+              moduleType);
+          return;
+        }
+        bootstrapComponents.push(this._getIdentifierMetadata(type));
+      });
+    }
+
+    entryComponents.push(
+        ...bootstrapComponents.map(type => this._getEntryComponentMetadata(type.reference) !));
+
+    if (meta.schemas) {
+      schemas.push(...flattenAndDedupeArray(meta.schemas));
+    }
+
+    compileMeta = new cpl.CompileNgModuleMetadata({
+      type: this._getTypeMetadata(moduleType),
+      providers,
+      entryComponents,
+      bootstrapComponents,
+      schemas,
+      declaredDirectives,
+      exportedDirectives,
+      declaredPipes,
+      exportedPipes,
+      importedModules,
+      exportedModules,
+      transitiveModule,
+      id: meta.id || null,
+    });
+
+    entryComponents.forEach((id) => transitiveModule.addEntryComponent(id));
+    providers.forEach((provider) => transitiveModule.addProvider(provider, compileMeta !.type));
+    transitiveModule.addModule(compileMeta.type);
+    this._ngModuleCache.set(moduleType, compileMeta);
+    return compileMeta;
+  }
+
+  private _checkSelfImport(moduleType: Type, importedModuleType: Type): boolean {
+    if (moduleType === importedModuleType) {
+      this._reportError(
+          syntaxError(`'${stringifyType(moduleType)}' module can't import itself`), moduleType);
+      return true;
+    }
+    return false;
+  }
+
+  private _getTypeDescriptor(type: Type): string {
+    if (this.isDirective(type)) {
+      return 'directive';
+    }
+
+    if (this.isPipe(type)) {
+      return 'pipe';
+    }
+
+    if (this.isNgModule(type)) {
+      return 'module';
+    }
+
+    if ((type as any).provide) {
+      return 'provider';
+    }
+
+    return 'value';
+  }
+
+
+  private _addTypeToModule(type: Type, moduleType: Type) {
+    const oldModule = this._ngModuleOfTypes.get(type);
+    if (oldModule && oldModule !== moduleType) {
+      this._reportError(
+          syntaxError(
+              `Type ${stringifyType(type)} is part of the declarations of 2 modules: ${stringifyType(oldModule)} and ${stringifyType(moduleType)}! ` +
+              `Please consider moving ${stringifyType(type)} to a higher module that imports ${stringifyType(oldModule)} and ${stringifyType(moduleType)}. ` +
+              `You can also create a new NgModule that exports and includes ${stringifyType(type)} then import that NgModule in ${stringifyType(oldModule)} and ${stringifyType(moduleType)}.`),
+          moduleType);
+      return;
+    }
+    this._ngModuleOfTypes.set(type, moduleType);
+  }
+
+  private _getTransitiveNgModuleMetadata(
+      importedModules: cpl.CompileNgModuleSummary[],
+      exportedModules: cpl.CompileNgModuleSummary[]): cpl.TransitiveCompileNgModuleMetadata {
+    // collect `providers` / `entryComponents` from all imported and all exported modules
+    const result = new cpl.TransitiveCompileNgModuleMetadata();
+    const modulesByToken = new Map<any, Set<any>>();
+    importedModules.concat(exportedModules).forEach((modSummary) => {
+      modSummary.modules.forEach((mod) => result.addModule(mod));
+      modSummary.entryComponents.forEach((comp) => result.addEntryComponent(comp));
+      const addedTokens = new Set<any>();
+      modSummary.providers.forEach((entry) => {
+        const tokenRef = cpl.tokenReference(entry.provider.token);
+        let prevModules = modulesByToken.get(tokenRef);
+        if (!prevModules) {
+          prevModules = new Set<any>();
+          modulesByToken.set(tokenRef, prevModules);
+        }
+        const moduleRef = entry.module.reference;
+        // Note: the providers of one module may still contain multiple providers
+        // per token (e.g. for multi providers), and we need to preserve these.
+        if (addedTokens.has(tokenRef) || !prevModules.has(moduleRef)) {
+          prevModules.add(moduleRef);
+          addedTokens.add(tokenRef);
+          result.addProvider(entry.provider, entry.module);
+        }
+      });
+    });
+    exportedModules.forEach((modSummary) => {
+      modSummary.exportedDirectives.forEach((id) => result.addExportedDirective(id));
+      modSummary.exportedPipes.forEach((id) => result.addExportedPipe(id));
+    });
+    importedModules.forEach((modSummary) => {
+      modSummary.exportedDirectives.forEach((id) => result.addDirective(id));
+      modSummary.exportedPipes.forEach((id) => result.addPipe(id));
+    });
+    return result;
+  }
+
+  private _getIdentifierMetadata(type: Type): cpl.CompileIdentifierMetadata {
+    type = resolveForwardRef(type);
+    return {reference: type};
+  }
+
+  isInjectable(type: any): boolean {
+    const annotations = this._reflector.annotations(type);
+    return annotations.some(ann => createInjectable.isTypeOf(ann));
+  }
+
+  getInjectableSummary(type: any): cpl.CompileTypeSummary {
+    return {
+      summaryKind: cpl.CompileSummaryKind.Injectable,
+      type: this._getTypeMetadata(type, null, false)
+    };
+  }
+
+  private _getInjectableMetadata(type: Type, dependencies: any[]|null = null):
+      cpl.CompileTypeMetadata {
+    const typeSummary = this._loadSummary(type, cpl.CompileSummaryKind.Injectable);
+    if (typeSummary) {
+      return typeSummary.type;
+    }
+    return this._getTypeMetadata(type, dependencies);
+  }
+
+  private _getTypeMetadata(type: Type, dependencies: any[]|null = null, throwOnUnknownDeps = true):
+      cpl.CompileTypeMetadata {
+    const identifier = this._getIdentifierMetadata(type);
+    return {
+      reference: identifier.reference,
+      diDeps: this._getDependenciesMetadata(identifier.reference, dependencies, throwOnUnknownDeps),
+      lifecycleHooks: getAllLifecycleHooks(this._reflector, identifier.reference),
+    };
+  }
+
+  private _getFactoryMetadata(factory: Function, dependencies: any[]|null = null):
+      cpl.CompileFactoryMetadata {
+    factory = resolveForwardRef(factory);
+    return {reference: factory, diDeps: this._getDependenciesMetadata(factory, dependencies)};
+  }
+
+  /**
+   * Gets the metadata for the given pipe.
+   * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first.
+   */
+  getPipeMetadata(pipeType: any): cpl.CompilePipeMetadata|null {
+    const pipeMeta = this._pipeCache.get(pipeType);
+    if (!pipeMeta) {
+      this._reportError(
+          syntaxError(
+              `Illegal state: getPipeMetadata can only be called after loadNgModuleDirectiveAndPipeMetadata for a module that declares it. Pipe ${stringifyType(pipeType)}.`),
+          pipeType);
+    }
+    return pipeMeta || null;
+  }
+
+  getPipeSummary(pipeType: any): cpl.CompilePipeSummary {
+    const pipeSummary =
+        <cpl.CompilePipeSummary>this._loadSummary(pipeType, cpl.CompileSummaryKind.Pipe);
+    if (!pipeSummary) {
+      this._reportError(
+          syntaxError(
+              `Illegal state: Could not load the summary for pipe ${stringifyType(pipeType)}.`),
+          pipeType);
+    }
+    return pipeSummary;
+  }
+
+  getOrLoadPipeMetadata(pipeType: any): cpl.CompilePipeMetadata {
+    let pipeMeta = this._pipeCache.get(pipeType);
+    if (!pipeMeta) {
+      pipeMeta = this._loadPipeMetadata(pipeType);
+    }
+    return pipeMeta;
+  }
+
+  private _loadPipeMetadata(pipeType: any): cpl.CompilePipeMetadata {
+    pipeType = resolveForwardRef(pipeType);
+    const pipeAnnotation = this._pipeResolver.resolve(pipeType) !;
+
+    const pipeMeta = new cpl.CompilePipeMetadata({
+      type: this._getTypeMetadata(pipeType),
+      name: pipeAnnotation.name,
+      pure: !!pipeAnnotation.pure
+    });
+    this._pipeCache.set(pipeType, pipeMeta);
+    this._summaryCache.set(pipeType, pipeMeta.toSummary());
+    return pipeMeta;
+  }
+
+  private _getDependenciesMetadata(
+      typeOrFunc: Type|Function, dependencies: any[]|null,
+      throwOnUnknownDeps = true): cpl.CompileDiDependencyMetadata[] {
+    let hasUnknownDeps = false;
+    const params = dependencies || this._reflector.parameters(typeOrFunc) || [];
+
+    const dependenciesMetadata: cpl.CompileDiDependencyMetadata[] = params.map((param) => {
+      let isAttribute = false;
+      let isHost = false;
+      let isSelf = false;
+      let isSkipSelf = false;
+      let isOptional = false;
+      let token: any = null;
+      if (Array.isArray(param)) {
+        param.forEach((paramEntry) => {
+          if (createHost.isTypeOf(paramEntry)) {
+            isHost = true;
+          } else if (createSelf.isTypeOf(paramEntry)) {
+            isSelf = true;
+          } else if (createSkipSelf.isTypeOf(paramEntry)) {
+            isSkipSelf = true;
+          } else if (createOptional.isTypeOf(paramEntry)) {
+            isOptional = true;
+          } else if (createAttribute.isTypeOf(paramEntry)) {
+            isAttribute = true;
+            token = paramEntry.attributeName;
+          } else if (createInject.isTypeOf(paramEntry)) {
+            token = paramEntry.token;
+          } else if (
+              createInjectionToken.isTypeOf(paramEntry) || paramEntry instanceof StaticSymbol) {
+            token = paramEntry;
+          } else if (isValidType(paramEntry) && token == null) {
+            token = paramEntry;
+          }
+        });
+      } else {
+        token = param;
+      }
+      if (token == null) {
+        hasUnknownDeps = true;
+        return null !;
+      }
+
+      return {
+        isAttribute,
+        isHost,
+        isSelf,
+        isSkipSelf,
+        isOptional,
+        token: this._getTokenMetadata(token)
+      };
+
+    });
+
+    if (hasUnknownDeps) {
+      const depsTokens =
+          dependenciesMetadata.map((dep) => dep ? stringifyType(dep.token) : '?').join(', ');
+      const message =
+          `Can't resolve all parameters for ${stringifyType(typeOrFunc)}: (${depsTokens}).`;
+      if (throwOnUnknownDeps) {
+        this._reportError(syntaxError(message), typeOrFunc);
+      } else {
+        this._console.warn(`Warning: ${message} This will become an error in Angular v5.x`);
+      }
+    }
+
+    return dependenciesMetadata;
+  }
+
+  private _getTokenMetadata(token: any): cpl.CompileTokenMetadata {
+    token = resolveForwardRef(token);
+    let compileToken: cpl.CompileTokenMetadata;
+    if (typeof token === 'string') {
+      compileToken = {value: token};
+    } else {
+      compileToken = {identifier: {reference: token}};
+    }
+    return compileToken;
+  }
+
+  private _getProvidersMetadata(
+      providers: Provider[], targetEntryComponents: cpl.CompileEntryComponentMetadata[],
+      debugInfo?: string, compileProviders: cpl.CompileProviderMetadata[] = [],
+      type?: any): cpl.CompileProviderMetadata[] {
+    providers.forEach((provider: any, providerIdx: number) => {
+      if (Array.isArray(provider)) {
+        this._getProvidersMetadata(provider, targetEntryComponents, debugInfo, compileProviders);
+      } else {
+        provider = resolveForwardRef(provider);
+        let providerMeta: cpl.ProviderMeta = undefined !;
+        if (provider && typeof provider === 'object' && provider.hasOwnProperty('provide')) {
+          this._validateProvider(provider);
+          providerMeta = new cpl.ProviderMeta(provider.provide, provider);
+        } else if (isValidType(provider)) {
+          providerMeta = new cpl.ProviderMeta(provider, {useClass: provider});
+        } else if (provider === void 0) {
+          this._reportError(syntaxError(
+              `Encountered undefined provider! Usually this means you have a circular dependencies (might be caused by using 'barrel' index.ts files.`));
+          return;
+        } else {
+          const providersInfo =
+              (<string[]>providers.reduce(
+                   (soFar: string[], seenProvider: any, seenProviderIdx: number) => {
+                     if (seenProviderIdx < providerIdx) {
+                       soFar.push(`${stringifyType(seenProvider)}`);
+                     } else if (seenProviderIdx == providerIdx) {
+                       soFar.push(`?${stringifyType(seenProvider)}?`);
+                     } else if (seenProviderIdx == providerIdx + 1) {
+                       soFar.push('...');
+                     }
+                     return soFar;
+                   },
+                   []))
+                  .join(', ');
+          this._reportError(
+              syntaxError(
+                  `Invalid ${debugInfo ? debugInfo : 'provider'} - only instances of Provider and Type are allowed, got: [${providersInfo}]`),
+              type);
+          return;
+        }
+        if (providerMeta.token ===
+            this._reflector.resolveExternalReference(Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS)) {
+          targetEntryComponents.push(...this._getEntryComponentsFromProvider(providerMeta, type));
+        } else {
+          compileProviders.push(this.getProviderMetadata(providerMeta));
+        }
+      }
+    });
+    return compileProviders;
+  }
+
+  private _validateProvider(provider: any): void {
+    if (provider.hasOwnProperty('useClass') && provider.useClass == null) {
+      this._reportError(syntaxError(
+          `Invalid provider for ${stringifyType(provider.provide)}. useClass cannot be ${provider.useClass}.
+           Usually it happens when:
+           1. There's a circular dependency (might be caused by using index.ts (barrel) files).
+           2. Class was used before it was declared. Use forwardRef in this case.`));
+    }
+  }
+
+  private _getEntryComponentsFromProvider(provider: cpl.ProviderMeta, type?: any):
+      cpl.CompileEntryComponentMetadata[] {
+    const components: cpl.CompileEntryComponentMetadata[] = [];
+    const collectedIdentifiers: cpl.CompileIdentifierMetadata[] = [];
+
+    if (provider.useFactory || provider.useExisting || provider.useClass) {
+      this._reportError(
+          syntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!`), type);
+      return [];
+    }
+
+    if (!provider.multi) {
+      this._reportError(
+          syntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!`),
+          type);
+      return [];
+    }
+
+    extractIdentifiers(provider.useValue, collectedIdentifiers);
+    collectedIdentifiers.forEach((identifier) => {
+      const entry = this._getEntryComponentMetadata(identifier.reference, false);
+      if (entry) {
+        components.push(entry);
+      }
+    });
+    return components;
+  }
+
+  private _getEntryComponentMetadata(dirType: any, throwIfNotFound = true):
+      cpl.CompileEntryComponentMetadata|null {
+    const dirMeta = this.getNonNormalizedDirectiveMetadata(dirType);
+    if (dirMeta && dirMeta.metadata.isComponent) {
+      return {componentType: dirType, componentFactory: dirMeta.metadata.componentFactory !};
+    }
+    const dirSummary =
+        <cpl.CompileDirectiveSummary>this._loadSummary(dirType, cpl.CompileSummaryKind.Directive);
+    if (dirSummary && dirSummary.isComponent) {
+      return {componentType: dirType, componentFactory: dirSummary.componentFactory !};
+    }
+    if (throwIfNotFound) {
+      throw syntaxError(`${dirType.name} cannot be used as an entry component.`);
+    }
+    return null;
+  }
+
+  getProviderMetadata(provider: cpl.ProviderMeta): cpl.CompileProviderMetadata {
+    let compileDeps: cpl.CompileDiDependencyMetadata[] = undefined !;
+    let compileTypeMetadata: cpl.CompileTypeMetadata = null !;
+    let compileFactoryMetadata: cpl.CompileFactoryMetadata = null !;
+    let token: cpl.CompileTokenMetadata = this._getTokenMetadata(provider.token);
+
+    if (provider.useClass) {
+      compileTypeMetadata = this._getInjectableMetadata(provider.useClass, provider.dependencies);
+      compileDeps = compileTypeMetadata.diDeps;
+      if (provider.token === provider.useClass) {
+        // use the compileTypeMetadata as it contains information about lifecycleHooks...
+        token = {identifier: compileTypeMetadata};
+      }
+    } else if (provider.useFactory) {
+      compileFactoryMetadata = this._getFactoryMetadata(provider.useFactory, provider.dependencies);
+      compileDeps = compileFactoryMetadata.diDeps;
+    }
+
+    return {
+      token: token,
+      useClass: compileTypeMetadata,
+      useValue: provider.useValue,
+      useFactory: compileFactoryMetadata,
+      useExisting: provider.useExisting ? this._getTokenMetadata(provider.useExisting) : undefined,
+      deps: compileDeps,
+      multi: provider.multi
+    };
+  }
+
+  private _getQueriesMetadata(
+      queries: {[key: string]: Query}, isViewQuery: boolean,
+      directiveType: Type): cpl.CompileQueryMetadata[] {
+    const res: cpl.CompileQueryMetadata[] = [];
+
+    Object.keys(queries).forEach((propertyName: string) => {
+      const query = queries[propertyName];
+      if (query.isViewQuery === isViewQuery) {
+        res.push(this._getQueryMetadata(query, propertyName, directiveType));
+      }
+    });
+
+    return res;
+  }
+
+  private _queryVarBindings(selector: any): string[] { return selector.split(/\s*,\s*/); }
+
+  private _getQueryMetadata(q: Query, propertyName: string, typeOrFunc: Type|Function):
+      cpl.CompileQueryMetadata {
+    let selectors: cpl.CompileTokenMetadata[];
+    if (typeof q.selector === 'string') {
+      selectors =
+          this._queryVarBindings(q.selector).map(varName => this._getTokenMetadata(varName));
+    } else {
+      if (!q.selector) {
+        this._reportError(
+            syntaxError(
+                `Can't construct a query for the property "${propertyName}" of "${stringifyType(typeOrFunc)}" since the query selector wasn't defined.`),
+            typeOrFunc);
+        selectors = [];
+      } else {
+        selectors = [this._getTokenMetadata(q.selector)];
+      }
+    }
+
+    return {
+      selectors,
+      first: q.first,
+      descendants: q.descendants, propertyName,
+      read: q.read ? this._getTokenMetadata(q.read) : null !
+    };
+  }
+
+  private _reportError(error: any, type?: any, otherType?: any) {
+    if (this._errorCollector) {
+      this._errorCollector(error, type);
+      if (otherType) {
+        this._errorCollector(error, otherType);
+      }
+    } else {
+      throw error;
+    }
+  }
+}
+
+function flattenArray(tree: any[], out: Array<any> = []): Array<any> {
+  if (tree) {
+    for (let i = 0; i < tree.length; i++) {
+      const item = resolveForwardRef(tree[i]);
+      if (Array.isArray(item)) {
+        flattenArray(item, out);
+      } else {
+        out.push(item);
+      }
+    }
+  }
+  return out;
+}
+
+function dedupeArray(array: any[]): Array<any> {
+  if (array) {
+    return Array.from(new Set(array));
+  }
+  return [];
+}
+
+function flattenAndDedupeArray(tree: any[]): Array<any> {
+  return dedupeArray(flattenArray(tree));
+}
+
+function isValidType(value: any): boolean {
+  return (value instanceof StaticSymbol) || (value instanceof Type);
+}
+
+function extractIdentifiers(value: any, targetIdentifiers: cpl.CompileIdentifierMetadata[]) {
+  visitValue(value, new _CompileValueConverter(), targetIdentifiers);
+}
+
+class _CompileValueConverter extends ValueTransformer {
+  visitOther(value: any, targetIdentifiers: cpl.CompileIdentifierMetadata[]): any {
+    targetIdentifiers.push({reference: value});
+  }
+}
+
+function stringifyType(type: any): string {
+  if (type instanceof StaticSymbol) {
+    return `${type.name} in ${type.filePath}`;
+  } else {
+    return stringify(type);
+  }
+}
+
+/**
+ * Indicates that a component is still being loaded in a synchronous compile.
+ */
+function componentStillLoadingError(compType: Type) {
+  const error =
+      Error(`Can't compile synchronously as ${stringify(compType)} is still being loaded!`);
+  (error as any)[ERROR_COMPONENT_TYPE] = compType;
+  return error;
+}
diff --git a/angular/compiler/src/ml_parser/ast.ts b/angular/compiler/src/ml_parser/ast.ts
new file mode 100644
index 0000000..3bd8742
--- /dev/null
+++ b/angular/compiler/src/ml_parser/ast.ts
@@ -0,0 +1,150 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {AstPath} from '../ast_path';
+import {ParseSourceSpan} from '../parse_util';
+
+export interface Node {
+  sourceSpan: ParseSourceSpan;
+  visit(visitor: Visitor, context: any): any;
+}
+
+export class Text implements Node {
+  constructor(public value: string, public sourceSpan: ParseSourceSpan) {}
+  visit(visitor: Visitor, context: any): any { return visitor.visitText(this, context); }
+}
+
+export class Expansion implements Node {
+  constructor(
+      public switchValue: string, public type: string, public cases: ExpansionCase[],
+      public sourceSpan: ParseSourceSpan, public switchValueSourceSpan: ParseSourceSpan) {}
+  visit(visitor: Visitor, context: any): any { return visitor.visitExpansion(this, context); }
+}
+
+export class ExpansionCase implements Node {
+  constructor(
+      public value: string, public expression: Node[], public sourceSpan: ParseSourceSpan,
+      public valueSourceSpan: ParseSourceSpan, public expSourceSpan: ParseSourceSpan) {}
+
+  visit(visitor: Visitor, context: any): any { return visitor.visitExpansionCase(this, context); }
+}
+
+export class Attribute implements Node {
+  constructor(
+      public name: string, public value: string, public sourceSpan: ParseSourceSpan,
+      public valueSpan?: ParseSourceSpan) {}
+  visit(visitor: Visitor, context: any): any { return visitor.visitAttribute(this, context); }
+}
+
+export class Element implements Node {
+  constructor(
+      public name: string, public attrs: Attribute[], public children: Node[],
+      public sourceSpan: ParseSourceSpan, public startSourceSpan: ParseSourceSpan|null = null,
+      public endSourceSpan: ParseSourceSpan|null = null) {}
+  visit(visitor: Visitor, context: any): any { return visitor.visitElement(this, context); }
+}
+
+export class Comment implements Node {
+  constructor(public value: string|null, public sourceSpan: ParseSourceSpan) {}
+  visit(visitor: Visitor, context: any): any { return visitor.visitComment(this, context); }
+}
+
+export interface Visitor {
+  // Returning a truthy value from `visit()` will prevent `visitAll()` from the call to the typed
+  // method and result returned will become the result included in `visitAll()`s result array.
+  visit?(node: Node, context: any): any;
+
+  visitElement(element: Element, context: any): any;
+  visitAttribute(attribute: Attribute, context: any): any;
+  visitText(text: Text, context: any): any;
+  visitComment(comment: Comment, context: any): any;
+  visitExpansion(expansion: Expansion, context: any): any;
+  visitExpansionCase(expansionCase: ExpansionCase, context: any): any;
+}
+
+export function visitAll(visitor: Visitor, nodes: Node[], context: any = null): any[] {
+  const result: any[] = [];
+
+  const visit = visitor.visit ?
+      (ast: Node) => visitor.visit !(ast, context) || ast.visit(visitor, context) :
+      (ast: Node) => ast.visit(visitor, context);
+  nodes.forEach(ast => {
+    const astResult = visit(ast);
+    if (astResult) {
+      result.push(astResult);
+    }
+  });
+  return result;
+}
+
+export class RecursiveVisitor implements Visitor {
+  constructor() {}
+
+  visitElement(ast: Element, context: any): any {
+    this.visitChildren(context, visit => {
+      visit(ast.attrs);
+      visit(ast.children);
+    });
+  }
+
+  visitAttribute(ast: Attribute, context: any): any {}
+  visitText(ast: Text, context: any): any {}
+  visitComment(ast: Comment, context: any): any {}
+
+  visitExpansion(ast: Expansion, context: any): any {
+    return this.visitChildren(context, visit => { visit(ast.cases); });
+  }
+
+  visitExpansionCase(ast: ExpansionCase, context: any): any {}
+
+  private visitChildren<T extends Node>(
+      context: any, cb: (visit: (<V extends Node>(children: V[]|undefined) => void)) => void) {
+    let results: any[][] = [];
+    let t = this;
+    function visit<T extends Node>(children: T[] | undefined) {
+      if (children) results.push(visitAll(t, children, context));
+    }
+    cb(visit);
+    return [].concat.apply([], results);
+  }
+}
+
+export type HtmlAstPath = AstPath<Node>;
+
+function spanOf(ast: Node) {
+  const start = ast.sourceSpan.start.offset;
+  let end = ast.sourceSpan.end.offset;
+  if (ast instanceof Element) {
+    if (ast.endSourceSpan) {
+      end = ast.endSourceSpan.end.offset;
+    } else if (ast.children && ast.children.length) {
+      end = spanOf(ast.children[ast.children.length - 1]).end;
+    }
+  }
+  return {start, end};
+}
+
+export function findNode(nodes: Node[], position: number): HtmlAstPath {
+  const path: Node[] = [];
+
+  const visitor = new class extends RecursiveVisitor {
+    visit(ast: Node, context: any): any {
+      const span = spanOf(ast);
+      if (span.start <= position && position < span.end) {
+        path.push(ast);
+      } else {
+        // Returning a value here will result in the children being skipped.
+        return true;
+      }
+    }
+  };
+
+  visitAll(visitor, nodes);
+
+  return new AstPath<Node>(path, position);
+}
\ No newline at end of file
diff --git a/angular/compiler/src/ml_parser/html_parser.ts b/angular/compiler/src/ml_parser/html_parser.ts
new file mode 100644
index 0000000..60702f2
--- /dev/null
+++ b/angular/compiler/src/ml_parser/html_parser.ts
@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {getHtmlTagDefinition} from './html_tags';
+import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from './interpolation_config';
+import {ParseTreeResult, Parser} from './parser';
+
+export {ParseTreeResult, TreeError} from './parser';
+
+export class HtmlParser extends Parser {
+  constructor() { super(getHtmlTagDefinition); }
+
+  parse(
+      source: string, url: string, parseExpansionForms: boolean = false,
+      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ParseTreeResult {
+    return super.parse(source, url, parseExpansionForms, interpolationConfig);
+  }
+}
diff --git a/angular/compiler/src/ml_parser/html_tags.ts b/angular/compiler/src/ml_parser/html_tags.ts
new file mode 100644
index 0000000..351265b
--- /dev/null
+++ b/angular/compiler/src/ml_parser/html_tags.ts
@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {TagContentType, TagDefinition} from './tags';
+
+export class HtmlTagDefinition implements TagDefinition {
+  private closedByChildren: {[key: string]: boolean} = {};
+
+  closedByParent: boolean = false;
+  requiredParents: {[key: string]: boolean};
+  parentToAdd: string;
+  implicitNamespacePrefix: string|null;
+  contentType: TagContentType;
+  isVoid: boolean;
+  ignoreFirstLf: boolean;
+  canSelfClose: boolean = false;
+
+  constructor(
+      {closedByChildren, requiredParents, implicitNamespacePrefix,
+       contentType = TagContentType.PARSABLE_DATA, closedByParent = false, isVoid = false,
+       ignoreFirstLf = false}: {
+        closedByChildren?: string[],
+        closedByParent?: boolean,
+        requiredParents?: string[],
+        implicitNamespacePrefix?: string,
+        contentType?: TagContentType,
+        isVoid?: boolean,
+        ignoreFirstLf?: boolean
+      } = {}) {
+    if (closedByChildren && closedByChildren.length > 0) {
+      closedByChildren.forEach(tagName => this.closedByChildren[tagName] = true);
+    }
+    this.isVoid = isVoid;
+    this.closedByParent = closedByParent || isVoid;
+    if (requiredParents && requiredParents.length > 0) {
+      this.requiredParents = {};
+      // The first parent is the list is automatically when none of the listed parents are present
+      this.parentToAdd = requiredParents[0];
+      requiredParents.forEach(tagName => this.requiredParents[tagName] = true);
+    }
+    this.implicitNamespacePrefix = implicitNamespacePrefix || null;
+    this.contentType = contentType;
+    this.ignoreFirstLf = ignoreFirstLf;
+  }
+
+  requireExtraParent(currentParent: string): boolean {
+    if (!this.requiredParents) {
+      return false;
+    }
+
+    if (!currentParent) {
+      return true;
+    }
+
+    const lcParent = currentParent.toLowerCase();
+    const isParentTemplate = lcParent === 'template' || currentParent === 'ng-template';
+    return !isParentTemplate && this.requiredParents[lcParent] != true;
+  }
+
+  isClosedByChild(name: string): boolean {
+    return this.isVoid || name.toLowerCase() in this.closedByChildren;
+  }
+}
+
+// see http://www.w3.org/TR/html51/syntax.html#optional-tags
+// This implementation does not fully conform to the HTML5 spec.
+const TAG_DEFINITIONS: {[key: string]: HtmlTagDefinition} = {
+  'base': new HtmlTagDefinition({isVoid: true}),
+  'meta': new HtmlTagDefinition({isVoid: true}),
+  'area': new HtmlTagDefinition({isVoid: true}),
+  'embed': new HtmlTagDefinition({isVoid: true}),
+  'link': new HtmlTagDefinition({isVoid: true}),
+  'img': new HtmlTagDefinition({isVoid: true}),
+  'input': new HtmlTagDefinition({isVoid: true}),
+  'param': new HtmlTagDefinition({isVoid: true}),
+  'hr': new HtmlTagDefinition({isVoid: true}),
+  'br': new HtmlTagDefinition({isVoid: true}),
+  'source': new HtmlTagDefinition({isVoid: true}),
+  'track': new HtmlTagDefinition({isVoid: true}),
+  'wbr': new HtmlTagDefinition({isVoid: true}),
+  'p': new HtmlTagDefinition({
+    closedByChildren: [
+      'address', 'article', 'aside', 'blockquote', 'div', 'dl',      'fieldset', 'footer', 'form',
+      'h1',      'h2',      'h3',    'h4',         'h5',  'h6',      'header',   'hgroup', 'hr',
+      'main',    'nav',     'ol',    'p',          'pre', 'section', 'table',    'ul'
+    ],
+    closedByParent: true
+  }),
+  'thead': new HtmlTagDefinition({closedByChildren: ['tbody', 'tfoot']}),
+  'tbody': new HtmlTagDefinition({closedByChildren: ['tbody', 'tfoot'], closedByParent: true}),
+  'tfoot': new HtmlTagDefinition({closedByChildren: ['tbody'], closedByParent: true}),
+  'tr': new HtmlTagDefinition({
+    closedByChildren: ['tr'],
+    requiredParents: ['tbody', 'tfoot', 'thead'],
+    closedByParent: true
+  }),
+  'td': new HtmlTagDefinition({closedByChildren: ['td', 'th'], closedByParent: true}),
+  'th': new HtmlTagDefinition({closedByChildren: ['td', 'th'], closedByParent: true}),
+  'col': new HtmlTagDefinition({requiredParents: ['colgroup'], isVoid: true}),
+  'svg': new HtmlTagDefinition({implicitNamespacePrefix: 'svg'}),
+  'math': new HtmlTagDefinition({implicitNamespacePrefix: 'math'}),
+  'li': new HtmlTagDefinition({closedByChildren: ['li'], closedByParent: true}),
+  'dt': new HtmlTagDefinition({closedByChildren: ['dt', 'dd']}),
+  'dd': new HtmlTagDefinition({closedByChildren: ['dt', 'dd'], closedByParent: true}),
+  'rb': new HtmlTagDefinition({closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true}),
+  'rt': new HtmlTagDefinition({closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true}),
+  'rtc': new HtmlTagDefinition({closedByChildren: ['rb', 'rtc', 'rp'], closedByParent: true}),
+  'rp': new HtmlTagDefinition({closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true}),
+  'optgroup': new HtmlTagDefinition({closedByChildren: ['optgroup'], closedByParent: true}),
+  'option': new HtmlTagDefinition({closedByChildren: ['option', 'optgroup'], closedByParent: true}),
+  'pre': new HtmlTagDefinition({ignoreFirstLf: true}),
+  'listing': new HtmlTagDefinition({ignoreFirstLf: true}),
+  'style': new HtmlTagDefinition({contentType: TagContentType.RAW_TEXT}),
+  'script': new HtmlTagDefinition({contentType: TagContentType.RAW_TEXT}),
+  'title': new HtmlTagDefinition({contentType: TagContentType.ESCAPABLE_RAW_TEXT}),
+  'textarea':
+      new HtmlTagDefinition({contentType: TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true}),
+};
+
+const _DEFAULT_TAG_DEFINITION = new HtmlTagDefinition();
+
+export function getHtmlTagDefinition(tagName: string): HtmlTagDefinition {
+  return TAG_DEFINITIONS[tagName.toLowerCase()] || _DEFAULT_TAG_DEFINITION;
+}
diff --git a/angular/compiler/src/ml_parser/html_whitespaces.ts b/angular/compiler/src/ml_parser/html_whitespaces.ts
new file mode 100644
index 0000000..f2cd01f
--- /dev/null
+++ b/angular/compiler/src/ml_parser/html_whitespaces.ts
@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as html from './ast';
+import {ParseTreeResult} from './parser';
+import {NGSP_UNICODE} from './tags';
+
+export const PRESERVE_WS_ATTR_NAME = 'ngPreserveWhitespaces';
+
+const SKIP_WS_TRIM_TAGS = new Set(['pre', 'template', 'textarea', 'script', 'style']);
+
+function hasPreserveWhitespacesAttr(attrs: html.Attribute[]): boolean {
+  return attrs.some((attr: html.Attribute) => attr.name === PRESERVE_WS_ATTR_NAME);
+}
+
+/**
+ * This visitor can walk HTML parse tree and remove / trim text nodes using the following rules:
+ * - consider spaces, tabs and new lines as whitespace characters;
+ * - drop text nodes consisting of whitespace characters only;
+ * - for all other text nodes replace consecutive whitespace characters with one space;
+ * - convert &ngsp; pseudo-entity to a single space;
+ *
+ * The idea of using &ngsp; as a placeholder for non-removable space was originally introduced in
+ * Angular Dart, see:
+ * https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart#L25-L32
+ * In Angular Dart &ngsp; is converted to the 0xE500 PUA (Private Use Areas) unicode character
+ * and later on replaced by a space. We are re-implementing the same idea here.
+ *
+ * Removal and trimming of whitespaces have positive performance impact (less code to generate
+ * while compiling templates, faster view creation). At the same time it can be "destructive"
+ * in some cases (whitespaces can influence layout). Becouse of the potential of breaking layout
+ * this visitor is not activated by default in Angular 5 and people need to explicitly opt-in for
+ * whitespace removal. The default option for whitespace removal will be revisited in Angular 6
+ * and might be changed to "on" by default.
+ */
+class WhitespaceVisitor implements html.Visitor {
+  visitElement(element: html.Element, context: any): any {
+    if (SKIP_WS_TRIM_TAGS.has(element.name) || hasPreserveWhitespacesAttr(element.attrs)) {
+      // don't descent into elements where we need to preserve whitespaces
+      // but still visit all attributes to eliminate one used as a market to preserve WS
+      return new html.Element(
+          element.name, html.visitAll(this, element.attrs), element.children, element.sourceSpan,
+          element.startSourceSpan, element.endSourceSpan);
+    }
+
+    return new html.Element(
+        element.name, element.attrs, html.visitAll(this, element.children), element.sourceSpan,
+        element.startSourceSpan, element.endSourceSpan);
+  }
+
+  visitAttribute(attribute: html.Attribute, context: any): any {
+    return attribute.name !== PRESERVE_WS_ATTR_NAME ? attribute : null;
+  }
+
+  visitText(text: html.Text, context: any): any {
+    const isBlank = text.value.trim().length === 0;
+
+    if (!isBlank) {
+      // lexer is replacing the &ngsp; pseudo-entity with NGSP_UNICODE
+      return new html.Text(
+          text.value.replace(NGSP_UNICODE, ' ').replace(/\s\s+/g, ' '), text.sourceSpan);
+    }
+
+    return null;
+  }
+
+  visitComment(comment: html.Comment, context: any): any { return comment; }
+
+  visitExpansion(expansion: html.Expansion, context: any): any { return expansion; }
+
+  visitExpansionCase(expansionCase: html.ExpansionCase, context: any): any { return expansionCase; }
+}
+
+export function removeWhitespaces(htmlAstWithErrors: ParseTreeResult): ParseTreeResult {
+  return new ParseTreeResult(
+      html.visitAll(new WhitespaceVisitor(), htmlAstWithErrors.rootNodes),
+      htmlAstWithErrors.errors);
+}
diff --git a/angular/compiler/src/ml_parser/icu_ast_expander.ts b/angular/compiler/src/ml_parser/icu_ast_expander.ts
new file mode 100644
index 0000000..3e7d5d1
--- /dev/null
+++ b/angular/compiler/src/ml_parser/icu_ast_expander.ts
@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ParseError, ParseSourceSpan} from '../parse_util';
+
+import * as html from './ast';
+
+// http://cldr.unicode.org/index/cldr-spec/plural-rules
+const PLURAL_CASES: string[] = ['zero', 'one', 'two', 'few', 'many', 'other'];
+
+/**
+ * Expands special forms into elements.
+ *
+ * For example,
+ *
+ * ```
+ * { messages.length, plural,
+ *   =0 {zero}
+ *   =1 {one}
+ *   other {more than one}
+ * }
+ * ```
+ *
+ * will be expanded into
+ *
+ * ```
+ * <ng-container [ngPlural]="messages.length">
+ *   <ng-template ngPluralCase="=0">zero</ng-template>
+ *   <ng-template ngPluralCase="=1">one</ng-template>
+ *   <ng-template ngPluralCase="other">more than one</ng-template>
+ * </ng-container>
+ * ```
+ */
+export function expandNodes(nodes: html.Node[]): ExpansionResult {
+  const expander = new _Expander();
+  return new ExpansionResult(html.visitAll(expander, nodes), expander.isExpanded, expander.errors);
+}
+
+export class ExpansionResult {
+  constructor(public nodes: html.Node[], public expanded: boolean, public errors: ParseError[]) {}
+}
+
+export class ExpansionError extends ParseError {
+  constructor(span: ParseSourceSpan, errorMsg: string) { super(span, errorMsg); }
+}
+
+/**
+ * Expand expansion forms (plural, select) to directives
+ *
+ * @internal
+ */
+class _Expander implements html.Visitor {
+  isExpanded: boolean = false;
+  errors: ParseError[] = [];
+
+  visitElement(element: html.Element, context: any): any {
+    return new html.Element(
+        element.name, element.attrs, html.visitAll(this, element.children), element.sourceSpan,
+        element.startSourceSpan, element.endSourceSpan);
+  }
+
+  visitAttribute(attribute: html.Attribute, context: any): any { return attribute; }
+
+  visitText(text: html.Text, context: any): any { return text; }
+
+  visitComment(comment: html.Comment, context: any): any { return comment; }
+
+  visitExpansion(icu: html.Expansion, context: any): any {
+    this.isExpanded = true;
+    return icu.type == 'plural' ? _expandPluralForm(icu, this.errors) :
+                                  _expandDefaultForm(icu, this.errors);
+  }
+
+  visitExpansionCase(icuCase: html.ExpansionCase, context: any): any {
+    throw new Error('Should not be reached');
+  }
+}
+
+// Plural forms are expanded to `NgPlural` and `NgPluralCase`s
+function _expandPluralForm(ast: html.Expansion, errors: ParseError[]): html.Element {
+  const children = ast.cases.map(c => {
+    if (PLURAL_CASES.indexOf(c.value) == -1 && !c.value.match(/^=\d+$/)) {
+      errors.push(new ExpansionError(
+          c.valueSourceSpan,
+          `Plural cases should be "=<number>" or one of ${PLURAL_CASES.join(", ")}`));
+    }
+
+    const expansionResult = expandNodes(c.expression);
+    errors.push(...expansionResult.errors);
+
+    return new html.Element(
+        `ng-template`, [new html.Attribute('ngPluralCase', `${c.value}`, c.valueSourceSpan)],
+        expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);
+  });
+  const switchAttr = new html.Attribute('[ngPlural]', ast.switchValue, ast.switchValueSourceSpan);
+  return new html.Element(
+      'ng-container', [switchAttr], children, ast.sourceSpan, ast.sourceSpan, ast.sourceSpan);
+}
+
+// ICU messages (excluding plural form) are expanded to `NgSwitch`  and `NgSwitchCase`s
+function _expandDefaultForm(ast: html.Expansion, errors: ParseError[]): html.Element {
+  const children = ast.cases.map(c => {
+    const expansionResult = expandNodes(c.expression);
+    errors.push(...expansionResult.errors);
+
+    if (c.value === 'other') {
+      // other is the default case when no values match
+      return new html.Element(
+          `ng-template`, [new html.Attribute('ngSwitchDefault', '', c.valueSourceSpan)],
+          expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);
+    }
+
+    return new html.Element(
+        `ng-template`, [new html.Attribute('ngSwitchCase', `${c.value}`, c.valueSourceSpan)],
+        expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);
+  });
+  const switchAttr = new html.Attribute('[ngSwitch]', ast.switchValue, ast.switchValueSourceSpan);
+  return new html.Element(
+      'ng-container', [switchAttr], children, ast.sourceSpan, ast.sourceSpan, ast.sourceSpan);
+}
diff --git a/angular/compiler/src/ml_parser/interpolation_config.ts b/angular/compiler/src/ml_parser/interpolation_config.ts
new file mode 100644
index 0000000..7390a80
--- /dev/null
+++ b/angular/compiler/src/ml_parser/interpolation_config.ts
@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {assertInterpolationSymbols} from '../assertions';
+
+export class InterpolationConfig {
+  static fromArray(markers: [string, string]|null): InterpolationConfig {
+    if (!markers) {
+      return DEFAULT_INTERPOLATION_CONFIG;
+    }
+
+    assertInterpolationSymbols('interpolation', markers);
+    return new InterpolationConfig(markers[0], markers[1]);
+  }
+
+  constructor(public start: string, public end: string){};
+}
+
+export const DEFAULT_INTERPOLATION_CONFIG: InterpolationConfig =
+    new InterpolationConfig('{{', '}}');
diff --git a/angular/compiler/src/ml_parser/lexer.ts b/angular/compiler/src/ml_parser/lexer.ts
new file mode 100644
index 0000000..28adb6e
--- /dev/null
+++ b/angular/compiler/src/ml_parser/lexer.ts
@@ -0,0 +1,713 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as chars from '../chars';
+import {ParseError, ParseLocation, ParseSourceFile, ParseSourceSpan} from '../parse_util';
+
+import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from './interpolation_config';
+import {NAMED_ENTITIES, TagContentType, TagDefinition} from './tags';
+
+export enum TokenType {
+  TAG_OPEN_START,
+  TAG_OPEN_END,
+  TAG_OPEN_END_VOID,
+  TAG_CLOSE,
+  TEXT,
+  ESCAPABLE_RAW_TEXT,
+  RAW_TEXT,
+  COMMENT_START,
+  COMMENT_END,
+  CDATA_START,
+  CDATA_END,
+  ATTR_NAME,
+  ATTR_VALUE,
+  DOC_TYPE,
+  EXPANSION_FORM_START,
+  EXPANSION_CASE_VALUE,
+  EXPANSION_CASE_EXP_START,
+  EXPANSION_CASE_EXP_END,
+  EXPANSION_FORM_END,
+  EOF
+}
+
+export class Token {
+  constructor(public type: TokenType, public parts: string[], public sourceSpan: ParseSourceSpan) {}
+}
+
+export class TokenError extends ParseError {
+  constructor(errorMsg: string, public tokenType: TokenType, span: ParseSourceSpan) {
+    super(span, errorMsg);
+  }
+}
+
+export class TokenizeResult {
+  constructor(public tokens: Token[], public errors: TokenError[]) {}
+}
+
+export function tokenize(
+    source: string, url: string, getTagDefinition: (tagName: string) => TagDefinition,
+    tokenizeExpansionForms: boolean = false,
+    interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): TokenizeResult {
+  return new _Tokenizer(
+             new ParseSourceFile(source, url), getTagDefinition, tokenizeExpansionForms,
+             interpolationConfig)
+      .tokenize();
+}
+
+const _CR_OR_CRLF_REGEXP = /\r\n?/g;
+
+function _unexpectedCharacterErrorMsg(charCode: number): string {
+  const char = charCode === chars.$EOF ? 'EOF' : String.fromCharCode(charCode);
+  return `Unexpected character "${char}"`;
+}
+
+function _unknownEntityErrorMsg(entitySrc: string): string {
+  return `Unknown entity "${entitySrc}" - use the "&#<decimal>;" or  "&#x<hex>;" syntax`;
+}
+
+class _ControlFlowError {
+  constructor(public error: TokenError) {}
+}
+
+// See http://www.w3.org/TR/html51/syntax.html#writing
+class _Tokenizer {
+  private _input: string;
+  private _length: number;
+  // Note: this is always lowercase!
+  private _peek: number = -1;
+  private _nextPeek: number = -1;
+  private _index: number = -1;
+  private _line: number = 0;
+  private _column: number = -1;
+  private _currentTokenStart: ParseLocation;
+  private _currentTokenType: TokenType;
+  private _expansionCaseStack: TokenType[] = [];
+  private _inInterpolation: boolean = false;
+
+  tokens: Token[] = [];
+  errors: TokenError[] = [];
+
+  /**
+   * @param _file The html source
+   * @param _getTagDefinition
+   * @param _tokenizeIcu Whether to tokenize ICU messages (considered as text nodes when false)
+   * @param _interpolationConfig
+   */
+  constructor(
+      private _file: ParseSourceFile, private _getTagDefinition: (tagName: string) => TagDefinition,
+      private _tokenizeIcu: boolean,
+      private _interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    this._input = _file.content;
+    this._length = _file.content.length;
+    this._advance();
+  }
+
+  private _processCarriageReturns(content: string): string {
+    // http://www.w3.org/TR/html5/syntax.html#preprocessing-the-input-stream
+    // In order to keep the original position in the source, we can not
+    // pre-process it.
+    // Instead CRs are processed right before instantiating the tokens.
+    return content.replace(_CR_OR_CRLF_REGEXP, '\n');
+  }
+
+  tokenize(): TokenizeResult {
+    while (this._peek !== chars.$EOF) {
+      const start = this._getLocation();
+      try {
+        if (this._attemptCharCode(chars.$LT)) {
+          if (this._attemptCharCode(chars.$BANG)) {
+            if (this._attemptCharCode(chars.$LBRACKET)) {
+              this._consumeCdata(start);
+            } else if (this._attemptCharCode(chars.$MINUS)) {
+              this._consumeComment(start);
+            } else {
+              this._consumeDocType(start);
+            }
+          } else if (this._attemptCharCode(chars.$SLASH)) {
+            this._consumeTagClose(start);
+          } else {
+            this._consumeTagOpen(start);
+          }
+        } else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {
+          this._consumeText();
+        }
+      } catch (e) {
+        if (e instanceof _ControlFlowError) {
+          this.errors.push(e.error);
+        } else {
+          throw e;
+        }
+      }
+    }
+    this._beginToken(TokenType.EOF);
+    this._endToken([]);
+    return new TokenizeResult(mergeTextTokens(this.tokens), this.errors);
+  }
+
+  /**
+   * @returns whether an ICU token has been created
+   * @internal
+   */
+  private _tokenizeExpansionForm(): boolean {
+    if (isExpansionFormStart(this._input, this._index, this._interpolationConfig)) {
+      this._consumeExpansionFormStart();
+      return true;
+    }
+
+    if (isExpansionCaseStart(this._peek) && this._isInExpansionForm()) {
+      this._consumeExpansionCaseStart();
+      return true;
+    }
+
+    if (this._peek === chars.$RBRACE) {
+      if (this._isInExpansionCase()) {
+        this._consumeExpansionCaseEnd();
+        return true;
+      }
+
+      if (this._isInExpansionForm()) {
+        this._consumeExpansionFormEnd();
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  private _getLocation(): ParseLocation {
+    return new ParseLocation(this._file, this._index, this._line, this._column);
+  }
+
+  private _getSpan(
+      start: ParseLocation = this._getLocation(),
+      end: ParseLocation = this._getLocation()): ParseSourceSpan {
+    return new ParseSourceSpan(start, end);
+  }
+
+  private _beginToken(type: TokenType, start: ParseLocation = this._getLocation()) {
+    this._currentTokenStart = start;
+    this._currentTokenType = type;
+  }
+
+  private _endToken(parts: string[], end: ParseLocation = this._getLocation()): Token {
+    const token =
+        new Token(this._currentTokenType, parts, new ParseSourceSpan(this._currentTokenStart, end));
+    this.tokens.push(token);
+    this._currentTokenStart = null !;
+    this._currentTokenType = null !;
+    return token;
+  }
+
+  private _createError(msg: string, span: ParseSourceSpan): _ControlFlowError {
+    if (this._isInExpansionForm()) {
+      msg += ` (Do you have an unescaped "{" in your template? Use "{{ '{' }}") to escape it.)`;
+    }
+    const error = new TokenError(msg, this._currentTokenType, span);
+    this._currentTokenStart = null !;
+    this._currentTokenType = null !;
+    return new _ControlFlowError(error);
+  }
+
+  private _advance() {
+    if (this._index >= this._length) {
+      throw this._createError(_unexpectedCharacterErrorMsg(chars.$EOF), this._getSpan());
+    }
+    if (this._peek === chars.$LF) {
+      this._line++;
+      this._column = 0;
+    } else if (this._peek !== chars.$LF && this._peek !== chars.$CR) {
+      this._column++;
+    }
+    this._index++;
+    this._peek = this._index >= this._length ? chars.$EOF : this._input.charCodeAt(this._index);
+    this._nextPeek =
+        this._index + 1 >= this._length ? chars.$EOF : this._input.charCodeAt(this._index + 1);
+  }
+
+  private _attemptCharCode(charCode: number): boolean {
+    if (this._peek === charCode) {
+      this._advance();
+      return true;
+    }
+    return false;
+  }
+
+  private _attemptCharCodeCaseInsensitive(charCode: number): boolean {
+    if (compareCharCodeCaseInsensitive(this._peek, charCode)) {
+      this._advance();
+      return true;
+    }
+    return false;
+  }
+
+  private _requireCharCode(charCode: number) {
+    const location = this._getLocation();
+    if (!this._attemptCharCode(charCode)) {
+      throw this._createError(
+          _unexpectedCharacterErrorMsg(this._peek), this._getSpan(location, location));
+    }
+  }
+
+  private _attemptStr(chars: string): boolean {
+    const len = chars.length;
+    if (this._index + len > this._length) {
+      return false;
+    }
+    const initialPosition = this._savePosition();
+    for (let i = 0; i < len; i++) {
+      if (!this._attemptCharCode(chars.charCodeAt(i))) {
+        // If attempting to parse the string fails, we want to reset the parser
+        // to where it was before the attempt
+        this._restorePosition(initialPosition);
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private _attemptStrCaseInsensitive(chars: string): boolean {
+    for (let i = 0; i < chars.length; i++) {
+      if (!this._attemptCharCodeCaseInsensitive(chars.charCodeAt(i))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private _requireStr(chars: string) {
+    const location = this._getLocation();
+    if (!this._attemptStr(chars)) {
+      throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan(location));
+    }
+  }
+
+  private _attemptCharCodeUntilFn(predicate: (code: number) => boolean) {
+    while (!predicate(this._peek)) {
+      this._advance();
+    }
+  }
+
+  private _requireCharCodeUntilFn(predicate: (code: number) => boolean, len: number) {
+    const start = this._getLocation();
+    this._attemptCharCodeUntilFn(predicate);
+    if (this._index - start.offset < len) {
+      throw this._createError(
+          _unexpectedCharacterErrorMsg(this._peek), this._getSpan(start, start));
+    }
+  }
+
+  private _attemptUntilChar(char: number) {
+    while (this._peek !== char) {
+      this._advance();
+    }
+  }
+
+  private _readChar(decodeEntities: boolean): string {
+    if (decodeEntities && this._peek === chars.$AMPERSAND) {
+      return this._decodeEntity();
+    } else {
+      const index = this._index;
+      this._advance();
+      return this._input[index];
+    }
+  }
+
+  private _decodeEntity(): string {
+    const start = this._getLocation();
+    this._advance();
+    if (this._attemptCharCode(chars.$HASH)) {
+      const isHex = this._attemptCharCode(chars.$x) || this._attemptCharCode(chars.$X);
+      const numberStart = this._getLocation().offset;
+      this._attemptCharCodeUntilFn(isDigitEntityEnd);
+      if (this._peek != chars.$SEMICOLON) {
+        throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan());
+      }
+      this._advance();
+      const strNum = this._input.substring(numberStart, this._index - 1);
+      try {
+        const charCode = parseInt(strNum, isHex ? 16 : 10);
+        return String.fromCharCode(charCode);
+      } catch (e) {
+        const entity = this._input.substring(start.offset + 1, this._index - 1);
+        throw this._createError(_unknownEntityErrorMsg(entity), this._getSpan(start));
+      }
+    } else {
+      const startPosition = this._savePosition();
+      this._attemptCharCodeUntilFn(isNamedEntityEnd);
+      if (this._peek != chars.$SEMICOLON) {
+        this._restorePosition(startPosition);
+        return '&';
+      }
+      this._advance();
+      const name = this._input.substring(start.offset + 1, this._index - 1);
+      const char = NAMED_ENTITIES[name];
+      if (!char) {
+        throw this._createError(_unknownEntityErrorMsg(name), this._getSpan(start));
+      }
+      return char;
+    }
+  }
+
+  private _consumeRawText(
+      decodeEntities: boolean, firstCharOfEnd: number, attemptEndRest: () => boolean): Token {
+    let tagCloseStart: ParseLocation;
+    const textStart = this._getLocation();
+    this._beginToken(decodeEntities ? TokenType.ESCAPABLE_RAW_TEXT : TokenType.RAW_TEXT, textStart);
+    const parts: string[] = [];
+    while (true) {
+      tagCloseStart = this._getLocation();
+      if (this._attemptCharCode(firstCharOfEnd) && attemptEndRest()) {
+        break;
+      }
+      if (this._index > tagCloseStart.offset) {
+        // add the characters consumed by the previous if statement to the output
+        parts.push(this._input.substring(tagCloseStart.offset, this._index));
+      }
+      while (this._peek !== firstCharOfEnd) {
+        parts.push(this._readChar(decodeEntities));
+      }
+    }
+    return this._endToken([this._processCarriageReturns(parts.join(''))], tagCloseStart);
+  }
+
+  private _consumeComment(start: ParseLocation) {
+    this._beginToken(TokenType.COMMENT_START, start);
+    this._requireCharCode(chars.$MINUS);
+    this._endToken([]);
+    const textToken = this._consumeRawText(false, chars.$MINUS, () => this._attemptStr('->'));
+    this._beginToken(TokenType.COMMENT_END, textToken.sourceSpan.end);
+    this._endToken([]);
+  }
+
+  private _consumeCdata(start: ParseLocation) {
+    this._beginToken(TokenType.CDATA_START, start);
+    this._requireStr('CDATA[');
+    this._endToken([]);
+    const textToken = this._consumeRawText(false, chars.$RBRACKET, () => this._attemptStr(']>'));
+    this._beginToken(TokenType.CDATA_END, textToken.sourceSpan.end);
+    this._endToken([]);
+  }
+
+  private _consumeDocType(start: ParseLocation) {
+    this._beginToken(TokenType.DOC_TYPE, start);
+    this._attemptUntilChar(chars.$GT);
+    this._advance();
+    this._endToken([this._input.substring(start.offset + 2, this._index - 1)]);
+  }
+
+  private _consumePrefixAndName(): string[] {
+    const nameOrPrefixStart = this._index;
+    let prefix: string = null !;
+    while (this._peek !== chars.$COLON && !isPrefixEnd(this._peek)) {
+      this._advance();
+    }
+    let nameStart: number;
+    if (this._peek === chars.$COLON) {
+      this._advance();
+      prefix = this._input.substring(nameOrPrefixStart, this._index - 1);
+      nameStart = this._index;
+    } else {
+      nameStart = nameOrPrefixStart;
+    }
+    this._requireCharCodeUntilFn(isNameEnd, this._index === nameStart ? 1 : 0);
+    const name = this._input.substring(nameStart, this._index);
+    return [prefix, name];
+  }
+
+  private _consumeTagOpen(start: ParseLocation) {
+    const savedPos = this._savePosition();
+    let tagName: string;
+    let lowercaseTagName: string;
+    try {
+      if (!chars.isAsciiLetter(this._peek)) {
+        throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan());
+      }
+      const nameStart = this._index;
+      this._consumeTagOpenStart(start);
+      tagName = this._input.substring(nameStart, this._index);
+      lowercaseTagName = tagName.toLowerCase();
+      this._attemptCharCodeUntilFn(isNotWhitespace);
+      while (this._peek !== chars.$SLASH && this._peek !== chars.$GT) {
+        this._consumeAttributeName();
+        this._attemptCharCodeUntilFn(isNotWhitespace);
+        if (this._attemptCharCode(chars.$EQ)) {
+          this._attemptCharCodeUntilFn(isNotWhitespace);
+          this._consumeAttributeValue();
+        }
+        this._attemptCharCodeUntilFn(isNotWhitespace);
+      }
+      this._consumeTagOpenEnd();
+    } catch (e) {
+      if (e instanceof _ControlFlowError) {
+        // When the start tag is invalid, assume we want a "<"
+        this._restorePosition(savedPos);
+        // Back to back text tokens are merged at the end
+        this._beginToken(TokenType.TEXT, start);
+        this._endToken(['<']);
+        return;
+      }
+
+      throw e;
+    }
+
+    const contentTokenType = this._getTagDefinition(tagName).contentType;
+
+    if (contentTokenType === TagContentType.RAW_TEXT) {
+      this._consumeRawTextWithTagClose(lowercaseTagName, false);
+    } else if (contentTokenType === TagContentType.ESCAPABLE_RAW_TEXT) {
+      this._consumeRawTextWithTagClose(lowercaseTagName, true);
+    }
+  }
+
+  private _consumeRawTextWithTagClose(lowercaseTagName: string, decodeEntities: boolean) {
+    const textToken = this._consumeRawText(decodeEntities, chars.$LT, () => {
+      if (!this._attemptCharCode(chars.$SLASH)) return false;
+      this._attemptCharCodeUntilFn(isNotWhitespace);
+      if (!this._attemptStrCaseInsensitive(lowercaseTagName)) return false;
+      this._attemptCharCodeUntilFn(isNotWhitespace);
+      return this._attemptCharCode(chars.$GT);
+    });
+    this._beginToken(TokenType.TAG_CLOSE, textToken.sourceSpan.end);
+    this._endToken([null !, lowercaseTagName]);
+  }
+
+  private _consumeTagOpenStart(start: ParseLocation) {
+    this._beginToken(TokenType.TAG_OPEN_START, start);
+    const parts = this._consumePrefixAndName();
+    this._endToken(parts);
+  }
+
+  private _consumeAttributeName() {
+    this._beginToken(TokenType.ATTR_NAME);
+    const prefixAndName = this._consumePrefixAndName();
+    this._endToken(prefixAndName);
+  }
+
+  private _consumeAttributeValue() {
+    this._beginToken(TokenType.ATTR_VALUE);
+    let value: string;
+    if (this._peek === chars.$SQ || this._peek === chars.$DQ) {
+      const quoteChar = this._peek;
+      this._advance();
+      const parts: string[] = [];
+      while (this._peek !== quoteChar) {
+        parts.push(this._readChar(true));
+      }
+      value = parts.join('');
+      this._advance();
+    } else {
+      const valueStart = this._index;
+      this._requireCharCodeUntilFn(isNameEnd, 1);
+      value = this._input.substring(valueStart, this._index);
+    }
+    this._endToken([this._processCarriageReturns(value)]);
+  }
+
+  private _consumeTagOpenEnd() {
+    const tokenType =
+        this._attemptCharCode(chars.$SLASH) ? TokenType.TAG_OPEN_END_VOID : TokenType.TAG_OPEN_END;
+    this._beginToken(tokenType);
+    this._requireCharCode(chars.$GT);
+    this._endToken([]);
+  }
+
+  private _consumeTagClose(start: ParseLocation) {
+    this._beginToken(TokenType.TAG_CLOSE, start);
+    this._attemptCharCodeUntilFn(isNotWhitespace);
+    const prefixAndName = this._consumePrefixAndName();
+    this._attemptCharCodeUntilFn(isNotWhitespace);
+    this._requireCharCode(chars.$GT);
+    this._endToken(prefixAndName);
+  }
+
+  private _consumeExpansionFormStart() {
+    this._beginToken(TokenType.EXPANSION_FORM_START, this._getLocation());
+    this._requireCharCode(chars.$LBRACE);
+    this._endToken([]);
+
+    this._expansionCaseStack.push(TokenType.EXPANSION_FORM_START);
+
+    this._beginToken(TokenType.RAW_TEXT, this._getLocation());
+    const condition = this._readUntil(chars.$COMMA);
+    this._endToken([condition], this._getLocation());
+    this._requireCharCode(chars.$COMMA);
+    this._attemptCharCodeUntilFn(isNotWhitespace);
+
+    this._beginToken(TokenType.RAW_TEXT, this._getLocation());
+    const type = this._readUntil(chars.$COMMA);
+    this._endToken([type], this._getLocation());
+    this._requireCharCode(chars.$COMMA);
+    this._attemptCharCodeUntilFn(isNotWhitespace);
+  }
+
+  private _consumeExpansionCaseStart() {
+    this._beginToken(TokenType.EXPANSION_CASE_VALUE, this._getLocation());
+    const value = this._readUntil(chars.$LBRACE).trim();
+    this._endToken([value], this._getLocation());
+    this._attemptCharCodeUntilFn(isNotWhitespace);
+
+    this._beginToken(TokenType.EXPANSION_CASE_EXP_START, this._getLocation());
+    this._requireCharCode(chars.$LBRACE);
+    this._endToken([], this._getLocation());
+    this._attemptCharCodeUntilFn(isNotWhitespace);
+
+    this._expansionCaseStack.push(TokenType.EXPANSION_CASE_EXP_START);
+  }
+
+  private _consumeExpansionCaseEnd() {
+    this._beginToken(TokenType.EXPANSION_CASE_EXP_END, this._getLocation());
+    this._requireCharCode(chars.$RBRACE);
+    this._endToken([], this._getLocation());
+    this._attemptCharCodeUntilFn(isNotWhitespace);
+
+    this._expansionCaseStack.pop();
+  }
+
+  private _consumeExpansionFormEnd() {
+    this._beginToken(TokenType.EXPANSION_FORM_END, this._getLocation());
+    this._requireCharCode(chars.$RBRACE);
+    this._endToken([]);
+
+    this._expansionCaseStack.pop();
+  }
+
+  private _consumeText() {
+    const start = this._getLocation();
+    this._beginToken(TokenType.TEXT, start);
+    const parts: string[] = [];
+
+    do {
+      if (this._interpolationConfig && this._attemptStr(this._interpolationConfig.start)) {
+        parts.push(this._interpolationConfig.start);
+        this._inInterpolation = true;
+      } else if (
+          this._interpolationConfig && this._inInterpolation &&
+          this._attemptStr(this._interpolationConfig.end)) {
+        parts.push(this._interpolationConfig.end);
+        this._inInterpolation = false;
+      } else {
+        parts.push(this._readChar(true));
+      }
+    } while (!this._isTextEnd());
+
+    this._endToken([this._processCarriageReturns(parts.join(''))]);
+  }
+
+  private _isTextEnd(): boolean {
+    if (this._peek === chars.$LT || this._peek === chars.$EOF) {
+      return true;
+    }
+
+    if (this._tokenizeIcu && !this._inInterpolation) {
+      if (isExpansionFormStart(this._input, this._index, this._interpolationConfig)) {
+        // start of an expansion form
+        return true;
+      }
+
+      if (this._peek === chars.$RBRACE && this._isInExpansionCase()) {
+        // end of and expansion case
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  private _savePosition(): [number, number, number, number, number] {
+    return [this._peek, this._index, this._column, this._line, this.tokens.length];
+  }
+
+  private _readUntil(char: number): string {
+    const start = this._index;
+    this._attemptUntilChar(char);
+    return this._input.substring(start, this._index);
+  }
+
+  private _restorePosition(position: [number, number, number, number, number]): void {
+    this._peek = position[0];
+    this._index = position[1];
+    this._column = position[2];
+    this._line = position[3];
+    const nbTokens = position[4];
+    if (nbTokens < this.tokens.length) {
+      // remove any extra tokens
+      this.tokens = this.tokens.slice(0, nbTokens);
+    }
+  }
+
+  private _isInExpansionCase(): boolean {
+    return this._expansionCaseStack.length > 0 &&
+        this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
+        TokenType.EXPANSION_CASE_EXP_START;
+  }
+
+  private _isInExpansionForm(): boolean {
+    return this._expansionCaseStack.length > 0 &&
+        this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
+        TokenType.EXPANSION_FORM_START;
+  }
+}
+
+function isNotWhitespace(code: number): boolean {
+  return !chars.isWhitespace(code) || code === chars.$EOF;
+}
+
+function isNameEnd(code: number): boolean {
+  return chars.isWhitespace(code) || code === chars.$GT || code === chars.$SLASH ||
+      code === chars.$SQ || code === chars.$DQ || code === chars.$EQ;
+}
+
+function isPrefixEnd(code: number): boolean {
+  return (code < chars.$a || chars.$z < code) && (code < chars.$A || chars.$Z < code) &&
+      (code < chars.$0 || code > chars.$9);
+}
+
+function isDigitEntityEnd(code: number): boolean {
+  return code == chars.$SEMICOLON || code == chars.$EOF || !chars.isAsciiHexDigit(code);
+}
+
+function isNamedEntityEnd(code: number): boolean {
+  return code == chars.$SEMICOLON || code == chars.$EOF || !chars.isAsciiLetter(code);
+}
+
+function isExpansionFormStart(
+    input: string, offset: number, interpolationConfig: InterpolationConfig): boolean {
+  const isInterpolationStart =
+      interpolationConfig ? input.indexOf(interpolationConfig.start, offset) == offset : false;
+
+  return input.charCodeAt(offset) == chars.$LBRACE && !isInterpolationStart;
+}
+
+function isExpansionCaseStart(peek: number): boolean {
+  return peek === chars.$EQ || chars.isAsciiLetter(peek) || chars.isDigit(peek);
+}
+
+function compareCharCodeCaseInsensitive(code1: number, code2: number): boolean {
+  return toUpperCaseCharCode(code1) == toUpperCaseCharCode(code2);
+}
+
+function toUpperCaseCharCode(code: number): number {
+  return code >= chars.$a && code <= chars.$z ? code - chars.$a + chars.$A : code;
+}
+
+function mergeTextTokens(srcTokens: Token[]): Token[] {
+  const dstTokens: Token[] = [];
+  let lastDstToken: Token|undefined = undefined;
+  for (let i = 0; i < srcTokens.length; i++) {
+    const token = srcTokens[i];
+    if (lastDstToken && lastDstToken.type == TokenType.TEXT && token.type == TokenType.TEXT) {
+      lastDstToken.parts[0] += token.parts[0];
+      lastDstToken.sourceSpan.end = token.sourceSpan.end;
+    } else {
+      lastDstToken = token;
+      dstTokens.push(lastDstToken);
+    }
+  }
+
+  return dstTokens;
+}
diff --git a/angular/compiler/src/ml_parser/parser.ts b/angular/compiler/src/ml_parser/parser.ts
new file mode 100644
index 0000000..ab6a7c2
--- /dev/null
+++ b/angular/compiler/src/ml_parser/parser.ts
@@ -0,0 +1,414 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ParseError, ParseSourceSpan} from '../parse_util';
+
+import * as html from './ast';
+import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from './interpolation_config';
+import * as lex from './lexer';
+import {TagDefinition, getNsPrefix, isNgContainer, mergeNsAndName} from './tags';
+
+export class TreeError extends ParseError {
+  static create(elementName: string|null, span: ParseSourceSpan, msg: string): TreeError {
+    return new TreeError(elementName, span, msg);
+  }
+
+  constructor(public elementName: string|null, span: ParseSourceSpan, msg: string) {
+    super(span, msg);
+  }
+}
+
+export class ParseTreeResult {
+  constructor(public rootNodes: html.Node[], public errors: ParseError[]) {}
+}
+
+export class Parser {
+  constructor(public getTagDefinition: (tagName: string) => TagDefinition) {}
+
+  parse(
+      source: string, url: string, parseExpansionForms: boolean = false,
+      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ParseTreeResult {
+    const tokensAndErrors =
+        lex.tokenize(source, url, this.getTagDefinition, parseExpansionForms, interpolationConfig);
+
+    const treeAndErrors = new _TreeBuilder(tokensAndErrors.tokens, this.getTagDefinition).build();
+
+    return new ParseTreeResult(
+        treeAndErrors.rootNodes,
+        (<ParseError[]>tokensAndErrors.errors).concat(treeAndErrors.errors));
+  }
+}
+
+class _TreeBuilder {
+  private _index: number = -1;
+  private _peek: lex.Token;
+
+  private _rootNodes: html.Node[] = [];
+  private _errors: TreeError[] = [];
+
+  private _elementStack: html.Element[] = [];
+
+  constructor(
+      private tokens: lex.Token[], private getTagDefinition: (tagName: string) => TagDefinition) {
+    this._advance();
+  }
+
+  build(): ParseTreeResult {
+    while (this._peek.type !== lex.TokenType.EOF) {
+      if (this._peek.type === lex.TokenType.TAG_OPEN_START) {
+        this._consumeStartTag(this._advance());
+      } else if (this._peek.type === lex.TokenType.TAG_CLOSE) {
+        this._consumeEndTag(this._advance());
+      } else if (this._peek.type === lex.TokenType.CDATA_START) {
+        this._closeVoidElement();
+        this._consumeCdata(this._advance());
+      } else if (this._peek.type === lex.TokenType.COMMENT_START) {
+        this._closeVoidElement();
+        this._consumeComment(this._advance());
+      } else if (
+          this._peek.type === lex.TokenType.TEXT || this._peek.type === lex.TokenType.RAW_TEXT ||
+          this._peek.type === lex.TokenType.ESCAPABLE_RAW_TEXT) {
+        this._closeVoidElement();
+        this._consumeText(this._advance());
+      } else if (this._peek.type === lex.TokenType.EXPANSION_FORM_START) {
+        this._consumeExpansion(this._advance());
+      } else {
+        // Skip all other tokens...
+        this._advance();
+      }
+    }
+    return new ParseTreeResult(this._rootNodes, this._errors);
+  }
+
+  private _advance(): lex.Token {
+    const prev = this._peek;
+    if (this._index < this.tokens.length - 1) {
+      // Note: there is always an EOF token at the end
+      this._index++;
+    }
+    this._peek = this.tokens[this._index];
+    return prev;
+  }
+
+  private _advanceIf(type: lex.TokenType): lex.Token|null {
+    if (this._peek.type === type) {
+      return this._advance();
+    }
+    return null;
+  }
+
+  private _consumeCdata(startToken: lex.Token) {
+    this._consumeText(this._advance());
+    this._advanceIf(lex.TokenType.CDATA_END);
+  }
+
+  private _consumeComment(token: lex.Token) {
+    const text = this._advanceIf(lex.TokenType.RAW_TEXT);
+    this._advanceIf(lex.TokenType.COMMENT_END);
+    const value = text != null ? text.parts[0].trim() : null;
+    this._addToParent(new html.Comment(value, token.sourceSpan));
+  }
+
+  private _consumeExpansion(token: lex.Token) {
+    const switchValue = this._advance();
+
+    const type = this._advance();
+    const cases: html.ExpansionCase[] = [];
+
+    // read =
+    while (this._peek.type === lex.TokenType.EXPANSION_CASE_VALUE) {
+      const expCase = this._parseExpansionCase();
+      if (!expCase) return;  // error
+      cases.push(expCase);
+    }
+
+    // read the final }
+    if (this._peek.type !== lex.TokenType.EXPANSION_FORM_END) {
+      this._errors.push(
+          TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '}'.`));
+      return;
+    }
+    const sourceSpan = new ParseSourceSpan(token.sourceSpan.start, this._peek.sourceSpan.end);
+    this._addToParent(new html.Expansion(
+        switchValue.parts[0], type.parts[0], cases, sourceSpan, switchValue.sourceSpan));
+
+    this._advance();
+  }
+
+  private _parseExpansionCase(): html.ExpansionCase|null {
+    const value = this._advance();
+
+    // read {
+    if (this._peek.type !== lex.TokenType.EXPANSION_CASE_EXP_START) {
+      this._errors.push(
+          TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '{'.`));
+      return null;
+    }
+
+    // read until }
+    const start = this._advance();
+
+    const exp = this._collectExpansionExpTokens(start);
+    if (!exp) return null;
+
+    const end = this._advance();
+    exp.push(new lex.Token(lex.TokenType.EOF, [], end.sourceSpan));
+
+    // parse everything in between { and }
+    const parsedExp = new _TreeBuilder(exp, this.getTagDefinition).build();
+    if (parsedExp.errors.length > 0) {
+      this._errors = this._errors.concat(<TreeError[]>parsedExp.errors);
+      return null;
+    }
+
+    const sourceSpan = new ParseSourceSpan(value.sourceSpan.start, end.sourceSpan.end);
+    const expSourceSpan = new ParseSourceSpan(start.sourceSpan.start, end.sourceSpan.end);
+    return new html.ExpansionCase(
+        value.parts[0], parsedExp.rootNodes, sourceSpan, value.sourceSpan, expSourceSpan);
+  }
+
+  private _collectExpansionExpTokens(start: lex.Token): lex.Token[]|null {
+    const exp: lex.Token[] = [];
+    const expansionFormStack = [lex.TokenType.EXPANSION_CASE_EXP_START];
+
+    while (true) {
+      if (this._peek.type === lex.TokenType.EXPANSION_FORM_START ||
+          this._peek.type === lex.TokenType.EXPANSION_CASE_EXP_START) {
+        expansionFormStack.push(this._peek.type);
+      }
+
+      if (this._peek.type === lex.TokenType.EXPANSION_CASE_EXP_END) {
+        if (lastOnStack(expansionFormStack, lex.TokenType.EXPANSION_CASE_EXP_START)) {
+          expansionFormStack.pop();
+          if (expansionFormStack.length == 0) return exp;
+
+        } else {
+          this._errors.push(
+              TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
+          return null;
+        }
+      }
+
+      if (this._peek.type === lex.TokenType.EXPANSION_FORM_END) {
+        if (lastOnStack(expansionFormStack, lex.TokenType.EXPANSION_FORM_START)) {
+          expansionFormStack.pop();
+        } else {
+          this._errors.push(
+              TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
+          return null;
+        }
+      }
+
+      if (this._peek.type === lex.TokenType.EOF) {
+        this._errors.push(
+            TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
+        return null;
+      }
+
+      exp.push(this._advance());
+    }
+  }
+
+  private _consumeText(token: lex.Token) {
+    let text = token.parts[0];
+    if (text.length > 0 && text[0] == '\n') {
+      const parent = this._getParentElement();
+      if (parent != null && parent.children.length == 0 &&
+          this.getTagDefinition(parent.name).ignoreFirstLf) {
+        text = text.substring(1);
+      }
+    }
+
+    if (text.length > 0) {
+      this._addToParent(new html.Text(text, token.sourceSpan));
+    }
+  }
+
+  private _closeVoidElement(): void {
+    const el = this._getParentElement();
+    if (el && this.getTagDefinition(el.name).isVoid) {
+      this._elementStack.pop();
+    }
+  }
+
+  private _consumeStartTag(startTagToken: lex.Token) {
+    const prefix = startTagToken.parts[0];
+    const name = startTagToken.parts[1];
+    const attrs: html.Attribute[] = [];
+    while (this._peek.type === lex.TokenType.ATTR_NAME) {
+      attrs.push(this._consumeAttr(this._advance()));
+    }
+    const fullName = this._getElementFullName(prefix, name, this._getParentElement());
+    let selfClosing = false;
+    // Note: There could have been a tokenizer error
+    // so that we don't get a token for the end tag...
+    if (this._peek.type === lex.TokenType.TAG_OPEN_END_VOID) {
+      this._advance();
+      selfClosing = true;
+      const tagDef = this.getTagDefinition(fullName);
+      if (!(tagDef.canSelfClose || getNsPrefix(fullName) !== null || tagDef.isVoid)) {
+        this._errors.push(TreeError.create(
+            fullName, startTagToken.sourceSpan,
+            `Only void and foreign elements can be self closed "${startTagToken.parts[1]}"`));
+      }
+    } else if (this._peek.type === lex.TokenType.TAG_OPEN_END) {
+      this._advance();
+      selfClosing = false;
+    }
+    const end = this._peek.sourceSpan.start;
+    const span = new ParseSourceSpan(startTagToken.sourceSpan.start, end);
+    const el = new html.Element(fullName, attrs, [], span, span, undefined);
+    this._pushElement(el);
+    if (selfClosing) {
+      this._popElement(fullName);
+      el.endSourceSpan = span;
+    }
+  }
+
+  private _pushElement(el: html.Element) {
+    const parentEl = this._getParentElement();
+
+    if (parentEl && this.getTagDefinition(parentEl.name).isClosedByChild(el.name)) {
+      this._elementStack.pop();
+    }
+
+    const tagDef = this.getTagDefinition(el.name);
+    const {parent, container} = this._getParentElementSkippingContainers();
+
+    if (parent && tagDef.requireExtraParent(parent.name)) {
+      const newParent = new html.Element(
+          tagDef.parentToAdd, [], [], el.sourceSpan, el.startSourceSpan, el.endSourceSpan);
+      this._insertBeforeContainer(parent, container, newParent);
+    }
+
+    this._addToParent(el);
+    this._elementStack.push(el);
+  }
+
+  private _consumeEndTag(endTagToken: lex.Token) {
+    const fullName = this._getElementFullName(
+        endTagToken.parts[0], endTagToken.parts[1], this._getParentElement());
+
+    if (this._getParentElement()) {
+      this._getParentElement() !.endSourceSpan = endTagToken.sourceSpan;
+    }
+
+    if (this.getTagDefinition(fullName).isVoid) {
+      this._errors.push(TreeError.create(
+          fullName, endTagToken.sourceSpan,
+          `Void elements do not have end tags "${endTagToken.parts[1]}"`));
+    } else if (!this._popElement(fullName)) {
+      const errMsg =
+          `Unexpected closing tag "${fullName}". It may happen when the tag has already been closed by another tag. For more info see https://www.w3.org/TR/html5/syntax.html#closing-elements-that-have-implied-end-tags`;
+      this._errors.push(TreeError.create(fullName, endTagToken.sourceSpan, errMsg));
+    }
+  }
+
+  private _popElement(fullName: string): boolean {
+    for (let stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) {
+      const el = this._elementStack[stackIndex];
+      if (el.name == fullName) {
+        this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex);
+        return true;
+      }
+
+      if (!this.getTagDefinition(el.name).closedByParent) {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  private _consumeAttr(attrName: lex.Token): html.Attribute {
+    const fullName = mergeNsAndName(attrName.parts[0], attrName.parts[1]);
+    let end = attrName.sourceSpan.end;
+    let value = '';
+    let valueSpan: ParseSourceSpan = undefined !;
+    if (this._peek.type === lex.TokenType.ATTR_VALUE) {
+      const valueToken = this._advance();
+      value = valueToken.parts[0];
+      end = valueToken.sourceSpan.end;
+      valueSpan = valueToken.sourceSpan;
+    }
+    return new html.Attribute(
+        fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, end), valueSpan);
+  }
+
+  private _getParentElement(): html.Element|null {
+    return this._elementStack.length > 0 ? this._elementStack[this._elementStack.length - 1] : null;
+  }
+
+  /**
+   * Returns the parent in the DOM and the container.
+   *
+   * `<ng-container>` elements are skipped as they are not rendered as DOM element.
+   */
+  private _getParentElementSkippingContainers():
+      {parent: html.Element | null, container: html.Element|null} {
+    let container: html.Element|null = null;
+
+    for (let i = this._elementStack.length - 1; i >= 0; i--) {
+      if (!isNgContainer(this._elementStack[i].name)) {
+        return {parent: this._elementStack[i], container};
+      }
+      container = this._elementStack[i];
+    }
+
+    return {parent: null, container};
+  }
+
+  private _addToParent(node: html.Node) {
+    const parent = this._getParentElement();
+    if (parent != null) {
+      parent.children.push(node);
+    } else {
+      this._rootNodes.push(node);
+    }
+  }
+
+  /**
+   * Insert a node between the parent and the container.
+   * When no container is given, the node is appended as a child of the parent.
+   * Also updates the element stack accordingly.
+   *
+   * @internal
+   */
+  private _insertBeforeContainer(
+      parent: html.Element, container: html.Element|null, node: html.Element) {
+    if (!container) {
+      this._addToParent(node);
+      this._elementStack.push(node);
+    } else {
+      if (parent) {
+        // replace the container with the new node in the children
+        const index = parent.children.indexOf(container);
+        parent.children[index] = node;
+      } else {
+        this._rootNodes.push(node);
+      }
+      node.children.push(container);
+      this._elementStack.splice(this._elementStack.indexOf(container), 0, node);
+    }
+  }
+
+  private _getElementFullName(prefix: string, localName: string, parentElement: html.Element|null):
+      string {
+    if (prefix == null) {
+      prefix = this.getTagDefinition(localName).implicitNamespacePrefix !;
+      if (prefix == null && parentElement != null) {
+        prefix = getNsPrefix(parentElement.name);
+      }
+    }
+
+    return mergeNsAndName(prefix, localName);
+  }
+}
+
+function lastOnStack(stack: any[], element: any): boolean {
+  return stack.length > 0 && stack[stack.length - 1] === element;
+}
diff --git a/angular/compiler/src/ml_parser/tags.ts b/angular/compiler/src/ml_parser/tags.ts
new file mode 100644
index 0000000..8fb6580
--- /dev/null
+++ b/angular/compiler/src/ml_parser/tags.ts
@@ -0,0 +1,334 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export enum TagContentType {
+  RAW_TEXT,
+  ESCAPABLE_RAW_TEXT,
+  PARSABLE_DATA
+}
+
+export interface TagDefinition {
+  closedByParent: boolean;
+  requiredParents: {[key: string]: boolean};
+  parentToAdd: string;
+  implicitNamespacePrefix: string|null;
+  contentType: TagContentType;
+  isVoid: boolean;
+  ignoreFirstLf: boolean;
+  canSelfClose: boolean;
+
+  requireExtraParent(currentParent: string): boolean;
+
+  isClosedByChild(name: string): boolean;
+}
+
+export function splitNsName(elementName: string): [string | null, string] {
+  if (elementName[0] != ':') {
+    return [null, elementName];
+  }
+
+  const colonIndex = elementName.indexOf(':', 1);
+
+  if (colonIndex == -1) {
+    throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
+  }
+
+  return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];
+}
+
+// `<ng-container>` tags work the same regardless the namespace
+export function isNgContainer(tagName: string): boolean {
+  return splitNsName(tagName)[1] === 'ng-container';
+}
+
+// `<ng-content>` tags work the same regardless the namespace
+export function isNgContent(tagName: string): boolean {
+  return splitNsName(tagName)[1] === 'ng-content';
+}
+
+// `<ng-template>` tags work the same regardless the namespace
+export function isNgTemplate(tagName: string): boolean {
+  return splitNsName(tagName)[1] === 'ng-template';
+}
+
+export function getNsPrefix(fullName: string): string;
+export function getNsPrefix(fullName: null): null;
+export function getNsPrefix(fullName: string | null): string|null {
+  return fullName === null ? null : splitNsName(fullName)[0];
+}
+
+export function mergeNsAndName(prefix: string, localName: string): string {
+  return prefix ? `:${prefix}:${localName}` : localName;
+}
+
+// see http://www.w3.org/TR/html51/syntax.html#named-character-references
+// see https://html.spec.whatwg.org/multipage/entities.json
+// This list is not exhaustive to keep the compiler footprint low.
+// The `&#123;` / `&#x1ab;` syntax should be used when the named character reference does not
+// exist.
+
+export const NAMED_ENTITIES: {[k: string]: string} = {
+  'Aacute': '\u00C1',
+  'aacute': '\u00E1',
+  'Acirc': '\u00C2',
+  'acirc': '\u00E2',
+  'acute': '\u00B4',
+  'AElig': '\u00C6',
+  'aelig': '\u00E6',
+  'Agrave': '\u00C0',
+  'agrave': '\u00E0',
+  'alefsym': '\u2135',
+  'Alpha': '\u0391',
+  'alpha': '\u03B1',
+  'amp': '&',
+  'and': '\u2227',
+  'ang': '\u2220',
+  'apos': '\u0027',
+  'Aring': '\u00C5',
+  'aring': '\u00E5',
+  'asymp': '\u2248',
+  'Atilde': '\u00C3',
+  'atilde': '\u00E3',
+  'Auml': '\u00C4',
+  'auml': '\u00E4',
+  'bdquo': '\u201E',
+  'Beta': '\u0392',
+  'beta': '\u03B2',
+  'brvbar': '\u00A6',
+  'bull': '\u2022',
+  'cap': '\u2229',
+  'Ccedil': '\u00C7',
+  'ccedil': '\u00E7',
+  'cedil': '\u00B8',
+  'cent': '\u00A2',
+  'Chi': '\u03A7',
+  'chi': '\u03C7',
+  'circ': '\u02C6',
+  'clubs': '\u2663',
+  'cong': '\u2245',
+  'copy': '\u00A9',
+  'crarr': '\u21B5',
+  'cup': '\u222A',
+  'curren': '\u00A4',
+  'dagger': '\u2020',
+  'Dagger': '\u2021',
+  'darr': '\u2193',
+  'dArr': '\u21D3',
+  'deg': '\u00B0',
+  'Delta': '\u0394',
+  'delta': '\u03B4',
+  'diams': '\u2666',
+  'divide': '\u00F7',
+  'Eacute': '\u00C9',
+  'eacute': '\u00E9',
+  'Ecirc': '\u00CA',
+  'ecirc': '\u00EA',
+  'Egrave': '\u00C8',
+  'egrave': '\u00E8',
+  'empty': '\u2205',
+  'emsp': '\u2003',
+  'ensp': '\u2002',
+  'Epsilon': '\u0395',
+  'epsilon': '\u03B5',
+  'equiv': '\u2261',
+  'Eta': '\u0397',
+  'eta': '\u03B7',
+  'ETH': '\u00D0',
+  'eth': '\u00F0',
+  'Euml': '\u00CB',
+  'euml': '\u00EB',
+  'euro': '\u20AC',
+  'exist': '\u2203',
+  'fnof': '\u0192',
+  'forall': '\u2200',
+  'frac12': '\u00BD',
+  'frac14': '\u00BC',
+  'frac34': '\u00BE',
+  'frasl': '\u2044',
+  'Gamma': '\u0393',
+  'gamma': '\u03B3',
+  'ge': '\u2265',
+  'gt': '>',
+  'harr': '\u2194',
+  'hArr': '\u21D4',
+  'hearts': '\u2665',
+  'hellip': '\u2026',
+  'Iacute': '\u00CD',
+  'iacute': '\u00ED',
+  'Icirc': '\u00CE',
+  'icirc': '\u00EE',
+  'iexcl': '\u00A1',
+  'Igrave': '\u00CC',
+  'igrave': '\u00EC',
+  'image': '\u2111',
+  'infin': '\u221E',
+  'int': '\u222B',
+  'Iota': '\u0399',
+  'iota': '\u03B9',
+  'iquest': '\u00BF',
+  'isin': '\u2208',
+  'Iuml': '\u00CF',
+  'iuml': '\u00EF',
+  'Kappa': '\u039A',
+  'kappa': '\u03BA',
+  'Lambda': '\u039B',
+  'lambda': '\u03BB',
+  'lang': '\u27E8',
+  'laquo': '\u00AB',
+  'larr': '\u2190',
+  'lArr': '\u21D0',
+  'lceil': '\u2308',
+  'ldquo': '\u201C',
+  'le': '\u2264',
+  'lfloor': '\u230A',
+  'lowast': '\u2217',
+  'loz': '\u25CA',
+  'lrm': '\u200E',
+  'lsaquo': '\u2039',
+  'lsquo': '\u2018',
+  'lt': '<',
+  'macr': '\u00AF',
+  'mdash': '\u2014',
+  'micro': '\u00B5',
+  'middot': '\u00B7',
+  'minus': '\u2212',
+  'Mu': '\u039C',
+  'mu': '\u03BC',
+  'nabla': '\u2207',
+  'nbsp': '\u00A0',
+  'ndash': '\u2013',
+  'ne': '\u2260',
+  'ni': '\u220B',
+  'not': '\u00AC',
+  'notin': '\u2209',
+  'nsub': '\u2284',
+  'Ntilde': '\u00D1',
+  'ntilde': '\u00F1',
+  'Nu': '\u039D',
+  'nu': '\u03BD',
+  'Oacute': '\u00D3',
+  'oacute': '\u00F3',
+  'Ocirc': '\u00D4',
+  'ocirc': '\u00F4',
+  'OElig': '\u0152',
+  'oelig': '\u0153',
+  'Ograve': '\u00D2',
+  'ograve': '\u00F2',
+  'oline': '\u203E',
+  'Omega': '\u03A9',
+  'omega': '\u03C9',
+  'Omicron': '\u039F',
+  'omicron': '\u03BF',
+  'oplus': '\u2295',
+  'or': '\u2228',
+  'ordf': '\u00AA',
+  'ordm': '\u00BA',
+  'Oslash': '\u00D8',
+  'oslash': '\u00F8',
+  'Otilde': '\u00D5',
+  'otilde': '\u00F5',
+  'otimes': '\u2297',
+  'Ouml': '\u00D6',
+  'ouml': '\u00F6',
+  'para': '\u00B6',
+  'permil': '\u2030',
+  'perp': '\u22A5',
+  'Phi': '\u03A6',
+  'phi': '\u03C6',
+  'Pi': '\u03A0',
+  'pi': '\u03C0',
+  'piv': '\u03D6',
+  'plusmn': '\u00B1',
+  'pound': '\u00A3',
+  'prime': '\u2032',
+  'Prime': '\u2033',
+  'prod': '\u220F',
+  'prop': '\u221D',
+  'Psi': '\u03A8',
+  'psi': '\u03C8',
+  'quot': '\u0022',
+  'radic': '\u221A',
+  'rang': '\u27E9',
+  'raquo': '\u00BB',
+  'rarr': '\u2192',
+  'rArr': '\u21D2',
+  'rceil': '\u2309',
+  'rdquo': '\u201D',
+  'real': '\u211C',
+  'reg': '\u00AE',
+  'rfloor': '\u230B',
+  'Rho': '\u03A1',
+  'rho': '\u03C1',
+  'rlm': '\u200F',
+  'rsaquo': '\u203A',
+  'rsquo': '\u2019',
+  'sbquo': '\u201A',
+  'Scaron': '\u0160',
+  'scaron': '\u0161',
+  'sdot': '\u22C5',
+  'sect': '\u00A7',
+  'shy': '\u00AD',
+  'Sigma': '\u03A3',
+  'sigma': '\u03C3',
+  'sigmaf': '\u03C2',
+  'sim': '\u223C',
+  'spades': '\u2660',
+  'sub': '\u2282',
+  'sube': '\u2286',
+  'sum': '\u2211',
+  'sup': '\u2283',
+  'sup1': '\u00B9',
+  'sup2': '\u00B2',
+  'sup3': '\u00B3',
+  'supe': '\u2287',
+  'szlig': '\u00DF',
+  'Tau': '\u03A4',
+  'tau': '\u03C4',
+  'there4': '\u2234',
+  'Theta': '\u0398',
+  'theta': '\u03B8',
+  'thetasym': '\u03D1',
+  'thinsp': '\u2009',
+  'THORN': '\u00DE',
+  'thorn': '\u00FE',
+  'tilde': '\u02DC',
+  'times': '\u00D7',
+  'trade': '\u2122',
+  'Uacute': '\u00DA',
+  'uacute': '\u00FA',
+  'uarr': '\u2191',
+  'uArr': '\u21D1',
+  'Ucirc': '\u00DB',
+  'ucirc': '\u00FB',
+  'Ugrave': '\u00D9',
+  'ugrave': '\u00F9',
+  'uml': '\u00A8',
+  'upsih': '\u03D2',
+  'Upsilon': '\u03A5',
+  'upsilon': '\u03C5',
+  'Uuml': '\u00DC',
+  'uuml': '\u00FC',
+  'weierp': '\u2118',
+  'Xi': '\u039E',
+  'xi': '\u03BE',
+  'Yacute': '\u00DD',
+  'yacute': '\u00FD',
+  'yen': '\u00A5',
+  'yuml': '\u00FF',
+  'Yuml': '\u0178',
+  'Zeta': '\u0396',
+  'zeta': '\u03B6',
+  'zwj': '\u200D',
+  'zwnj': '\u200C',
+};
+
+// The &ngsp; pseudo-entity is denoting a space. see:
+// https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart
+export const NGSP_UNICODE = '\uE500';
+
+NAMED_ENTITIES['ngsp'] = NGSP_UNICODE;
diff --git a/angular/compiler/src/ml_parser/xml_parser.ts b/angular/compiler/src/ml_parser/xml_parser.ts
new file mode 100644
index 0000000..57f49eb
--- /dev/null
+++ b/angular/compiler/src/ml_parser/xml_parser.ts
@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ParseTreeResult, Parser} from './parser';
+import {getXmlTagDefinition} from './xml_tags';
+
+export {ParseTreeResult, TreeError} from './parser';
+
+export class XmlParser extends Parser {
+  constructor() { super(getXmlTagDefinition); }
+
+  parse(source: string, url: string, parseExpansionForms: boolean = false): ParseTreeResult {
+    return super.parse(source, url, parseExpansionForms);
+  }
+}
diff --git a/angular/compiler/src/ml_parser/xml_tags.ts b/angular/compiler/src/ml_parser/xml_tags.ts
new file mode 100644
index 0000000..6acc2f5
--- /dev/null
+++ b/angular/compiler/src/ml_parser/xml_tags.ts
@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {TagContentType, TagDefinition} from './tags';
+
+export class XmlTagDefinition implements TagDefinition {
+  closedByParent: boolean = false;
+  requiredParents: {[key: string]: boolean};
+  parentToAdd: string;
+  implicitNamespacePrefix: string;
+  contentType: TagContentType = TagContentType.PARSABLE_DATA;
+  isVoid: boolean = false;
+  ignoreFirstLf: boolean = false;
+  canSelfClose: boolean = true;
+
+  requireExtraParent(currentParent: string): boolean { return false; }
+
+  isClosedByChild(name: string): boolean { return false; }
+}
+
+const _TAG_DEFINITION = new XmlTagDefinition();
+
+export function getXmlTagDefinition(tagName: string): XmlTagDefinition {
+  return _TAG_DEFINITION;
+}
diff --git a/angular/compiler/src/ng_module_compiler.ts b/angular/compiler/src/ng_module_compiler.ts
new file mode 100644
index 0000000..70ba3f6
--- /dev/null
+++ b/angular/compiler/src/ng_module_compiler.ts
@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileNgModuleMetadata, CompileProviderMetadata, identifierName} from './compile_metadata';
+import {CompileReflector} from './compile_reflector';
+import {NodeFlags} from './core';
+import {Identifiers} from './identifiers';
+import * as o from './output/output_ast';
+import {typeSourceSpan} from './parse_util';
+import {NgModuleProviderAnalyzer} from './provider_analyzer';
+import {OutputContext} from './util';
+import {componentFactoryResolverProviderDef, depDef, providerDef} from './view_compiler/provider_compiler';
+
+export class NgModuleCompileResult {
+  constructor(public ngModuleFactoryVar: string) {}
+}
+
+const LOG_VAR = o.variable('_l');
+
+export class NgModuleCompiler {
+  constructor(private reflector: CompileReflector) {}
+  compile(
+      ctx: OutputContext, ngModuleMeta: CompileNgModuleMetadata,
+      extraProviders: CompileProviderMetadata[]): NgModuleCompileResult {
+    const sourceSpan = typeSourceSpan('NgModule', ngModuleMeta.type);
+    const entryComponentFactories = ngModuleMeta.transitiveModule.entryComponents;
+    const bootstrapComponents = ngModuleMeta.bootstrapComponents;
+    const providerParser =
+        new NgModuleProviderAnalyzer(this.reflector, ngModuleMeta, extraProviders, sourceSpan);
+    const providerDefs =
+        [componentFactoryResolverProviderDef(
+             this.reflector, ctx, NodeFlags.None, entryComponentFactories)]
+            .concat(providerParser.parse().map((provider) => providerDef(ctx, provider)))
+            .map(({providerExpr, depsExpr, flags, tokenExpr}) => {
+              return o.importExpr(Identifiers.moduleProviderDef).callFn([
+                o.literal(flags), tokenExpr, providerExpr, depsExpr
+              ]);
+            });
+
+    const ngModuleDef = o.importExpr(Identifiers.moduleDef).callFn([o.literalArr(providerDefs)]);
+    const ngModuleDefFactory = o.fn(
+        [new o.FnParam(LOG_VAR.name !)], [new o.ReturnStatement(ngModuleDef)], o.INFERRED_TYPE);
+
+    const ngModuleFactoryVar = `${identifierName(ngModuleMeta.type)}NgFactory`;
+    this._createNgModuleFactory(
+        ctx, ngModuleMeta.type.reference, o.importExpr(Identifiers.createModuleFactory).callFn([
+          ctx.importExpr(ngModuleMeta.type.reference),
+          o.literalArr(bootstrapComponents.map(id => ctx.importExpr(id.reference))),
+          ngModuleDefFactory
+        ]));
+
+    if (ngModuleMeta.id) {
+      const registerFactoryStmt =
+          o.importExpr(Identifiers.RegisterModuleFactoryFn)
+              .callFn([o.literal(ngModuleMeta.id), o.variable(ngModuleFactoryVar)])
+              .toStmt();
+      ctx.statements.push(registerFactoryStmt);
+    }
+
+    return new NgModuleCompileResult(ngModuleFactoryVar);
+  }
+
+  createStub(ctx: OutputContext, ngModuleReference: any) {
+    this._createNgModuleFactory(ctx, ngModuleReference, o.NULL_EXPR);
+  }
+
+  private _createNgModuleFactory(ctx: OutputContext, reference: any, value: o.Expression) {
+    const ngModuleFactoryVar = `${identifierName({reference: reference})}NgFactory`;
+    const ngModuleFactoryStmt =
+        o.variable(ngModuleFactoryVar)
+            .set(value)
+            .toDeclStmt(
+                o.importType(
+                    Identifiers.NgModuleFactory, [o.expressionType(ctx.importExpr(reference)) !],
+                    [o.TypeModifier.Const]),
+                [o.StmtModifier.Final, o.StmtModifier.Exported]);
+
+    ctx.statements.push(ngModuleFactoryStmt);
+  }
+}
diff --git a/angular/compiler/src/ng_module_resolver.ts b/angular/compiler/src/ng_module_resolver.ts
new file mode 100644
index 0000000..6996f37
--- /dev/null
+++ b/angular/compiler/src/ng_module_resolver.ts
@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileReflector} from './compile_reflector';
+import {NgModule, Type, createNgModule} from './core';
+import {findLast} from './directive_resolver';
+import {stringify} from './util';
+
+
+/**
+ * Resolves types to {@link NgModule}.
+ */
+export class NgModuleResolver {
+  constructor(private _reflector: CompileReflector) {}
+
+  isNgModule(type: any) { return this._reflector.annotations(type).some(createNgModule.isTypeOf); }
+
+  resolve(type: Type, throwIfNotFound = true): NgModule|null {
+    const ngModuleMeta: NgModule =
+        findLast(this._reflector.annotations(type), createNgModule.isTypeOf);
+
+    if (ngModuleMeta) {
+      return ngModuleMeta;
+    } else {
+      if (throwIfNotFound) {
+        throw new Error(`No NgModule metadata found for '${stringify(type)}'.`);
+      }
+      return null;
+    }
+  }
+}
diff --git a/angular/compiler/src/output/abstract_emitter.ts b/angular/compiler/src/output/abstract_emitter.ts
new file mode 100644
index 0000000..213c693
--- /dev/null
+++ b/angular/compiler/src/output/abstract_emitter.ts
@@ -0,0 +1,532 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ParseSourceSpan} from '../parse_util';
+
+import * as o from './output_ast';
+import {SourceMapGenerator} from './source_map';
+
+const _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\|\n|\r|\$/g;
+const _LEGAL_IDENTIFIER_RE = /^[$A-Z_][0-9A-Z_$]*$/i;
+const _INDENT_WITH = '  ';
+export const CATCH_ERROR_VAR = o.variable('error', null, null);
+export const CATCH_STACK_VAR = o.variable('stack', null, null);
+
+export abstract class OutputEmitter {
+  abstract emitStatements(
+      srcFilePath: string, genFilePath: string, stmts: o.Statement[],
+      preamble?: string|null): string;
+}
+
+class _EmittedLine {
+  partsLength = 0;
+  parts: string[] = [];
+  srcSpans: (ParseSourceSpan|null)[] = [];
+  constructor(public indent: number) {}
+}
+
+export class EmitterVisitorContext {
+  static createRoot(): EmitterVisitorContext { return new EmitterVisitorContext(0); }
+
+  private _lines: _EmittedLine[];
+  private _classes: o.ClassStmt[] = [];
+  private _preambleLineCount = 0;
+
+  constructor(private _indent: number) { this._lines = [new _EmittedLine(_indent)]; }
+
+  private get _currentLine(): _EmittedLine { return this._lines[this._lines.length - 1]; }
+
+  println(from?: {sourceSpan: ParseSourceSpan | null}|null, lastPart: string = ''): void {
+    this.print(from || null, lastPart, true);
+  }
+
+  lineIsEmpty(): boolean { return this._currentLine.parts.length === 0; }
+
+  lineLength(): number {
+    return this._currentLine.indent * _INDENT_WITH.length + this._currentLine.partsLength;
+  }
+
+  print(from: {sourceSpan: ParseSourceSpan | null}|null, part: string, newLine: boolean = false) {
+    if (part.length > 0) {
+      this._currentLine.parts.push(part);
+      this._currentLine.partsLength += part.length;
+      this._currentLine.srcSpans.push(from && from.sourceSpan || null);
+    }
+    if (newLine) {
+      this._lines.push(new _EmittedLine(this._indent));
+    }
+  }
+
+  removeEmptyLastLine() {
+    if (this.lineIsEmpty()) {
+      this._lines.pop();
+    }
+  }
+
+  incIndent() {
+    this._indent++;
+    if (this.lineIsEmpty()) {
+      this._currentLine.indent = this._indent;
+    }
+  }
+
+  decIndent() {
+    this._indent--;
+    if (this.lineIsEmpty()) {
+      this._currentLine.indent = this._indent;
+    }
+  }
+
+  pushClass(clazz: o.ClassStmt) { this._classes.push(clazz); }
+
+  popClass(): o.ClassStmt { return this._classes.pop() !; }
+
+  get currentClass(): o.ClassStmt|null {
+    return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null;
+  }
+
+  toSource(): string {
+    return this.sourceLines
+        .map(l => l.parts.length > 0 ? _createIndent(l.indent) + l.parts.join('') : '')
+        .join('\n');
+  }
+
+  toSourceMapGenerator(sourceFilePath: string, genFilePath: string, startsAtLine: number = 0):
+      SourceMapGenerator {
+    const map = new SourceMapGenerator(genFilePath);
+
+    let firstOffsetMapped = false;
+    const mapFirstOffsetIfNeeded = () => {
+      if (!firstOffsetMapped) {
+        // Add a single space so that tools won't try to load the file from disk.
+        // Note: We are using virtual urls like `ng:///`, so we have to
+        // provide a content here.
+        map.addSource(sourceFilePath, ' ').addMapping(0, sourceFilePath, 0, 0);
+        firstOffsetMapped = true;
+      }
+    };
+
+    for (let i = 0; i < startsAtLine; i++) {
+      map.addLine();
+      mapFirstOffsetIfNeeded();
+    }
+
+    this.sourceLines.forEach((line, lineIdx) => {
+      map.addLine();
+
+      const spans = line.srcSpans;
+      const parts = line.parts;
+      let col0 = line.indent * _INDENT_WITH.length;
+      let spanIdx = 0;
+      // skip leading parts without source spans
+      while (spanIdx < spans.length && !spans[spanIdx]) {
+        col0 += parts[spanIdx].length;
+        spanIdx++;
+      }
+      if (spanIdx < spans.length && lineIdx === 0 && col0 === 0) {
+        firstOffsetMapped = true;
+      } else {
+        mapFirstOffsetIfNeeded();
+      }
+
+      while (spanIdx < spans.length) {
+        const span = spans[spanIdx] !;
+        const source = span.start.file;
+        const sourceLine = span.start.line;
+        const sourceCol = span.start.col;
+        map.addSource(source.url, source.content)
+            .addMapping(col0, source.url, sourceLine, sourceCol);
+
+        col0 += parts[spanIdx].length;
+        spanIdx++;
+
+        // assign parts without span or the same span to the previous segment
+        while (spanIdx < spans.length && (span === spans[spanIdx] || !spans[spanIdx])) {
+          col0 += parts[spanIdx].length;
+          spanIdx++;
+        }
+      }
+    });
+
+    return map;
+  }
+
+  setPreambleLineCount(count: number) { return this._preambleLineCount = count; }
+
+  spanOf(line: number, column: number): ParseSourceSpan|null {
+    const emittedLine = this._lines[line - this._preambleLineCount];
+    if (emittedLine) {
+      let columnsLeft = column - emittedLine.indent;
+      for (let partIndex = 0; partIndex < emittedLine.parts.length; partIndex++) {
+        const part = emittedLine.parts[partIndex];
+        if (part.length > columnsLeft) {
+          return emittedLine.srcSpans[partIndex];
+        }
+        columnsLeft -= part.length;
+      }
+    }
+    return null;
+  }
+
+  private get sourceLines(): _EmittedLine[] {
+    if (this._lines.length && this._lines[this._lines.length - 1].parts.length === 0) {
+      return this._lines.slice(0, -1);
+    }
+    return this._lines;
+  }
+}
+
+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(stmt, ';');
+    return null;
+  }
+
+  visitReturnStmt(stmt: o.ReturnStatement, ctx: EmitterVisitorContext): any {
+    ctx.print(stmt, `return `);
+    stmt.value.visitExpression(this, ctx);
+    ctx.println(stmt, ';');
+    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(stmt, `if (`);
+    stmt.condition.visitExpression(this, ctx);
+    ctx.print(stmt, `) {`);
+    const hasElseCase = stmt.falseCase != null && stmt.falseCase.length > 0;
+    if (stmt.trueCase.length <= 1 && !hasElseCase) {
+      ctx.print(stmt, ` `);
+      this.visitAllStatements(stmt.trueCase, ctx);
+      ctx.removeEmptyLastLine();
+      ctx.print(stmt, ` `);
+    } else {
+      ctx.println();
+      ctx.incIndent();
+      this.visitAllStatements(stmt.trueCase, ctx);
+      ctx.decIndent();
+      if (hasElseCase) {
+        ctx.println(stmt, `} else {`);
+        ctx.incIndent();
+        this.visitAllStatements(stmt.falseCase, ctx);
+        ctx.decIndent();
+      }
+    }
+    ctx.println(stmt, `}`);
+    return null;
+  }
+
+  abstract visitTryCatchStmt(stmt: o.TryCatchStmt, ctx: EmitterVisitorContext): any;
+
+  visitThrowStmt(stmt: o.ThrowStmt, ctx: EmitterVisitorContext): any {
+    ctx.print(stmt, `throw `);
+    stmt.error.visitExpression(this, ctx);
+    ctx.println(stmt, `;`);
+    return null;
+  }
+  visitCommentStmt(stmt: o.CommentStmt, ctx: EmitterVisitorContext): any {
+    const lines = stmt.comment.split('\n');
+    lines.forEach((line) => { ctx.println(stmt, `// ${line}`); });
+    return null;
+  }
+  abstract visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any;
+
+  visitWriteVarExpr(expr: o.WriteVarExpr, ctx: EmitterVisitorContext): any {
+    const lineWasEmpty = ctx.lineIsEmpty();
+    if (!lineWasEmpty) {
+      ctx.print(expr, '(');
+    }
+    ctx.print(expr, `${expr.name} = `);
+    expr.value.visitExpression(this, ctx);
+    if (!lineWasEmpty) {
+      ctx.print(expr, ')');
+    }
+    return null;
+  }
+  visitWriteKeyExpr(expr: o.WriteKeyExpr, ctx: EmitterVisitorContext): any {
+    const lineWasEmpty = ctx.lineIsEmpty();
+    if (!lineWasEmpty) {
+      ctx.print(expr, '(');
+    }
+    expr.receiver.visitExpression(this, ctx);
+    ctx.print(expr, `[`);
+    expr.index.visitExpression(this, ctx);
+    ctx.print(expr, `] = `);
+    expr.value.visitExpression(this, ctx);
+    if (!lineWasEmpty) {
+      ctx.print(expr, ')');
+    }
+    return null;
+  }
+  visitWritePropExpr(expr: o.WritePropExpr, ctx: EmitterVisitorContext): any {
+    const lineWasEmpty = ctx.lineIsEmpty();
+    if (!lineWasEmpty) {
+      ctx.print(expr, '(');
+    }
+    expr.receiver.visitExpression(this, ctx);
+    ctx.print(expr, `.${expr.name} = `);
+    expr.value.visitExpression(this, ctx);
+    if (!lineWasEmpty) {
+      ctx.print(expr, ')');
+    }
+    return null;
+  }
+  visitInvokeMethodExpr(expr: o.InvokeMethodExpr, ctx: EmitterVisitorContext): any {
+    expr.receiver.visitExpression(this, ctx);
+    let name = expr.name;
+    if (expr.builtin != null) {
+      name = this.getBuiltinMethodName(expr.builtin);
+      if (name == null) {
+        // some builtins just mean to skip the call.
+        return null;
+      }
+    }
+    ctx.print(expr, `.${name}(`);
+    this.visitAllExpressions(expr.args, ctx, `,`);
+    ctx.print(expr, `)`);
+    return null;
+  }
+
+  abstract getBuiltinMethodName(method: o.BuiltinMethod): string;
+
+  visitInvokeFunctionExpr(expr: o.InvokeFunctionExpr, ctx: EmitterVisitorContext): any {
+    expr.fn.visitExpression(this, ctx);
+    ctx.print(expr, `(`);
+    this.visitAllExpressions(expr.args, ctx, ',');
+    ctx.print(expr, `)`);
+    return null;
+  }
+  visitReadVarExpr(ast: o.ReadVarExpr, ctx: EmitterVisitorContext): any {
+    let varName = ast.name !;
+    if (ast.builtin != null) {
+      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 Error(`Unknown builtin variable ${ast.builtin}`);
+      }
+    }
+    ctx.print(ast, varName);
+    return null;
+  }
+  visitInstantiateExpr(ast: o.InstantiateExpr, ctx: EmitterVisitorContext): any {
+    ctx.print(ast, `new `);
+    ast.classExpr.visitExpression(this, ctx);
+    ctx.print(ast, `(`);
+    this.visitAllExpressions(ast.args, ctx, ',');
+    ctx.print(ast, `)`);
+    return null;
+  }
+
+  visitLiteralExpr(ast: o.LiteralExpr, ctx: EmitterVisitorContext): any {
+    const value = ast.value;
+    if (typeof value === 'string') {
+      ctx.print(ast, escapeIdentifier(value, this._escapeDollarInStrings));
+    } else {
+      ctx.print(ast, `${value}`);
+    }
+    return null;
+  }
+
+  abstract visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any;
+
+  visitConditionalExpr(ast: o.ConditionalExpr, ctx: EmitterVisitorContext): any {
+    ctx.print(ast, `(`);
+    ast.condition.visitExpression(this, ctx);
+    ctx.print(ast, '? ');
+    ast.trueCase.visitExpression(this, ctx);
+    ctx.print(ast, ': ');
+    ast.falseCase !.visitExpression(this, ctx);
+    ctx.print(ast, `)`);
+    return null;
+  }
+  visitNotExpr(ast: o.NotExpr, ctx: EmitterVisitorContext): any {
+    ctx.print(ast, '!');
+    ast.condition.visitExpression(this, ctx);
+    return null;
+  }
+  visitAssertNotNullExpr(ast: o.AssertNotNull, ctx: EmitterVisitorContext): any {
+    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 {
+    let opStr: string;
+    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 Error(`Unknown operator ${ast.operator}`);
+    }
+    ctx.print(ast, `(`);
+    ast.lhs.visitExpression(this, ctx);
+    ctx.print(ast, ` ${opStr} `);
+    ast.rhs.visitExpression(this, ctx);
+    ctx.print(ast, `)`);
+    return null;
+  }
+
+  visitReadPropExpr(ast: o.ReadPropExpr, ctx: EmitterVisitorContext): any {
+    ast.receiver.visitExpression(this, ctx);
+    ctx.print(ast, `.`);
+    ctx.print(ast, ast.name);
+    return null;
+  }
+  visitReadKeyExpr(ast: o.ReadKeyExpr, ctx: EmitterVisitorContext): any {
+    ast.receiver.visitExpression(this, ctx);
+    ctx.print(ast, `[`);
+    ast.index.visitExpression(this, ctx);
+    ctx.print(ast, `]`);
+    return null;
+  }
+  visitLiteralArrayExpr(ast: o.LiteralArrayExpr, ctx: EmitterVisitorContext): any {
+    ctx.print(ast, `[`);
+    this.visitAllExpressions(ast.entries, ctx, ',');
+    ctx.print(ast, `]`);
+    return null;
+  }
+  visitLiteralMapExpr(ast: o.LiteralMapExpr, ctx: EmitterVisitorContext): any {
+    ctx.print(ast, `{`);
+    this.visitAllObjects(entry => {
+      ctx.print(ast, `${escapeIdentifier(entry.key, this._escapeDollarInStrings, entry.quoted)}:`);
+      entry.value.visitExpression(this, ctx);
+    }, ast.entries, ctx, ',');
+    ctx.print(ast, `}`);
+    return null;
+  }
+  visitCommaExpr(ast: o.CommaExpr, ctx: EmitterVisitorContext): any {
+    ctx.print(ast, '(');
+    this.visitAllExpressions(ast.parts, ctx, ',');
+    ctx.print(ast, ')');
+    return null;
+  }
+  visitAllExpressions(expressions: o.Expression[], ctx: EmitterVisitorContext, separator: string):
+      void {
+    this.visitAllObjects(expr => expr.visitExpression(this, ctx), expressions, ctx, separator);
+  }
+
+  visitAllObjects<T>(
+      handler: (t: T) => void, expressions: T[], ctx: EmitterVisitorContext,
+      separator: string): void {
+    let incrementedIndent = false;
+    for (let i = 0; i < expressions.length; i++) {
+      if (i > 0) {
+        if (ctx.lineLength() > 80) {
+          ctx.print(null, separator, true);
+          if (!incrementedIndent) {
+            // continuation are marked with double indent.
+            ctx.incIndent();
+            ctx.incIndent();
+            incrementedIndent = true;
+          }
+        } else {
+          ctx.print(null, separator, false);
+        }
+      }
+      handler(expressions[i]);
+    }
+    if (incrementedIndent) {
+      // continuation are marked with double indent.
+      ctx.decIndent();
+      ctx.decIndent();
+    }
+  }
+
+  visitAllStatements(statements: o.Statement[], ctx: EmitterVisitorContext): void {
+    statements.forEach((stmt) => stmt.visitStatement(this, ctx));
+  }
+}
+
+export function escapeIdentifier(
+    input: string, escapeDollar: boolean, alwaysQuote: boolean = true): any {
+  if (input == null) {
+    return null;
+  }
+  const body = input.replace(_SINGLE_QUOTE_ESCAPE_STRING_RE, (...match: string[]) => {
+    if (match[0] == '$') {
+      return escapeDollar ? '\\$' : '$';
+    } else if (match[0] == '\n') {
+      return '\\n';
+    } else if (match[0] == '\r') {
+      return '\\r';
+    } else {
+      return `\\${match[0]}`;
+    }
+  });
+  const requiresQuotes = alwaysQuote || !_LEGAL_IDENTIFIER_RE.test(body);
+  return requiresQuotes ? `'${body}'` : body;
+}
+
+function _createIndent(count: number): string {
+  let res = '';
+  for (let i = 0; i < count; i++) {
+    res += _INDENT_WITH;
+  }
+  return res;
+}
diff --git a/angular/compiler/src/output/abstract_js_emitter.ts b/angular/compiler/src/output/abstract_js_emitter.ts
new file mode 100644
index 0000000..60ed0b7
--- /dev/null
+++ b/angular/compiler/src/output/abstract_js_emitter.ts
@@ -0,0 +1,167 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+import {AbstractEmitterVisitor, CATCH_ERROR_VAR, CATCH_STACK_VAR, EmitterVisitorContext} from './abstract_emitter';
+import * as o from './output_ast';
+
+export abstract class AbstractJsEmitterVisitor extends AbstractEmitterVisitor {
+  constructor() { super(false); }
+  visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {
+    ctx.pushClass(stmt);
+    this._visitClassConstructor(stmt, ctx);
+
+    if (stmt.parent != null) {
+      ctx.print(stmt, `${stmt.name}.prototype = Object.create(`);
+      stmt.parent.visitExpression(this, ctx);
+      ctx.println(stmt, `.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(stmt, `function ${stmt.name}(`);
+    if (stmt.constructorMethod != null) {
+      this._visitParams(stmt.constructorMethod.params, ctx);
+    }
+    ctx.println(stmt, `) {`);
+    ctx.incIndent();
+    if (stmt.constructorMethod != null) {
+      if (stmt.constructorMethod.body.length > 0) {
+        ctx.println(stmt, `var self = this;`);
+        this.visitAllStatements(stmt.constructorMethod.body, ctx);
+      }
+    }
+    ctx.decIndent();
+    ctx.println(stmt, `}`);
+  }
+
+  private _visitClassGetter(stmt: o.ClassStmt, getter: o.ClassGetter, ctx: EmitterVisitorContext) {
+    ctx.println(
+        stmt,
+        `Object.defineProperty(${stmt.name}.prototype, '${getter.name}', { get: function() {`);
+    ctx.incIndent();
+    if (getter.body.length > 0) {
+      ctx.println(stmt, `var self = this;`);
+      this.visitAllStatements(getter.body, ctx);
+    }
+    ctx.decIndent();
+    ctx.println(stmt, `}});`);
+  }
+
+  private _visitClassMethod(stmt: o.ClassStmt, method: o.ClassMethod, ctx: EmitterVisitorContext) {
+    ctx.print(stmt, `${stmt.name}.prototype.${method.name} = function(`);
+    this._visitParams(method.params, ctx);
+    ctx.println(stmt, `) {`);
+    ctx.incIndent();
+    if (method.body.length > 0) {
+      ctx.println(stmt, `var self = this;`);
+      this.visitAllStatements(method.body, ctx);
+    }
+    ctx.decIndent();
+    ctx.println(stmt, `};`);
+  }
+
+  visitReadVarExpr(ast: o.ReadVarExpr, ctx: EmitterVisitorContext): string|null {
+    if (ast.builtin === o.BuiltinVar.This) {
+      ctx.print(ast, 'self');
+    } else if (ast.builtin === o.BuiltinVar.Super) {
+      throw new Error(
+          `'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(stmt, `var ${stmt.name} = `);
+    stmt.value.visitExpression(this, ctx);
+    ctx.println(stmt, `;`);
+    return null;
+  }
+  visitCastExpr(ast: o.CastExpr, ctx: EmitterVisitorContext): any {
+    ast.value.visitExpression(this, ctx);
+    return null;
+  }
+  visitInvokeFunctionExpr(expr: o.InvokeFunctionExpr, ctx: EmitterVisitorContext): string|null {
+    const fnExpr = expr.fn;
+    if (fnExpr instanceof o.ReadVarExpr && fnExpr.builtin === o.BuiltinVar.Super) {
+      ctx.currentClass !.parent !.visitExpression(this, ctx);
+      ctx.print(expr, `.call(this`);
+      if (expr.args.length > 0) {
+        ctx.print(expr, `, `);
+        this.visitAllExpressions(expr.args, ctx, ',');
+      }
+      ctx.print(expr, `)`);
+    } else {
+      super.visitInvokeFunctionExpr(expr, ctx);
+    }
+    return null;
+  }
+  visitFunctionExpr(ast: o.FunctionExpr, ctx: EmitterVisitorContext): any {
+    ctx.print(ast, `function(`);
+    this._visitParams(ast.params, ctx);
+    ctx.println(ast, `) {`);
+    ctx.incIndent();
+    this.visitAllStatements(ast.statements, ctx);
+    ctx.decIndent();
+    ctx.print(ast, `}`);
+    return null;
+  }
+  visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: EmitterVisitorContext): any {
+    ctx.print(stmt, `function ${stmt.name}(`);
+    this._visitParams(stmt.params, ctx);
+    ctx.println(stmt, `) {`);
+    ctx.incIndent();
+    this.visitAllStatements(stmt.statements, ctx);
+    ctx.decIndent();
+    ctx.println(stmt, `}`);
+    return null;
+  }
+  visitTryCatchStmt(stmt: o.TryCatchStmt, ctx: EmitterVisitorContext): any {
+    ctx.println(stmt, `try {`);
+    ctx.incIndent();
+    this.visitAllStatements(stmt.bodyStmts, ctx);
+    ctx.decIndent();
+    ctx.println(stmt, `} catch (${CATCH_ERROR_VAR.name}) {`);
+    ctx.incIndent();
+    const 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(stmt, `}`);
+    return null;
+  }
+
+  private _visitParams(params: o.FnParam[], ctx: EmitterVisitorContext): void {
+    this.visitAllObjects(param => ctx.print(null, param.name), params, ctx, ',');
+  }
+
+  getBuiltinMethodName(method: o.BuiltinMethod): string {
+    let name: string;
+    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 Error(`Unknown builtin method: ${method}`);
+    }
+    return name;
+  }
+}
diff --git a/angular/compiler/src/output/js_emitter.ts b/angular/compiler/src/output/js_emitter.ts
new file mode 100644
index 0000000..5a022b7
--- /dev/null
+++ b/angular/compiler/src/output/js_emitter.ts
@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+import {StaticSymbol} from '../aot/static_symbol';
+import {CompileIdentifierMetadata} from '../compile_metadata';
+
+import {EmitterVisitorContext, OutputEmitter} from './abstract_emitter';
+import {AbstractJsEmitterVisitor} from './abstract_js_emitter';
+import * as o from './output_ast';
+
+export class JavaScriptEmitter implements OutputEmitter {
+  emitStatements(
+      srcFilePath: string, genFilePath: string, stmts: o.Statement[],
+      preamble: string = ''): string {
+    const converter = new JsEmitterVisitor();
+    const ctx = EmitterVisitorContext.createRoot();
+    converter.visitAllStatements(stmts, ctx);
+
+    const preambleLines = preamble ? preamble.split('\n') : [];
+    converter.importsWithPrefixes.forEach((prefix, importedModuleName) => {
+      // Note: can't write the real word for import as it screws up system.js auto detection...
+      preambleLines.push(
+          `var ${prefix} = req` +
+          `uire('${importedModuleName}');`);
+    });
+
+    const sm =
+        ctx.toSourceMapGenerator(srcFilePath, genFilePath, preambleLines.length).toJsComment();
+    const lines = [...preambleLines, ctx.toSource(), sm];
+    if (sm) {
+      // always add a newline at the end, as some tools have bugs without it.
+      lines.push('');
+    }
+    return lines.join('\n');
+  }
+}
+
+class JsEmitterVisitor extends AbstractJsEmitterVisitor {
+  importsWithPrefixes = new Map<string, string>();
+
+  visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any {
+    const {name, moduleName} = ast.value;
+    if (moduleName) {
+      let prefix = this.importsWithPrefixes.get(moduleName);
+      if (prefix == null) {
+        prefix = `i${this.importsWithPrefixes.size}`;
+        this.importsWithPrefixes.set(moduleName, prefix);
+      }
+      ctx.print(ast, `${prefix}.`);
+    }
+    ctx.print(ast, name !);
+    return null;
+  }
+  visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any {
+    super.visitDeclareVarStmt(stmt, ctx);
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      ctx.println(stmt, exportVar(stmt.name));
+    }
+    return null;
+  }
+  visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: EmitterVisitorContext): any {
+    super.visitDeclareFunctionStmt(stmt, ctx);
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      ctx.println(stmt, exportVar(stmt.name));
+    }
+    return null;
+  }
+  visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {
+    super.visitDeclareClassStmt(stmt, ctx);
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      ctx.println(stmt, exportVar(stmt.name));
+    }
+    return null;
+  }
+}
+
+function exportVar(varName: string): string {
+  return `Object.defineProperty(exports, '${varName}', { get: function() { return ${varName}; }});`;
+}
diff --git a/angular/compiler/src/output/output_ast.ts b/angular/compiler/src/output/output_ast.ts
new file mode 100644
index 0000000..4f36042
--- /dev/null
+++ b/angular/compiler/src/output/output_ast.ts
@@ -0,0 +1,1179 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+import {ParseSourceSpan} from '../parse_util';
+
+//// Types
+export enum TypeModifier {
+  Const
+}
+
+export abstract class Type {
+  constructor(public modifiers: TypeModifier[]|null = null) {
+    if (!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,
+  Inferred
+}
+
+export class BuiltinType extends Type {
+  constructor(public name: BuiltinTypeName, modifiers: TypeModifier[]|null = null) {
+    super(modifiers);
+  }
+  visitType(visitor: TypeVisitor, context: any): any {
+    return visitor.visitBuiltintType(this, context);
+  }
+}
+
+export class ExpressionType extends Type {
+  constructor(public value: Expression, modifiers: TypeModifier[]|null = null) { super(modifiers); }
+  visitType(visitor: TypeVisitor, context: any): any {
+    return visitor.visitExpressionType(this, context);
+  }
+}
+
+
+export class ArrayType extends Type {
+  constructor(public of : Type, modifiers: TypeModifier[]|null = null) { super(modifiers); }
+  visitType(visitor: TypeVisitor, context: any): any {
+    return visitor.visitArrayType(this, context);
+  }
+}
+
+
+export class MapType extends Type {
+  public valueType: Type|null;
+  constructor(valueType: Type|null|undefined, modifiers: TypeModifier[]|null = null) {
+    super(modifiers);
+    this.valueType = valueType || null;
+  }
+  visitType(visitor: TypeVisitor, context: any): any { return visitor.visitMapType(this, context); }
+}
+
+export const DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);
+export const INFERRED_TYPE = new BuiltinType(BuiltinTypeName.Inferred);
+export const BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);
+export const INT_TYPE = new BuiltinType(BuiltinTypeName.Int);
+export const NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);
+export const STRING_TYPE = new BuiltinType(BuiltinTypeName.String);
+export const FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);
+
+export interface TypeVisitor {
+  visitBuiltintType(type: BuiltinType, context: any): any;
+  visitExpressionType(type: ExpressionType, 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 {
+  public type: Type|null;
+  public sourceSpan: ParseSourceSpan|null;
+
+  constructor(type: Type|null|undefined, sourceSpan?: ParseSourceSpan|null) {
+    this.type = type || null;
+    this.sourceSpan = sourceSpan || null;
+  }
+
+  abstract visitExpression(visitor: ExpressionVisitor, context: any): any;
+
+  prop(name: string, sourceSpan?: ParseSourceSpan|null): ReadPropExpr {
+    return new ReadPropExpr(this, name, null, sourceSpan);
+  }
+
+  key(index: Expression, type?: Type|null, sourceSpan?: ParseSourceSpan|null): ReadKeyExpr {
+    return new ReadKeyExpr(this, index, type, sourceSpan);
+  }
+
+  callMethod(name: string|BuiltinMethod, params: Expression[], sourceSpan?: ParseSourceSpan|null):
+      InvokeMethodExpr {
+    return new InvokeMethodExpr(this, name, params, null, sourceSpan);
+  }
+
+  callFn(params: Expression[], sourceSpan?: ParseSourceSpan|null): InvokeFunctionExpr {
+    return new InvokeFunctionExpr(this, params, null, sourceSpan);
+  }
+
+  instantiate(params: Expression[], type?: Type|null, sourceSpan?: ParseSourceSpan|null):
+      InstantiateExpr {
+    return new InstantiateExpr(this, params, type, sourceSpan);
+  }
+
+  conditional(
+      trueCase: Expression, falseCase: Expression|null = null,
+      sourceSpan?: ParseSourceSpan|null): ConditionalExpr {
+    return new ConditionalExpr(this, trueCase, falseCase, null, sourceSpan);
+  }
+
+  equals(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.Equals, this, rhs, null, sourceSpan);
+  }
+  notEquals(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.NotEquals, this, rhs, null, sourceSpan);
+  }
+  identical(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.Identical, this, rhs, null, sourceSpan);
+  }
+  notIdentical(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.NotIdentical, this, rhs, null, sourceSpan);
+  }
+  minus(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.Minus, this, rhs, null, sourceSpan);
+  }
+  plus(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.Plus, this, rhs, null, sourceSpan);
+  }
+  divide(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.Divide, this, rhs, null, sourceSpan);
+  }
+  multiply(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.Multiply, this, rhs, null, sourceSpan);
+  }
+  modulo(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.Modulo, this, rhs, null, sourceSpan);
+  }
+  and(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.And, this, rhs, null, sourceSpan);
+  }
+  or(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs, null, sourceSpan);
+  }
+  lower(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.Lower, this, rhs, null, sourceSpan);
+  }
+  lowerEquals(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.LowerEquals, this, rhs, null, sourceSpan);
+  }
+  bigger(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.Bigger, this, rhs, null, sourceSpan);
+  }
+  biggerEquals(rhs: Expression, sourceSpan?: ParseSourceSpan|null): BinaryOperatorExpr {
+    return new BinaryOperatorExpr(BinaryOperator.BiggerEquals, this, rhs, null, sourceSpan);
+  }
+  isBlank(sourceSpan?: ParseSourceSpan|null): Expression {
+    // Note: We use equals by purpose here to compare to null and undefined in JS.
+    // We use the typed null to allow strictNullChecks to narrow types.
+    return this.equals(TYPED_NULL_EXPR, sourceSpan);
+  }
+  cast(type: Type, sourceSpan?: ParseSourceSpan|null): Expression {
+    return new CastExpr(this, type, sourceSpan);
+  }
+
+  toStmt(): Statement { return new ExpressionStatement(this, null); }
+}
+
+export enum BuiltinVar {
+  This,
+  Super,
+  CatchError,
+  CatchStack
+}
+
+export class ReadVarExpr extends Expression {
+  public name: string|null;
+  public builtin: BuiltinVar|null;
+
+  constructor(name: string|BuiltinVar, type?: Type|null, sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+    if (typeof name === 'string') {
+      this.name = 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 {
+    if (!this.name) {
+      throw new Error(`Built in variable ${this.builtin} can not be assigned to.`);
+    }
+    return new WriteVarExpr(this.name, value, null, this.sourceSpan);
+  }
+}
+
+
+export class WriteVarExpr extends Expression {
+  public value: Expression;
+  constructor(
+      public name: string, value: Expression, type?: Type|null, sourceSpan?: ParseSourceSpan|null) {
+    super(type || value.type, sourceSpan);
+    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, this.sourceSpan);
+  }
+}
+
+
+export class WriteKeyExpr extends Expression {
+  public value: Expression;
+  constructor(
+      public receiver: Expression, public index: Expression, value: Expression, type?: Type|null,
+      sourceSpan?: ParseSourceSpan|null) {
+    super(type || value.type, sourceSpan);
+    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,
+      sourceSpan?: ParseSourceSpan|null) {
+    super(type || value.type, sourceSpan);
+    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|null;
+  public builtin: BuiltinMethod|null;
+  constructor(
+      public receiver: Expression, method: string|BuiltinMethod, public args: Expression[],
+      type?: Type|null, sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+    if (typeof method === 'string') {
+      this.name = 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,
+      sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+  }
+  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|null,
+      sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitInstantiateExpr(this, context);
+  }
+}
+
+
+export class LiteralExpr extends Expression {
+  constructor(public value: any, type?: Type|null, sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitLiteralExpr(this, context);
+  }
+}
+
+
+export class ExternalExpr extends Expression {
+  constructor(
+      public value: ExternalReference, type?: Type|null, public typeParams: Type[]|null = null,
+      sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitExternalExpr(this, context);
+  }
+}
+
+export class ExternalReference {
+  constructor(public moduleName: string|null, public name: string|null, public runtime?: any|null) {
+  }
+}
+
+export class ConditionalExpr extends Expression {
+  public trueCase: Expression;
+  constructor(
+      public condition: Expression, trueCase: Expression, public falseCase: Expression|null = null,
+      type?: Type|null, sourceSpan?: ParseSourceSpan|null) {
+    super(type || trueCase.type, sourceSpan);
+    this.trueCase = trueCase;
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitConditionalExpr(this, context);
+  }
+}
+
+
+export class NotExpr extends Expression {
+  constructor(public condition: Expression, sourceSpan?: ParseSourceSpan|null) {
+    super(BOOL_TYPE, sourceSpan);
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitNotExpr(this, context);
+  }
+}
+
+export class AssertNotNull extends Expression {
+  constructor(public condition: Expression, sourceSpan?: ParseSourceSpan|null) {
+    super(condition.type, sourceSpan);
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitAssertNotNullExpr(this, context);
+  }
+}
+
+export class CastExpr extends Expression {
+  constructor(public value: Expression, type?: Type|null, sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitCastExpr(this, context);
+  }
+}
+
+
+export class FnParam {
+  constructor(public name: string, public type: Type|null = null) {}
+}
+
+
+export class FunctionExpr extends Expression {
+  constructor(
+      public params: FnParam[], public statements: Statement[], type?: Type|null,
+      sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitFunctionExpr(this, context);
+  }
+
+  toDeclStmt(name: string, modifiers: StmtModifier[]|null = null): DeclareFunctionStmt {
+    return new DeclareFunctionStmt(
+        name, this.params, this.statements, this.type, modifiers, this.sourceSpan);
+  }
+}
+
+
+export class BinaryOperatorExpr extends Expression {
+  public lhs: Expression;
+  constructor(
+      public operator: BinaryOperator, lhs: Expression, public rhs: Expression, type?: Type|null,
+      sourceSpan?: ParseSourceSpan|null) {
+    super(type || lhs.type, sourceSpan);
+    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,
+      sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitReadPropExpr(this, context);
+  }
+  set(value: Expression): WritePropExpr {
+    return new WritePropExpr(this.receiver, this.name, value, null, this.sourceSpan);
+  }
+}
+
+
+export class ReadKeyExpr extends Expression {
+  constructor(
+      public receiver: Expression, public index: Expression, type?: Type|null,
+      sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitReadKeyExpr(this, context);
+  }
+  set(value: Expression): WriteKeyExpr {
+    return new WriteKeyExpr(this.receiver, this.index, value, null, this.sourceSpan);
+  }
+}
+
+
+export class LiteralArrayExpr extends Expression {
+  public entries: Expression[];
+  constructor(entries: Expression[], type?: Type|null, sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+    this.entries = entries;
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitLiteralArrayExpr(this, context);
+  }
+}
+
+export class LiteralMapEntry {
+  constructor(public key: string, public value: Expression, public quoted: boolean) {}
+}
+
+export class LiteralMapExpr extends Expression {
+  public valueType: Type|null = null;
+  constructor(
+      public entries: LiteralMapEntry[], type?: MapType|null, sourceSpan?: ParseSourceSpan|null) {
+    super(type, sourceSpan);
+    if (type) {
+      this.valueType = type.valueType;
+    }
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitLiteralMapExpr(this, context);
+  }
+}
+
+export class CommaExpr extends Expression {
+  constructor(public parts: Expression[], sourceSpan?: ParseSourceSpan|null) {
+    super(parts[parts.length - 1].type, sourceSpan);
+  }
+  visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitCommaExpr(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;
+  visitAssertNotNullExpr(ast: AssertNotNull, 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;
+  visitCommaExpr(ast: CommaExpr, context: any): any;
+}
+
+export const THIS_EXPR = new ReadVarExpr(BuiltinVar.This, null, null);
+export const SUPER_EXPR = new ReadVarExpr(BuiltinVar.Super, null, null);
+export const CATCH_ERROR_VAR = new ReadVarExpr(BuiltinVar.CatchError, null, null);
+export const CATCH_STACK_VAR = new ReadVarExpr(BuiltinVar.CatchStack, null, null);
+export const NULL_EXPR = new LiteralExpr(null, null, null);
+export const TYPED_NULL_EXPR = new LiteralExpr(null, INFERRED_TYPE, null);
+
+//// Statements
+export enum StmtModifier {
+  Final,
+  Private,
+  Exported
+}
+
+export abstract class Statement {
+  public modifiers: StmtModifier[];
+  public sourceSpan: ParseSourceSpan|null;
+  constructor(modifiers?: StmtModifier[]|null, sourceSpan?: ParseSourceSpan|null) {
+    this.modifiers = modifiers || [];
+    this.sourceSpan = sourceSpan || null;
+  }
+
+  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|null;
+  constructor(
+      public name: string, public value: Expression, type?: Type|null,
+      modifiers: StmtModifier[]|null = null, sourceSpan?: ParseSourceSpan|null) {
+    super(modifiers, sourceSpan);
+    this.type = type || value.type;
+  }
+
+  visitStatement(visitor: StatementVisitor, context: any): any {
+    return visitor.visitDeclareVarStmt(this, context);
+  }
+}
+
+export class DeclareFunctionStmt extends Statement {
+  public type: Type|null;
+  constructor(
+      public name: string, public params: FnParam[], public statements: Statement[],
+      type?: Type|null, modifiers: StmtModifier[]|null = null, sourceSpan?: ParseSourceSpan|null) {
+    super(modifiers, sourceSpan);
+    this.type = type || null;
+  }
+
+  visitStatement(visitor: StatementVisitor, context: any): any {
+    return visitor.visitDeclareFunctionStmt(this, context);
+  }
+}
+
+export class ExpressionStatement extends Statement {
+  constructor(public expr: Expression, sourceSpan?: ParseSourceSpan|null) {
+    super(null, sourceSpan);
+  }
+
+  visitStatement(visitor: StatementVisitor, context: any): any {
+    return visitor.visitExpressionStmt(this, context);
+  }
+}
+
+
+export class ReturnStatement extends Statement {
+  constructor(public value: Expression, sourceSpan?: ParseSourceSpan|null) {
+    super(null, sourceSpan);
+  }
+  visitStatement(visitor: StatementVisitor, context: any): any {
+    return visitor.visitReturnStmt(this, context);
+  }
+}
+
+export class AbstractClassPart {
+  public type: Type|null;
+  constructor(type: Type|null|undefined, public modifiers: StmtModifier[]|null) {
+    if (!modifiers) {
+      this.modifiers = [];
+    }
+    this.type = type || null;
+  }
+  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 = null) {
+    super(type, modifiers);
+  }
+}
+
+
+export class ClassMethod extends AbstractClassPart {
+  constructor(
+      public name: string|null, public params: FnParam[], public body: Statement[],
+      type?: Type|null, modifiers: StmtModifier[]|null = null) {
+    super(type, modifiers);
+  }
+}
+
+
+export class ClassGetter extends AbstractClassPart {
+  constructor(
+      public name: string, public body: Statement[], type?: Type|null,
+      modifiers: StmtModifier[]|null = null) {
+    super(type, modifiers);
+  }
+}
+
+
+export class ClassStmt extends Statement {
+  constructor(
+      public name: string, public parent: Expression|null, public fields: ClassField[],
+      public getters: ClassGetter[], public constructorMethod: ClassMethod,
+      public methods: ClassMethod[], modifiers: StmtModifier[]|null = null,
+      sourceSpan?: ParseSourceSpan|null) {
+    super(modifiers, sourceSpan);
+  }
+  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[] = [], sourceSpan?: ParseSourceSpan|null) {
+    super(null, sourceSpan);
+  }
+  visitStatement(visitor: StatementVisitor, context: any): any {
+    return visitor.visitIfStmt(this, context);
+  }
+}
+
+
+export class CommentStmt extends Statement {
+  constructor(public comment: string, sourceSpan?: ParseSourceSpan|null) {
+    super(null, sourceSpan);
+  }
+  visitStatement(visitor: StatementVisitor, context: any): any {
+    return visitor.visitCommentStmt(this, context);
+  }
+}
+
+
+export class TryCatchStmt extends Statement {
+  constructor(
+      public bodyStmts: Statement[], public catchStmts: Statement[],
+      sourceSpan?: ParseSourceSpan|null) {
+    super(null, sourceSpan);
+  }
+  visitStatement(visitor: StatementVisitor, context: any): any {
+    return visitor.visitTryCatchStmt(this, context);
+  }
+}
+
+
+export class ThrowStmt extends Statement {
+  constructor(public error: Expression, sourceSpan?: ParseSourceSpan|null) {
+    super(null, sourceSpan);
+  }
+  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 AstTransformer implements StatementVisitor, ExpressionVisitor {
+  transformExpr(expr: Expression, context: any): Expression { return expr; }
+
+  transformStmt(stmt: Statement, context: any): Statement { return stmt; }
+
+  visitReadVarExpr(ast: ReadVarExpr, context: any): any { return this.transformExpr(ast, context); }
+
+  visitWriteVarExpr(expr: WriteVarExpr, context: any): any {
+    return this.transformExpr(
+        new WriteVarExpr(
+            expr.name, expr.value.visitExpression(this, context), expr.type, expr.sourceSpan),
+        context);
+  }
+
+  visitWriteKeyExpr(expr: WriteKeyExpr, context: any): any {
+    return this.transformExpr(
+        new WriteKeyExpr(
+            expr.receiver.visitExpression(this, context), expr.index.visitExpression(this, context),
+            expr.value.visitExpression(this, context), expr.type, expr.sourceSpan),
+        context);
+  }
+
+  visitWritePropExpr(expr: WritePropExpr, context: any): any {
+    return this.transformExpr(
+        new WritePropExpr(
+            expr.receiver.visitExpression(this, context), expr.name,
+            expr.value.visitExpression(this, context), expr.type, expr.sourceSpan),
+        context);
+  }
+
+  visitInvokeMethodExpr(ast: InvokeMethodExpr, context: any): any {
+    const method = ast.builtin || ast.name;
+    return this.transformExpr(
+        new InvokeMethodExpr(
+            ast.receiver.visitExpression(this, context), method !,
+            this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan),
+        context);
+  }
+
+  visitInvokeFunctionExpr(ast: InvokeFunctionExpr, context: any): any {
+    return this.transformExpr(
+        new InvokeFunctionExpr(
+            ast.fn.visitExpression(this, context), this.visitAllExpressions(ast.args, context),
+            ast.type, ast.sourceSpan),
+        context);
+  }
+
+  visitInstantiateExpr(ast: InstantiateExpr, context: any): any {
+    return this.transformExpr(
+        new InstantiateExpr(
+            ast.classExpr.visitExpression(this, context),
+            this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan),
+        context);
+  }
+
+  visitLiteralExpr(ast: LiteralExpr, context: any): any { return this.transformExpr(ast, context); }
+
+  visitExternalExpr(ast: ExternalExpr, context: any): any {
+    return this.transformExpr(ast, context);
+  }
+
+  visitConditionalExpr(ast: ConditionalExpr, context: any): any {
+    return this.transformExpr(
+        new ConditionalExpr(
+            ast.condition.visitExpression(this, context),
+            ast.trueCase.visitExpression(this, context),
+            ast.falseCase !.visitExpression(this, context), ast.type, ast.sourceSpan),
+        context);
+  }
+
+  visitNotExpr(ast: NotExpr, context: any): any {
+    return this.transformExpr(
+        new NotExpr(ast.condition.visitExpression(this, context), ast.sourceSpan), context);
+  }
+
+  visitAssertNotNullExpr(ast: AssertNotNull, context: any): any {
+    return this.transformExpr(
+        new AssertNotNull(ast.condition.visitExpression(this, context), ast.sourceSpan), context);
+  }
+
+  visitCastExpr(ast: CastExpr, context: any): any {
+    return this.transformExpr(
+        new CastExpr(ast.value.visitExpression(this, context), ast.type, ast.sourceSpan), context);
+  }
+
+  visitFunctionExpr(ast: FunctionExpr, context: any): any {
+    return this.transformExpr(
+        new FunctionExpr(
+            ast.params, this.visitAllStatements(ast.statements, context), ast.type, ast.sourceSpan),
+        context);
+  }
+
+  visitBinaryOperatorExpr(ast: BinaryOperatorExpr, context: any): any {
+    return this.transformExpr(
+        new BinaryOperatorExpr(
+            ast.operator, ast.lhs.visitExpression(this, context),
+            ast.rhs.visitExpression(this, context), ast.type, ast.sourceSpan),
+        context);
+  }
+
+  visitReadPropExpr(ast: ReadPropExpr, context: any): any {
+    return this.transformExpr(
+        new ReadPropExpr(
+            ast.receiver.visitExpression(this, context), ast.name, ast.type, ast.sourceSpan),
+        context);
+  }
+
+  visitReadKeyExpr(ast: ReadKeyExpr, context: any): any {
+    return this.transformExpr(
+        new ReadKeyExpr(
+            ast.receiver.visitExpression(this, context), ast.index.visitExpression(this, context),
+            ast.type, ast.sourceSpan),
+        context);
+  }
+
+  visitLiteralArrayExpr(ast: LiteralArrayExpr, context: any): any {
+    return this.transformExpr(
+        new LiteralArrayExpr(
+            this.visitAllExpressions(ast.entries, context), ast.type, ast.sourceSpan),
+        context);
+  }
+
+  visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any {
+    const entries = ast.entries.map(
+        (entry): LiteralMapEntry => new LiteralMapEntry(
+            entry.key, entry.value.visitExpression(this, context), entry.quoted));
+    const mapType = new MapType(ast.valueType, null);
+    return this.transformExpr(new LiteralMapExpr(entries, mapType, ast.sourceSpan), context);
+  }
+  visitCommaExpr(ast: CommaExpr, context: any): any {
+    return this.transformExpr(
+        new CommaExpr(this.visitAllExpressions(ast.parts, context), ast.sourceSpan), context);
+  }
+  visitAllExpressions(exprs: Expression[], context: any): Expression[] {
+    return exprs.map(expr => expr.visitExpression(this, context));
+  }
+
+  visitDeclareVarStmt(stmt: DeclareVarStmt, context: any): any {
+    return this.transformStmt(
+        new DeclareVarStmt(
+            stmt.name, stmt.value.visitExpression(this, context), stmt.type, stmt.modifiers,
+            stmt.sourceSpan),
+        context);
+  }
+  visitDeclareFunctionStmt(stmt: DeclareFunctionStmt, context: any): any {
+    return this.transformStmt(
+        new DeclareFunctionStmt(
+            stmt.name, stmt.params, this.visitAllStatements(stmt.statements, context), stmt.type,
+            stmt.modifiers, stmt.sourceSpan),
+        context);
+  }
+
+  visitExpressionStmt(stmt: ExpressionStatement, context: any): any {
+    return this.transformStmt(
+        new ExpressionStatement(stmt.expr.visitExpression(this, context), stmt.sourceSpan),
+        context);
+  }
+
+  visitReturnStmt(stmt: ReturnStatement, context: any): any {
+    return this.transformStmt(
+        new ReturnStatement(stmt.value.visitExpression(this, context), stmt.sourceSpan), context);
+  }
+
+  visitDeclareClassStmt(stmt: ClassStmt, context: any): any {
+    const parent = stmt.parent !.visitExpression(this, context);
+    const getters = stmt.getters.map(
+        getter => new ClassGetter(
+            getter.name, this.visitAllStatements(getter.body, context), getter.type,
+            getter.modifiers));
+    const ctorMethod = stmt.constructorMethod &&
+        new ClassMethod(stmt.constructorMethod.name, stmt.constructorMethod.params,
+                        this.visitAllStatements(stmt.constructorMethod.body, context),
+                        stmt.constructorMethod.type, stmt.constructorMethod.modifiers);
+    const methods = stmt.methods.map(
+        method => new ClassMethod(
+            method.name, method.params, this.visitAllStatements(method.body, context), method.type,
+            method.modifiers));
+    return this.transformStmt(
+        new ClassStmt(
+            stmt.name, parent, stmt.fields, getters, ctorMethod, methods, stmt.modifiers,
+            stmt.sourceSpan),
+        context);
+  }
+
+  visitIfStmt(stmt: IfStmt, context: any): any {
+    return this.transformStmt(
+        new IfStmt(
+            stmt.condition.visitExpression(this, context),
+            this.visitAllStatements(stmt.trueCase, context),
+            this.visitAllStatements(stmt.falseCase, context), stmt.sourceSpan),
+        context);
+  }
+
+  visitTryCatchStmt(stmt: TryCatchStmt, context: any): any {
+    return this.transformStmt(
+        new TryCatchStmt(
+            this.visitAllStatements(stmt.bodyStmts, context),
+            this.visitAllStatements(stmt.catchStmts, context), stmt.sourceSpan),
+        context);
+  }
+
+  visitThrowStmt(stmt: ThrowStmt, context: any): any {
+    return this.transformStmt(
+        new ThrowStmt(stmt.error.visitExpression(this, context), stmt.sourceSpan), context);
+  }
+
+  visitCommentStmt(stmt: CommentStmt, context: any): any {
+    return this.transformStmt(stmt, context);
+  }
+
+  visitAllStatements(stmts: Statement[], context: any): Statement[] {
+    return stmts.map(stmt => stmt.visitStatement(this, context));
+  }
+}
+
+
+export class RecursiveAstVisitor 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;
+  }
+  visitAssertNotNullExpr(ast: AssertNotNull, 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 {
+    this.visitAllStatements(ast.statements, context);
+    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) => entry.value.visitExpression(this, context));
+    return ast;
+  }
+  visitCommaExpr(ast: CommaExpr, context: any): any {
+    this.visitAllExpressions(ast.parts, context);
+  }
+  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 {
+    this.visitAllStatements(stmt.statements, context);
+    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 {
+    stmt.parent !.visitExpression(this, context);
+    stmt.getters.forEach(getter => this.visitAllStatements(getter.body, context));
+    if (stmt.constructorMethod) {
+      this.visitAllStatements(stmt.constructorMethod.body, context);
+    }
+    stmt.methods.forEach(method => this.visitAllStatements(method.body, context));
+    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 findReadVarNames(stmts: Statement[]): Set<string> {
+  const visitor = new _ReadVarVisitor();
+  visitor.visitAllStatements(stmts, null);
+  return visitor.varNames;
+}
+
+class _ReadVarVisitor extends RecursiveAstVisitor {
+  varNames = new Set<string>();
+  visitDeclareFunctionStmt(stmt: DeclareFunctionStmt, context: any): any {
+    // Don't descend into nested functions
+    return stmt;
+  }
+  visitDeclareClassStmt(stmt: ClassStmt, context: any): any {
+    // Don't descend into nested classes
+    return stmt;
+  }
+  visitReadVarExpr(ast: ReadVarExpr, context: any): any {
+    if (ast.name) {
+      this.varNames.add(ast.name);
+    }
+    return null;
+  }
+}
+
+export function applySourceSpanToStatementIfNeeded(
+    stmt: Statement, sourceSpan: ParseSourceSpan | null): Statement {
+  if (!sourceSpan) {
+    return stmt;
+  }
+  const transformer = new _ApplySourceSpanTransformer(sourceSpan);
+  return stmt.visitStatement(transformer, null);
+}
+
+export function applySourceSpanToExpressionIfNeeded(
+    expr: Expression, sourceSpan: ParseSourceSpan | null): Expression {
+  if (!sourceSpan) {
+    return expr;
+  }
+  const transformer = new _ApplySourceSpanTransformer(sourceSpan);
+  return expr.visitExpression(transformer, null);
+}
+
+class _ApplySourceSpanTransformer extends AstTransformer {
+  constructor(private sourceSpan: ParseSourceSpan) { super(); }
+  private _clone(obj: any): any {
+    const clone = Object.create(obj.constructor.prototype);
+    for (let prop in obj) {
+      clone[prop] = obj[prop];
+    }
+    return clone;
+  }
+
+  transformExpr(expr: Expression, context: any): Expression {
+    if (!expr.sourceSpan) {
+      expr = this._clone(expr);
+      expr.sourceSpan = this.sourceSpan;
+    }
+    return expr;
+  }
+
+  transformStmt(stmt: Statement, context: any): Statement {
+    if (!stmt.sourceSpan) {
+      stmt = this._clone(stmt);
+      stmt.sourceSpan = this.sourceSpan;
+    }
+    return stmt;
+  }
+}
+
+export function variable(
+    name: string, type?: Type | null, sourceSpan?: ParseSourceSpan | null): ReadVarExpr {
+  return new ReadVarExpr(name, type, sourceSpan);
+}
+
+export function importExpr(
+    id: ExternalReference, typeParams: Type[] | null = null,
+    sourceSpan?: ParseSourceSpan | null): ExternalExpr {
+  return new ExternalExpr(id, null, typeParams, sourceSpan);
+}
+
+export function importType(
+    id: ExternalReference, typeParams: Type[] | null = null,
+    typeModifiers: TypeModifier[] | null = null): ExpressionType|null {
+  return id != null ? expressionType(importExpr(id, typeParams, null), typeModifiers) : null;
+}
+
+export function expressionType(
+    expr: Expression, typeModifiers: TypeModifier[] | null = null): ExpressionType|null {
+  return expr != null ? new ExpressionType(expr, typeModifiers) ! : null;
+}
+
+export function literalArr(
+    values: Expression[], type?: Type | null,
+    sourceSpan?: ParseSourceSpan | null): LiteralArrayExpr {
+  return new LiteralArrayExpr(values, type, sourceSpan);
+}
+
+export function literalMap(
+    values: {key: string, quoted: boolean, value: Expression}[],
+    type: MapType | null = null): LiteralMapExpr {
+  return new LiteralMapExpr(
+      values.map(e => new LiteralMapEntry(e.key, e.value, e.quoted)), type, null);
+}
+
+export function not(expr: Expression, sourceSpan?: ParseSourceSpan | null): NotExpr {
+  return new NotExpr(expr, sourceSpan);
+}
+
+export function assertNotNull(
+    expr: Expression, sourceSpan?: ParseSourceSpan | null): AssertNotNull {
+  return new AssertNotNull(expr, sourceSpan);
+}
+
+export function fn(
+    params: FnParam[], body: Statement[], type?: Type | null,
+    sourceSpan?: ParseSourceSpan | null): FunctionExpr {
+  return new FunctionExpr(params, body, type, sourceSpan);
+}
+
+export function literal(
+    value: any, type?: Type | null, sourceSpan?: ParseSourceSpan | null): LiteralExpr {
+  return new LiteralExpr(value, type, sourceSpan);
+}
diff --git a/angular/compiler/src/output/output_interpreter.ts b/angular/compiler/src/output/output_interpreter.ts
new file mode 100644
index 0000000..3f2b134
--- /dev/null
+++ b/angular/compiler/src/output/output_interpreter.ts
@@ -0,0 +1,351 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+
+import {CompileReflector} from '../compile_reflector';
+
+import * as o from './output_ast';
+import {debugOutputAstAsTypeScript} from './ts_emitter';
+
+export function interpretStatements(
+    statements: o.Statement[], reflector: CompileReflector): {[key: string]: any} {
+  const ctx = new _ExecutionContext(null, null, null, new Map<string, any>());
+  const visitor = new StatementInterpreter(reflector);
+  visitor.visitAllStatements(statements, ctx);
+  const result: {[key: string]: any} = {};
+  ctx.exports.forEach((exportName) => { result[exportName] = ctx.vars.get(exportName); });
+  return result;
+}
+
+function _executeFunctionStatements(
+    varNames: string[], varValues: any[], statements: o.Statement[], ctx: _ExecutionContext,
+    visitor: StatementInterpreter): any {
+  const childCtx = ctx.createChildWihtLocalVars();
+  for (let i = 0; i < varNames.length; i++) {
+    childCtx.vars.set(varNames[i], varValues[i]);
+  }
+  const result = visitor.visitAllStatements(statements, childCtx);
+  return result ? result.value : null;
+}
+
+class _ExecutionContext {
+  exports: string[] = [];
+
+  constructor(
+      public parent: _ExecutionContext|null, public instance: any, public className: string|null,
+      public vars: Map<string, any>) {}
+
+  createChildWihtLocalVars(): _ExecutionContext {
+    return new _ExecutionContext(this, this.instance, this.className, new Map<string, any>());
+  }
+}
+
+class ReturnValue {
+  constructor(public value: any) {}
+}
+
+function createDynamicClass(
+    _classStmt: o.ClassStmt, _ctx: _ExecutionContext, _visitor: StatementInterpreter): Function {
+  const propertyDescriptors: {[key: string]: any} = {};
+
+  _classStmt.getters.forEach((getter: o.ClassGetter) => {
+    // Note: use `function` instead of arrow function to capture `this`
+    propertyDescriptors[getter.name] = {
+      configurable: false,
+      get: function() {
+        const instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars);
+        return _executeFunctionStatements([], [], getter.body, instanceCtx, _visitor);
+      }
+    };
+  });
+  _classStmt.methods.forEach(function(method: o.ClassMethod) {
+    const paramNames = method.params.map(param => param.name);
+    // Note: use `function` instead of arrow function to capture `this`
+    propertyDescriptors[method.name !] = {
+      writable: false,
+      configurable: false,
+      value: function(...args: any[]) {
+        const instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars);
+        return _executeFunctionStatements(paramNames, args, method.body, instanceCtx, _visitor);
+      }
+    };
+  });
+
+  const ctorParamNames = _classStmt.constructorMethod.params.map(param => param.name);
+  // Note: use `function` instead of arrow function to capture `this`
+  const ctor = function(...args: any[]) {
+    const instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars);
+    _classStmt.fields.forEach((field) => { this[field.name] = undefined; });
+    _executeFunctionStatements(
+        ctorParamNames, args, _classStmt.constructorMethod.body, instanceCtx, _visitor);
+  };
+  const superClass = _classStmt.parent ? _classStmt.parent.visitExpression(_visitor, _ctx) : Object;
+  ctor.prototype = Object.create(superClass.prototype, propertyDescriptors);
+  return ctor;
+}
+
+class StatementInterpreter implements o.StatementVisitor, o.ExpressionVisitor {
+  constructor(private reflector: CompileReflector) {}
+  debugAst(ast: o.Expression|o.Statement|o.Type): string { return debugOutputAstAsTypeScript(ast); }
+
+  visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: _ExecutionContext): any {
+    ctx.vars.set(stmt.name, stmt.value.visitExpression(this, ctx));
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      ctx.exports.push(stmt.name);
+    }
+    return null;
+  }
+  visitWriteVarExpr(expr: o.WriteVarExpr, ctx: _ExecutionContext): any {
+    const value = expr.value.visitExpression(this, ctx);
+    let currCtx = ctx;
+    while (currCtx != null) {
+      if (currCtx.vars.has(expr.name)) {
+        currCtx.vars.set(expr.name, value);
+        return value;
+      }
+      currCtx = currCtx.parent !;
+    }
+    throw new Error(`Not declared variable ${expr.name}`);
+  }
+  visitReadVarExpr(ast: o.ReadVarExpr, ctx: _ExecutionContext): any {
+    let varName = ast.name !;
+    if (ast.builtin != null) {
+      switch (ast.builtin) {
+        case o.BuiltinVar.Super:
+          return ctx.instance.__proto__;
+        case o.BuiltinVar.This:
+          return ctx.instance;
+        case o.BuiltinVar.CatchError:
+          varName = CATCH_ERROR_VAR;
+          break;
+        case o.BuiltinVar.CatchStack:
+          varName = CATCH_STACK_VAR;
+          break;
+        default:
+          throw new Error(`Unknown builtin variable ${ast.builtin}`);
+      }
+    }
+    let currCtx = ctx;
+    while (currCtx != null) {
+      if (currCtx.vars.has(varName)) {
+        return currCtx.vars.get(varName);
+      }
+      currCtx = currCtx.parent !;
+    }
+    throw new Error(`Not declared variable ${varName}`);
+  }
+  visitWriteKeyExpr(expr: o.WriteKeyExpr, ctx: _ExecutionContext): any {
+    const receiver = expr.receiver.visitExpression(this, ctx);
+    const index = expr.index.visitExpression(this, ctx);
+    const value = expr.value.visitExpression(this, ctx);
+    receiver[index] = value;
+    return value;
+  }
+  visitWritePropExpr(expr: o.WritePropExpr, ctx: _ExecutionContext): any {
+    const receiver = expr.receiver.visitExpression(this, ctx);
+    const value = expr.value.visitExpression(this, ctx);
+    receiver[expr.name] = value;
+    return value;
+  }
+
+  visitInvokeMethodExpr(expr: o.InvokeMethodExpr, ctx: _ExecutionContext): any {
+    const receiver = expr.receiver.visitExpression(this, ctx);
+    const args = this.visitAllExpressions(expr.args, ctx);
+    let result: any;
+    if (expr.builtin != null) {
+      switch (expr.builtin) {
+        case o.BuiltinMethod.ConcatArray:
+          result = receiver.concat(...args);
+          break;
+        case o.BuiltinMethod.SubscribeObservable:
+          result = receiver.subscribe({next: args[0]});
+          break;
+        case o.BuiltinMethod.Bind:
+          result = receiver.bind(...args);
+          break;
+        default:
+          throw new Error(`Unknown builtin method ${expr.builtin}`);
+      }
+    } else {
+      result = receiver[expr.name !].apply(receiver, args);
+    }
+    return result;
+  }
+  visitInvokeFunctionExpr(stmt: o.InvokeFunctionExpr, ctx: _ExecutionContext): any {
+    const args = this.visitAllExpressions(stmt.args, ctx);
+    const fnExpr = stmt.fn;
+    if (fnExpr instanceof o.ReadVarExpr && fnExpr.builtin === o.BuiltinVar.Super) {
+      ctx.instance.constructor.prototype.constructor.apply(ctx.instance, args);
+      return null;
+    } else {
+      const fn = stmt.fn.visitExpression(this, ctx);
+      return fn.apply(null, args);
+    }
+  }
+  visitReturnStmt(stmt: o.ReturnStatement, ctx: _ExecutionContext): any {
+    return new ReturnValue(stmt.value.visitExpression(this, ctx));
+  }
+  visitDeclareClassStmt(stmt: o.ClassStmt, ctx: _ExecutionContext): any {
+    const clazz = createDynamicClass(stmt, ctx, this);
+    ctx.vars.set(stmt.name, clazz);
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      ctx.exports.push(stmt.name);
+    }
+    return null;
+  }
+  visitExpressionStmt(stmt: o.ExpressionStatement, ctx: _ExecutionContext): any {
+    return stmt.expr.visitExpression(this, ctx);
+  }
+  visitIfStmt(stmt: o.IfStmt, ctx: _ExecutionContext): any {
+    const condition = stmt.condition.visitExpression(this, ctx);
+    if (condition) {
+      return this.visitAllStatements(stmt.trueCase, ctx);
+    } else if (stmt.falseCase != null) {
+      return this.visitAllStatements(stmt.falseCase, ctx);
+    }
+    return null;
+  }
+  visitTryCatchStmt(stmt: o.TryCatchStmt, ctx: _ExecutionContext): any {
+    try {
+      return this.visitAllStatements(stmt.bodyStmts, ctx);
+    } catch (e) {
+      const 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 {
+    const args = this.visitAllExpressions(ast.args, ctx);
+    const clazz = ast.classExpr.visitExpression(this, ctx);
+    return new clazz(...args);
+  }
+  visitLiteralExpr(ast: o.LiteralExpr, ctx: _ExecutionContext): any { return ast.value; }
+  visitExternalExpr(ast: o.ExternalExpr, ctx: _ExecutionContext): any {
+    return this.reflector.resolveExternalReference(ast.value);
+  }
+  visitConditionalExpr(ast: o.ConditionalExpr, ctx: _ExecutionContext): any {
+    if (ast.condition.visitExpression(this, ctx)) {
+      return ast.trueCase.visitExpression(this, ctx);
+    } else if (ast.falseCase != null) {
+      return ast.falseCase.visitExpression(this, ctx);
+    }
+    return null;
+  }
+  visitNotExpr(ast: o.NotExpr, ctx: _ExecutionContext): any {
+    return !ast.condition.visitExpression(this, ctx);
+  }
+  visitAssertNotNullExpr(ast: o.AssertNotNull, 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 {
+    const paramNames = ast.params.map((param) => param.name);
+    return _declareFn(paramNames, ast.statements, ctx, this);
+  }
+  visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: _ExecutionContext): any {
+    const paramNames = stmt.params.map((param) => param.name);
+    ctx.vars.set(stmt.name, _declareFn(paramNames, stmt.statements, ctx, this));
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      ctx.exports.push(stmt.name);
+    }
+    return null;
+  }
+  visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, ctx: _ExecutionContext): any {
+    const lhs = () => ast.lhs.visitExpression(this, ctx);
+    const 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 Error(`Unknown operator ${ast.operator}`);
+    }
+  }
+  visitReadPropExpr(ast: o.ReadPropExpr, ctx: _ExecutionContext): any {
+    let result: any;
+    const receiver = ast.receiver.visitExpression(this, ctx);
+    result = receiver[ast.name];
+    return result;
+  }
+  visitReadKeyExpr(ast: o.ReadKeyExpr, ctx: _ExecutionContext): any {
+    const receiver = ast.receiver.visitExpression(this, ctx);
+    const 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 {
+    const result: {[k: string]: any} = {};
+    ast.entries.forEach(entry => result[entry.key] = entry.value.visitExpression(this, ctx));
+    return result;
+  }
+  visitCommaExpr(ast: o.CommaExpr, context: any): any {
+    const values = this.visitAllExpressions(ast.parts, context);
+    return values[values.length - 1];
+  }
+  visitAllExpressions(expressions: o.Expression[], ctx: _ExecutionContext): any {
+    return expressions.map((expr) => expr.visitExpression(this, ctx));
+  }
+
+  visitAllStatements(statements: o.Statement[], ctx: _ExecutionContext): ReturnValue|null {
+    for (let i = 0; i < statements.length; i++) {
+      const stmt = statements[i];
+      const 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 {
+  return (...args: any[]) => _executeFunctionStatements(varNames, args, statements, ctx, visitor);
+}
+
+const CATCH_ERROR_VAR = 'error';
+const CATCH_STACK_VAR = 'stack';
diff --git a/angular/compiler/src/output/output_jit.ts b/angular/compiler/src/output/output_jit.ts
new file mode 100644
index 0000000..1239c92
--- /dev/null
+++ b/angular/compiler/src/output/output_jit.ts
@@ -0,0 +1,103 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {identifierName} from '../compile_metadata';
+import {CompileReflector} from '../compile_reflector';
+
+import {EmitterVisitorContext} from './abstract_emitter';
+import {AbstractJsEmitterVisitor} from './abstract_js_emitter';
+import * as o from './output_ast';
+
+function evalExpression(
+    sourceUrl: string, ctx: EmitterVisitorContext, vars: {[key: string]: any},
+    createSourceMap: boolean): any {
+  let fnBody = `${ctx.toSource()}\n//# sourceURL=${sourceUrl}`;
+  const fnArgNames: string[] = [];
+  const fnArgValues: any[] = [];
+  for (const argName in vars) {
+    fnArgNames.push(argName);
+    fnArgValues.push(vars[argName]);
+  }
+  if (createSourceMap) {
+    // using `new Function(...)` generates a header, 1 line of no arguments, 2 lines otherwise
+    // E.g. ```
+    // function anonymous(a,b,c
+    // /**/) { ... }```
+    // We don't want to hard code this fact, so we auto detect it via an empty function first.
+    const emptyFn = new Function(...fnArgNames.concat('return null;')).toString();
+    const headerLines = emptyFn.slice(0, emptyFn.indexOf('return null;')).split('\n').length - 1;
+    fnBody += `\n${ctx.toSourceMapGenerator(sourceUrl, sourceUrl, headerLines).toJsComment()}`;
+  }
+  return new Function(...fnArgNames.concat(fnBody))(...fnArgValues);
+}
+
+export function jitStatements(
+    sourceUrl: string, statements: o.Statement[], reflector: CompileReflector,
+    createSourceMaps: boolean): {[key: string]: any} {
+  const converter = new JitEmitterVisitor(reflector);
+  const ctx = EmitterVisitorContext.createRoot();
+  converter.visitAllStatements(statements, ctx);
+  converter.createReturnStmt(ctx);
+  return evalExpression(sourceUrl, ctx, converter.getArgs(), createSourceMaps);
+}
+
+export class JitEmitterVisitor extends AbstractJsEmitterVisitor {
+  private _evalArgNames: string[] = [];
+  private _evalArgValues: any[] = [];
+  private _evalExportedVars: string[] = [];
+
+  constructor(private reflector: CompileReflector) { super(); }
+
+  createReturnStmt(ctx: EmitterVisitorContext) {
+    const stmt = new o.ReturnStatement(new o.LiteralMapExpr(this._evalExportedVars.map(
+        resultVar => new o.LiteralMapEntry(resultVar, o.variable(resultVar), false))));
+    stmt.visitStatement(this, ctx);
+  }
+
+  getArgs(): {[key: string]: any} {
+    const result: {[key: string]: any} = {};
+    for (let i = 0; i < this._evalArgNames.length; i++) {
+      result[this._evalArgNames[i]] = this._evalArgValues[i];
+    }
+    return result;
+  }
+
+  visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any {
+    const value = this.reflector.resolveExternalReference(ast.value);
+    let id = this._evalArgValues.indexOf(value);
+    if (id === -1) {
+      id = this._evalArgValues.length;
+      this._evalArgValues.push(value);
+      const name = identifierName({reference: value}) || 'val';
+      this._evalArgNames.push(`jit_${name}_${id}`);
+    }
+    ctx.print(ast, this._evalArgNames[id]);
+    return null;
+  }
+
+  visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any {
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      this._evalExportedVars.push(stmt.name);
+    }
+    return super.visitDeclareVarStmt(stmt, ctx);
+  }
+
+  visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: EmitterVisitorContext): any {
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      this._evalExportedVars.push(stmt.name);
+    }
+    return super.visitDeclareFunctionStmt(stmt, ctx);
+  }
+
+  visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      this._evalExportedVars.push(stmt.name);
+    }
+    return super.visitDeclareClassStmt(stmt, ctx);
+  }
+}
diff --git a/angular/compiler/src/output/source_map.ts b/angular/compiler/src/output/source_map.ts
new file mode 100644
index 0000000..595e942
--- /dev/null
+++ b/angular/compiler/src/output/source_map.ts
@@ -0,0 +1,186 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {utf8Encode} from '../util';
+
+// https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+const VERSION = 3;
+
+const JS_B64_PREFIX = '# sourceMappingURL=data:application/json;base64,';
+
+type Segment = {
+  col0: number,
+  sourceUrl?: string,
+  sourceLine0?: number,
+  sourceCol0?: number,
+};
+
+export type SourceMap = {
+  version: number,
+  file?: string,
+  sourceRoot: string,
+  sources: string[],
+  sourcesContent: (string | null)[],
+  mappings: string,
+};
+
+export class SourceMapGenerator {
+  private sourcesContent: Map<string, string|null> = new Map();
+  private lines: Segment[][] = [];
+  private lastCol0: number = 0;
+  private hasMappings = false;
+
+  constructor(private file: string|null = null) {}
+
+  // The content is `null` when the content is expected to be loaded using the URL
+  addSource(url: string, content: string|null = null): this {
+    if (!this.sourcesContent.has(url)) {
+      this.sourcesContent.set(url, content);
+    }
+    return this;
+  }
+
+  addLine(): this {
+    this.lines.push([]);
+    this.lastCol0 = 0;
+    return this;
+  }
+
+  addMapping(col0: number, sourceUrl?: string, sourceLine0?: number, sourceCol0?: number): this {
+    if (!this.currentLine) {
+      throw new Error(`A line must be added before mappings can be added`);
+    }
+    if (sourceUrl != null && !this.sourcesContent.has(sourceUrl)) {
+      throw new Error(`Unknown source file "${sourceUrl}"`);
+    }
+    if (col0 == null) {
+      throw new Error(`The column in the generated code must be provided`);
+    }
+    if (col0 < this.lastCol0) {
+      throw new Error(`Mapping should be added in output order`);
+    }
+    if (sourceUrl && (sourceLine0 == null || sourceCol0 == null)) {
+      throw new Error(`The source location must be provided when a source url is provided`);
+    }
+
+    this.hasMappings = true;
+    this.lastCol0 = col0;
+    this.currentLine.push({col0, sourceUrl, sourceLine0, sourceCol0});
+    return this;
+  }
+
+  private get currentLine(): Segment[]|null { return this.lines.slice(-1)[0]; }
+
+  toJSON(): SourceMap|null {
+    if (!this.hasMappings) {
+      return null;
+    }
+
+    const sourcesIndex = new Map<string, number>();
+    const sources: string[] = [];
+    const sourcesContent: (string | null)[] = [];
+
+    Array.from(this.sourcesContent.keys()).forEach((url: string, i: number) => {
+      sourcesIndex.set(url, i);
+      sources.push(url);
+      sourcesContent.push(this.sourcesContent.get(url) || null);
+    });
+
+    let mappings: string = '';
+    let lastCol0: number = 0;
+    let lastSourceIndex: number = 0;
+    let lastSourceLine0: number = 0;
+    let lastSourceCol0: number = 0;
+
+    this.lines.forEach(segments => {
+      lastCol0 = 0;
+
+      mappings += segments
+                      .map(segment => {
+                        // zero-based starting column of the line in the generated code
+                        let segAsStr = toBase64VLQ(segment.col0 - lastCol0);
+                        lastCol0 = segment.col0;
+
+                        if (segment.sourceUrl != null) {
+                          // zero-based index into the “sources” list
+                          segAsStr +=
+                              toBase64VLQ(sourcesIndex.get(segment.sourceUrl) ! - lastSourceIndex);
+                          lastSourceIndex = sourcesIndex.get(segment.sourceUrl) !;
+                          // the zero-based starting line in the original source
+                          segAsStr += toBase64VLQ(segment.sourceLine0 ! - lastSourceLine0);
+                          lastSourceLine0 = segment.sourceLine0 !;
+                          // the zero-based starting column in the original source
+                          segAsStr += toBase64VLQ(segment.sourceCol0 ! - lastSourceCol0);
+                          lastSourceCol0 = segment.sourceCol0 !;
+                        }
+
+                        return segAsStr;
+                      })
+                      .join(',');
+      mappings += ';';
+    });
+
+    mappings = mappings.slice(0, -1);
+
+    return {
+      'file': this.file || '',
+      'version': VERSION,
+      'sourceRoot': '',
+      'sources': sources,
+      'sourcesContent': sourcesContent,
+      'mappings': mappings,
+    };
+  }
+
+  toJsComment(): string {
+    return this.hasMappings ? '//' + JS_B64_PREFIX + toBase64String(JSON.stringify(this, null, 0)) :
+                              '';
+  }
+}
+
+export function toBase64String(value: string): string {
+  let b64 = '';
+  value = utf8Encode(value);
+  for (let i = 0; i < value.length;) {
+    const i1 = value.charCodeAt(i++);
+    const i2 = value.charCodeAt(i++);
+    const i3 = value.charCodeAt(i++);
+    b64 += toBase64Digit(i1 >> 2);
+    b64 += toBase64Digit(((i1 & 3) << 4) | (isNaN(i2) ? 0 : i2 >> 4));
+    b64 += isNaN(i2) ? '=' : toBase64Digit(((i2 & 15) << 2) | (i3 >> 6));
+    b64 += isNaN(i2) || isNaN(i3) ? '=' : toBase64Digit(i3 & 63);
+  }
+
+  return b64;
+}
+
+function toBase64VLQ(value: number): string {
+  value = value < 0 ? ((-value) << 1) + 1 : value << 1;
+
+  let out = '';
+  do {
+    let digit = value & 31;
+    value = value >> 5;
+    if (value > 0) {
+      digit = digit | 32;
+    }
+    out += toBase64Digit(digit);
+  } while (value > 0);
+
+  return out;
+}
+
+const B64_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+function toBase64Digit(value: number): string {
+  if (value < 0 || value >= 64) {
+    throw new Error(`Can only encode value in the range [0, 63]`);
+  }
+
+  return B64_DIGITS[value];
+}
diff --git a/angular/compiler/src/output/ts_emitter.ts b/angular/compiler/src/output/ts_emitter.ts
new file mode 100644
index 0000000..74f2b84
--- /dev/null
+++ b/angular/compiler/src/output/ts_emitter.ts
@@ -0,0 +1,411 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+import {StaticSymbol} from '../aot/static_symbol';
+import {CompileIdentifierMetadata} from '../compile_metadata';
+
+import {AbstractEmitterVisitor, CATCH_ERROR_VAR, CATCH_STACK_VAR, EmitterVisitorContext, OutputEmitter} from './abstract_emitter';
+import * as o from './output_ast';
+
+const _debugFilePath = '/debug/lib';
+
+export function debugOutputAstAsTypeScript(ast: o.Statement | o.Expression | o.Type | any[]):
+    string {
+  const converter = new _TsEmitterVisitor();
+  const ctx = EmitterVisitorContext.createRoot();
+  const asts: any[] = Array.isArray(ast) ? ast : [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 Error(`Don't know how to print debug info for ${ast}`);
+    }
+  });
+  return ctx.toSource();
+}
+
+
+export class TypeScriptEmitter implements OutputEmitter {
+  emitStatementsAndContext(
+      srcFilePath: string, genFilePath: string, stmts: o.Statement[], preamble: string = '',
+      emitSourceMaps: boolean = true): {sourceText: string, context: EmitterVisitorContext} {
+    const converter = new _TsEmitterVisitor();
+
+    const ctx = EmitterVisitorContext.createRoot();
+
+    converter.visitAllStatements(stmts, ctx);
+
+    const preambleLines = preamble ? preamble.split('\n') : [];
+    converter.reexports.forEach((reexports, exportedModuleName) => {
+      const reexportsCode =
+          reexports.map(reexport => `${reexport.name} as ${reexport.as}`).join(',');
+      preambleLines.push(`export {${reexportsCode}} from '${exportedModuleName}';`);
+    });
+
+    converter.importsWithPrefixes.forEach((prefix, importedModuleName) => {
+      // Note: can't write the real word for import as it screws up system.js auto detection...
+      preambleLines.push(
+          `imp` +
+          `ort * as ${prefix} from '${importedModuleName}';`);
+    });
+
+    const sm = emitSourceMaps ?
+        ctx.toSourceMapGenerator(srcFilePath, genFilePath, preambleLines.length).toJsComment() :
+        '';
+    const lines = [...preambleLines, ctx.toSource(), sm];
+    if (sm) {
+      // always add a newline at the end, as some tools have bugs without it.
+      lines.push('');
+    }
+    ctx.setPreambleLineCount(preambleLines.length);
+    return {sourceText: lines.join('\n'), context: ctx};
+  }
+
+  emitStatements(
+      srcFilePath: string, genFilePath: string, stmts: o.Statement[], preamble: string = '') {
+    return this.emitStatementsAndContext(srcFilePath, genFilePath, stmts, preamble).sourceText;
+  }
+}
+
+class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor {
+  private typeExpression = 0;
+
+  constructor() { super(false); }
+
+  importsWithPrefixes = new Map<string, string>();
+  reexports = new Map<string, {name: string, as: string}[]>();
+
+  visitType(t: o.Type|null, ctx: EmitterVisitorContext, defaultType: string = 'any') {
+    if (t) {
+      this.typeExpression++;
+      t.visitType(this, ctx);
+      this.typeExpression--;
+    } else {
+      ctx.print(null, defaultType);
+    }
+  }
+
+  visitLiteralExpr(ast: o.LiteralExpr, ctx: EmitterVisitorContext): any {
+    const value = ast.value;
+    if (value == null && ast.type != o.INFERRED_TYPE) {
+      ctx.print(ast, `(${value} as any)`);
+      return null;
+    }
+    return super.visitLiteralExpr(ast, ctx);
+  }
+
+
+  // Temporary workaround to support strictNullCheck enabled consumers of ngc emit.
+  // In SNC mode, [] have the type never[], so we cast here to any[].
+  // TODO: narrow the cast to a more explicit type, or use a pattern that does not
+  // start with [].concat. see https://github.com/angular/angular/pull/11846
+  visitLiteralArrayExpr(ast: o.LiteralArrayExpr, ctx: EmitterVisitorContext): any {
+    if (ast.entries.length === 0) {
+      ctx.print(ast, '(');
+    }
+    const result = super.visitLiteralArrayExpr(ast, ctx);
+    if (ast.entries.length === 0) {
+      ctx.print(ast, ' as any[])');
+    }
+    return result;
+  }
+
+  visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any {
+    this._visitIdentifier(ast.value, ast.typeParams, ctx);
+    return null;
+  }
+
+  visitAssertNotNullExpr(ast: o.AssertNotNull, ctx: EmitterVisitorContext): any {
+    const result = super.visitAssertNotNullExpr(ast, ctx);
+    ctx.print(ast, '!');
+    return result;
+  }
+
+  visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any {
+    if (stmt.hasModifier(o.StmtModifier.Exported) && stmt.value instanceof o.ExternalExpr &&
+        !stmt.type) {
+      // check for a reexport
+      const {name, moduleName} = stmt.value.value;
+      if (moduleName) {
+        let reexports = this.reexports.get(moduleName);
+        if (!reexports) {
+          reexports = [];
+          this.reexports.set(moduleName, reexports);
+        }
+        reexports.push({name: name !, as: stmt.name});
+        return null;
+      }
+    }
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      ctx.print(stmt, `export `);
+    }
+    if (stmt.hasModifier(o.StmtModifier.Final)) {
+      ctx.print(stmt, `const`);
+    } else {
+      ctx.print(stmt, `var`);
+    }
+    ctx.print(stmt, ` ${stmt.name}`);
+    this._printColonType(stmt.type, ctx);
+    ctx.print(stmt, ` = `);
+    stmt.value.visitExpression(this, ctx);
+    ctx.println(stmt, `;`);
+    return null;
+  }
+
+  visitCastExpr(ast: o.CastExpr, ctx: EmitterVisitorContext): any {
+    ctx.print(ast, `(<`);
+    ast.type !.visitType(this, ctx);
+    ctx.print(ast, `>`);
+    ast.value.visitExpression(this, ctx);
+    ctx.print(ast, `)`);
+    return null;
+  }
+
+  visitInstantiateExpr(ast: o.InstantiateExpr, ctx: EmitterVisitorContext): any {
+    ctx.print(ast, `new `);
+    this.typeExpression++;
+    ast.classExpr.visitExpression(this, ctx);
+    this.typeExpression--;
+    ctx.print(ast, `(`);
+    this.visitAllExpressions(ast.args, ctx, ',');
+    ctx.print(ast, `)`);
+    return null;
+  }
+
+  visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {
+    ctx.pushClass(stmt);
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      ctx.print(stmt, `export `);
+    }
+    ctx.print(stmt, `class ${stmt.name}`);
+    if (stmt.parent != null) {
+      ctx.print(stmt, ` extends `);
+      this.typeExpression++;
+      stmt.parent.visitExpression(this, ctx);
+      this.typeExpression--;
+    }
+    ctx.println(stmt, ` {`);
+    ctx.incIndent();
+    stmt.fields.forEach((field) => this._visitClassField(field, ctx));
+    if (stmt.constructorMethod != null) {
+      this._visitClassConstructor(stmt, ctx);
+    }
+    stmt.getters.forEach((getter) => this._visitClassGetter(getter, ctx));
+    stmt.methods.forEach((method) => this._visitClassMethod(method, ctx));
+    ctx.decIndent();
+    ctx.println(stmt, `}`);
+    ctx.popClass();
+    return null;
+  }
+
+  private _visitClassField(field: o.ClassField, ctx: EmitterVisitorContext) {
+    if (field.hasModifier(o.StmtModifier.Private)) {
+      // comment out as a workaround for #10967
+      ctx.print(null, `/*private*/ `);
+    }
+    ctx.print(null, field.name);
+    this._printColonType(field.type, ctx);
+    ctx.println(null, `;`);
+  }
+
+  private _visitClassGetter(getter: o.ClassGetter, ctx: EmitterVisitorContext) {
+    if (getter.hasModifier(o.StmtModifier.Private)) {
+      ctx.print(null, `private `);
+    }
+    ctx.print(null, `get ${getter.name}()`);
+    this._printColonType(getter.type, ctx);
+    ctx.println(null, ` {`);
+    ctx.incIndent();
+    this.visitAllStatements(getter.body, ctx);
+    ctx.decIndent();
+    ctx.println(null, `}`);
+  }
+
+  private _visitClassConstructor(stmt: o.ClassStmt, ctx: EmitterVisitorContext) {
+    ctx.print(stmt, `constructor(`);
+    this._visitParams(stmt.constructorMethod.params, ctx);
+    ctx.println(stmt, `) {`);
+    ctx.incIndent();
+    this.visitAllStatements(stmt.constructorMethod.body, ctx);
+    ctx.decIndent();
+    ctx.println(stmt, `}`);
+  }
+
+  private _visitClassMethod(method: o.ClassMethod, ctx: EmitterVisitorContext) {
+    if (method.hasModifier(o.StmtModifier.Private)) {
+      ctx.print(null, `private `);
+    }
+    ctx.print(null, `${method.name}(`);
+    this._visitParams(method.params, ctx);
+    ctx.print(null, `)`);
+    this._printColonType(method.type, ctx, 'void');
+    ctx.println(null, ` {`);
+    ctx.incIndent();
+    this.visitAllStatements(method.body, ctx);
+    ctx.decIndent();
+    ctx.println(null, `}`);
+  }
+
+  visitFunctionExpr(ast: o.FunctionExpr, ctx: EmitterVisitorContext): any {
+    ctx.print(ast, `(`);
+    this._visitParams(ast.params, ctx);
+    ctx.print(ast, `)`);
+    this._printColonType(ast.type, ctx, 'void');
+    ctx.println(ast, ` => {`);
+    ctx.incIndent();
+    this.visitAllStatements(ast.statements, ctx);
+    ctx.decIndent();
+    ctx.print(ast, `}`);
+    return null;
+  }
+
+  visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: EmitterVisitorContext): any {
+    if (stmt.hasModifier(o.StmtModifier.Exported)) {
+      ctx.print(stmt, `export `);
+    }
+    ctx.print(stmt, `function ${stmt.name}(`);
+    this._visitParams(stmt.params, ctx);
+    ctx.print(stmt, `)`);
+    this._printColonType(stmt.type, ctx, 'void');
+    ctx.println(stmt, ` {`);
+    ctx.incIndent();
+    this.visitAllStatements(stmt.statements, ctx);
+    ctx.decIndent();
+    ctx.println(stmt, `}`);
+    return null;
+  }
+
+  visitTryCatchStmt(stmt: o.TryCatchStmt, ctx: EmitterVisitorContext): any {
+    ctx.println(stmt, `try {`);
+    ctx.incIndent();
+    this.visitAllStatements(stmt.bodyStmts, ctx);
+    ctx.decIndent();
+    ctx.println(stmt, `} catch (${CATCH_ERROR_VAR.name}) {`);
+    ctx.incIndent();
+    const catchStmts =
+        [<o.Statement>CATCH_STACK_VAR.set(CATCH_ERROR_VAR.prop('stack', null)).toDeclStmt(null, [
+          o.StmtModifier.Final
+        ])].concat(stmt.catchStmts);
+    this.visitAllStatements(catchStmts, ctx);
+    ctx.decIndent();
+    ctx.println(stmt, `}`);
+    return null;
+  }
+
+  visitBuiltintType(type: o.BuiltinType, ctx: EmitterVisitorContext): any {
+    let typeStr: string;
+    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 Error(`Unsupported builtin type ${type.name}`);
+    }
+    ctx.print(null, typeStr);
+    return null;
+  }
+
+  visitExpressionType(ast: o.ExpressionType, ctx: EmitterVisitorContext): any {
+    ast.value.visitExpression(this, ctx);
+    return null;
+  }
+
+  visitArrayType(type: o.ArrayType, ctx: EmitterVisitorContext): any {
+    this.visitType(type.of, ctx);
+    ctx.print(null, `[]`);
+    return null;
+  }
+
+  visitMapType(type: o.MapType, ctx: EmitterVisitorContext): any {
+    ctx.print(null, `{[key: string]:`);
+    this.visitType(type.valueType, ctx);
+    ctx.print(null, `}`);
+    return null;
+  }
+
+  getBuiltinMethodName(method: o.BuiltinMethod): string {
+    let name: string;
+    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 Error(`Unknown builtin method: ${method}`);
+    }
+    return name;
+  }
+
+  private _visitParams(params: o.FnParam[], ctx: EmitterVisitorContext): void {
+    this.visitAllObjects(param => {
+      ctx.print(null, param.name);
+      this._printColonType(param.type, ctx);
+    }, params, ctx, ',');
+  }
+
+  private _visitIdentifier(
+      value: o.ExternalReference, typeParams: o.Type[]|null, ctx: EmitterVisitorContext): void {
+    const {name, moduleName} = value;
+    if (moduleName) {
+      let prefix = this.importsWithPrefixes.get(moduleName);
+      if (prefix == null) {
+        prefix = `i${this.importsWithPrefixes.size}`;
+        this.importsWithPrefixes.set(moduleName, prefix);
+      }
+      ctx.print(null, `${prefix}.`);
+    }
+    ctx.print(null, name !);
+
+    if (this.typeExpression > 0) {
+      // If we are in a type expression that refers to a generic type then supply
+      // the required type parameters. If there were not enough type parameters
+      // supplied, supply any as the type. Outside a type expression the reference
+      // should not supply type parameters and be treated as a simple value reference
+      // to the constructor function itself.
+      const suppliedParameters = typeParams || [];
+      if (suppliedParameters.length > 0) {
+        ctx.print(null, `<`);
+        this.visitAllObjects(type => type.visitType(this, ctx), typeParams !, ctx, ',');
+        ctx.print(null, `>`);
+      }
+    }
+  }
+
+  private _printColonType(type: o.Type|null, ctx: EmitterVisitorContext, defaultType?: string) {
+    if (type !== o.INFERRED_TYPE) {
+      ctx.print(null, ':');
+      this.visitType(type, ctx, defaultType);
+    }
+  }
+}
diff --git a/angular/compiler/src/output/value_util.ts b/angular/compiler/src/output/value_util.ts
new file mode 100644
index 0000000..c043800
--- /dev/null
+++ b/angular/compiler/src/output/value_util.ts
@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+import {OutputContext, ValueTransformer, visitValue} from '../util';
+
+import * as o from './output_ast';
+
+export const QUOTED_KEYS = '$quoted$';
+
+export function convertValueToOutputAst(
+    ctx: OutputContext, value: any, type: o.Type | null = null): o.Expression {
+  return visitValue(value, new _ValueOutputAstTransformer(ctx), type);
+}
+
+class _ValueOutputAstTransformer implements ValueTransformer {
+  constructor(private ctx: OutputContext) {}
+  visitArray(arr: any[], type: o.Type): o.Expression {
+    return o.literalArr(arr.map(value => visitValue(value, this, null)), type);
+  }
+
+  visitStringMap(map: {[key: string]: any}, type: o.MapType): o.Expression {
+    const entries: o.LiteralMapEntry[] = [];
+    const quotedSet = new Set<string>(map && map[QUOTED_KEYS]);
+    Object.keys(map).forEach(key => {
+      entries.push(
+          new o.LiteralMapEntry(key, visitValue(map[key], this, null), quotedSet.has(key)));
+    });
+    return new o.LiteralMapExpr(entries, type);
+  }
+
+  visitPrimitive(value: any, type: o.Type): o.Expression { return o.literal(value, type); }
+
+  visitOther(value: any, type: o.Type): o.Expression {
+    if (value instanceof o.Expression) {
+      return value;
+    } else {
+      return this.ctx.importExpr(value);
+    }
+  }
+}
diff --git a/angular/compiler/src/parse_util.ts b/angular/compiler/src/parse_util.ts
new file mode 100644
index 0000000..536309c
--- /dev/null
+++ b/angular/compiler/src/parse_util.ts
@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as chars from './chars';
+import {CompileIdentifierMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
+
+export class ParseLocation {
+  constructor(
+      public file: ParseSourceFile, public offset: number, public line: number,
+      public col: number) {}
+
+  toString(): string {
+    return this.offset != null ? `${this.file.url}@${this.line}:${this.col}` : this.file.url;
+  }
+
+  moveBy(delta: number): ParseLocation {
+    const source = this.file.content;
+    const len = source.length;
+    let offset = this.offset;
+    let line = this.line;
+    let col = this.col;
+    while (offset > 0 && delta < 0) {
+      offset--;
+      delta++;
+      const ch = source.charCodeAt(offset);
+      if (ch == chars.$LF) {
+        line--;
+        const priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode(chars.$LF));
+        col = priorLine > 0 ? offset - priorLine : offset;
+      } else {
+        col--;
+      }
+    }
+    while (offset < len && delta > 0) {
+      const ch = source.charCodeAt(offset);
+      offset++;
+      delta--;
+      if (ch == chars.$LF) {
+        line++;
+        col = 0;
+      } else {
+        col++;
+      }
+    }
+    return new ParseLocation(this.file, offset, line, col);
+  }
+
+  // Return the source around the location
+  // Up to `maxChars` or `maxLines` on each side of the location
+  getContext(maxChars: number, maxLines: number): {before: string, after: string}|null {
+    const content = this.file.content;
+    let startOffset = this.offset;
+
+    if (startOffset != null) {
+      if (startOffset > content.length - 1) {
+        startOffset = content.length - 1;
+      }
+      let endOffset = startOffset;
+      let ctxChars = 0;
+      let ctxLines = 0;
+
+      while (ctxChars < maxChars && startOffset > 0) {
+        startOffset--;
+        ctxChars++;
+        if (content[startOffset] == '\n') {
+          if (++ctxLines == maxLines) {
+            break;
+          }
+        }
+      }
+
+      ctxChars = 0;
+      ctxLines = 0;
+      while (ctxChars < maxChars && endOffset < content.length - 1) {
+        endOffset++;
+        ctxChars++;
+        if (content[endOffset] == '\n') {
+          if (++ctxLines == maxLines) {
+            break;
+          }
+        }
+      }
+
+      return {
+        before: content.substring(startOffset, this.offset),
+        after: content.substring(this.offset, endOffset + 1),
+      };
+    }
+
+    return null;
+  }
+}
+
+export class ParseSourceFile {
+  constructor(public content: string, public url: string) {}
+}
+
+export class ParseSourceSpan {
+  constructor(
+      public start: ParseLocation, public end: ParseLocation, public details: string|null = null) {}
+
+  toString(): string {
+    return this.start.file.content.substring(this.start.offset, this.end.offset);
+  }
+}
+
+export enum ParseErrorLevel {
+  WARNING,
+  ERROR,
+}
+
+export class ParseError {
+  constructor(
+      public span: ParseSourceSpan, public msg: string,
+      public level: ParseErrorLevel = ParseErrorLevel.ERROR) {}
+
+  contextualMessage(): string {
+    const ctx = this.span.start.getContext(100, 3);
+    return ctx ? ` ("${ctx.before}[${ParseErrorLevel[this.level]} ->]${ctx.after}")` : '';
+  }
+
+  toString(): string {
+    const details = this.span.details ? `, ${this.span.details}` : '';
+    return `${this.msg}${this.contextualMessage()}: ${this.span.start}${details}`;
+  }
+}
+
+export function typeSourceSpan(kind: string, type: CompileIdentifierMetadata): ParseSourceSpan {
+  const moduleUrl = identifierModuleUrl(type);
+  const sourceFileName = moduleUrl != null ? `in ${kind} ${identifierName(type)} in ${moduleUrl}` :
+                                             `in ${kind} ${identifierName(type)}`;
+  const sourceFile = new ParseSourceFile('', sourceFileName);
+  return new ParseSourceSpan(
+      new ParseLocation(sourceFile, -1, -1, -1), new ParseLocation(sourceFile, -1, -1, -1));
+}
diff --git a/angular/compiler/src/pipe_resolver.ts b/angular/compiler/src/pipe_resolver.ts
new file mode 100644
index 0000000..4f15e9a
--- /dev/null
+++ b/angular/compiler/src/pipe_resolver.ts
@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileReflector} from './compile_reflector';
+import {Pipe, Type, createPipe} from './core';
+import {findLast} from './directive_resolver';
+import {resolveForwardRef, stringify} from './util';
+
+/**
+ * Resolve a `Type` for {@link Pipe}.
+ *
+ * This interface can be overridden by the application developer to create custom behavior.
+ *
+ * See {@link Compiler}
+ */
+export class PipeResolver {
+  constructor(private _reflector: CompileReflector) {}
+
+  isPipe(type: Type) {
+    const typeMetadata = this._reflector.annotations(resolveForwardRef(type));
+    return typeMetadata && typeMetadata.some(createPipe.isTypeOf);
+  }
+
+  /**
+   * Return {@link Pipe} for a given `Type`.
+   */
+  resolve(type: Type, throwIfNotFound = true): Pipe|null {
+    const metas = this._reflector.annotations(resolveForwardRef(type));
+    if (metas) {
+      const annotation = findLast(metas, createPipe.isTypeOf);
+      if (annotation) {
+        return annotation;
+      }
+    }
+    if (throwIfNotFound) {
+      throw new Error(`No Pipe decorator found on ${stringify(type)}`);
+    }
+    return null;
+  }
+}
diff --git a/angular/compiler/src/provider_analyzer.ts b/angular/compiler/src/provider_analyzer.ts
new file mode 100644
index 0000000..f3a1ca4
--- /dev/null
+++ b/angular/compiler/src/provider_analyzer.ts
@@ -0,0 +1,546 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+import {CompileDiDependencyMetadata, CompileDirectiveMetadata, CompileDirectiveSummary, CompileNgModuleMetadata, CompileProviderMetadata, CompileQueryMetadata, CompileTokenMetadata, CompileTypeMetadata, tokenName, tokenReference} from './compile_metadata';
+import {CompileReflector} from './compile_reflector';
+import {Identifiers, createTokenForExternalReference} from './identifiers';
+import {ParseError, ParseSourceSpan} from './parse_util';
+import {AttrAst, DirectiveAst, ProviderAst, ProviderAstType, QueryMatch, ReferenceAst} from './template_parser/template_ast';
+
+export class ProviderError extends ParseError {
+  constructor(message: string, span: ParseSourceSpan) { super(span, message); }
+}
+
+export interface QueryWithId {
+  meta: CompileQueryMetadata;
+  queryId: number;
+}
+
+export class ProviderViewContext {
+  /**
+   * @internal
+   */
+  viewQueries: Map<any, QueryWithId[]>;
+  /**
+   * @internal
+   */
+  viewProviders: Map<any, boolean>;
+  errors: ProviderError[] = [];
+
+  constructor(public reflector: CompileReflector, public component: CompileDirectiveMetadata) {
+    this.viewQueries = _getViewQueries(component);
+    this.viewProviders = new Map<any, boolean>();
+    component.viewProviders.forEach((provider) => {
+      if (this.viewProviders.get(tokenReference(provider.token)) == null) {
+        this.viewProviders.set(tokenReference(provider.token), true);
+      }
+    });
+  }
+}
+
+export class ProviderElementContext {
+  private _contentQueries: Map<any, QueryWithId[]>;
+
+  private _transformedProviders = new Map<any, ProviderAst>();
+  private _seenProviders = new Map<any, boolean>();
+  private _allProviders: Map<any, ProviderAst>;
+  private _attrs: {[key: string]: string};
+  private _hasViewContainer: boolean = false;
+  private _queriedTokens = new Map<any, QueryMatch[]>();
+
+  constructor(
+      public viewContext: ProviderViewContext, private _parent: ProviderElementContext,
+      private _isViewRoot: boolean, private _directiveAsts: DirectiveAst[], attrs: AttrAst[],
+      refs: ReferenceAst[], isTemplate: boolean, contentQueryStartId: number,
+      private _sourceSpan: ParseSourceSpan) {
+    this._attrs = {};
+    attrs.forEach((attrAst) => this._attrs[attrAst.name] = attrAst.value);
+    const directivesMeta = _directiveAsts.map(directiveAst => directiveAst.directive);
+    this._allProviders =
+        _resolveProvidersFromDirectives(directivesMeta, _sourceSpan, viewContext.errors);
+    this._contentQueries = _getContentQueries(contentQueryStartId, directivesMeta);
+    Array.from(this._allProviders.values()).forEach((provider) => {
+      this._addQueryReadsTo(provider.token, provider.token, this._queriedTokens);
+    });
+    if (isTemplate) {
+      const templateRefId =
+          createTokenForExternalReference(this.viewContext.reflector, Identifiers.TemplateRef);
+      this._addQueryReadsTo(templateRefId, templateRefId, this._queriedTokens);
+    }
+    refs.forEach((refAst) => {
+      let defaultQueryValue = refAst.value ||
+          createTokenForExternalReference(this.viewContext.reflector, Identifiers.ElementRef);
+      this._addQueryReadsTo({value: refAst.name}, defaultQueryValue, this._queriedTokens);
+    });
+    if (this._queriedTokens.get(
+            this.viewContext.reflector.resolveExternalReference(Identifiers.ViewContainerRef))) {
+      this._hasViewContainer = true;
+    }
+
+    // create the providers that we know are eager first
+    Array.from(this._allProviders.values()).forEach((provider) => {
+      const eager = provider.eager || this._queriedTokens.get(tokenReference(provider.token));
+      if (eager) {
+        this._getOrCreateLocalProvider(provider.providerType, provider.token, true);
+      }
+    });
+  }
+
+  afterElement() {
+    // collect lazy providers
+    Array.from(this._allProviders.values()).forEach((provider) => {
+      this._getOrCreateLocalProvider(provider.providerType, provider.token, false);
+    });
+  }
+
+  get transformProviders(): ProviderAst[] {
+    // Note: Maps keep their insertion order.
+    const lazyProviders: ProviderAst[] = [];
+    const eagerProviders: ProviderAst[] = [];
+    this._transformedProviders.forEach(provider => {
+      if (provider.eager) {
+        eagerProviders.push(provider);
+      } else {
+        lazyProviders.push(provider);
+      }
+    });
+    return lazyProviders.concat(eagerProviders);
+  }
+
+  get transformedDirectiveAsts(): DirectiveAst[] {
+    const sortedProviderTypes = this.transformProviders.map(provider => provider.token.identifier);
+    const sortedDirectives = this._directiveAsts.slice();
+    sortedDirectives.sort(
+        (dir1, dir2) => sortedProviderTypes.indexOf(dir1.directive.type) -
+            sortedProviderTypes.indexOf(dir2.directive.type));
+    return sortedDirectives;
+  }
+
+  get transformedHasViewContainer(): boolean { return this._hasViewContainer; }
+
+  get queryMatches(): QueryMatch[] {
+    const allMatches: QueryMatch[] = [];
+    this._queriedTokens.forEach((matches: QueryMatch[]) => { allMatches.push(...matches); });
+    return allMatches;
+  }
+
+  private _addQueryReadsTo(
+      token: CompileTokenMetadata, defaultValue: CompileTokenMetadata,
+      queryReadTokens: Map<any, QueryMatch[]>) {
+    this._getQueriesFor(token).forEach((query) => {
+      const queryValue = query.meta.read || defaultValue;
+      const tokenRef = tokenReference(queryValue);
+      let queryMatches = queryReadTokens.get(tokenRef);
+      if (!queryMatches) {
+        queryMatches = [];
+        queryReadTokens.set(tokenRef, queryMatches);
+      }
+      queryMatches.push({queryId: query.queryId, value: queryValue});
+    });
+  }
+
+  private _getQueriesFor(token: CompileTokenMetadata): QueryWithId[] {
+    const result: QueryWithId[] = [];
+    let currentEl: ProviderElementContext = this;
+    let distance = 0;
+    let queries: QueryWithId[]|undefined;
+    while (currentEl !== null) {
+      queries = currentEl._contentQueries.get(tokenReference(token));
+      if (queries) {
+        result.push(...queries.filter((query) => query.meta.descendants || distance <= 1));
+      }
+      if (currentEl._directiveAsts.length > 0) {
+        distance++;
+      }
+      currentEl = currentEl._parent;
+    }
+    queries = this.viewContext.viewQueries.get(tokenReference(token));
+    if (queries) {
+      result.push(...queries);
+    }
+    return result;
+  }
+
+
+  private _getOrCreateLocalProvider(
+      requestingProviderType: ProviderAstType, token: CompileTokenMetadata,
+      eager: boolean): ProviderAst|null {
+    const resolvedProvider = this._allProviders.get(tokenReference(token));
+    if (!resolvedProvider || ((requestingProviderType === ProviderAstType.Directive ||
+                               requestingProviderType === ProviderAstType.PublicService) &&
+                              resolvedProvider.providerType === ProviderAstType.PrivateService) ||
+        ((requestingProviderType === ProviderAstType.PrivateService ||
+          requestingProviderType === ProviderAstType.PublicService) &&
+         resolvedProvider.providerType === ProviderAstType.Builtin)) {
+      return null;
+    }
+    let transformedProviderAst = this._transformedProviders.get(tokenReference(token));
+    if (transformedProviderAst) {
+      return transformedProviderAst;
+    }
+    if (this._seenProviders.get(tokenReference(token)) != null) {
+      this.viewContext.errors.push(new ProviderError(
+          `Cannot instantiate cyclic dependency! ${tokenName(token)}`, this._sourceSpan));
+      return null;
+    }
+    this._seenProviders.set(tokenReference(token), true);
+    const transformedProviders = resolvedProvider.providers.map((provider) => {
+      let transformedUseValue = provider.useValue;
+      let transformedUseExisting = provider.useExisting !;
+      let transformedDeps: CompileDiDependencyMetadata[] = undefined !;
+      if (provider.useExisting != null) {
+        const existingDiDep = this._getDependency(
+            resolvedProvider.providerType, {token: provider.useExisting}, eager) !;
+        if (existingDiDep.token != null) {
+          transformedUseExisting = existingDiDep.token;
+        } else {
+          transformedUseExisting = null !;
+          transformedUseValue = existingDiDep.value;
+        }
+      } else if (provider.useFactory) {
+        const deps = provider.deps || provider.useFactory.diDeps;
+        transformedDeps =
+            deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep, eager) !);
+      } else if (provider.useClass) {
+        const 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.set(tokenReference(token), transformedProviderAst);
+    return transformedProviderAst;
+  }
+
+  private _getLocalDependency(
+      requestingProviderType: ProviderAstType, dep: CompileDiDependencyMetadata,
+      eager: boolean = false): CompileDiDependencyMetadata|null {
+    if (dep.isAttribute) {
+      const attrValue = this._attrs[dep.token !.value];
+      return {isValue: true, value: attrValue == null ? null : attrValue};
+    }
+
+    if (dep.token != null) {
+      // access builtints
+      if ((requestingProviderType === ProviderAstType.Directive ||
+           requestingProviderType === ProviderAstType.Component)) {
+        if (tokenReference(dep.token) ===
+                this.viewContext.reflector.resolveExternalReference(Identifiers.Renderer) ||
+            tokenReference(dep.token) ===
+                this.viewContext.reflector.resolveExternalReference(Identifiers.ElementRef) ||
+            tokenReference(dep.token) ===
+                this.viewContext.reflector.resolveExternalReference(
+                    Identifiers.ChangeDetectorRef) ||
+            tokenReference(dep.token) ===
+                this.viewContext.reflector.resolveExternalReference(Identifiers.TemplateRef)) {
+          return dep;
+        }
+        if (tokenReference(dep.token) ===
+            this.viewContext.reflector.resolveExternalReference(Identifiers.ViewContainerRef)) {
+          this._hasViewContainer = true;
+        }
+      }
+      // access the injector
+      if (tokenReference(dep.token) ===
+          this.viewContext.reflector.resolveExternalReference(Identifiers.Injector)) {
+        return dep;
+      }
+      // access providers
+      if (this._getOrCreateLocalProvider(requestingProviderType, dep.token, eager) != null) {
+        return dep;
+      }
+    }
+    return null;
+  }
+
+  private _getDependency(
+      requestingProviderType: ProviderAstType, dep: CompileDiDependencyMetadata,
+      eager: boolean = false): CompileDiDependencyMetadata|null {
+    let currElement: ProviderElementContext = this;
+    let currEager: boolean = eager;
+    let result: CompileDiDependencyMetadata|null = null;
+    if (!dep.isSkipSelf) {
+      result = this._getLocalDependency(requestingProviderType, dep, eager);
+    }
+    if (dep.isSelf) {
+      if (!result && dep.isOptional) {
+        result = {isValue: true, value: null};
+      }
+    } else {
+      // check parent elements
+      while (!result && currElement._parent) {
+        const prevElement = currElement;
+        currElement = currElement._parent;
+        if (prevElement._isViewRoot) {
+          currEager = false;
+        }
+        result = currElement._getLocalDependency(ProviderAstType.PublicService, dep, currEager);
+      }
+      // check @Host restriction
+      if (!result) {
+        if (!dep.isHost || this.viewContext.component.isHost ||
+            this.viewContext.component.type.reference === tokenReference(dep.token !) ||
+            this.viewContext.viewProviders.get(tokenReference(dep.token !)) != null) {
+          result = dep;
+        } else {
+          result = dep.isOptional ? result = {isValue: true, value: null} : null;
+        }
+      }
+    }
+    if (!result) {
+      this.viewContext.errors.push(
+          new ProviderError(`No provider for ${tokenName(dep.token!)}`, this._sourceSpan));
+    }
+    return result;
+  }
+}
+
+
+export class NgModuleProviderAnalyzer {
+  private _transformedProviders = new Map<any, ProviderAst>();
+  private _seenProviders = new Map<any, boolean>();
+  private _allProviders: Map<any, ProviderAst>;
+  private _errors: ProviderError[] = [];
+
+  constructor(
+      private reflector: CompileReflector, ngModule: CompileNgModuleMetadata,
+      extraProviders: CompileProviderMetadata[], sourceSpan: ParseSourceSpan) {
+    this._allProviders = new Map<any, ProviderAst>();
+    ngModule.transitiveModule.modules.forEach((ngModuleType: CompileTypeMetadata) => {
+      const ngModuleProvider = {token: {identifier: ngModuleType}, useClass: ngModuleType};
+      _resolveProviders(
+          [ngModuleProvider], ProviderAstType.PublicService, true, sourceSpan, this._errors,
+          this._allProviders);
+    });
+    _resolveProviders(
+        ngModule.transitiveModule.providers.map(entry => entry.provider).concat(extraProviders),
+        ProviderAstType.PublicService, false, sourceSpan, this._errors, this._allProviders);
+  }
+
+  parse(): ProviderAst[] {
+    Array.from(this._allProviders.values()).forEach((provider) => {
+      this._getOrCreateLocalProvider(provider.token, provider.eager);
+    });
+    if (this._errors.length > 0) {
+      const errorString = this._errors.join('\n');
+      throw new Error(`Provider parse errors:\n${errorString}`);
+    }
+    // Note: Maps keep their insertion order.
+    const lazyProviders: ProviderAst[] = [];
+    const eagerProviders: ProviderAst[] = [];
+    this._transformedProviders.forEach(provider => {
+      if (provider.eager) {
+        eagerProviders.push(provider);
+      } else {
+        lazyProviders.push(provider);
+      }
+    });
+    return lazyProviders.concat(eagerProviders);
+  }
+
+  private _getOrCreateLocalProvider(token: CompileTokenMetadata, eager: boolean): ProviderAst|null {
+    const resolvedProvider = this._allProviders.get(tokenReference(token));
+    if (!resolvedProvider) {
+      return null;
+    }
+    let transformedProviderAst = this._transformedProviders.get(tokenReference(token));
+    if (transformedProviderAst) {
+      return transformedProviderAst;
+    }
+    if (this._seenProviders.get(tokenReference(token)) != null) {
+      this._errors.push(new ProviderError(
+          `Cannot instantiate cyclic dependency! ${tokenName(token)}`,
+          resolvedProvider.sourceSpan));
+      return null;
+    }
+    this._seenProviders.set(tokenReference(token), true);
+    const transformedProviders = resolvedProvider.providers.map((provider) => {
+      let transformedUseValue = provider.useValue;
+      let transformedUseExisting = provider.useExisting !;
+      let transformedDeps: CompileDiDependencyMetadata[] = undefined !;
+      if (provider.useExisting != null) {
+        const existingDiDep =
+            this._getDependency({token: provider.useExisting}, eager, resolvedProvider.sourceSpan);
+        if (existingDiDep.token != null) {
+          transformedUseExisting = existingDiDep.token;
+        } else {
+          transformedUseExisting = null !;
+          transformedUseValue = existingDiDep.value;
+        }
+      } else if (provider.useFactory) {
+        const deps = provider.deps || provider.useFactory.diDeps;
+        transformedDeps =
+            deps.map((dep) => this._getDependency(dep, eager, resolvedProvider.sourceSpan));
+      } else if (provider.useClass) {
+        const deps = provider.deps || provider.useClass.diDeps;
+        transformedDeps =
+            deps.map((dep) => this._getDependency(dep, eager, resolvedProvider.sourceSpan));
+      }
+      return _transformProvider(provider, {
+        useExisting: transformedUseExisting,
+        useValue: transformedUseValue,
+        deps: transformedDeps
+      });
+    });
+    transformedProviderAst =
+        _transformProviderAst(resolvedProvider, {eager: eager, providers: transformedProviders});
+    this._transformedProviders.set(tokenReference(token), transformedProviderAst);
+    return transformedProviderAst;
+  }
+
+  private _getDependency(
+      dep: CompileDiDependencyMetadata, eager: boolean = false,
+      requestorSourceSpan: ParseSourceSpan): CompileDiDependencyMetadata {
+    let foundLocal = false;
+    if (!dep.isSkipSelf && dep.token != null) {
+      // access the injector
+      if (tokenReference(dep.token) ===
+              this.reflector.resolveExternalReference(Identifiers.Injector) ||
+          tokenReference(dep.token) ===
+              this.reflector.resolveExternalReference(Identifiers.ComponentFactoryResolver)) {
+        foundLocal = true;
+        // access providers
+      } else if (this._getOrCreateLocalProvider(dep.token, eager) != null) {
+        foundLocal = true;
+      }
+    }
+    let result: CompileDiDependencyMetadata = dep;
+    if (dep.isSelf && !foundLocal) {
+      if (dep.isOptional) {
+        result = {isValue: true, value: null};
+      } else {
+        this._errors.push(
+            new ProviderError(`No provider for ${tokenName(dep.token!)}`, requestorSourceSpan));
+      }
+    }
+    return result;
+  }
+}
+
+function _transformProvider(
+    provider: CompileProviderMetadata,
+    {useExisting, useValue, deps}:
+        {useExisting: CompileTokenMetadata, useValue: any, deps: CompileDiDependencyMetadata[]}) {
+  return {
+    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.lifecycleHooks, provider.sourceSpan);
+}
+
+function _resolveProvidersFromDirectives(
+    directives: CompileDirectiveSummary[], sourceSpan: ParseSourceSpan,
+    targetErrors: ParseError[]): Map<any, ProviderAst> {
+  const providersByToken = new Map<any, ProviderAst>();
+  directives.forEach((directive) => {
+    const dirProvider:
+        CompileProviderMetadata = {token: {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!
+  const directivesWithComponentFirst =
+      directives.filter(dir => dir.isComponent).concat(directives.filter(dir => !dir.isComponent));
+  directivesWithComponentFirst.forEach((directive) => {
+    _resolveProviders(
+        directive.providers, ProviderAstType.PublicService, false, sourceSpan, targetErrors,
+        providersByToken);
+    _resolveProviders(
+        directive.viewProviders, ProviderAstType.PrivateService, false, sourceSpan, targetErrors,
+        providersByToken);
+  });
+  return providersByToken;
+}
+
+function _resolveProviders(
+    providers: CompileProviderMetadata[], providerType: ProviderAstType, eager: boolean,
+    sourceSpan: ParseSourceSpan, targetErrors: ParseError[],
+    targetProvidersByToken: Map<any, ProviderAst>) {
+  providers.forEach((provider) => {
+    let resolvedProvider = targetProvidersByToken.get(tokenReference(provider.token));
+    if (resolvedProvider != null && !!resolvedProvider.multiProvider !== !!provider.multi) {
+      targetErrors.push(new ProviderError(
+          `Mixing multi and non multi provider is not possible for token ${tokenName(resolvedProvider.token)}`,
+          sourceSpan));
+    }
+    if (!resolvedProvider) {
+      const lifecycleHooks = provider.token.identifier &&
+              (<CompileTypeMetadata>provider.token.identifier).lifecycleHooks ?
+          (<CompileTypeMetadata>provider.token.identifier).lifecycleHooks :
+          [];
+      const isUseValue = !(provider.useClass || provider.useExisting || provider.useFactory);
+      resolvedProvider = new ProviderAst(
+          provider.token, !!provider.multi, eager || isUseValue, [provider], providerType,
+          lifecycleHooks, sourceSpan);
+      targetProvidersByToken.set(tokenReference(provider.token), resolvedProvider);
+    } else {
+      if (!provider.multi) {
+        resolvedProvider.providers.length = 0;
+      }
+      resolvedProvider.providers.push(provider);
+    }
+  });
+}
+
+
+function _getViewQueries(component: CompileDirectiveMetadata): Map<any, QueryWithId[]> {
+  // Note: queries start with id 1 so we can use the number in a Bloom filter!
+  let viewQueryId = 1;
+  const viewQueries = new Map<any, QueryWithId[]>();
+  if (component.viewQueries) {
+    component.viewQueries.forEach(
+        (query) => _addQueryToTokenMap(viewQueries, {meta: query, queryId: viewQueryId++}));
+  }
+  return viewQueries;
+}
+
+function _getContentQueries(
+    contentQueryStartId: number, directives: CompileDirectiveSummary[]): Map<any, QueryWithId[]> {
+  let contentQueryId = contentQueryStartId;
+  const contentQueries = new Map<any, QueryWithId[]>();
+  directives.forEach((directive, directiveIndex) => {
+    if (directive.queries) {
+      directive.queries.forEach(
+          (query) => _addQueryToTokenMap(contentQueries, {meta: query, queryId: contentQueryId++}));
+    }
+  });
+  return contentQueries;
+}
+
+function _addQueryToTokenMap(map: Map<any, QueryWithId[]>, query: QueryWithId) {
+  query.meta.selectors.forEach((token: CompileTokenMetadata) => {
+    let entry = map.get(tokenReference(token));
+    if (!entry) {
+      entry = [];
+      map.set(tokenReference(token), entry);
+    }
+    entry.push(query);
+  });
+}
diff --git a/angular/compiler/src/resource_loader.ts b/angular/compiler/src/resource_loader.ts
new file mode 100644
index 0000000..a0237cd
--- /dev/null
+++ b/angular/compiler/src/resource_loader.ts
@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * An interface for retrieving documents by URL that the compiler uses
+ * to load templates.
+ */
+export class ResourceLoader {
+  get(url: string): Promise<string>|string { return ''; }
+}
diff --git a/angular/compiler/src/schema/dom_element_schema_registry.ts b/angular/compiler/src/schema/dom_element_schema_registry.ts
new file mode 100644
index 0000000..7382670
--- /dev/null
+++ b/angular/compiler/src/schema/dom_element_schema_registry.ts
@@ -0,0 +1,440 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA, SchemaMetadata, SecurityContext} from '../core';
+
+import {isNgContainer, isNgContent} from '../ml_parser/tags';
+import {dashCaseToCamelCase} from '../util';
+
+import {SECURITY_SCHEMA} from './dom_security_schema';
+import {ElementSchemaRegistry} from './element_schema_registry';
+
+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|properties` 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]` 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 representation 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,
+ *       see dom_element_schema_registry_spec.ts
+ */
+
+// =================================================================================================
+// =================================================================================================
+// =========== S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P  ===========
+// =================================================================================================
+// =================================================================================================
+//
+//                       DO NOT EDIT THIS DOM SCHEMA WITHOUT A SECURITY REVIEW!
+//
+// Newly added properties must be security reviewed and assigned an appropriate SecurityContext in
+// dom_security_schema.ts. Reach out to mprobst & rjamet for details.
+//
+// =================================================================================================
+
+const SCHEMA: string[] = [
+  '[Element]|textContent,%classList,className,id,innerHTML,*beforecopy,*beforecut,*beforepaste,*copy,*cut,*paste,*search,*selectstart,*webkitfullscreenchange,*webkitfullscreenerror,*wheel,outerHTML,#scrollLeft,#scrollTop,slot' +
+      /* added manually to avoid breaking changes */
+      ',*message,*mozfullscreenchange,*mozfullscreenerror,*mozpointerlockchange,*mozpointerlockerror,*webglcontextcreationerror,*webglcontextlost,*webglcontextrestored',
+  '[HTMLElement]^[Element]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,outerText,!spellcheck,%style,#tabIndex,title,!translate',
+  'abbr,address,article,aside,b,bdi,bdo,cite,code,dd,dfn,dt,em,figcaption,figure,footer,header,i,kbd,main,mark,nav,noscript,rb,rp,rt,rtc,ruby,s,samp,section,small,strong,sub,sup,u,var,wbr^[HTMLElement]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,outerText,!spellcheck,%style,#tabIndex,title,!translate',
+  'media^[HTMLElement]|!autoplay,!controls,%controlsList,%crossOrigin,#currentTime,!defaultMuted,#defaultPlaybackRate,!disableRemotePlayback,!loop,!muted,*encrypted,*waitingforkey,#playbackRate,preload,src,%srcObject,#volume',
+  ':svg:^[HTMLElement]|*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*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^[HTMLElement]|charset,coords,download,hash,host,hostname,href,hreflang,name,password,pathname,ping,port,protocol,referrerPolicy,rel,rev,search,shape,target,text,type,username',
+  'area^[HTMLElement]|alt,coords,download,hash,host,hostname,href,!noHref,password,pathname,ping,port,protocol,referrerPolicy,rel,search,shape,target,username',
+  'audio^media|',
+  'br^[HTMLElement]|clear',
+  'base^[HTMLElement]|href,target',
+  'body^[HTMLElement]|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^[HTMLElement]|!autofocus,!disabled,formAction,formEnctype,formMethod,!formNoValidate,formTarget,name,type,value',
+  'canvas^[HTMLElement]|#height,#width',
+  'content^[HTMLElement]|select',
+  'dl^[HTMLElement]|!compact',
+  'datalist^[HTMLElement]|',
+  'details^[HTMLElement]|!open',
+  'dialog^[HTMLElement]|!open,returnValue',
+  'dir^[HTMLElement]|!compact',
+  'div^[HTMLElement]|align',
+  'embed^[HTMLElement]|align,height,name,src,type,width',
+  'fieldset^[HTMLElement]|!disabled,name',
+  'font^[HTMLElement]|color,face,size',
+  'form^[HTMLElement]|acceptCharset,action,autocomplete,encoding,enctype,method,name,!noValidate,target',
+  'frame^[HTMLElement]|frameBorder,longDesc,marginHeight,marginWidth,name,!noResize,scrolling,src',
+  'frameset^[HTMLElement]|cols,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,rows',
+  'hr^[HTMLElement]|align,color,!noShade,size,width',
+  'head^[HTMLElement]|',
+  'h1,h2,h3,h4,h5,h6^[HTMLElement]|align',
+  'html^[HTMLElement]|version',
+  'iframe^[HTMLElement]|align,!allowFullscreen,frameBorder,height,longDesc,marginHeight,marginWidth,name,referrerPolicy,%sandbox,scrolling,src,srcdoc,width',
+  'img^[HTMLElement]|align,alt,border,%crossOrigin,#height,#hspace,!isMap,longDesc,lowsrc,name,referrerPolicy,sizes,src,srcset,useMap,#vspace,#width',
+  'input^[HTMLElement]|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',
+  'li^[HTMLElement]|type,#value',
+  'label^[HTMLElement]|htmlFor',
+  'legend^[HTMLElement]|align',
+  'link^[HTMLElement]|as,charset,%crossOrigin,!disabled,href,hreflang,integrity,media,referrerPolicy,rel,%relList,rev,%sizes,target,type',
+  'map^[HTMLElement]|name',
+  'marquee^[HTMLElement]|behavior,bgColor,direction,height,#hspace,#loop,#scrollAmount,#scrollDelay,!trueSpeed,#vspace,width',
+  'menu^[HTMLElement]|!compact',
+  'meta^[HTMLElement]|content,httpEquiv,name,scheme',
+  'meter^[HTMLElement]|#high,#low,#max,#min,#optimum,#value',
+  'ins,del^[HTMLElement]|cite,dateTime',
+  'ol^[HTMLElement]|!compact,!reversed,#start,type',
+  'object^[HTMLElement]|align,archive,border,code,codeBase,codeType,data,!declare,height,#hspace,name,standby,type,useMap,#vspace,width',
+  'optgroup^[HTMLElement]|!disabled,label',
+  'option^[HTMLElement]|!defaultSelected,!disabled,label,!selected,text,value',
+  'output^[HTMLElement]|defaultValue,%htmlFor,name,value',
+  'p^[HTMLElement]|align',
+  'param^[HTMLElement]|name,type,value,valueType',
+  'picture^[HTMLElement]|',
+  'pre^[HTMLElement]|#width',
+  'progress^[HTMLElement]|#max,#value',
+  'q,blockquote,cite^[HTMLElement]|',
+  'script^[HTMLElement]|!async,charset,%crossOrigin,!defer,event,htmlFor,integrity,src,text,type',
+  'select^[HTMLElement]|!autofocus,!disabled,#length,!multiple,name,!required,#selectedIndex,#size,value',
+  'shadow^[HTMLElement]|',
+  'slot^[HTMLElement]|name',
+  'source^[HTMLElement]|media,sizes,src,srcset,type',
+  'span^[HTMLElement]|',
+  'style^[HTMLElement]|!disabled,media,type',
+  'caption^[HTMLElement]|align',
+  'th,td^[HTMLElement]|abbr,align,axis,bgColor,ch,chOff,#colSpan,headers,height,!noWrap,#rowSpan,scope,vAlign,width',
+  'col,colgroup^[HTMLElement]|align,ch,chOff,#span,vAlign,width',
+  'table^[HTMLElement]|align,bgColor,border,%caption,cellPadding,cellSpacing,frame,rules,summary,%tFoot,%tHead,width',
+  'tr^[HTMLElement]|align,bgColor,ch,chOff,vAlign',
+  'tfoot,thead,tbody^[HTMLElement]|align,ch,chOff,vAlign',
+  'template^[HTMLElement]|',
+  'textarea^[HTMLElement]|autocapitalize,!autofocus,#cols,defaultValue,dirName,!disabled,#maxLength,#minLength,name,placeholder,!readOnly,!required,#rows,selectionDirection,#selectionEnd,#selectionStart,value,wrap',
+  'title^[HTMLElement]|text',
+  'track^[HTMLElement]|!default,kind,label,src,srclang',
+  'ul^[HTMLElement]|!compact,type',
+  'unknown^[HTMLElement]|',
+  '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: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',
+  'data^[HTMLElement]|value',
+  'keygen^[HTMLElement]|!autofocus,challenge,!disabled,form,keytype,name',
+  'menuitem^[HTMLElement]|type,label,icon,!disabled,!checked,radiogroup,!default',
+  'summary^[HTMLElement]|',
+  'time^[HTMLElement]|dateTime',
+  ':svg:cursor^:svg:|',
+];
+
+const _ATTR_TO_PROP: {[name: string]: string} = {
+  'class': 'className',
+  'for': 'htmlFor',
+  'formaction': 'formAction',
+  'innerHtml': 'innerHTML',
+  'readonly': 'readOnly',
+  'tabindex': 'tabIndex',
+};
+
+export class DomElementSchemaRegistry extends ElementSchemaRegistry {
+  private _schema: {[element: string]: {[property: string]: string}} = {};
+
+  constructor() {
+    super();
+    SCHEMA.forEach(encodedType => {
+      const type: {[property: string]: string} = {};
+      const [strType, strProperties] = encodedType.split('|');
+      const properties = strProperties.split(',');
+      const [typeNames, superName] = strType.split('^');
+      typeNames.split(',').forEach(tag => this._schema[tag.toLowerCase()] = type);
+      const superType = superName && this._schema[superName.toLowerCase()];
+      if (superType) {
+        Object.keys(superType).forEach((prop: string) => { type[prop] = superType[prop]; });
+      }
+      properties.forEach((property: string) => {
+        if (property.length > 0) {
+          switch (property[0]) {
+            case '*':
+              // We don't yet support events.
+              // If ever allowing to bind to events, GO THROUGH A SECURITY REVIEW, allowing events
+              // will
+              // almost certainly introduce bad XSS vulnerabilities.
+              // type[property.substring(1)] = EVENT;
+              break;
+            case '!':
+              type[property.substring(1)] = BOOLEAN;
+              break;
+            case '#':
+              type[property.substring(1)] = NUMBER;
+              break;
+            case '%':
+              type[property.substring(1)] = OBJECT;
+              break;
+            default:
+              type[property] = STRING;
+          }
+        }
+      });
+    });
+  }
+
+  hasProperty(tagName: string, propName: string, schemaMetas: SchemaMetadata[]): boolean {
+    if (schemaMetas.some((schema) => schema.name === NO_ERRORS_SCHEMA.name)) {
+      return true;
+    }
+
+    if (tagName.indexOf('-') > -1) {
+      if (isNgContainer(tagName) || isNgContent(tagName)) {
+        return false;
+      }
+
+      if (schemaMetas.some((schema) => schema.name === CUSTOM_ELEMENTS_SCHEMA.name)) {
+        // Can't tell now as we don't know which properties a custom element will get
+        // once it is instantiated
+        return true;
+      }
+    }
+
+    const elementProperties = this._schema[tagName.toLowerCase()] || this._schema['unknown'];
+    return !!elementProperties[propName];
+  }
+
+  hasElement(tagName: string, schemaMetas: SchemaMetadata[]): boolean {
+    if (schemaMetas.some((schema) => schema.name === NO_ERRORS_SCHEMA.name)) {
+      return true;
+    }
+
+    if (tagName.indexOf('-') > -1) {
+      if (isNgContainer(tagName) || isNgContent(tagName)) {
+        return true;
+      }
+
+      if (schemaMetas.some((schema) => schema.name === CUSTOM_ELEMENTS_SCHEMA.name)) {
+        // Allow any custom elements
+        return true;
+      }
+    }
+
+    return !!this._schema[tagName.toLowerCase()];
+  }
+
+  /**
+   * securityContext returns the security context for the given property on the given DOM tag.
+   *
+   * Tag and property name are statically known and cannot change at runtime, i.e. it is not
+   * possible to bind a value into a changing attribute or tag name.
+   *
+   * The filtering is white list based. All attributes in the schema above are assumed to have the
+   * 'NONE' security context, i.e. that they are safe inert string values. Only specific well known
+   * attack vectors are assigned their appropriate context.
+   */
+  securityContext(tagName: string, propName: string, isAttribute: boolean): SecurityContext {
+    if (isAttribute) {
+      // NB: For security purposes, use the mapped property name, not the attribute name.
+      propName = this.getMappedPropName(propName);
+    }
+
+    // Make sure comparisons are case insensitive, so that case differences between attribute and
+    // property names do not have a security impact.
+    tagName = tagName.toLowerCase();
+    propName = propName.toLowerCase();
+    let ctx = SECURITY_SCHEMA[tagName + '|' + propName];
+    if (ctx) {
+      return ctx;
+    }
+    ctx = SECURITY_SCHEMA['*|' + propName];
+    return ctx ? ctx : SecurityContext.NONE;
+  }
+
+  getMappedPropName(propName: string): string { return _ATTR_TO_PROP[propName] || propName; }
+
+  getDefaultComponentElementName(): string { return 'ng-component'; }
+
+  validateProperty(name: string): {error: boolean, msg?: string} {
+    if (name.toLowerCase().startsWith('on')) {
+      const msg = `Binding to event property '${name}' is disallowed for security reasons, ` +
+          `please use (${name.slice(2)})=...` +
+          `\nIf '${name}' is a directive input, make sure the directive is imported by the` +
+          ` current module.`;
+      return {error: true, msg: msg};
+    } else {
+      return {error: false};
+    }
+  }
+
+  validateAttribute(name: string): {error: boolean, msg?: string} {
+    if (name.toLowerCase().startsWith('on')) {
+      const msg = `Binding to event attribute '${name}' is disallowed for security reasons, ` +
+          `please use (${name.slice(2)})=...`;
+      return {error: true, msg: msg};
+    } else {
+      return {error: false};
+    }
+  }
+
+  allKnownElementNames(): string[] { return Object.keys(this._schema); }
+
+  normalizeAnimationStyleProperty(propName: string): string {
+    return dashCaseToCamelCase(propName);
+  }
+
+  normalizeAnimationStyleValue(camelCaseProp: string, userProvidedProp: string, val: string|number):
+      {error: string, value: string} {
+    let unit: string = '';
+    const strVal = val.toString().trim();
+    let errorMsg: string = null !;
+
+    if (_isPixelDimensionStyle(camelCaseProp) && val !== 0 && val !== '0') {
+      if (typeof val === 'number') {
+        unit = 'px';
+      } else {
+        const valAndSuffixMatch = val.match(/^[+-]?[\d\.]+([a-z]*)$/);
+        if (valAndSuffixMatch && valAndSuffixMatch[1].length == 0) {
+          errorMsg = `Please provide a CSS unit value for ${userProvidedProp}:${val}`;
+        }
+      }
+    }
+    return {error: errorMsg, value: strVal + unit};
+  }
+}
+
+function _isPixelDimensionStyle(prop: string): boolean {
+  switch (prop) {
+    case 'width':
+    case 'height':
+    case 'minWidth':
+    case 'minHeight':
+    case 'maxWidth':
+    case 'maxHeight':
+    case 'left':
+    case 'top':
+    case 'bottom':
+    case 'right':
+    case 'fontSize':
+    case 'outlineWidth':
+    case 'outlineOffset':
+    case 'paddingTop':
+    case 'paddingLeft':
+    case 'paddingBottom':
+    case 'paddingRight':
+    case 'marginTop':
+    case 'marginLeft':
+    case 'marginBottom':
+    case 'marginRight':
+    case 'borderRadius':
+    case 'borderWidth':
+    case 'borderTopWidth':
+    case 'borderLeftWidth':
+    case 'borderRightWidth':
+    case 'borderBottomWidth':
+    case 'textIndent':
+      return true;
+
+    default:
+      return false;
+  }
+}
diff --git a/angular/compiler/src/schema/dom_security_schema.ts b/angular/compiler/src/schema/dom_security_schema.ts
new file mode 100644
index 0000000..0843a95
--- /dev/null
+++ b/angular/compiler/src/schema/dom_security_schema.ts
@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {SecurityContext} from '../core';
+
+// =================================================================================================
+// =================================================================================================
+// =========== S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P  ===========
+// =================================================================================================
+// =================================================================================================
+//
+//        DO NOT EDIT THIS LIST OF SECURITY SENSITIVE PROPERTIES WITHOUT A SECURITY REVIEW!
+//                               Reach out to mprobst for details.
+//
+// =================================================================================================
+
+/** Map from tagName|propertyName SecurityContext. Properties applying to all tags use '*'. */
+export const SECURITY_SCHEMA: {[k: string]: SecurityContext} = {};
+
+function registerContext(ctx: SecurityContext, specs: string[]) {
+  for (const spec of specs) SECURITY_SCHEMA[spec.toLowerCase()] = ctx;
+}
+
+// Case is insignificant below, all element and attribute names are lower-cased for lookup.
+
+registerContext(SecurityContext.HTML, [
+  'iframe|srcdoc',
+  '*|innerHTML',
+  '*|outerHTML',
+]);
+registerContext(SecurityContext.STYLE, ['*|style']);
+// NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them.
+registerContext(SecurityContext.URL, [
+  '*|formAction', 'area|href',       'area|ping',       'audio|src',    'a|href',
+  'a|ping',       'blockquote|cite', 'body|background', 'del|cite',     'form|action',
+  'img|src',      'img|srcset',      'input|src',       'ins|cite',     'q|cite',
+  'source|src',   'source|srcset',   'track|src',       'video|poster', 'video|src',
+]);
+registerContext(SecurityContext.RESOURCE_URL, [
+  'applet|code',
+  'applet|codebase',
+  'base|href',
+  'embed|src',
+  'frame|src',
+  'head|profile',
+  'html|manifest',
+  'iframe|src',
+  'link|href',
+  'media|src',
+  'object|codebase',
+  'object|data',
+  'script|src',
+]);
diff --git a/angular/compiler/src/schema/element_schema_registry.ts b/angular/compiler/src/schema/element_schema_registry.ts
new file mode 100644
index 0000000..ce856f2
--- /dev/null
+++ b/angular/compiler/src/schema/element_schema_registry.ts
@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {SchemaMetadata, SecurityContext} from '../core';
+
+export abstract class ElementSchemaRegistry {
+  abstract hasProperty(tagName: string, propName: string, schemaMetas: SchemaMetadata[]): boolean;
+  abstract hasElement(tagName: string, schemaMetas: SchemaMetadata[]): boolean;
+  abstract securityContext(elementName: string, propName: string, isAttribute: boolean):
+      SecurityContext;
+  abstract allKnownElementNames(): string[];
+  abstract getMappedPropName(propName: string): string;
+  abstract getDefaultComponentElementName(): string;
+  abstract validateProperty(name: string): {error: boolean, msg?: string};
+  abstract validateAttribute(name: string): {error: boolean, msg?: string};
+  abstract normalizeAnimationStyleProperty(propName: string): string;
+  abstract normalizeAnimationStyleValue(
+      camelCaseProp: string, userProvidedProp: string,
+      val: string|number): {error: string, value: string};
+}
diff --git a/angular/compiler/src/selector.ts b/angular/compiler/src/selector.ts
new file mode 100644
index 0000000..f5e7c56
--- /dev/null
+++ b/angular/compiler/src/selector.ts
@@ -0,0 +1,371 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {getHtmlTagDefinition} from './ml_parser/html_tags';
+
+const _SELECTOR_REGEXP = new RegExp(
+    '(\\:not\\()|' +           //":not("
+        '([-\\w]+)|' +         // "tag"
+        '(?:\\.([-\\w]+))|' +  // ".class"
+        // "-" should appear first in the regexp below as FF31 parses "[.-\w]" as a range
+        '(?:\\[([-.\\w*]+)(?:=([\"\']?)([^\\]\"\']*)\\5)?\\])|' +  // "[name]", "[name=value]",
+                                                                   // "[name="value"]",
+                                                                   // "[name='value']"
+        '(\\))|' +                                                 // ")"
+        '(\\s*,\\s*)',                                             // ","
+    'g');
+
+/**
+ * A css selector contains an element name,
+ * css classes and attribute/value pairs with the purpose
+ * of selecting subsets out of them.
+ */
+export class CssSelector {
+  element: string|null = null;
+  classNames: string[] = [];
+  attrs: string[] = [];
+  notSelectors: CssSelector[] = [];
+
+  static parse(selector: string): CssSelector[] {
+    const results: CssSelector[] = [];
+    const _addResult = (res: CssSelector[], cssSel: CssSelector) => {
+      if (cssSel.notSelectors.length > 0 && !cssSel.element && cssSel.classNames.length == 0 &&
+          cssSel.attrs.length == 0) {
+        cssSel.element = '*';
+      }
+      res.push(cssSel);
+    };
+    let cssSelector = new CssSelector();
+    let match: string[]|null;
+    let current = cssSelector;
+    let inNot = false;
+    _SELECTOR_REGEXP.lastIndex = 0;
+    while (match = _SELECTOR_REGEXP.exec(selector)) {
+      if (match[1]) {
+        if (inNot) {
+          throw new Error('Nesting :not is not allowed in a selector');
+        }
+        inNot = true;
+        current = new CssSelector();
+        cssSelector.notSelectors.push(current);
+      }
+      if (match[2]) {
+        current.setElement(match[2]);
+      }
+      if (match[3]) {
+        current.addClassName(match[3]);
+      }
+      if (match[4]) {
+        current.addAttribute(match[4], match[6]);
+      }
+      if (match[7]) {
+        inNot = false;
+        current = cssSelector;
+      }
+      if (match[8]) {
+        if (inNot) {
+          throw new Error('Multiple selectors in :not are not supported');
+        }
+        _addResult(results, cssSelector);
+        cssSelector = current = new CssSelector();
+      }
+    }
+    _addResult(results, cssSelector);
+    return results;
+  }
+
+  isElementSelector(): boolean {
+    return this.hasElementSelector() && this.classNames.length == 0 && this.attrs.length == 0 &&
+        this.notSelectors.length === 0;
+  }
+
+  hasElementSelector(): boolean { return !!this.element; }
+
+  setElement(element: string|null = null) { this.element = element; }
+
+  /** Gets a template string for an element that matches the selector. */
+  getMatchingElementTemplate(): string {
+    const tagName = this.element || 'div';
+    const classAttr = this.classNames.length > 0 ? ` class="${this.classNames.join(' ')}"` : '';
+
+    let attrs = '';
+    for (let i = 0; i < this.attrs.length; i += 2) {
+      const attrName = this.attrs[i];
+      const attrValue = this.attrs[i + 1] !== '' ? `="${this.attrs[i + 1]}"` : '';
+      attrs += ` ${attrName}${attrValue}`;
+    }
+
+    return getHtmlTagDefinition(tagName).isVoid ? `<${tagName}${classAttr}${attrs}/>` :
+                                                  `<${tagName}${classAttr}${attrs}></${tagName}>`;
+  }
+
+  addAttribute(name: string, value: string = '') {
+    this.attrs.push(name, value && value.toLowerCase() || '');
+  }
+
+  addClassName(name: string) { this.classNames.push(name.toLowerCase()); }
+
+  toString(): string {
+    let res: string = this.element || '';
+    if (this.classNames) {
+      this.classNames.forEach(klass => res += `.${klass}`);
+    }
+    if (this.attrs) {
+      for (let i = 0; i < this.attrs.length; i += 2) {
+        const name = this.attrs[i];
+        const value = this.attrs[i + 1];
+        res += `[${name}${value ? '=' + value : ''}]`;
+      }
+    }
+    this.notSelectors.forEach(notSelector => res += `:not(${notSelector})`);
+    return res;
+  }
+}
+
+/**
+ * Reads a list of CssSelectors and allows to calculate which ones
+ * are contained in a given CssSelector.
+ */
+export class SelectorMatcher {
+  static createNotMatcher(notSelectors: CssSelector[]): SelectorMatcher {
+    const notMatcher = new SelectorMatcher();
+    notMatcher.addSelectables(notSelectors, null);
+    return notMatcher;
+  }
+
+  private _elementMap = new Map<string, SelectorContext[]>();
+  private _elementPartialMap = new Map<string, SelectorMatcher>();
+  private _classMap = new Map<string, SelectorContext[]>();
+  private _classPartialMap = new Map<string, SelectorMatcher>();
+  private _attrValueMap = new Map<string, Map<string, SelectorContext[]>>();
+  private _attrValuePartialMap = new Map<string, Map<string, SelectorMatcher>>();
+  private _listContexts: SelectorListContext[] = [];
+
+  addSelectables(cssSelectors: CssSelector[], callbackCtxt?: any) {
+    let listContext: SelectorListContext = null !;
+    if (cssSelectors.length > 1) {
+      listContext = new SelectorListContext(cssSelectors);
+      this._listContexts.push(listContext);
+    }
+    for (let i = 0; i < cssSelectors.length; i++) {
+      this._addSelectable(cssSelectors[i], callbackCtxt, listContext);
+    }
+  }
+
+  /**
+   * Add an object that can be found later on by calling `match`.
+   * @param cssSelector A css selector
+   * @param callbackCtxt An opaque object that will be given to the callback of the `match` function
+   */
+  private _addSelectable(
+      cssSelector: CssSelector, callbackCtxt: any, listContext: SelectorListContext) {
+    let matcher: SelectorMatcher = this;
+    const element = cssSelector.element;
+    const classNames = cssSelector.classNames;
+    const attrs = cssSelector.attrs;
+    const selectable = new SelectorContext(cssSelector, callbackCtxt, listContext);
+
+    if (element) {
+      const isTerminal = attrs.length === 0 && classNames.length === 0;
+      if (isTerminal) {
+        this._addTerminal(matcher._elementMap, element, selectable);
+      } else {
+        matcher = this._addPartial(matcher._elementPartialMap, element);
+      }
+    }
+
+    if (classNames) {
+      for (let i = 0; i < classNames.length; i++) {
+        const isTerminal = attrs.length === 0 && i === classNames.length - 1;
+        const className = classNames[i];
+        if (isTerminal) {
+          this._addTerminal(matcher._classMap, className, selectable);
+        } else {
+          matcher = this._addPartial(matcher._classPartialMap, className);
+        }
+      }
+    }
+
+    if (attrs) {
+      for (let i = 0; i < attrs.length; i += 2) {
+        const isTerminal = i === attrs.length - 2;
+        const name = attrs[i];
+        const value = attrs[i + 1];
+        if (isTerminal) {
+          const terminalMap = matcher._attrValueMap;
+          let terminalValuesMap = terminalMap.get(name);
+          if (!terminalValuesMap) {
+            terminalValuesMap = new Map<string, SelectorContext[]>();
+            terminalMap.set(name, terminalValuesMap);
+          }
+          this._addTerminal(terminalValuesMap, value, selectable);
+        } else {
+          const partialMap = matcher._attrValuePartialMap;
+          let partialValuesMap = partialMap.get(name);
+          if (!partialValuesMap) {
+            partialValuesMap = new Map<string, SelectorMatcher>();
+            partialMap.set(name, partialValuesMap);
+          }
+          matcher = this._addPartial(partialValuesMap, value);
+        }
+      }
+    }
+  }
+
+  private _addTerminal(
+      map: Map<string, SelectorContext[]>, name: string, selectable: SelectorContext) {
+    let terminalList = map.get(name);
+    if (!terminalList) {
+      terminalList = [];
+      map.set(name, terminalList);
+    }
+    terminalList.push(selectable);
+  }
+
+  private _addPartial(map: Map<string, SelectorMatcher>, name: string): SelectorMatcher {
+    let matcher = map.get(name);
+    if (!matcher) {
+      matcher = new SelectorMatcher();
+      map.set(name, matcher);
+    }
+    return matcher;
+  }
+
+  /**
+   * Find the objects that have been added via `addSelectable`
+   * whose css selector is contained in the given css selector.
+   * @param cssSelector A css selector
+   * @param matchedCallback This callback will be called with the object handed into `addSelectable`
+   * @return boolean true if a match was found
+  */
+  match(cssSelector: CssSelector, matchedCallback: ((c: CssSelector, a: any) => void)|null):
+      boolean {
+    let result = false;
+    const element = cssSelector.element !;
+    const classNames = cssSelector.classNames;
+    const attrs = cssSelector.attrs;
+
+    for (let i = 0; i < this._listContexts.length; i++) {
+      this._listContexts[i].alreadyMatched = false;
+    }
+
+    result = this._matchTerminal(this._elementMap, element, cssSelector, matchedCallback) || result;
+    result = this._matchPartial(this._elementPartialMap, element, cssSelector, matchedCallback) ||
+        result;
+
+    if (classNames) {
+      for (let i = 0; i < classNames.length; i++) {
+        const className = classNames[i];
+        result =
+            this._matchTerminal(this._classMap, className, cssSelector, matchedCallback) || result;
+        result =
+            this._matchPartial(this._classPartialMap, className, cssSelector, matchedCallback) ||
+            result;
+      }
+    }
+
+    if (attrs) {
+      for (let i = 0; i < attrs.length; i += 2) {
+        const name = attrs[i];
+        const value = attrs[i + 1];
+
+        const terminalValuesMap = this._attrValueMap.get(name) !;
+        if (value) {
+          result =
+              this._matchTerminal(terminalValuesMap, '', cssSelector, matchedCallback) || result;
+        }
+        result =
+            this._matchTerminal(terminalValuesMap, value, cssSelector, matchedCallback) || result;
+
+        const partialValuesMap = this._attrValuePartialMap.get(name) !;
+        if (value) {
+          result = this._matchPartial(partialValuesMap, '', cssSelector, matchedCallback) || result;
+        }
+        result =
+            this._matchPartial(partialValuesMap, value, cssSelector, matchedCallback) || result;
+      }
+    }
+    return result;
+  }
+
+  /** @internal */
+  _matchTerminal(
+      map: Map<string, SelectorContext[]>, name: string, cssSelector: CssSelector,
+      matchedCallback: ((c: CssSelector, a: any) => void)|null): boolean {
+    if (!map || typeof name !== 'string') {
+      return false;
+    }
+
+    let selectables: SelectorContext[] = map.get(name) || [];
+    const starSelectables: SelectorContext[] = map.get('*') !;
+    if (starSelectables) {
+      selectables = selectables.concat(starSelectables);
+    }
+    if (selectables.length === 0) {
+      return false;
+    }
+    let selectable: SelectorContext;
+    let result = false;
+    for (let i = 0; i < selectables.length; i++) {
+      selectable = selectables[i];
+      result = selectable.finalize(cssSelector, matchedCallback) || result;
+    }
+    return result;
+  }
+
+  /** @internal */
+  _matchPartial(
+      map: Map<string, SelectorMatcher>, name: string, cssSelector: CssSelector,
+      matchedCallback: ((c: CssSelector, a: any) => void)|null): boolean {
+    if (!map || typeof name !== 'string') {
+      return false;
+    }
+
+    const nestedSelector = map.get(name);
+    if (!nestedSelector) {
+      return false;
+    }
+    // TODO(perf): get rid of recursion and measure again
+    // TODO(perf): don't pass the whole selector into the recursion,
+    // but only the not processed parts
+    return nestedSelector.match(cssSelector, matchedCallback);
+  }
+}
+
+
+export class SelectorListContext {
+  alreadyMatched: boolean = false;
+
+  constructor(public selectors: CssSelector[]) {}
+}
+
+// Store context to pass back selector and context when a selector is matched
+export class SelectorContext {
+  notSelectors: CssSelector[];
+
+  constructor(
+      public selector: CssSelector, public cbContext: any,
+      public listContext: SelectorListContext) {
+    this.notSelectors = selector.notSelectors;
+  }
+
+  finalize(cssSelector: CssSelector, callback: ((c: CssSelector, a: any) => void)|null): boolean {
+    let result = true;
+    if (this.notSelectors.length > 0 && (!this.listContext || !this.listContext.alreadyMatched)) {
+      const notMatcher = SelectorMatcher.createNotMatcher(this.notSelectors);
+      result = !notMatcher.match(cssSelector, null);
+    }
+    if (result && callback && (!this.listContext || !this.listContext.alreadyMatched)) {
+      if (this.listContext) {
+        this.listContext.alreadyMatched = true;
+      }
+      callback(this.selector, this.cbContext);
+    }
+    return result;
+  }
+}
diff --git a/angular/compiler/src/shadow_css.ts b/angular/compiler/src/shadow_css.ts
new file mode 100644
index 0000000..330a531
--- /dev/null
+++ b/angular/compiler/src/shadow_css.ts
@@ -0,0 +1,602 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * This file is a port of shadowCSS from webcomponents.js to TypeScript.
+ *
+ * Please make sure to keep to edits in sync with the source file.
+ *
+ * Source:
+ * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js
+ *
+ * The original file level comment is reproduced below
+ */
+
+/*
+  This is a limited shim for ShadowDOM css styling.
+  https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles
+
+  The intention here is to support only the styling features which can be
+  relatively simply implemented. The goal is to allow users to avoid the
+  most obvious pitfalls and do so without compromising performance significantly.
+  For ShadowDOM styling that's not covered here, a set of best practices
+  can be provided that should allow users to accomplish more complex styling.
+
+  The following is a list of specific ShadowDOM styling features and a brief
+  discussion of the approach used to shim.
+
+  Shimmed features:
+
+  * :host, :host-context: ShadowDOM allows styling of the shadowRoot's host
+  element using the :host rule. To shim this feature, the :host styles are
+  reformatted and prefixed with a given scope name and promoted to a
+  document level stylesheet.
+  For example, given a scope name of .foo, a rule like this:
+
+    :host {
+        background: red;
+      }
+    }
+
+  becomes:
+
+    .foo {
+      background: red;
+    }
+
+  * encapsulation: Styles defined within ShadowDOM, apply only to
+  dom inside the ShadowDOM. Polymer uses one of two techniques to implement
+  this feature.
+
+  By default, rules are prefixed with the host element tag name
+  as a descendant selector. This ensures styling does not leak out of the 'top'
+  of the element's ShadowDOM. For example,
+
+  div {
+      font-weight: bold;
+    }
+
+  becomes:
+
+  x-foo div {
+      font-weight: bold;
+    }
+
+  becomes:
+
+
+  Alternatively, if WebComponents.ShadowCSS.strictStyling is set to true then
+  selectors are scoped by adding an attribute selector suffix to each
+  simple selector that contains the host element tag name. Each element
+  in the element's ShadowDOM template is also given the scope attribute.
+  Thus, these rules match only elements that have the scope attribute.
+  For example, given a scope name of x-foo, a rule like this:
+
+    div {
+      font-weight: bold;
+    }
+
+  becomes:
+
+    div[x-foo] {
+      font-weight: bold;
+    }
+
+  Note that elements that are dynamically added to a scope must have the scope
+  selector added to them manually.
+
+  * upper/lower bound encapsulation: Styles which are defined outside a
+  shadowRoot should not cross the ShadowDOM boundary and should not apply
+  inside a shadowRoot.
+
+  This styling behavior is not emulated. Some possible ways to do this that
+  were rejected due to complexity and/or performance concerns include: (1) reset
+  every possible property for every possible selector for a given scope name;
+  (2) re-implement css in javascript.
+
+  As an alternative, users should make sure to use selectors
+  specific to the scope in which they are working.
+
+  * ::distributed: This behavior is not emulated. It's often not necessary
+  to style the contents of a specific insertion point and instead, descendants
+  of the host element can be styled selectively. Users can also create an
+  extra node around an insertion point and style that node's contents
+  via descendent selectors. For example, with a shadowRoot like this:
+
+    <style>
+      ::content(div) {
+        background: red;
+      }
+    </style>
+    <content></content>
+
+  could become:
+
+    <style>
+      / *@polyfill .content-container div * /
+      ::content(div) {
+        background: red;
+      }
+    </style>
+    <div class="content-container">
+      <content></content>
+    </div>
+
+  Note the use of @polyfill in the comment above a ShadowDOM specific style
+  declaration. This is a directive to the styling shim to use the selector
+  in comments in lieu of the next selector when running under polyfill.
+*/
+
+export class ShadowCss {
+  strictStyling: boolean = true;
+
+  constructor() {}
+
+  /*
+  * Shim some cssText with the given selector. Returns cssText that can
+  * be included in the document via WebComponents.ShadowCSS.addCssToDocument(css).
+  *
+  * When strictStyling is true:
+  * - selector is the attribute added to all elements inside the host,
+  * - hostSelector is the attribute added to the host itself.
+  */
+  shimCssText(cssText: string, selector: string, hostSelector: string = ''): string {
+    const sourceMappingUrl: string = extractSourceMappingUrl(cssText);
+    cssText = stripComments(cssText);
+    cssText = this._insertDirectives(cssText);
+    return this._scopeCssText(cssText, selector, hostSelector) + sourceMappingUrl;
+  }
+
+  private _insertDirectives(cssText: string): string {
+    cssText = this._insertPolyfillDirectivesInCssText(cssText);
+    return this._insertPolyfillRulesInCssText(cssText);
+  }
+
+  /*
+   * Process styles to convert native ShadowDOM rules that will trip
+   * up the css parser; we rely on decorating the stylesheet with inert rules.
+   *
+   * For example, we convert this rule:
+   *
+   * polyfill-next-selector { content: ':host menu-item'; }
+   * ::content menu-item {
+   *
+   * to this:
+   *
+   * scopeName menu-item {
+   *
+  **/
+  private _insertPolyfillDirectivesInCssText(cssText: string): string {
+    // Difference with webcomponents.js: does not handle comments
+    return cssText.replace(
+        _cssContentNextSelectorRe, function(...m: string[]) { return m[2] + '{'; });
+  }
+
+  /*
+   * Process styles to add rules which will only apply under the polyfill
+   *
+   * For example, we convert this rule:
+   *
+   * polyfill-rule {
+   *   content: ':host menu-item';
+   * ...
+   * }
+   *
+   * to this:
+   *
+   * scopeName menu-item {...}
+   *
+  **/
+  private _insertPolyfillRulesInCssText(cssText: string): string {
+    // Difference with webcomponents.js: does not handle comments
+    return cssText.replace(_cssContentRuleRe, (...m: string[]) => {
+      const rule = m[0].replace(m[1], '').replace(m[2], '');
+      return m[4] + rule;
+    });
+  }
+
+  /* Ensure styles are scoped. Pseudo-scoping takes a rule like:
+   *
+   *  .foo {... }
+   *
+   *  and converts this to
+   *
+   *  scopeName .foo { ... }
+  */
+  private _scopeCssText(cssText: string, scopeSelector: string, hostSelector: string): string {
+    const unscopedRules = this._extractUnscopedRulesFromCssText(cssText);
+    // replace :host and :host-context -shadowcsshost and -shadowcsshost respectively
+    cssText = this._insertPolyfillHostInCssText(cssText);
+    cssText = this._convertColonHost(cssText);
+    cssText = this._convertColonHostContext(cssText);
+    cssText = this._convertShadowDOMSelectors(cssText);
+    if (scopeSelector) {
+      cssText = this._scopeSelectors(cssText, scopeSelector, hostSelector);
+    }
+    cssText = cssText + '\n' + unscopedRules;
+    return cssText.trim();
+  }
+
+  /*
+   * Process styles to add rules which will only apply under the polyfill
+   * and do not process via CSSOM. (CSSOM is destructive to rules on rare
+   * occasions, e.g. -webkit-calc on Safari.)
+   * For example, we convert this rule:
+   *
+   * @polyfill-unscoped-rule {
+   *   content: 'menu-item';
+   * ... }
+   *
+   * to this:
+   *
+   * menu-item {...}
+   *
+  **/
+  private _extractUnscopedRulesFromCssText(cssText: string): string {
+    // Difference with webcomponents.js: does not handle comments
+    let r = '';
+    let m: RegExpExecArray|null;
+    _cssContentUnscopedRuleRe.lastIndex = 0;
+    while ((m = _cssContentUnscopedRuleRe.exec(cssText)) !== null) {
+      const rule = m[0].replace(m[2], '').replace(m[1], m[4]);
+      r += rule + '\n\n';
+    }
+    return r;
+  }
+
+  /*
+   * convert a rule like :host(.foo) > .bar { }
+   *
+   * to
+   *
+   * .foo<scopeName> > .bar
+  */
+  private _convertColonHost(cssText: string): string {
+    return this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer);
+  }
+
+  /*
+   * convert a rule like :host-context(.foo) > .bar { }
+   *
+   * to
+   *
+   * .foo<scopeName> > .bar, .foo scopeName > .bar { }
+   *
+   * and
+   *
+   * :host-context(.foo:host) .bar { ... }
+   *
+   * to
+   *
+   * .foo<scopeName> .bar { ... }
+  */
+  private _convertColonHostContext(cssText: string): string {
+    return this._convertColonRule(
+        cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer);
+  }
+
+  private _convertColonRule(cssText: string, regExp: RegExp, partReplacer: Function): string {
+    // m[1] = :host(-context), m[2] = contents of (), m[3] rest of rule
+    return cssText.replace(regExp, function(...m: string[]) {
+      if (m[2]) {
+        const parts = m[2].split(',');
+        const r: string[] = [];
+        for (let i = 0; i < parts.length; i++) {
+          const p = parts[i].trim();
+          if (!p) break;
+          r.push(partReplacer(_polyfillHostNoCombinator, p, m[3]));
+        }
+        return r.join(',');
+      } else {
+        return _polyfillHostNoCombinator + m[3];
+      }
+    });
+  }
+
+  private _colonHostContextPartReplacer(host: string, part: string, suffix: string): string {
+    if (part.indexOf(_polyfillHost) > -1) {
+      return this._colonHostPartReplacer(host, part, suffix);
+    } else {
+      return host + part + suffix + ', ' + part + ' ' + host + suffix;
+    }
+  }
+
+  private _colonHostPartReplacer(host: string, part: string, suffix: string): string {
+    return host + part.replace(_polyfillHost, '') + suffix;
+  }
+
+  /*
+   * Convert combinators like ::shadow and pseudo-elements like ::content
+   * by replacing with space.
+  */
+  private _convertShadowDOMSelectors(cssText: string): string {
+    return _shadowDOMSelectorsRe.reduce((result, pattern) => result.replace(pattern, ' '), cssText);
+  }
+
+  // change a selector like 'div' to 'name div'
+  private _scopeSelectors(cssText: string, scopeSelector: string, hostSelector: string): string {
+    return processRules(cssText, (rule: CssRule) => {
+      let selector = rule.selector;
+      let content = rule.content;
+      if (rule.selector[0] != '@') {
+        selector =
+            this._scopeSelector(rule.selector, scopeSelector, hostSelector, this.strictStyling);
+      } else if (
+          rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||
+          rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) {
+        content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
+      }
+      return new CssRule(selector, content);
+    });
+  }
+
+  private _scopeSelector(
+      selector: string, scopeSelector: string, hostSelector: string, strict: boolean): string {
+    return selector.split(',')
+        .map(part => part.trim().split(_shadowDeepSelectors))
+        .map((deepParts) => {
+          const [shallowPart, ...otherParts] = deepParts;
+          const applyScope = (shallowPart: string) => {
+            if (this._selectorNeedsScoping(shallowPart, scopeSelector)) {
+              return strict ?
+                  this._applyStrictSelectorScope(shallowPart, scopeSelector, hostSelector) :
+                  this._applySelectorScope(shallowPart, scopeSelector, hostSelector);
+            } else {
+              return shallowPart;
+            }
+          };
+          return [applyScope(shallowPart), ...otherParts].join(' ');
+        })
+        .join(', ');
+  }
+
+  private _selectorNeedsScoping(selector: string, scopeSelector: string): boolean {
+    const re = this._makeScopeMatcher(scopeSelector);
+    return !re.test(selector);
+  }
+
+  private _makeScopeMatcher(scopeSelector: string): RegExp {
+    const lre = /\[/g;
+    const rre = /\]/g;
+    scopeSelector = scopeSelector.replace(lre, '\\[').replace(rre, '\\]');
+    return new RegExp('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');
+  }
+
+  private _applySelectorScope(selector: string, scopeSelector: string, hostSelector: string):
+      string {
+    // Difference from webcomponents.js: scopeSelector could not be an array
+    return this._applySimpleSelectorScope(selector, scopeSelector, hostSelector);
+  }
+
+  // scope via name and [is=name]
+  private _applySimpleSelectorScope(selector: string, scopeSelector: string, hostSelector: string):
+      string {
+    // In Android browser, the lastIndex is not reset when the regex is used in String.replace()
+    _polyfillHostRe.lastIndex = 0;
+    if (_polyfillHostRe.test(selector)) {
+      const replaceBy = this.strictStyling ? `[${hostSelector}]` : scopeSelector;
+      return selector
+          .replace(
+              _polyfillHostNoCombinatorRe,
+              (hnc, selector) => {
+                return selector.replace(
+                    /([^:]*)(:*)(.*)/,
+                    (_: string, before: string, colon: string, after: string) => {
+                      return before + replaceBy + colon + after;
+                    });
+              })
+          .replace(_polyfillHostRe, replaceBy + ' ');
+    }
+
+    return scopeSelector + ' ' + selector;
+  }
+
+  // return a selector with [name] suffix on each simple selector
+  // e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name]  /** @internal */
+  private _applyStrictSelectorScope(selector: string, scopeSelector: string, hostSelector: string):
+      string {
+    const isRe = /\[is=([^\]]*)\]/g;
+    scopeSelector = scopeSelector.replace(isRe, (_: string, ...parts: string[]) => parts[0]);
+
+    const attrName = '[' + scopeSelector + ']';
+
+    const _scopeSelectorPart = (p: string) => {
+      let scopedP = p.trim();
+
+      if (!scopedP) {
+        return '';
+      }
+
+      if (p.indexOf(_polyfillHostNoCombinator) > -1) {
+        scopedP = this._applySimpleSelectorScope(p, scopeSelector, hostSelector);
+      } else {
+        // remove :host since it should be unnecessary
+        const t = p.replace(_polyfillHostRe, '');
+        if (t.length > 0) {
+          const matches = t.match(/([^:]*)(:*)(.*)/);
+          if (matches) {
+            scopedP = matches[1] + attrName + matches[2] + matches[3];
+          }
+        }
+      }
+
+      return scopedP;
+    };
+
+    const safeContent = new SafeSelector(selector);
+    selector = safeContent.content();
+
+    let scopedSelector = '';
+    let startIndex = 0;
+    let res: RegExpExecArray|null;
+    const sep = /( |>|\+|~(?!=))\s*/g;
+    const scopeAfter = selector.indexOf(_polyfillHostNoCombinator);
+
+    while ((res = sep.exec(selector)) !== null) {
+      const separator = res[1];
+      const part = selector.slice(startIndex, res.index).trim();
+      // if a selector appears before :host-context it should not be shimmed as it
+      // matches on ancestor elements and not on elements in the host's shadow
+      const scopedPart = startIndex >= scopeAfter ? _scopeSelectorPart(part) : part;
+      scopedSelector += `${scopedPart} ${separator} `;
+      startIndex = sep.lastIndex;
+    }
+
+    scopedSelector += _scopeSelectorPart(selector.substring(startIndex));
+
+    // replace the placeholders with their original values
+    return safeContent.restore(scopedSelector);
+  }
+
+  private _insertPolyfillHostInCssText(selector: string): string {
+    return selector.replace(_colonHostContextRe, _polyfillHostContext)
+        .replace(_colonHostRe, _polyfillHost);
+  }
+}
+
+class SafeSelector {
+  private placeholders: string[] = [];
+  private index = 0;
+  private _content: string;
+
+  constructor(selector: string) {
+    // Replaces attribute selectors with placeholders.
+    // The WS in [attr="va lue"] would otherwise be interpreted as a selector separator.
+    selector = selector.replace(/(\[[^\]]*\])/g, (_, keep) => {
+      const replaceBy = `__ph-${this.index}__`;
+      this.placeholders.push(keep);
+      this.index++;
+      return replaceBy;
+    });
+
+    // Replaces the expression in `:nth-child(2n + 1)` with a placeholder.
+    // WS and "+" would otherwise be interpreted as selector separators.
+    this._content = selector.replace(/(:nth-[-\w]+)(\([^)]+\))/g, (_, pseudo, exp) => {
+      const replaceBy = `__ph-${this.index}__`;
+      this.placeholders.push(exp);
+      this.index++;
+      return pseudo + replaceBy;
+    });
+  };
+
+  restore(content: string): string {
+    return content.replace(/__ph-(\d+)__/g, (ph, index) => this.placeholders[+index]);
+  }
+
+  content(): string { return this._content; }
+}
+
+const _cssContentNextSelectorRe =
+    /polyfill-next-selector[^}]*content:[\s]*?(['"])(.*?)\1[;\s]*}([^{]*?){/gim;
+const _cssContentRuleRe = /(polyfill-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim;
+const _cssContentUnscopedRuleRe =
+    /(polyfill-unscoped-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim;
+const _polyfillHost = '-shadowcsshost';
+// note: :host-context pre-processed to -shadowcsshostcontext.
+const _polyfillHostContext = '-shadowcsscontext';
+const _parenSuffix = ')(?:\\((' +
+    '(?:\\([^)(]*\\)|[^)(]*)+?' +
+    ')\\))?([^,{]*)';
+const _cssColonHostRe = new RegExp('(' + _polyfillHost + _parenSuffix, 'gim');
+const _cssColonHostContextRe = new RegExp('(' + _polyfillHostContext + _parenSuffix, 'gim');
+const _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';
+const _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\s]*)/;
+const _shadowDOMSelectorsRe = [
+  /::shadow/g,
+  /::content/g,
+  // Deprecated selectors
+  /\/shadow-deep\//g,
+  /\/shadow\//g,
+];
+
+// The deep combinator is deprecated in the CSS spec
+// Support for `>>>`, `deep`, `::ng-deep` is then also deprecated and will be removed in the future.
+// see https://github.com/angular/angular/pull/17677
+const _shadowDeepSelectors = /(?:>>>)|(?:\/deep\/)|(?:::ng-deep)/g;
+const _selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$';
+const _polyfillHostRe = /-shadowcsshost/gim;
+const _colonHostRe = /:host/gim;
+const _colonHostContextRe = /:host-context/gim;
+
+const _commentRe = /\/\*\s*[\s\S]*?\*\//g;
+
+function stripComments(input: string): string {
+  return input.replace(_commentRe, '');
+}
+
+// all comments except inline source mapping
+const _sourceMappingUrlRe = /\/\*\s*#\s*sourceMappingURL=[\s\S]+?\*\//;
+
+function extractSourceMappingUrl(input: string): string {
+  const matcher = input.match(_sourceMappingUrlRe);
+  return matcher ? matcher[0] : '';
+}
+
+const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
+const _curlyRe = /([{}])/g;
+const OPEN_CURLY = '{';
+const CLOSE_CURLY = '}';
+const BLOCK_PLACEHOLDER = '%BLOCK%';
+
+export class CssRule {
+  constructor(public selector: string, public content: string) {}
+}
+
+export function processRules(input: string, ruleCallback: (rule: CssRule) => CssRule): string {
+  const inputWithEscapedBlocks = escapeBlocks(input);
+  let nextBlockIndex = 0;
+  return inputWithEscapedBlocks.escapedString.replace(_ruleRe, function(...m: string[]) {
+    const selector = m[2];
+    let content = '';
+    let suffix = m[4];
+    let contentPrefix = '';
+    if (suffix && suffix.startsWith('{' + BLOCK_PLACEHOLDER)) {
+      content = inputWithEscapedBlocks.blocks[nextBlockIndex++];
+      suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);
+      contentPrefix = '{';
+    }
+    const rule = ruleCallback(new CssRule(selector, content));
+    return `${m[1]}${rule.selector}${m[3]}${contentPrefix}${rule.content}${suffix}`;
+  });
+}
+
+class StringWithEscapedBlocks {
+  constructor(public escapedString: string, public blocks: string[]) {}
+}
+
+function escapeBlocks(input: string): StringWithEscapedBlocks {
+  const inputParts = input.split(_curlyRe);
+  const resultParts: string[] = [];
+  const escapedBlocks: string[] = [];
+  let bracketCount = 0;
+  let currentBlockParts: string[] = [];
+  for (let partIndex = 0; partIndex < inputParts.length; partIndex++) {
+    const part = inputParts[partIndex];
+    if (part == CLOSE_CURLY) {
+      bracketCount--;
+    }
+    if (bracketCount > 0) {
+      currentBlockParts.push(part);
+    } else {
+      if (currentBlockParts.length > 0) {
+        escapedBlocks.push(currentBlockParts.join(''));
+        resultParts.push(BLOCK_PLACEHOLDER);
+        currentBlockParts = [];
+      }
+      resultParts.push(part);
+    }
+    if (part == OPEN_CURLY) {
+      bracketCount++;
+    }
+  }
+  if (currentBlockParts.length > 0) {
+    escapedBlocks.push(currentBlockParts.join(''));
+    resultParts.push(BLOCK_PLACEHOLDER);
+  }
+  return new StringWithEscapedBlocks(resultParts.join(''), escapedBlocks);
+}
diff --git a/angular/compiler/src/style_compiler.ts b/angular/compiler/src/style_compiler.ts
new file mode 100644
index 0000000..59010f3
--- /dev/null
+++ b/angular/compiler/src/style_compiler.ts
@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileStylesheetMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
+import {ViewEncapsulation} from './core';
+import * as o from './output/output_ast';
+import {ShadowCss} from './shadow_css';
+import {UrlResolver} from './url_resolver';
+import {OutputContext} from './util';
+
+const COMPONENT_VARIABLE = '%COMP%';
+const HOST_ATTR = `_nghost-${COMPONENT_VARIABLE}`;
+const CONTENT_ATTR = `_ngcontent-${COMPONENT_VARIABLE}`;
+
+export class StylesCompileDependency {
+  constructor(
+      public name: string, public moduleUrl: string, public setValue: (value: any) => void) {}
+}
+
+export class CompiledStylesheet {
+  constructor(
+      public outputCtx: OutputContext, public stylesVar: string,
+      public dependencies: StylesCompileDependency[], public isShimmed: boolean,
+      public meta: CompileStylesheetMetadata) {}
+}
+
+export class StyleCompiler {
+  private _shadowCss: ShadowCss = new ShadowCss();
+
+  constructor(private _urlResolver: UrlResolver) {}
+
+  compileComponent(outputCtx: OutputContext, comp: CompileDirectiveMetadata): CompiledStylesheet {
+    const template = comp.template !;
+    return this._compileStyles(
+        outputCtx, comp, new CompileStylesheetMetadata({
+          styles: template.styles,
+          styleUrls: template.styleUrls,
+          moduleUrl: identifierModuleUrl(comp.type)
+        }),
+        true);
+  }
+
+  compileStyles(
+      outputCtx: OutputContext, comp: CompileDirectiveMetadata,
+      stylesheet: CompileStylesheetMetadata): CompiledStylesheet {
+    return this._compileStyles(outputCtx, comp, stylesheet, false);
+  }
+
+  needsStyleShim(comp: CompileDirectiveMetadata): boolean {
+    return comp.template !.encapsulation === ViewEncapsulation.Emulated;
+  }
+
+  private _compileStyles(
+      outputCtx: OutputContext, comp: CompileDirectiveMetadata,
+      stylesheet: CompileStylesheetMetadata, isComponentStylesheet: boolean): CompiledStylesheet {
+    const shim = this.needsStyleShim(comp);
+    const styleExpressions: o.Expression[] =
+        stylesheet.styles.map(plainStyle => o.literal(this._shimIfNeeded(plainStyle, shim)));
+    const dependencies: StylesCompileDependency[] = [];
+    stylesheet.styleUrls.forEach((styleUrl) => {
+      const exprIndex = styleExpressions.length;
+      // Note: This placeholder will be filled later.
+      styleExpressions.push(null !);
+      dependencies.push(new StylesCompileDependency(
+          getStylesVarName(null), styleUrl,
+          (value) => styleExpressions[exprIndex] = outputCtx.importExpr(value)));
+    });
+    // styles variable contains plain strings and arrays of other styles arrays (recursive),
+    // so we set its type to dynamic.
+    const stylesVar = getStylesVarName(isComponentStylesheet ? comp : null);
+    const stmt = o.variable(stylesVar)
+                     .set(o.literalArr(
+                         styleExpressions, new o.ArrayType(o.DYNAMIC_TYPE, [o.TypeModifier.Const])))
+                     .toDeclStmt(null, isComponentStylesheet ? [o.StmtModifier.Final] : [
+                       o.StmtModifier.Final, o.StmtModifier.Exported
+                     ]);
+    outputCtx.statements.push(stmt);
+    return new CompiledStylesheet(outputCtx, stylesVar, dependencies, shim, stylesheet);
+  }
+
+  private _shimIfNeeded(style: string, shim: boolean): string {
+    return shim ? this._shadowCss.shimCssText(style, CONTENT_ATTR, HOST_ATTR) : style;
+  }
+}
+
+function getStylesVarName(component: CompileDirectiveMetadata | null): string {
+  let result = `styles`;
+  if (component) {
+    result += `_${identifierName(component.type)}`;
+  }
+  return result;
+}
diff --git a/angular/compiler/src/style_url_resolver.ts b/angular/compiler/src/style_url_resolver.ts
new file mode 100644
index 0000000..844871e
--- /dev/null
+++ b/angular/compiler/src/style_url_resolver.ts
@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+// Some of the code comes from WebComponents.JS
+// https://github.com/webcomponents/webcomponentsjs/blob/master/src/HTMLImports/path.js
+
+import {UrlResolver} from './url_resolver';
+
+export class StyleWithImports {
+  constructor(public style: string, public styleUrls: string[]) {}
+}
+
+export function isStyleUrlResolvable(url: string): boolean {
+  if (url == null || url.length === 0 || url[0] == '/') return false;
+  const schemeMatch = url.match(URL_WITH_SCHEMA_REGEXP);
+  return schemeMatch === null || schemeMatch[1] == 'package' || schemeMatch[1] == 'asset';
+}
+
+/**
+ * Rewrites stylesheets by resolving and removing the @import urls that
+ * are either relative or don't have a `package:` scheme
+ */
+export function extractStyleUrls(
+    resolver: UrlResolver, baseUrl: string, cssText: string): StyleWithImports {
+  const foundUrls: string[] = [];
+
+  const modifiedCssText = cssText.replace(CSS_STRIPPABLE_COMMENT_REGEXP, '')
+                              .replace(CSS_IMPORT_REGEXP, (...m: string[]) => {
+                                const url = m[1] || m[2];
+                                if (!isStyleUrlResolvable(url)) {
+                                  // Do not attempt to resolve non-package absolute URLs with URI
+                                  // scheme
+                                  return m[0];
+                                }
+                                foundUrls.push(resolver.resolve(baseUrl, url));
+                                return '';
+                              });
+  return new StyleWithImports(modifiedCssText, foundUrls);
+}
+
+const CSS_IMPORT_REGEXP = /@import\s+(?:url\()?\s*(?:(?:['"]([^'"]*))|([^;\)\s]*))[^;]*;?/g;
+const CSS_STRIPPABLE_COMMENT_REGEXP = /\/\*(?!#\s*(?:sourceURL|sourceMappingURL)=)[\s\S]+?\*\//g;
+const URL_WITH_SCHEMA_REGEXP = /^([^:/?#]+):/;
diff --git a/angular/compiler/src/summary_resolver.ts b/angular/compiler/src/summary_resolver.ts
new file mode 100644
index 0000000..1c7cd7a
--- /dev/null
+++ b/angular/compiler/src/summary_resolver.ts
@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import {CompileTypeSummary} from './compile_metadata';
+import {Type} from './core';
+
+export interface Summary<T> {
+  symbol: T;
+  metadata: any;
+  type?: CompileTypeSummary;
+}
+
+export abstract class SummaryResolver<T> {
+  abstract isLibraryFile(fileName: string): boolean;
+  abstract toSummaryFileName(fileName: string, referringSrcFileName: string): string;
+  abstract fromSummaryFileName(fileName: string, referringLibFileName: string): string;
+  abstract resolveSummary(reference: T): Summary<T>|null;
+  abstract getSymbolsOf(filePath: string): T[];
+  abstract getImportAs(reference: T): T;
+  abstract addSummary(summary: Summary<T>): void;
+}
+
+export class JitSummaryResolver implements SummaryResolver<Type> {
+  private _summaries = new Map<Type, Summary<Type>>();
+
+  isLibraryFile(): boolean { return false; };
+  toSummaryFileName(fileName: string): string { return fileName; }
+  fromSummaryFileName(fileName: string): string { return fileName; }
+  resolveSummary(reference: Type): Summary<Type>|null {
+    return this._summaries.get(reference) || null;
+  };
+  getSymbolsOf(): Type[] { return []; }
+  getImportAs(reference: Type): Type { return reference; }
+  addSummary(summary: Summary<Type>) { this._summaries.set(summary.symbol, summary); };
+}
diff --git a/angular/compiler/src/template_parser/binding_parser.ts b/angular/compiler/src/template_parser/binding_parser.ts
new file mode 100644
index 0000000..1d57173
--- /dev/null
+++ b/angular/compiler/src/template_parser/binding_parser.ts
@@ -0,0 +1,444 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileDirectiveSummary, CompilePipeSummary} from '../compile_metadata';
+import {SecurityContext} from '../core';
+import {ASTWithSource, BindingPipe, EmptyExpr, ParserError, RecursiveAstVisitor, TemplateBinding} from '../expression_parser/ast';
+import {Parser} from '../expression_parser/parser';
+import {InterpolationConfig} from '../ml_parser/interpolation_config';
+import {mergeNsAndName} from '../ml_parser/tags';
+import {ParseError, ParseErrorLevel, ParseSourceSpan} from '../parse_util';
+import {ElementSchemaRegistry} from '../schema/element_schema_registry';
+import {CssSelector} from '../selector';
+import {splitAtColon, splitAtPeriod} from '../util';
+
+import {BoundElementPropertyAst, BoundEventAst, PropertyBindingType, VariableAst} from './template_ast';
+
+const PROPERTY_PARTS_SEPARATOR = '.';
+const ATTRIBUTE_PREFIX = 'attr';
+const CLASS_PREFIX = 'class';
+const STYLE_PREFIX = 'style';
+
+const ANIMATE_PROP_PREFIX = 'animate-';
+
+export enum BoundPropertyType {
+  DEFAULT,
+  LITERAL_ATTR,
+  ANIMATION
+}
+
+/**
+ * Represents a parsed property.
+ */
+export class BoundProperty {
+  constructor(
+      public name: string, public expression: ASTWithSource, public type: BoundPropertyType,
+      public sourceSpan: ParseSourceSpan) {}
+
+  get isLiteral() { return this.type === BoundPropertyType.LITERAL_ATTR; }
+
+  get isAnimation() { return this.type === BoundPropertyType.ANIMATION; }
+}
+
+/**
+ * Parses bindings in templates and in the directive host area.
+ */
+export class BindingParser {
+  pipesByName: Map<string, CompilePipeSummary> = new Map();
+  private _usedPipes: Map<string, CompilePipeSummary> = new Map();
+
+  constructor(
+      private _exprParser: Parser, private _interpolationConfig: InterpolationConfig,
+      private _schemaRegistry: ElementSchemaRegistry, pipes: CompilePipeSummary[],
+      private _targetErrors: ParseError[]) {
+    pipes.forEach(pipe => this.pipesByName.set(pipe.name, pipe));
+  }
+
+  getUsedPipes(): CompilePipeSummary[] { return Array.from(this._usedPipes.values()); }
+
+  createDirectiveHostPropertyAsts(
+      dirMeta: CompileDirectiveSummary, elementSelector: string,
+      sourceSpan: ParseSourceSpan): BoundElementPropertyAst[]|null {
+    if (dirMeta.hostProperties) {
+      const boundProps: BoundProperty[] = [];
+      Object.keys(dirMeta.hostProperties).forEach(propName => {
+        const expression = dirMeta.hostProperties[propName];
+        if (typeof expression === 'string') {
+          this.parsePropertyBinding(propName, expression, true, sourceSpan, [], boundProps);
+        } else {
+          this._reportError(
+              `Value of the host property binding "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`,
+              sourceSpan);
+        }
+      });
+      return boundProps.map((prop) => this.createElementPropertyAst(elementSelector, prop));
+    }
+    return null;
+  }
+
+  createDirectiveHostEventAsts(dirMeta: CompileDirectiveSummary, sourceSpan: ParseSourceSpan):
+      BoundEventAst[]|null {
+    if (dirMeta.hostListeners) {
+      const targetEventAsts: BoundEventAst[] = [];
+      Object.keys(dirMeta.hostListeners).forEach(propName => {
+        const expression = dirMeta.hostListeners[propName];
+        if (typeof expression === 'string') {
+          this.parseEvent(propName, expression, sourceSpan, [], targetEventAsts);
+        } else {
+          this._reportError(
+              `Value of the host listener "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`,
+              sourceSpan);
+        }
+      });
+      return targetEventAsts;
+    }
+    return null;
+  }
+
+  parseInterpolation(value: string, sourceSpan: ParseSourceSpan): ASTWithSource {
+    const sourceInfo = sourceSpan.start.toString();
+
+    try {
+      const ast =
+          this._exprParser.parseInterpolation(value, sourceInfo, this._interpolationConfig) !;
+      if (ast) this._reportExpressionParserErrors(ast.errors, sourceSpan);
+      this._checkPipes(ast, sourceSpan);
+      return ast;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
+    }
+  }
+
+  parseInlineTemplateBinding(
+      prefixToken: string, value: string, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetProps: BoundProperty[], targetVars: VariableAst[]) {
+    const bindings = this._parseTemplateBindings(prefixToken, value, sourceSpan);
+    for (let i = 0; i < bindings.length; i++) {
+      const binding = bindings[i];
+      if (binding.keyIsVar) {
+        targetVars.push(new VariableAst(binding.key, binding.name, sourceSpan));
+      } else if (binding.expression) {
+        this._parsePropertyAst(
+            binding.key, binding.expression, sourceSpan, targetMatchableAttrs, targetProps);
+      } else {
+        targetMatchableAttrs.push([binding.key, '']);
+        this.parseLiteralAttr(binding.key, null, sourceSpan, targetMatchableAttrs, targetProps);
+      }
+    }
+  }
+
+  private _parseTemplateBindings(prefixToken: string, value: string, sourceSpan: ParseSourceSpan):
+      TemplateBinding[] {
+    const sourceInfo = sourceSpan.start.toString();
+
+    try {
+      const bindingsResult = this._exprParser.parseTemplateBindings(prefixToken, value, sourceInfo);
+      this._reportExpressionParserErrors(bindingsResult.errors, sourceSpan);
+      bindingsResult.templateBindings.forEach((binding) => {
+        if (binding.expression) {
+          this._checkPipes(binding.expression, sourceSpan);
+        }
+      });
+      bindingsResult.warnings.forEach(
+          (warning) => { this._reportError(warning, sourceSpan, ParseErrorLevel.WARNING); });
+      return bindingsResult.templateBindings;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return [];
+    }
+  }
+
+  parseLiteralAttr(
+      name: string, value: string|null, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetProps: BoundProperty[]) {
+    if (_isAnimationLabel(name)) {
+      name = name.substring(1);
+      if (value) {
+        this._reportError(
+            `Assigning animation triggers via @prop="exp" attributes with an expression is invalid.` +
+                ` Use property bindings (e.g. [@prop]="exp") or use an attribute without a value (e.g. @prop) instead.`,
+            sourceSpan, ParseErrorLevel.ERROR);
+      }
+      this._parseAnimation(name, value, sourceSpan, targetMatchableAttrs, targetProps);
+    } else {
+      targetProps.push(new BoundProperty(
+          name, this._exprParser.wrapLiteralPrimitive(value, ''), BoundPropertyType.LITERAL_ATTR,
+          sourceSpan));
+    }
+  }
+
+  parsePropertyBinding(
+      name: string, expression: string, isHost: boolean, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetProps: BoundProperty[]) {
+    let isAnimationProp = false;
+    if (name.startsWith(ANIMATE_PROP_PREFIX)) {
+      isAnimationProp = true;
+      name = name.substring(ANIMATE_PROP_PREFIX.length);
+    } else if (_isAnimationLabel(name)) {
+      isAnimationProp = true;
+      name = name.substring(1);
+    }
+
+    if (isAnimationProp) {
+      this._parseAnimation(name, expression, sourceSpan, targetMatchableAttrs, targetProps);
+    } else {
+      this._parsePropertyAst(
+          name, this._parseBinding(expression, isHost, sourceSpan), sourceSpan,
+          targetMatchableAttrs, targetProps);
+    }
+  }
+
+  parsePropertyInterpolation(
+      name: string, value: string, sourceSpan: ParseSourceSpan, targetMatchableAttrs: string[][],
+      targetProps: BoundProperty[]): boolean {
+    const expr = this.parseInterpolation(value, sourceSpan);
+    if (expr) {
+      this._parsePropertyAst(name, expr, sourceSpan, targetMatchableAttrs, targetProps);
+      return true;
+    }
+    return false;
+  }
+
+  private _parsePropertyAst(
+      name: string, ast: ASTWithSource, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetProps: BoundProperty[]) {
+    targetMatchableAttrs.push([name, ast.source !]);
+    targetProps.push(new BoundProperty(name, ast, BoundPropertyType.DEFAULT, sourceSpan));
+  }
+
+  private _parseAnimation(
+      name: string, expression: string|null, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetProps: BoundProperty[]) {
+    // This will occur when a @trigger is not paired with an expression.
+    // For animations it is valid to not have an expression since */void
+    // states will be applied by angular when the element is attached/detached
+    const ast = this._parseBinding(expression || 'null', false, sourceSpan);
+    targetMatchableAttrs.push([name, ast.source !]);
+    targetProps.push(new BoundProperty(name, ast, BoundPropertyType.ANIMATION, sourceSpan));
+  }
+
+  private _parseBinding(value: string, isHostBinding: boolean, sourceSpan: ParseSourceSpan):
+      ASTWithSource {
+    const sourceInfo = sourceSpan.start.toString();
+
+    try {
+      const ast = isHostBinding ?
+          this._exprParser.parseSimpleBinding(value, sourceInfo, this._interpolationConfig) :
+          this._exprParser.parseBinding(value, sourceInfo, this._interpolationConfig);
+      if (ast) this._reportExpressionParserErrors(ast.errors, sourceSpan);
+      this._checkPipes(ast, sourceSpan);
+      return ast;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
+    }
+  }
+
+  createElementPropertyAst(elementSelector: string, boundProp: BoundProperty):
+      BoundElementPropertyAst {
+    if (boundProp.isAnimation) {
+      return new BoundElementPropertyAst(
+          boundProp.name, PropertyBindingType.Animation, SecurityContext.NONE, boundProp.expression,
+          null, boundProp.sourceSpan);
+    }
+
+    let unit: string|null = null;
+    let bindingType: PropertyBindingType = undefined !;
+    let boundPropertyName: string|null = null;
+    const parts = boundProp.name.split(PROPERTY_PARTS_SEPARATOR);
+    let securityContexts: SecurityContext[] = undefined !;
+
+    // Check check for special cases (prefix style, attr, class)
+    if (parts.length > 1) {
+      if (parts[0] == ATTRIBUTE_PREFIX) {
+        boundPropertyName = parts[1];
+        this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, true);
+        securityContexts = calcPossibleSecurityContexts(
+            this._schemaRegistry, elementSelector, boundPropertyName, true);
+
+        const nsSeparatorIdx = boundPropertyName.indexOf(':');
+        if (nsSeparatorIdx > -1) {
+          const ns = boundPropertyName.substring(0, nsSeparatorIdx);
+          const name = boundPropertyName.substring(nsSeparatorIdx + 1);
+          boundPropertyName = mergeNsAndName(ns, name);
+        }
+
+        bindingType = PropertyBindingType.Attribute;
+      } else if (parts[0] == CLASS_PREFIX) {
+        boundPropertyName = parts[1];
+        bindingType = PropertyBindingType.Class;
+        securityContexts = [SecurityContext.NONE];
+      } else if (parts[0] == STYLE_PREFIX) {
+        unit = parts.length > 2 ? parts[2] : null;
+        boundPropertyName = parts[1];
+        bindingType = PropertyBindingType.Style;
+        securityContexts = [SecurityContext.STYLE];
+      }
+    }
+
+    // If not a special case, use the full property name
+    if (boundPropertyName === null) {
+      boundPropertyName = this._schemaRegistry.getMappedPropName(boundProp.name);
+      securityContexts = calcPossibleSecurityContexts(
+          this._schemaRegistry, elementSelector, boundPropertyName, false);
+      bindingType = PropertyBindingType.Property;
+      this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, false);
+    }
+
+    return new BoundElementPropertyAst(
+        boundPropertyName, bindingType, securityContexts[0], boundProp.expression, unit,
+        boundProp.sourceSpan);
+  }
+
+  parseEvent(
+      name: string, expression: string, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetEvents: BoundEventAst[]) {
+    if (_isAnimationLabel(name)) {
+      name = name.substr(1);
+      this._parseAnimationEvent(name, expression, sourceSpan, targetEvents);
+    } else {
+      this._parseEvent(name, expression, sourceSpan, targetMatchableAttrs, targetEvents);
+    }
+  }
+
+  private _parseAnimationEvent(
+      name: string, expression: string, sourceSpan: ParseSourceSpan,
+      targetEvents: BoundEventAst[]) {
+    const matches = splitAtPeriod(name, [name, '']);
+    const eventName = matches[0];
+    const phase = matches[1].toLowerCase();
+    if (phase) {
+      switch (phase) {
+        case 'start':
+        case 'done':
+          const ast = this._parseAction(expression, sourceSpan);
+          targetEvents.push(new BoundEventAst(eventName, null, phase, ast, sourceSpan));
+          break;
+
+        default:
+          this._reportError(
+              `The provided animation output phase value "${phase}" for "@${eventName}" is not supported (use start or done)`,
+              sourceSpan);
+          break;
+      }
+    } else {
+      this._reportError(
+          `The animation trigger output event (@${eventName}) is missing its phase value name (start or done are currently supported)`,
+          sourceSpan);
+    }
+  }
+
+  private _parseEvent(
+      name: string, expression: string, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetEvents: BoundEventAst[]) {
+    // long format: 'target: eventName'
+    const [target, eventName] = splitAtColon(name, [null !, name]);
+    const ast = this._parseAction(expression, sourceSpan);
+    targetMatchableAttrs.push([name !, ast.source !]);
+    targetEvents.push(new BoundEventAst(eventName, target, null, ast, sourceSpan));
+    // Don't detect directives for event names for now,
+    // so don't add the event name to the matchableAttrs
+  }
+
+  private _parseAction(value: string, sourceSpan: ParseSourceSpan): ASTWithSource {
+    const sourceInfo = sourceSpan.start.toString();
+
+    try {
+      const ast = this._exprParser.parseAction(value, sourceInfo, this._interpolationConfig);
+      if (ast) {
+        this._reportExpressionParserErrors(ast.errors, sourceSpan);
+      }
+      if (!ast || ast.ast instanceof EmptyExpr) {
+        this._reportError(`Empty expressions are not allowed`, sourceSpan);
+        return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
+      }
+      this._checkPipes(ast, sourceSpan);
+      return ast;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
+    }
+  }
+
+  private _reportError(
+      message: string, sourceSpan: ParseSourceSpan,
+      level: ParseErrorLevel = ParseErrorLevel.ERROR) {
+    this._targetErrors.push(new ParseError(sourceSpan, message, level));
+  }
+
+  private _reportExpressionParserErrors(errors: ParserError[], sourceSpan: ParseSourceSpan) {
+    for (const error of errors) {
+      this._reportError(error.message, sourceSpan);
+    }
+  }
+
+  private _checkPipes(ast: ASTWithSource, sourceSpan: ParseSourceSpan) {
+    if (ast) {
+      const collector = new PipeCollector();
+      ast.visit(collector);
+      collector.pipes.forEach((ast, pipeName) => {
+        const pipeMeta = this.pipesByName.get(pipeName);
+        if (!pipeMeta) {
+          this._reportError(
+              `The pipe '${pipeName}' could not be found`,
+              new ParseSourceSpan(
+                  sourceSpan.start.moveBy(ast.span.start), sourceSpan.start.moveBy(ast.span.end)));
+        } else {
+          this._usedPipes.set(pipeName, pipeMeta);
+        }
+      });
+    }
+  }
+
+  /**
+   * @param propName the name of the property / attribute
+   * @param sourceSpan
+   * @param isAttr true when binding to an attribute
+   */
+  private _validatePropertyOrAttributeName(
+      propName: string, sourceSpan: ParseSourceSpan, isAttr: boolean): void {
+    const report = isAttr ? this._schemaRegistry.validateAttribute(propName) :
+                            this._schemaRegistry.validateProperty(propName);
+    if (report.error) {
+      this._reportError(report.msg !, sourceSpan, ParseErrorLevel.ERROR);
+    }
+  }
+}
+
+export class PipeCollector extends RecursiveAstVisitor {
+  pipes = new Map<string, BindingPipe>();
+  visitPipe(ast: BindingPipe, context: any): any {
+    this.pipes.set(ast.name, ast);
+    ast.exp.visit(this);
+    this.visitAll(ast.args, context);
+    return null;
+  }
+}
+
+function _isAnimationLabel(name: string): boolean {
+  return name[0] == '@';
+}
+
+export function calcPossibleSecurityContexts(
+    registry: ElementSchemaRegistry, selector: string, propName: string,
+    isAttribute: boolean): SecurityContext[] {
+  const ctxs: SecurityContext[] = [];
+  CssSelector.parse(selector).forEach((selector) => {
+    const elementNames = selector.element ? [selector.element] : registry.allKnownElementNames();
+    const notElementNames =
+        new Set(selector.notSelectors.filter(selector => selector.isElementSelector())
+                    .map((selector) => selector.element));
+    const possibleElementNames =
+        elementNames.filter(elementName => !notElementNames.has(elementName));
+
+    ctxs.push(...possibleElementNames.map(
+        elementName => registry.securityContext(elementName, propName, isAttribute)));
+  });
+  return ctxs.length === 0 ? [SecurityContext.NONE] : Array.from(new Set(ctxs)).sort();
+}
diff --git a/angular/compiler/src/template_parser/template_ast.ts b/angular/compiler/src/template_parser/template_ast.ts
new file mode 100644
index 0000000..391caf6
--- /dev/null
+++ b/angular/compiler/src/template_parser/template_ast.ts
@@ -0,0 +1,363 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {AstPath} from '../ast_path';
+import {CompileDirectiveSummary, CompileProviderMetadata, CompileTokenMetadata} from '../compile_metadata';
+import {SecurityContext} from '../core';
+import {AST} from '../expression_parser/ast';
+import {LifecycleHooks} from '../lifecycle_reflector';
+import {ParseSourceSpan} from '../parse_util';
+
+
+
+/**
+ * An Abstract Syntax Tree node representing part of a parsed Angular template.
+ */
+export interface TemplateAst {
+  /**
+   * The source span from which this node was parsed.
+   */
+  sourceSpan: ParseSourceSpan;
+
+  /**
+   * Visit this node and possibly transform it.
+   */
+  visit(visitor: TemplateAstVisitor, context: any): any;
+}
+
+/**
+ * A segment of text within the template.
+ */
+export class TextAst implements TemplateAst {
+  constructor(
+      public value: string, public ngContentIndex: number, public sourceSpan: ParseSourceSpan) {}
+  visit(visitor: TemplateAstVisitor, context: any): any { return visitor.visitText(this, context); }
+}
+
+/**
+ * A bound expression within the text of a template.
+ */
+export class BoundTextAst implements TemplateAst {
+  constructor(
+      public value: AST, public ngContentIndex: number, public sourceSpan: ParseSourceSpan) {}
+  visit(visitor: TemplateAstVisitor, context: any): any {
+    return visitor.visitBoundText(this, context);
+  }
+}
+
+/**
+ * A plain attribute on an element.
+ */
+export class AttrAst implements TemplateAst {
+  constructor(public name: string, public value: string, public sourceSpan: ParseSourceSpan) {}
+  visit(visitor: TemplateAstVisitor, context: any): any { return visitor.visitAttr(this, context); }
+}
+
+/**
+ * A binding for an element property (e.g. `[property]="expression"`) or an animation trigger (e.g.
+ * `[@trigger]="stateExp"`)
+ */
+export class BoundElementPropertyAst implements TemplateAst {
+  constructor(
+      public name: string, public type: PropertyBindingType,
+      public securityContext: SecurityContext, public value: AST, public unit: string|null,
+      public sourceSpan: ParseSourceSpan) {}
+  visit(visitor: TemplateAstVisitor, context: any): any {
+    return visitor.visitElementProperty(this, context);
+  }
+  get isAnimation(): boolean { return this.type === PropertyBindingType.Animation; }
+}
+
+/**
+ * A binding for an element event (e.g. `(event)="handler()"`) or an animation trigger event (e.g.
+ * `(@trigger.phase)="callback($event)"`).
+ */
+export class BoundEventAst implements TemplateAst {
+  static calcFullName(name: string, target: string|null, phase: string|null): string {
+    if (target) {
+      return `${target}:${name}`;
+    } else if (phase) {
+      return `@${name}.${phase}`;
+    } else {
+      return name;
+    }
+  }
+
+  constructor(
+      public name: string, public target: string|null, public phase: string|null,
+      public handler: AST, public sourceSpan: ParseSourceSpan) {}
+  visit(visitor: TemplateAstVisitor, context: any): any {
+    return visitor.visitEvent(this, context);
+  }
+  get fullName() { return BoundEventAst.calcFullName(this.name, this.target, this.phase); }
+  get isAnimation(): boolean { return !!this.phase; }
+}
+
+/**
+ * A reference declaration on an element (e.g. `let someName="expression"`).
+ */
+export class ReferenceAst implements TemplateAst {
+  constructor(
+      public name: string, public value: CompileTokenMetadata, public sourceSpan: ParseSourceSpan) {
+  }
+  visit(visitor: TemplateAstVisitor, context: any): any {
+    return visitor.visitReference(this, context);
+  }
+}
+
+/**
+ * A variable declaration on a <ng-template> (e.g. `var-someName="someLocalName"`).
+ */
+export class VariableAst implements TemplateAst {
+  constructor(public name: string, public value: string, public sourceSpan: ParseSourceSpan) {}
+  visit(visitor: TemplateAstVisitor, context: any): any {
+    return visitor.visitVariable(this, context);
+  }
+}
+
+/**
+ * An element declaration in a template.
+ */
+export class ElementAst implements TemplateAst {
+  constructor(
+      public name: string, public attrs: AttrAst[], public inputs: BoundElementPropertyAst[],
+      public outputs: BoundEventAst[], public references: ReferenceAst[],
+      public directives: DirectiveAst[], public providers: ProviderAst[],
+      public hasViewContainer: boolean, public queryMatches: QueryMatch[],
+      public children: TemplateAst[], public ngContentIndex: number|null,
+      public sourceSpan: ParseSourceSpan, public endSourceSpan: ParseSourceSpan|null) {}
+
+  visit(visitor: TemplateAstVisitor, context: any): any {
+    return visitor.visitElement(this, context);
+  }
+}
+
+/**
+ * A `<ng-template>` element included in an Angular template.
+ */
+export class EmbeddedTemplateAst implements TemplateAst {
+  constructor(
+      public attrs: AttrAst[], public outputs: BoundEventAst[], public references: ReferenceAst[],
+      public variables: VariableAst[], public directives: DirectiveAst[],
+      public providers: ProviderAst[], public hasViewContainer: boolean,
+      public queryMatches: QueryMatch[], public children: TemplateAst[],
+      public ngContentIndex: number, public sourceSpan: ParseSourceSpan) {}
+
+  visit(visitor: TemplateAstVisitor, context: any): any {
+    return visitor.visitEmbeddedTemplate(this, context);
+  }
+}
+
+/**
+ * A directive property with a bound value (e.g. `*ngIf="condition").
+ */
+export class BoundDirectivePropertyAst implements TemplateAst {
+  constructor(
+      public directiveName: string, public templateName: string, public value: AST,
+      public sourceSpan: ParseSourceSpan) {}
+  visit(visitor: TemplateAstVisitor, context: any): any {
+    return visitor.visitDirectiveProperty(this, context);
+  }
+}
+
+/**
+ * A directive declared on an element.
+ */
+export class DirectiveAst implements TemplateAst {
+  constructor(
+      public directive: CompileDirectiveSummary, public inputs: BoundDirectivePropertyAst[],
+      public hostProperties: BoundElementPropertyAst[], public hostEvents: BoundEventAst[],
+      public contentQueryStartId: number, public sourceSpan: ParseSourceSpan) {}
+  visit(visitor: TemplateAstVisitor, context: any): any {
+    return visitor.visitDirective(this, context);
+  }
+}
+
+/**
+ * A provider declared on an element
+ */
+export class ProviderAst implements TemplateAst {
+  constructor(
+      public token: CompileTokenMetadata, public multiProvider: boolean, public eager: boolean,
+      public providers: CompileProviderMetadata[], public providerType: ProviderAstType,
+      public lifecycleHooks: LifecycleHooks[], public sourceSpan: ParseSourceSpan) {}
+
+  visit(visitor: TemplateAstVisitor, context: any): any {
+    // No visit method in the visitor for now...
+    return null;
+  }
+}
+
+export enum ProviderAstType {
+  PublicService,
+  PrivateService,
+  Component,
+  Directive,
+  Builtin
+}
+
+/**
+ * Position where content is to be projected (instance of `<ng-content>` in a template).
+ */
+export class NgContentAst implements TemplateAst {
+  constructor(
+      public index: number, public ngContentIndex: number, public sourceSpan: ParseSourceSpan) {}
+  visit(visitor: TemplateAstVisitor, context: any): any {
+    return visitor.visitNgContent(this, context);
+  }
+}
+
+/**
+ * Enumeration of types of property bindings.
+ */
+export enum PropertyBindingType {
+
+  /**
+   * A normal binding to a property (e.g. `[property]="expression"`).
+   */
+  Property,
+
+  /**
+   * A binding to an element attribute (e.g. `[attr.name]="expression"`).
+   */
+  Attribute,
+
+  /**
+   * A binding to a CSS class (e.g. `[class.name]="condition"`).
+   */
+  Class,
+
+  /**
+   * A binding to a style rule (e.g. `[style.rule]="expression"`).
+   */
+  Style,
+
+  /**
+   * A binding to an animation reference (e.g. `[animate.key]="expression"`).
+   */
+  Animation
+}
+
+export interface QueryMatch {
+  queryId: number;
+  value: CompileTokenMetadata;
+}
+
+/**
+ * A visitor for {@link TemplateAst} trees that will process each node.
+ */
+export interface TemplateAstVisitor {
+  // Returning a truthy value from `visit()` will prevent `templateVisitAll()` from the call to
+  // the typed method and result returned will become the result included in `visitAll()`s
+  // result array.
+  visit?(ast: TemplateAst, context: any): any;
+
+  visitNgContent(ast: NgContentAst, context: any): any;
+  visitEmbeddedTemplate(ast: EmbeddedTemplateAst, context: any): any;
+  visitElement(ast: ElementAst, context: any): any;
+  visitReference(ast: ReferenceAst, context: any): any;
+  visitVariable(ast: VariableAst, context: any): any;
+  visitEvent(ast: BoundEventAst, context: any): any;
+  visitElementProperty(ast: BoundElementPropertyAst, context: any): any;
+  visitAttr(ast: AttrAst, context: any): any;
+  visitBoundText(ast: BoundTextAst, context: any): any;
+  visitText(ast: TextAst, context: any): any;
+  visitDirective(ast: DirectiveAst, context: any): any;
+  visitDirectiveProperty(ast: BoundDirectivePropertyAst, context: any): any;
+}
+
+/**
+ * A visitor that accepts each node but doesn't do anything. It is intended to be used
+ * as the base class for a visitor that is only interested in a subset of the node types.
+ */
+export class NullTemplateVisitor implements TemplateAstVisitor {
+  visitNgContent(ast: NgContentAst, context: any): void {}
+  visitEmbeddedTemplate(ast: EmbeddedTemplateAst, context: any): void {}
+  visitElement(ast: ElementAst, context: any): void {}
+  visitReference(ast: ReferenceAst, context: any): void {}
+  visitVariable(ast: VariableAst, context: any): void {}
+  visitEvent(ast: BoundEventAst, context: any): void {}
+  visitElementProperty(ast: BoundElementPropertyAst, context: any): void {}
+  visitAttr(ast: AttrAst, context: any): void {}
+  visitBoundText(ast: BoundTextAst, context: any): void {}
+  visitText(ast: TextAst, context: any): void {}
+  visitDirective(ast: DirectiveAst, context: any): void {}
+  visitDirectiveProperty(ast: BoundDirectivePropertyAst, context: any): void {}
+}
+
+/**
+ * Base class that can be used to build a visitor that visits each node
+ * in an template ast recursively.
+ */
+export class RecursiveTemplateAstVisitor extends NullTemplateVisitor implements TemplateAstVisitor {
+  constructor() { super(); }
+
+  // Nodes with children
+  visitEmbeddedTemplate(ast: EmbeddedTemplateAst, context: any): any {
+    return this.visitChildren(context, visit => {
+      visit(ast.attrs);
+      visit(ast.references);
+      visit(ast.variables);
+      visit(ast.directives);
+      visit(ast.providers);
+      visit(ast.children);
+    });
+  }
+
+  visitElement(ast: ElementAst, context: any): any {
+    return this.visitChildren(context, visit => {
+      visit(ast.attrs);
+      visit(ast.inputs);
+      visit(ast.outputs);
+      visit(ast.references);
+      visit(ast.directives);
+      visit(ast.providers);
+      visit(ast.children);
+    });
+  }
+
+  visitDirective(ast: DirectiveAst, context: any): any {
+    return this.visitChildren(context, visit => {
+      visit(ast.inputs);
+      visit(ast.hostProperties);
+      visit(ast.hostEvents);
+    });
+  }
+
+  protected visitChildren<T extends TemplateAst>(
+      context: any,
+      cb: (visit: (<V extends TemplateAst>(children: V[]|undefined) => void)) => void) {
+    let results: any[][] = [];
+    let t = this;
+    function visit<T extends TemplateAst>(children: T[] | undefined) {
+      if (children && children.length) results.push(templateVisitAll(t, children, context));
+    }
+    cb(visit);
+    return [].concat.apply([], results);
+  }
+}
+
+/**
+ * Visit every node in a list of {@link TemplateAst}s with the given {@link TemplateAstVisitor}.
+ */
+export function templateVisitAll(
+    visitor: TemplateAstVisitor, asts: TemplateAst[], context: any = null): any[] {
+  const result: any[] = [];
+  const visit = visitor.visit ?
+      (ast: TemplateAst) => visitor.visit !(ast, context) || ast.visit(visitor, context) :
+      (ast: TemplateAst) => ast.visit(visitor, context);
+  asts.forEach(ast => {
+    const astResult = visit(ast);
+    if (astResult) {
+      result.push(astResult);
+    }
+  });
+  return result;
+}
+
+export type TemplateAstPath = AstPath<TemplateAst>;
diff --git a/angular/compiler/src/template_parser/template_parser.ts b/angular/compiler/src/template_parser/template_parser.ts
new file mode 100644
index 0000000..255e048
--- /dev/null
+++ b/angular/compiler/src/template_parser/template_parser.ts
@@ -0,0 +1,919 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileDirectiveMetadata, CompileDirectiveSummary, CompilePipeSummary, CompileTokenMetadata, CompileTypeMetadata, identifierName} from '../compile_metadata';
+import {CompileReflector} from '../compile_reflector';
+import {CompilerConfig} from '../config';
+import {SchemaMetadata} from '../core';
+import {AST, ASTWithSource, EmptyExpr} from '../expression_parser/ast';
+import {Parser} from '../expression_parser/parser';
+import {I18NHtmlParser} from '../i18n/i18n_html_parser';
+import {Identifiers, createTokenForExternalReference, createTokenForReference} from '../identifiers';
+import * as html from '../ml_parser/ast';
+import {ParseTreeResult} from '../ml_parser/html_parser';
+import {removeWhitespaces} from '../ml_parser/html_whitespaces';
+import {expandNodes} from '../ml_parser/icu_ast_expander';
+import {InterpolationConfig} from '../ml_parser/interpolation_config';
+import {isNgTemplate, splitNsName} from '../ml_parser/tags';
+import {ParseError, ParseErrorLevel, ParseSourceSpan} from '../parse_util';
+import {ProviderElementContext, ProviderViewContext} from '../provider_analyzer';
+import {ElementSchemaRegistry} from '../schema/element_schema_registry';
+import {CssSelector, SelectorMatcher} from '../selector';
+import {isStyleUrlResolvable} from '../style_url_resolver';
+import {Console, syntaxError} from '../util';
+
+import {BindingParser, BoundProperty} from './binding_parser';
+import {AttrAst, BoundDirectivePropertyAst, BoundElementPropertyAst, BoundEventAst, BoundTextAst, DirectiveAst, ElementAst, EmbeddedTemplateAst, NgContentAst, PropertyBindingType, ReferenceAst, TemplateAst, TemplateAstVisitor, TextAst, VariableAst, templateVisitAll} from './template_ast';
+import {PreparsedElementType, preparseElement} from './template_preparser';
+
+const BIND_NAME_REGEXP =
+    /^(?:(?:(?:(bind-)|(let-)|(ref-|#)|(on-)|(bindon-)|(@))(.+))|\[\(([^\)]+)\)\]|\[([^\]]+)\]|\(([^\)]+)\))$/;
+
+// Group 1 = "bind-"
+const KW_BIND_IDX = 1;
+// Group 2 = "let-"
+const KW_LET_IDX = 2;
+// Group 3 = "ref-/#"
+const KW_REF_IDX = 3;
+// Group 4 = "on-"
+const KW_ON_IDX = 4;
+// Group 5 = "bindon-"
+const KW_BINDON_IDX = 5;
+// Group 6 = "@"
+const KW_AT_IDX = 6;
+// Group 7 = the identifier after "bind-", "let-", "ref-/#", "on-", "bindon-" or "@"
+const IDENT_KW_IDX = 7;
+// Group 8 = identifier inside [()]
+const IDENT_BANANA_BOX_IDX = 8;
+// Group 9 = identifier inside []
+const IDENT_PROPERTY_IDX = 9;
+// Group 10 = identifier inside ()
+const IDENT_EVENT_IDX = 10;
+
+// deprecated in 4.x
+const TEMPLATE_ELEMENT = 'template';
+// deprecated in 4.x
+const TEMPLATE_ATTR = 'template';
+const TEMPLATE_ATTR_PREFIX = '*';
+const CLASS_ATTR = 'class';
+
+const TEXT_CSS_SELECTOR = CssSelector.parse('*')[0];
+
+const TEMPLATE_ELEMENT_DEPRECATION_WARNING =
+    'The <template> element is deprecated. Use <ng-template> instead';
+const TEMPLATE_ATTR_DEPRECATION_WARNING =
+    'The template attribute is deprecated. Use an ng-template element instead.';
+
+let warningCounts: {[warning: string]: number} = {};
+
+function warnOnlyOnce(warnings: string[]): (warning: ParseError) => boolean {
+  return (error: ParseError) => {
+    if (warnings.indexOf(error.msg) !== -1) {
+      warningCounts[error.msg] = (warningCounts[error.msg] || 0) + 1;
+      return warningCounts[error.msg] <= 1;
+    }
+    return true;
+  };
+}
+
+export class TemplateParseError extends ParseError {
+  constructor(message: string, span: ParseSourceSpan, level: ParseErrorLevel) {
+    super(span, message, level);
+  }
+}
+
+export class TemplateParseResult {
+  constructor(
+      public templateAst?: TemplateAst[], public usedPipes?: CompilePipeSummary[],
+      public errors?: ParseError[]) {}
+}
+
+export class TemplateParser {
+  constructor(
+      private _config: CompilerConfig, private _reflector: CompileReflector,
+      private _exprParser: Parser, private _schemaRegistry: ElementSchemaRegistry,
+      private _htmlParser: I18NHtmlParser, private _console: Console,
+      public transforms: TemplateAstVisitor[]) {}
+
+  parse(
+      component: CompileDirectiveMetadata, template: string, directives: CompileDirectiveSummary[],
+      pipes: CompilePipeSummary[], schemas: SchemaMetadata[], templateUrl: string,
+      preserveWhitespaces: boolean): {template: TemplateAst[], pipes: CompilePipeSummary[]} {
+    const result = this.tryParse(
+        component, template, directives, pipes, schemas, templateUrl, preserveWhitespaces);
+    const warnings =
+        result.errors !.filter(error => error.level === ParseErrorLevel.WARNING)
+            .filter(warnOnlyOnce(
+                [TEMPLATE_ATTR_DEPRECATION_WARNING, TEMPLATE_ELEMENT_DEPRECATION_WARNING]));
+
+    const errors = result.errors !.filter(error => error.level === ParseErrorLevel.ERROR);
+
+    if (warnings.length > 0) {
+      this._console.warn(`Template parse warnings:\n${warnings.join('\n')}`);
+    }
+
+    if (errors.length > 0) {
+      const errorString = errors.join('\n');
+      throw syntaxError(`Template parse errors:\n${errorString}`, errors);
+    }
+
+    return {template: result.templateAst !, pipes: result.usedPipes !};
+  }
+
+  tryParse(
+      component: CompileDirectiveMetadata, template: string, directives: CompileDirectiveSummary[],
+      pipes: CompilePipeSummary[], schemas: SchemaMetadata[], templateUrl: string,
+      preserveWhitespaces: boolean): TemplateParseResult {
+    let htmlParseResult = this._htmlParser !.parse(
+        template, templateUrl, true, this.getInterpolationConfig(component));
+
+    if (!preserveWhitespaces) {
+      htmlParseResult = removeWhitespaces(htmlParseResult);
+    }
+
+    return this.tryParseHtml(
+        this.expandHtml(htmlParseResult), component, directives, pipes, schemas);
+  }
+
+  tryParseHtml(
+      htmlAstWithErrors: ParseTreeResult, component: CompileDirectiveMetadata,
+      directives: CompileDirectiveSummary[], pipes: CompilePipeSummary[],
+      schemas: SchemaMetadata[]): TemplateParseResult {
+    let result: TemplateAst[];
+    const errors = htmlAstWithErrors.errors;
+    const usedPipes: CompilePipeSummary[] = [];
+    if (htmlAstWithErrors.rootNodes.length > 0) {
+      const uniqDirectives = removeSummaryDuplicates(directives);
+      const uniqPipes = removeSummaryDuplicates(pipes);
+      const providerViewContext = new ProviderViewContext(this._reflector, component);
+      let interpolationConfig: InterpolationConfig = undefined !;
+      if (component.template && component.template.interpolation) {
+        interpolationConfig = {
+          start: component.template.interpolation[0],
+          end: component.template.interpolation[1]
+        };
+      }
+      const bindingParser = new BindingParser(
+          this._exprParser, interpolationConfig !, this._schemaRegistry, uniqPipes, errors);
+      const parseVisitor = new TemplateParseVisitor(
+          this._reflector, this._config, providerViewContext, uniqDirectives, bindingParser,
+          this._schemaRegistry, schemas, errors);
+      result = html.visitAll(parseVisitor, htmlAstWithErrors.rootNodes, EMPTY_ELEMENT_CONTEXT);
+      errors.push(...providerViewContext.errors);
+      usedPipes.push(...bindingParser.getUsedPipes());
+    } else {
+      result = [];
+    }
+    this._assertNoReferenceDuplicationOnTemplate(result, errors);
+
+    if (errors.length > 0) {
+      return new TemplateParseResult(result, usedPipes, errors);
+    }
+
+    if (this.transforms) {
+      this.transforms.forEach(
+          (transform: TemplateAstVisitor) => { result = templateVisitAll(transform, result); });
+    }
+
+    return new TemplateParseResult(result, usedPipes, errors);
+  }
+
+  expandHtml(htmlAstWithErrors: ParseTreeResult, forced: boolean = false): ParseTreeResult {
+    const errors: ParseError[] = htmlAstWithErrors.errors;
+
+    if (errors.length == 0 || forced) {
+      // Transform ICU messages to angular directives
+      const expandedHtmlAst = expandNodes(htmlAstWithErrors.rootNodes);
+      errors.push(...expandedHtmlAst.errors);
+      htmlAstWithErrors = new ParseTreeResult(expandedHtmlAst.nodes, errors);
+    }
+    return htmlAstWithErrors;
+  }
+
+  getInterpolationConfig(component: CompileDirectiveMetadata): InterpolationConfig|undefined {
+    if (component.template) {
+      return InterpolationConfig.fromArray(component.template.interpolation);
+    }
+    return undefined;
+  }
+
+  /** @internal */
+  _assertNoReferenceDuplicationOnTemplate(result: TemplateAst[], errors: TemplateParseError[]):
+      void {
+    const existingReferences: string[] = [];
+
+    result.filter(element => !!(<any>element).references)
+        .forEach(element => (<any>element).references.forEach((reference: ReferenceAst) => {
+          const name = reference.name;
+          if (existingReferences.indexOf(name) < 0) {
+            existingReferences.push(name);
+          } else {
+            const error = new TemplateParseError(
+                `Reference "#${name}" is defined several times`, reference.sourceSpan,
+                ParseErrorLevel.ERROR);
+            errors.push(error);
+          }
+        }));
+  }
+}
+
+class TemplateParseVisitor implements html.Visitor {
+  selectorMatcher = new SelectorMatcher();
+  directivesIndex = new Map<CompileDirectiveSummary, number>();
+  ngContentCount = 0;
+  contentQueryStartId: number;
+
+  constructor(
+      private reflector: CompileReflector, private config: CompilerConfig,
+      public providerViewContext: ProviderViewContext, directives: CompileDirectiveSummary[],
+      private _bindingParser: BindingParser, private _schemaRegistry: ElementSchemaRegistry,
+      private _schemas: SchemaMetadata[], private _targetErrors: TemplateParseError[]) {
+    // Note: queries start with id 1 so we can use the number in a Bloom filter!
+    this.contentQueryStartId = providerViewContext.component.viewQueries.length + 1;
+    directives.forEach((directive, index) => {
+      const selector = CssSelector.parse(directive.selector !);
+      this.selectorMatcher.addSelectables(selector, directive);
+      this.directivesIndex.set(directive, index);
+    });
+  }
+
+  visitExpansion(expansion: html.Expansion, context: any): any { return null; }
+
+  visitExpansionCase(expansionCase: html.ExpansionCase, context: any): any { return null; }
+
+  visitText(text: html.Text, parent: ElementContext): any {
+    const ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR) !;
+    const expr = this._bindingParser.parseInterpolation(text.value, text.sourceSpan !);
+    return expr ? new BoundTextAst(expr, ngContentIndex, text.sourceSpan !) :
+                  new TextAst(text.value, ngContentIndex, text.sourceSpan !);
+  }
+
+  visitAttribute(attribute: html.Attribute, context: any): any {
+    return new AttrAst(attribute.name, attribute.value, attribute.sourceSpan);
+  }
+
+  visitComment(comment: html.Comment, context: any): any { return null; }
+
+  visitElement(element: html.Element, parent: ElementContext): any {
+    const queryStartIndex = this.contentQueryStartId;
+    const nodeName = element.name;
+    const preparsedElement = preparseElement(element);
+    if (preparsedElement.type === PreparsedElementType.SCRIPT ||
+        preparsedElement.type === PreparsedElementType.STYLE) {
+      // Skipping <script> for security reasons
+      // Skipping <style> as we already processed them
+      // in the StyleCompiler
+      return null;
+    }
+    if (preparsedElement.type === PreparsedElementType.STYLESHEET &&
+        isStyleUrlResolvable(preparsedElement.hrefAttr)) {
+      // Skipping stylesheets with either relative urls or package scheme as we already processed
+      // them in the StyleCompiler
+      return null;
+    }
+
+    const matchableAttrs: [string, string][] = [];
+    const elementOrDirectiveProps: BoundProperty[] = [];
+    const elementOrDirectiveRefs: ElementOrDirectiveRef[] = [];
+    const elementVars: VariableAst[] = [];
+    const events: BoundEventAst[] = [];
+
+    const templateElementOrDirectiveProps: BoundProperty[] = [];
+    const templateMatchableAttrs: [string, string][] = [];
+    const templateElementVars: VariableAst[] = [];
+
+    let hasInlineTemplates = false;
+    const attrs: AttrAst[] = [];
+    const isTemplateElement = isTemplate(
+        element, this.config.enableLegacyTemplate,
+        (m: string, span: ParseSourceSpan) => this._reportError(m, span, ParseErrorLevel.WARNING));
+
+    element.attrs.forEach(attr => {
+      const hasBinding = this._parseAttr(
+          isTemplateElement, attr, matchableAttrs, elementOrDirectiveProps, events,
+          elementOrDirectiveRefs, elementVars);
+
+      let templateBindingsSource: string|undefined;
+      let prefixToken: string|undefined;
+      let normalizedName = this._normalizeAttributeName(attr.name);
+
+      if (this.config.enableLegacyTemplate && normalizedName == TEMPLATE_ATTR) {
+        this._reportError(
+            TEMPLATE_ATTR_DEPRECATION_WARNING, attr.sourceSpan, ParseErrorLevel.WARNING);
+        templateBindingsSource = attr.value;
+      } else if (normalizedName.startsWith(TEMPLATE_ATTR_PREFIX)) {
+        templateBindingsSource = attr.value;
+        prefixToken = normalizedName.substring(TEMPLATE_ATTR_PREFIX.length) + ':';
+      }
+
+      const hasTemplateBinding = templateBindingsSource != null;
+      if (hasTemplateBinding) {
+        if (hasInlineTemplates) {
+          this._reportError(
+              `Can't have multiple template bindings on one element. Use only one attribute named 'template' or prefixed with *`,
+              attr.sourceSpan);
+        }
+        hasInlineTemplates = true;
+        this._bindingParser.parseInlineTemplateBinding(
+            prefixToken !, templateBindingsSource !, attr.sourceSpan, templateMatchableAttrs,
+            templateElementOrDirectiveProps, templateElementVars);
+      }
+
+      if (!hasBinding && !hasTemplateBinding) {
+        // don't include the bindings as attributes as well in the AST
+        attrs.push(this.visitAttribute(attr, null));
+        matchableAttrs.push([attr.name, attr.value]);
+      }
+    });
+
+    const elementCssSelector = createElementCssSelector(nodeName, matchableAttrs);
+    const {directives: directiveMetas, matchElement} =
+        this._parseDirectives(this.selectorMatcher, elementCssSelector);
+    const references: ReferenceAst[] = [];
+    const boundDirectivePropNames = new Set<string>();
+    const directiveAsts = this._createDirectiveAsts(
+        isTemplateElement, element.name, directiveMetas, elementOrDirectiveProps,
+        elementOrDirectiveRefs, element.sourceSpan !, references, boundDirectivePropNames);
+    const elementProps: BoundElementPropertyAst[] = this._createElementPropertyAsts(
+        element.name, elementOrDirectiveProps, boundDirectivePropNames);
+    const isViewRoot = parent.isTemplateElement || hasInlineTemplates;
+
+    const providerContext = new ProviderElementContext(
+        this.providerViewContext, parent.providerContext !, isViewRoot, directiveAsts, attrs,
+        references, isTemplateElement, queryStartIndex, element.sourceSpan !);
+
+    const children: TemplateAst[] = html.visitAll(
+        preparsedElement.nonBindable ? NON_BINDABLE_VISITOR : this, element.children,
+        ElementContext.create(
+            isTemplateElement, directiveAsts,
+            isTemplateElement ? parent.providerContext ! : providerContext));
+    providerContext.afterElement();
+    // Override the actual selector when the `ngProjectAs` attribute is provided
+    const projectionSelector = preparsedElement.projectAs != null ?
+        CssSelector.parse(preparsedElement.projectAs)[0] :
+        elementCssSelector;
+    const ngContentIndex = parent.findNgContentIndex(projectionSelector) !;
+    let parsedElement: TemplateAst;
+
+    if (preparsedElement.type === PreparsedElementType.NG_CONTENT) {
+      if (element.children && !element.children.every(_isEmptyTextNode)) {
+        this._reportError(`<ng-content> element cannot have content.`, element.sourceSpan !);
+      }
+
+      parsedElement = new NgContentAst(
+          this.ngContentCount++, hasInlineTemplates ? null ! : ngContentIndex,
+          element.sourceSpan !);
+    } else if (isTemplateElement) {
+      this._assertAllEventsPublishedByDirectives(directiveAsts, events);
+      this._assertNoComponentsNorElementBindingsOnTemplate(
+          directiveAsts, elementProps, element.sourceSpan !);
+
+      parsedElement = new EmbeddedTemplateAst(
+          attrs, events, references, elementVars, providerContext.transformedDirectiveAsts,
+          providerContext.transformProviders, providerContext.transformedHasViewContainer,
+          providerContext.queryMatches, children, hasInlineTemplates ? null ! : ngContentIndex,
+          element.sourceSpan !);
+    } else {
+      this._assertElementExists(matchElement, element);
+      this._assertOnlyOneComponent(directiveAsts, element.sourceSpan !);
+
+      const ngContentIndex =
+          hasInlineTemplates ? null : parent.findNgContentIndex(projectionSelector);
+      parsedElement = new ElementAst(
+          nodeName, attrs, elementProps, events, references,
+          providerContext.transformedDirectiveAsts, providerContext.transformProviders,
+          providerContext.transformedHasViewContainer, providerContext.queryMatches, children,
+          hasInlineTemplates ? null : ngContentIndex, element.sourceSpan,
+          element.endSourceSpan || null);
+    }
+
+    if (hasInlineTemplates) {
+      const templateQueryStartIndex = this.contentQueryStartId;
+      const templateSelector = createElementCssSelector(TEMPLATE_ELEMENT, templateMatchableAttrs);
+      const {directives: templateDirectiveMetas} =
+          this._parseDirectives(this.selectorMatcher, templateSelector);
+      const templateBoundDirectivePropNames = new Set<string>();
+      const templateDirectiveAsts = this._createDirectiveAsts(
+          true, element.name, templateDirectiveMetas, templateElementOrDirectiveProps, [],
+          element.sourceSpan !, [], templateBoundDirectivePropNames);
+      const templateElementProps: BoundElementPropertyAst[] = this._createElementPropertyAsts(
+          element.name, templateElementOrDirectiveProps, templateBoundDirectivePropNames);
+      this._assertNoComponentsNorElementBindingsOnTemplate(
+          templateDirectiveAsts, templateElementProps, element.sourceSpan !);
+      const templateProviderContext = new ProviderElementContext(
+          this.providerViewContext, parent.providerContext !, parent.isTemplateElement,
+          templateDirectiveAsts, [], [], true, templateQueryStartIndex, element.sourceSpan !);
+      templateProviderContext.afterElement();
+
+      parsedElement = new EmbeddedTemplateAst(
+          [], [], [], templateElementVars, templateProviderContext.transformedDirectiveAsts,
+          templateProviderContext.transformProviders,
+          templateProviderContext.transformedHasViewContainer, templateProviderContext.queryMatches,
+          [parsedElement], ngContentIndex, element.sourceSpan !);
+    }
+
+    return parsedElement;
+  }
+
+  private _parseAttr(
+      isTemplateElement: boolean, attr: html.Attribute, targetMatchableAttrs: string[][],
+      targetProps: BoundProperty[], targetEvents: BoundEventAst[],
+      targetRefs: ElementOrDirectiveRef[], targetVars: VariableAst[]): boolean {
+    const name = this._normalizeAttributeName(attr.name);
+    const value = attr.value;
+    const srcSpan = attr.sourceSpan;
+
+    const bindParts = name.match(BIND_NAME_REGEXP);
+    let hasBinding = false;
+
+    if (bindParts !== null) {
+      hasBinding = true;
+      if (bindParts[KW_BIND_IDX] != null) {
+        this._bindingParser.parsePropertyBinding(
+            bindParts[IDENT_KW_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps);
+
+      } else if (bindParts[KW_LET_IDX]) {
+        if (isTemplateElement) {
+          const identifier = bindParts[IDENT_KW_IDX];
+          this._parseVariable(identifier, value, srcSpan, targetVars);
+        } else {
+          this._reportError(`"let-" is only supported on template elements.`, srcSpan);
+        }
+
+      } else if (bindParts[KW_REF_IDX]) {
+        const identifier = bindParts[IDENT_KW_IDX];
+        this._parseReference(identifier, value, srcSpan, targetRefs);
+
+      } else if (bindParts[KW_ON_IDX]) {
+        this._bindingParser.parseEvent(
+            bindParts[IDENT_KW_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);
+
+      } else if (bindParts[KW_BINDON_IDX]) {
+        this._bindingParser.parsePropertyBinding(
+            bindParts[IDENT_KW_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps);
+        this._parseAssignmentEvent(
+            bindParts[IDENT_KW_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);
+
+      } else if (bindParts[KW_AT_IDX]) {
+        this._bindingParser.parseLiteralAttr(
+            name, value, srcSpan, targetMatchableAttrs, targetProps);
+
+      } else if (bindParts[IDENT_BANANA_BOX_IDX]) {
+        this._bindingParser.parsePropertyBinding(
+            bindParts[IDENT_BANANA_BOX_IDX], value, false, srcSpan, targetMatchableAttrs,
+            targetProps);
+        this._parseAssignmentEvent(
+            bindParts[IDENT_BANANA_BOX_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);
+
+      } else if (bindParts[IDENT_PROPERTY_IDX]) {
+        this._bindingParser.parsePropertyBinding(
+            bindParts[IDENT_PROPERTY_IDX], value, false, srcSpan, targetMatchableAttrs,
+            targetProps);
+
+      } else if (bindParts[IDENT_EVENT_IDX]) {
+        this._bindingParser.parseEvent(
+            bindParts[IDENT_EVENT_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);
+      }
+    } else {
+      hasBinding = this._bindingParser.parsePropertyInterpolation(
+          name, value, srcSpan, targetMatchableAttrs, targetProps);
+    }
+
+    if (!hasBinding) {
+      this._bindingParser.parseLiteralAttr(name, value, srcSpan, targetMatchableAttrs, targetProps);
+    }
+
+    return hasBinding;
+  }
+
+  private _normalizeAttributeName(attrName: string): string {
+    return /^data-/i.test(attrName) ? attrName.substring(5) : attrName;
+  }
+
+  private _parseVariable(
+      identifier: string, value: string, sourceSpan: ParseSourceSpan, targetVars: VariableAst[]) {
+    if (identifier.indexOf('-') > -1) {
+      this._reportError(`"-" is not allowed in variable names`, sourceSpan);
+    }
+
+    targetVars.push(new VariableAst(identifier, value, sourceSpan));
+  }
+
+  private _parseReference(
+      identifier: string, value: string, sourceSpan: ParseSourceSpan,
+      targetRefs: ElementOrDirectiveRef[]) {
+    if (identifier.indexOf('-') > -1) {
+      this._reportError(`"-" is not allowed in reference names`, sourceSpan);
+    }
+
+    targetRefs.push(new ElementOrDirectiveRef(identifier, value, sourceSpan));
+  }
+
+  private _parseAssignmentEvent(
+      name: string, expression: string, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetEvents: BoundEventAst[]) {
+    this._bindingParser.parseEvent(
+        `${name}Change`, `${expression}=$event`, sourceSpan, targetMatchableAttrs, targetEvents);
+  }
+
+  private _parseDirectives(selectorMatcher: SelectorMatcher, elementCssSelector: CssSelector):
+      {directives: CompileDirectiveSummary[], matchElement: boolean} {
+    // Need to sort the directives so that we get consistent results throughout,
+    // as selectorMatcher uses Maps inside.
+    // Also deduplicate directives as they might match more than one time!
+    const directives = new Array(this.directivesIndex.size);
+    // Whether any directive selector matches on the element name
+    let matchElement = false;
+
+    selectorMatcher.match(elementCssSelector, (selector, directive) => {
+      directives[this.directivesIndex.get(directive) !] = directive;
+      matchElement = matchElement || selector.hasElementSelector();
+    });
+
+    return {
+      directives: directives.filter(dir => !!dir),
+      matchElement,
+    };
+  }
+
+  private _createDirectiveAsts(
+      isTemplateElement: boolean, elementName: string, directives: CompileDirectiveSummary[],
+      props: BoundProperty[], elementOrDirectiveRefs: ElementOrDirectiveRef[],
+      elementSourceSpan: ParseSourceSpan, targetReferences: ReferenceAst[],
+      targetBoundDirectivePropNames: Set<string>): DirectiveAst[] {
+    const matchedReferences = new Set<string>();
+    let component: CompileDirectiveSummary = null !;
+
+    const directiveAsts = directives.map((directive) => {
+      const sourceSpan = new ParseSourceSpan(
+          elementSourceSpan.start, elementSourceSpan.end,
+          `Directive ${identifierName(directive.type)}`);
+
+      if (directive.isComponent) {
+        component = directive;
+      }
+      const directiveProperties: BoundDirectivePropertyAst[] = [];
+      let hostProperties =
+          this._bindingParser.createDirectiveHostPropertyAsts(directive, elementName, sourceSpan) !;
+      // Note: We need to check the host properties here as well,
+      // as we don't know the element name in the DirectiveWrapperCompiler yet.
+      hostProperties = this._checkPropertiesInSchema(elementName, hostProperties);
+      const hostEvents = this._bindingParser.createDirectiveHostEventAsts(directive, sourceSpan) !;
+      this._createDirectivePropertyAsts(
+          directive.inputs, props, directiveProperties, targetBoundDirectivePropNames);
+      elementOrDirectiveRefs.forEach((elOrDirRef) => {
+        if ((elOrDirRef.value.length === 0 && directive.isComponent) ||
+            (elOrDirRef.isReferenceToDirective(directive))) {
+          targetReferences.push(new ReferenceAst(
+              elOrDirRef.name, createTokenForReference(directive.type.reference),
+              elOrDirRef.sourceSpan));
+          matchedReferences.add(elOrDirRef.name);
+        }
+      });
+      const contentQueryStartId = this.contentQueryStartId;
+      this.contentQueryStartId += directive.queries.length;
+      return new DirectiveAst(
+          directive, directiveProperties, hostProperties, hostEvents, contentQueryStartId,
+          sourceSpan);
+    });
+
+    elementOrDirectiveRefs.forEach((elOrDirRef) => {
+      if (elOrDirRef.value.length > 0) {
+        if (!matchedReferences.has(elOrDirRef.name)) {
+          this._reportError(
+              `There is no directive with "exportAs" set to "${elOrDirRef.value}"`,
+              elOrDirRef.sourceSpan);
+        }
+      } else if (!component) {
+        let refToken: CompileTokenMetadata = null !;
+        if (isTemplateElement) {
+          refToken = createTokenForExternalReference(this.reflector, Identifiers.TemplateRef);
+        }
+        targetReferences.push(new ReferenceAst(elOrDirRef.name, refToken, elOrDirRef.sourceSpan));
+      }
+    });
+    return directiveAsts;
+  }
+
+  private _createDirectivePropertyAsts(
+      directiveProperties: {[key: string]: string}, boundProps: BoundProperty[],
+      targetBoundDirectiveProps: BoundDirectivePropertyAst[],
+      targetBoundDirectivePropNames: Set<string>) {
+    if (directiveProperties) {
+      const boundPropsByName = new Map<string, BoundProperty>();
+      boundProps.forEach(boundProp => {
+        const prevValue = boundPropsByName.get(boundProp.name);
+        if (!prevValue || prevValue.isLiteral) {
+          // give [a]="b" a higher precedence than a="b" on the same element
+          boundPropsByName.set(boundProp.name, boundProp);
+        }
+      });
+
+      Object.keys(directiveProperties).forEach(dirProp => {
+        const elProp = directiveProperties[dirProp];
+        const boundProp = boundPropsByName.get(elProp);
+
+        // Bindings are optional, so this binding only needs to be set up if an expression is given.
+        if (boundProp) {
+          targetBoundDirectivePropNames.add(boundProp.name);
+          if (!isEmptyExpression(boundProp.expression)) {
+            targetBoundDirectiveProps.push(new BoundDirectivePropertyAst(
+                dirProp, boundProp.name, boundProp.expression, boundProp.sourceSpan));
+          }
+        }
+      });
+    }
+  }
+
+  private _createElementPropertyAsts(
+      elementName: string, props: BoundProperty[],
+      boundDirectivePropNames: Set<string>): BoundElementPropertyAst[] {
+    const boundElementProps: BoundElementPropertyAst[] = [];
+
+    props.forEach((prop: BoundProperty) => {
+      if (!prop.isLiteral && !boundDirectivePropNames.has(prop.name)) {
+        boundElementProps.push(this._bindingParser.createElementPropertyAst(elementName, prop));
+      }
+    });
+    return this._checkPropertiesInSchema(elementName, boundElementProps);
+  }
+
+  private _findComponentDirectives(directives: DirectiveAst[]): DirectiveAst[] {
+    return directives.filter(directive => directive.directive.isComponent);
+  }
+
+  private _findComponentDirectiveNames(directives: DirectiveAst[]): string[] {
+    return this._findComponentDirectives(directives)
+        .map(directive => identifierName(directive.directive.type) !);
+  }
+
+  private _assertOnlyOneComponent(directives: DirectiveAst[], sourceSpan: ParseSourceSpan) {
+    const componentTypeNames = this._findComponentDirectiveNames(directives);
+    if (componentTypeNames.length > 1) {
+      this._reportError(
+          `More than one component matched on this element.\n` +
+              `Make sure that only one component's selector can match a given element.\n` +
+              `Conflicting components: ${componentTypeNames.join(',')}`,
+          sourceSpan);
+    }
+  }
+
+  /**
+   * Make sure that non-angular tags conform to the schemas.
+   *
+   * Note: An element is considered an angular tag when at least one directive selector matches the
+   * tag name.
+   *
+   * @param matchElement Whether any directive has matched on the tag name
+   * @param element the html element
+   */
+  private _assertElementExists(matchElement: boolean, element: html.Element) {
+    const elName = element.name.replace(/^:xhtml:/, '');
+
+    if (!matchElement && !this._schemaRegistry.hasElement(elName, this._schemas)) {
+      let errorMsg = `'${elName}' is not a known element:\n`;
+      errorMsg +=
+          `1. If '${elName}' is an Angular component, then verify that it is part of this module.\n`;
+      if (elName.indexOf('-') > -1) {
+        errorMsg +=
+            `2. If '${elName}' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the '@NgModule.schemas' of this component to suppress this message.`;
+      } else {
+        errorMsg +=
+            `2. To allow any element add 'NO_ERRORS_SCHEMA' to the '@NgModule.schemas' of this component.`;
+      }
+      this._reportError(errorMsg, element.sourceSpan !);
+    }
+  }
+
+  private _assertNoComponentsNorElementBindingsOnTemplate(
+      directives: DirectiveAst[], elementProps: BoundElementPropertyAst[],
+      sourceSpan: ParseSourceSpan) {
+    const componentTypeNames: string[] = this._findComponentDirectiveNames(directives);
+    if (componentTypeNames.length > 0) {
+      this._reportError(
+          `Components on an embedded template: ${componentTypeNames.join(',')}`, sourceSpan);
+    }
+    elementProps.forEach(prop => {
+      this._reportError(
+          `Property binding ${prop.name} not used by any directive on an embedded template. Make sure that the property name is spelled correctly and all directives are listed in the "@NgModule.declarations".`,
+          sourceSpan);
+    });
+  }
+
+  private _assertAllEventsPublishedByDirectives(
+      directives: DirectiveAst[], events: BoundEventAst[]) {
+    const allDirectiveEvents = new Set<string>();
+
+    directives.forEach(directive => {
+      Object.keys(directive.directive.outputs).forEach(k => {
+        const eventName = directive.directive.outputs[k];
+        allDirectiveEvents.add(eventName);
+      });
+    });
+
+    events.forEach(event => {
+      if (event.target != null || !allDirectiveEvents.has(event.name)) {
+        this._reportError(
+            `Event binding ${event.fullName} not emitted by any directive on an embedded template. Make sure that the event name is spelled correctly and all directives are listed in the "@NgModule.declarations".`,
+            event.sourceSpan);
+      }
+    });
+  }
+
+  private _checkPropertiesInSchema(elementName: string, boundProps: BoundElementPropertyAst[]):
+      BoundElementPropertyAst[] {
+    // Note: We can't filter out empty expressions before this method,
+    // as we still want to validate them!
+    return boundProps.filter((boundProp) => {
+      if (boundProp.type === PropertyBindingType.Property &&
+          !this._schemaRegistry.hasProperty(elementName, boundProp.name, this._schemas)) {
+        let errorMsg =
+            `Can't bind to '${boundProp.name}' since it isn't a known property of '${elementName}'.`;
+        if (elementName.startsWith('ng-')) {
+          errorMsg +=
+              `\n1. If '${boundProp.name}' is an Angular directive, then add 'CommonModule' to the '@NgModule.imports' of this component.` +
+              `\n2. To allow any property add 'NO_ERRORS_SCHEMA' to the '@NgModule.schemas' of this component.`;
+        } else if (elementName.indexOf('-') > -1) {
+          errorMsg +=
+              `\n1. If '${elementName}' is an Angular component and it has '${boundProp.name}' input, then verify that it is part of this module.` +
+              `\n2. If '${elementName}' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the '@NgModule.schemas' of this component to suppress this message.` +
+              `\n3. To allow any property add 'NO_ERRORS_SCHEMA' to the '@NgModule.schemas' of this component.`;
+        }
+        this._reportError(errorMsg, boundProp.sourceSpan);
+      }
+      return !isEmptyExpression(boundProp.value);
+    });
+  }
+
+  private _reportError(
+      message: string, sourceSpan: ParseSourceSpan,
+      level: ParseErrorLevel = ParseErrorLevel.ERROR) {
+    this._targetErrors.push(new ParseError(sourceSpan, message, level));
+  }
+}
+
+class NonBindableVisitor implements html.Visitor {
+  visitElement(ast: html.Element, parent: ElementContext): ElementAst|null {
+    const preparsedElement = preparseElement(ast);
+    if (preparsedElement.type === PreparsedElementType.SCRIPT ||
+        preparsedElement.type === PreparsedElementType.STYLE ||
+        preparsedElement.type === PreparsedElementType.STYLESHEET) {
+      // Skipping <script> for security reasons
+      // Skipping <style> and stylesheets as we already processed them
+      // in the StyleCompiler
+      return null;
+    }
+
+    const attrNameAndValues = ast.attrs.map((attr): [string, string] => [attr.name, attr.value]);
+    const selector = createElementCssSelector(ast.name, attrNameAndValues);
+    const ngContentIndex = parent.findNgContentIndex(selector);
+    const children: TemplateAst[] = html.visitAll(this, ast.children, EMPTY_ELEMENT_CONTEXT);
+    return new ElementAst(
+        ast.name, html.visitAll(this, ast.attrs), [], [], [], [], [], false, [], children,
+        ngContentIndex, ast.sourceSpan, ast.endSourceSpan);
+  }
+  visitComment(comment: html.Comment, context: any): any { return null; }
+
+  visitAttribute(attribute: html.Attribute, context: any): AttrAst {
+    return new AttrAst(attribute.name, attribute.value, attribute.sourceSpan);
+  }
+
+  visitText(text: html.Text, parent: ElementContext): TextAst {
+    const ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR) !;
+    return new TextAst(text.value, ngContentIndex, text.sourceSpan !);
+  }
+
+  visitExpansion(expansion: html.Expansion, context: any): any { return expansion; }
+
+  visitExpansionCase(expansionCase: html.ExpansionCase, context: any): any { return expansionCase; }
+}
+
+/**
+ * A reference to an element or directive in a template. E.g., the reference in this template:
+ *
+ * <div #myMenu="coolMenu">
+ *
+ * would be {name: 'myMenu', value: 'coolMenu', sourceSpan: ...}
+ */
+class ElementOrDirectiveRef {
+  constructor(public name: string, public value: string, public sourceSpan: ParseSourceSpan) {}
+
+  /** Gets whether this is a reference to the given directive. */
+  isReferenceToDirective(directive: CompileDirectiveSummary) {
+    return splitExportAs(directive.exportAs).indexOf(this.value) !== -1;
+  }
+}
+
+/** Splits a raw, potentially comma-delimted `exportAs` value into an array of names. */
+function splitExportAs(exportAs: string | null): string[] {
+  return exportAs ? exportAs.split(',').map(e => e.trim()) : [];
+}
+
+export function splitClasses(classAttrValue: string): string[] {
+  return classAttrValue.trim().split(/\s+/g);
+}
+
+class ElementContext {
+  static create(
+      isTemplateElement: boolean, directives: DirectiveAst[],
+      providerContext: ProviderElementContext): ElementContext {
+    const matcher = new SelectorMatcher();
+    let wildcardNgContentIndex: number = null !;
+    const component = directives.find(directive => directive.directive.isComponent);
+    if (component) {
+      const ngContentSelectors = component.directive.template !.ngContentSelectors;
+      for (let i = 0; i < ngContentSelectors.length; i++) {
+        const selector = ngContentSelectors[i];
+        if (selector === '*') {
+          wildcardNgContentIndex = i;
+        } else {
+          matcher.addSelectables(CssSelector.parse(ngContentSelectors[i]), i);
+        }
+      }
+    }
+    return new ElementContext(isTemplateElement, matcher, wildcardNgContentIndex, providerContext);
+  }
+  constructor(
+      public isTemplateElement: boolean, private _ngContentIndexMatcher: SelectorMatcher,
+      private _wildcardNgContentIndex: number|null,
+      public providerContext: ProviderElementContext|null) {}
+
+  findNgContentIndex(selector: CssSelector): number|null {
+    const ngContentIndices: number[] = [];
+    this._ngContentIndexMatcher.match(
+        selector, (selector, ngContentIndex) => { ngContentIndices.push(ngContentIndex); });
+    ngContentIndices.sort();
+    if (this._wildcardNgContentIndex != null) {
+      ngContentIndices.push(this._wildcardNgContentIndex);
+    }
+    return ngContentIndices.length > 0 ? ngContentIndices[0] : null;
+  }
+}
+
+export function createElementCssSelector(
+    elementName: string, attributes: [string, string][]): CssSelector {
+  const cssSelector = new CssSelector();
+  const elNameNoNs = splitNsName(elementName)[1];
+
+  cssSelector.setElement(elNameNoNs);
+
+  for (let i = 0; i < attributes.length; i++) {
+    const attrName = attributes[i][0];
+    const attrNameNoNs = splitNsName(attrName)[1];
+    const attrValue = attributes[i][1];
+
+    cssSelector.addAttribute(attrNameNoNs, attrValue);
+    if (attrName.toLowerCase() == CLASS_ATTR) {
+      const classes = splitClasses(attrValue);
+      classes.forEach(className => cssSelector.addClassName(className));
+    }
+  }
+  return cssSelector;
+}
+
+const EMPTY_ELEMENT_CONTEXT = new ElementContext(true, new SelectorMatcher(), null, null);
+const NON_BINDABLE_VISITOR = new NonBindableVisitor();
+
+function _isEmptyTextNode(node: html.Node): boolean {
+  return node instanceof html.Text && node.value.trim().length == 0;
+}
+
+export function removeSummaryDuplicates<T extends{type: CompileTypeMetadata}>(items: T[]): T[] {
+  const map = new Map<any, T>();
+
+  items.forEach((item) => {
+    if (!map.get(item.type.reference)) {
+      map.set(item.type.reference, item);
+    }
+  });
+
+  return Array.from(map.values());
+}
+
+function isEmptyExpression(ast: AST): boolean {
+  if (ast instanceof ASTWithSource) {
+    ast = ast.ast;
+  }
+  return ast instanceof EmptyExpr;
+}
+
+// `template` is deprecated in 4.x
+function isTemplate(
+    el: html.Element, enableLegacyTemplate: boolean,
+    reportDeprecation: (m: string, span: ParseSourceSpan) => void): boolean {
+  if (isNgTemplate(el.name)) return true;
+  const tagNoNs = splitNsName(el.name)[1];
+  // `<template>` is HTML and case insensitive
+  if (tagNoNs.toLowerCase() === TEMPLATE_ELEMENT) {
+    if (enableLegacyTemplate && tagNoNs.toLowerCase() === TEMPLATE_ELEMENT) {
+      reportDeprecation(TEMPLATE_ELEMENT_DEPRECATION_WARNING, el.sourceSpan !);
+      return true;
+    }
+  }
+  return false;
+}
diff --git a/angular/compiler/src/template_parser/template_preparser.ts b/angular/compiler/src/template_parser/template_preparser.ts
new file mode 100644
index 0000000..f0b4842
--- /dev/null
+++ b/angular/compiler/src/template_parser/template_preparser.ts
@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as html from '../ml_parser/ast';
+import {isNgContent} from '../ml_parser/tags';
+
+const NG_CONTENT_SELECT_ATTR = 'select';
+const LINK_ELEMENT = 'link';
+const LINK_STYLE_REL_ATTR = 'rel';
+const LINK_STYLE_HREF_ATTR = 'href';
+const LINK_STYLE_REL_VALUE = 'stylesheet';
+const STYLE_ELEMENT = 'style';
+const SCRIPT_ELEMENT = 'script';
+const NG_NON_BINDABLE_ATTR = 'ngNonBindable';
+const NG_PROJECT_AS = 'ngProjectAs';
+
+export function preparseElement(ast: html.Element): PreparsedElement {
+  let selectAttr: string = null !;
+  let hrefAttr: string = null !;
+  let relAttr: string = null !;
+  let nonBindable = false;
+  let projectAs: string = null !;
+  ast.attrs.forEach(attr => {
+    const lcAttrName = attr.name.toLowerCase();
+    if (lcAttrName == NG_CONTENT_SELECT_ATTR) {
+      selectAttr = attr.value;
+    } else if (lcAttrName == LINK_STYLE_HREF_ATTR) {
+      hrefAttr = attr.value;
+    } else if (lcAttrName == LINK_STYLE_REL_ATTR) {
+      relAttr = attr.value;
+    } else if (attr.name == NG_NON_BINDABLE_ATTR) {
+      nonBindable = true;
+    } else if (attr.name == NG_PROJECT_AS) {
+      if (attr.value.length > 0) {
+        projectAs = attr.value;
+      }
+    }
+  });
+  selectAttr = normalizeNgContentSelect(selectAttr);
+  const nodeName = ast.name.toLowerCase();
+  let type = PreparsedElementType.OTHER;
+  if (isNgContent(nodeName)) {
+    type = PreparsedElementType.NG_CONTENT;
+  } else if (nodeName == STYLE_ELEMENT) {
+    type = PreparsedElementType.STYLE;
+  } else if (nodeName == SCRIPT_ELEMENT) {
+    type = PreparsedElementType.SCRIPT;
+  } else if (nodeName == LINK_ELEMENT && relAttr == LINK_STYLE_REL_VALUE) {
+    type = PreparsedElementType.STYLESHEET;
+  }
+  return new PreparsedElement(type, selectAttr, hrefAttr, nonBindable, projectAs);
+}
+
+export enum PreparsedElementType {
+  NG_CONTENT,
+  STYLE,
+  STYLESHEET,
+  SCRIPT,
+  OTHER
+}
+
+export class PreparsedElement {
+  constructor(
+      public type: PreparsedElementType, public selectAttr: string, public hrefAttr: string,
+      public nonBindable: boolean, public projectAs: string) {}
+}
+
+
+function normalizeNgContentSelect(selectAttr: string): string {
+  if (selectAttr === null || selectAttr.length === 0) {
+    return '*';
+  }
+  return selectAttr;
+}
diff --git a/angular/compiler/src/url_resolver.ts b/angular/compiler/src/url_resolver.ts
new file mode 100644
index 0000000..3f81930
--- /dev/null
+++ b/angular/compiler/src/url_resolver.ts
@@ -0,0 +1,339 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * Create a {@link UrlResolver} with no package prefix.
+ */
+export function createUrlResolverWithoutPackagePrefix(): UrlResolver {
+  return new UrlResolver();
+}
+
+export function createOfflineCompileUrlResolver(): UrlResolver {
+  return new UrlResolver('.');
+}
+
+/**
+ * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
+ *
+ * This class can be overridden by the application developer to create custom behavior.
+ *
+ * See {@link Compiler}
+ *
+ * ## Example
+ *
+ * {@example compiler/ts/url_resolver/url_resolver.ts region='url_resolver'}
+ *
+ * @security  When compiling templates at runtime, you must
+ * ensure that the entire template comes from a trusted source.
+ * Attacker-controlled data introduced by a template could expose your
+ * application to XSS risks. For more detail, see the [Security Guide](http://g.co/ng/security).
+ */
+export interface UrlResolver { resolve(baseUrl: string, url: string): string; }
+
+export interface UrlResolverCtor { new (packagePrefix?: string|null): UrlResolver; }
+
+export const UrlResolver: UrlResolverCtor = class UrlResolverImpl {
+  constructor(private _packagePrefix: string|null = null) {}
+
+  /**
+   * Resolves the `url` given the `baseUrl`:
+   * - when the `url` is null, the `baseUrl` is returned,
+   * - if `url` is relative ('path/to/here', './path/to/here'), the resolved url is a combination of
+   * `baseUrl` and `url`,
+   * - if `url` is absolute (it has a scheme: 'http://', 'https://' or start with '/'), the `url` is
+   * returned as is (ignoring the `baseUrl`)
+   */
+  resolve(baseUrl: string, url: string): string {
+    let resolvedUrl = url;
+    if (baseUrl != null && baseUrl.length > 0) {
+      resolvedUrl = _resolveUrl(baseUrl, resolvedUrl);
+    }
+    const resolvedParts = _split(resolvedUrl);
+    let prefix = this._packagePrefix;
+    if (prefix != null && resolvedParts != null &&
+        resolvedParts[_ComponentIndex.Scheme] == 'package') {
+      let path = resolvedParts[_ComponentIndex.Path];
+      prefix = prefix.replace(/\/+$/, '');
+      path = path.replace(/^\/+/, '');
+      return `${prefix}/${path}`;
+    }
+    return resolvedUrl;
+  }
+};
+
+/**
+ * Extract the scheme of a URL.
+ */
+export function getUrlScheme(url: string): string {
+  const match = _split(url);
+  return (match && match[_ComponentIndex.Scheme]) || '';
+}
+
+// The code below is adapted from Traceur:
+// https://github.com/google/traceur-compiler/blob/9511c1dafa972bf0de1202a8a863bad02f0f95a8/src/runtime/url.js
+
+/**
+ * Builds a URI string from already-encoded parts.
+ *
+ * No encoding is performed.  Any component may be omitted as either null or
+ * undefined.
+ *
+ * @param opt_scheme The scheme such as 'http'.
+ * @param opt_userInfo The user name before the '@'.
+ * @param opt_domain The domain such as 'www.google.com', already
+ *     URI-encoded.
+ * @param opt_port The port number.
+ * @param opt_path The path, already URI-encoded.  If it is not
+ *     empty, it must begin with a slash.
+ * @param opt_queryData The URI-encoded query data.
+ * @param opt_fragment The URI-encoded fragment identifier.
+ * @return The fully combined URI.
+ */
+function _buildFromEncodedParts(
+    opt_scheme?: string, opt_userInfo?: string, opt_domain?: string, opt_port?: string,
+    opt_path?: string, opt_queryData?: string, opt_fragment?: string): string {
+  const out: string[] = [];
+
+  if (opt_scheme != null) {
+    out.push(opt_scheme + ':');
+  }
+
+  if (opt_domain != null) {
+    out.push('//');
+
+    if (opt_userInfo != null) {
+      out.push(opt_userInfo + '@');
+    }
+
+    out.push(opt_domain);
+
+    if (opt_port != null) {
+      out.push(':' + opt_port);
+    }
+  }
+
+  if (opt_path != null) {
+    out.push(opt_path);
+  }
+
+  if (opt_queryData != null) {
+    out.push('?' + opt_queryData);
+  }
+
+  if (opt_fragment != null) {
+    out.push('#' + opt_fragment);
+  }
+
+  return out.join('');
+}
+
+/**
+ * A regular expression for breaking a URI into its component parts.
+ *
+ * {@link http://www.gbiv.com/protocols/uri/rfc/rfc3986.html#RFC2234} says
+ * As the "first-match-wins" algorithm is identical to the "greedy"
+ * disambiguation method used by POSIX regular expressions, it is natural and
+ * commonplace to use a regular expression for parsing the potential five
+ * components of a URI reference.
+ *
+ * The following line is the regular expression for breaking-down a
+ * well-formed URI reference into its components.
+ *
+ * <pre>
+ * ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
+ *  12            3  4          5       6  7        8 9
+ * </pre>
+ *
+ * The numbers in the second line above are only to assist readability; they
+ * indicate the reference points for each subexpression (i.e., each paired
+ * parenthesis). We refer to the value matched for subexpression <n> as $<n>.
+ * For example, matching the above expression to
+ * <pre>
+ *     http://www.ics.uci.edu/pub/ietf/uri/#Related
+ * </pre>
+ * results in the following subexpression matches:
+ * <pre>
+ *    $1 = http:
+ *    $2 = http
+ *    $3 = //www.ics.uci.edu
+ *    $4 = www.ics.uci.edu
+ *    $5 = /pub/ietf/uri/
+ *    $6 = <undefined>
+ *    $7 = <undefined>
+ *    $8 = #Related
+ *    $9 = Related
+ * </pre>
+ * where <undefined> indicates that the component is not present, as is the
+ * case for the query component in the above example. Therefore, we can
+ * determine the value of the five components as
+ * <pre>
+ *    scheme    = $2
+ *    authority = $4
+ *    path      = $5
+ *    query     = $7
+ *    fragment  = $9
+ * </pre>
+ *
+ * The regular expression has been modified slightly to expose the
+ * userInfo, domain, and port separately from the authority.
+ * The modified version yields
+ * <pre>
+ *    $1 = http              scheme
+ *    $2 = <undefined>       userInfo -\
+ *    $3 = www.ics.uci.edu   domain     | authority
+ *    $4 = <undefined>       port     -/
+ *    $5 = /pub/ietf/uri/    path
+ *    $6 = <undefined>       query without ?
+ *    $7 = Related           fragment without #
+ * </pre>
+ * @internal
+ */
+const _splitRe = new RegExp(
+    '^' +
+    '(?:' +
+    '([^:/?#.]+)' +  // scheme - ignore special characters
+                     // used by other URL parts such as :,
+                     // ?, /, #, and .
+    ':)?' +
+    '(?://' +
+    '(?:([^/?#]*)@)?' +                  // userInfo
+    '([\\w\\d\\-\\u0100-\\uffff.%]*)' +  // domain - restrict to letters,
+                                         // digits, dashes, dots, percent
+                                         // escapes, and unicode characters.
+    '(?::([0-9]+))?' +                   // port
+    ')?' +
+    '([^?#]+)?' +        // path
+    '(?:\\?([^#]*))?' +  // query
+    '(?:#(.*))?' +       // fragment
+    '$');
+
+/**
+ * The index of each URI component in the return value of goog.uri.utils.split.
+ * @enum {number}
+ */
+enum _ComponentIndex {
+  Scheme = 1,
+  UserInfo,
+  Domain,
+  Port,
+  Path,
+  QueryData,
+  Fragment
+}
+
+/**
+ * Splits a URI into its component parts.
+ *
+ * Each component can be accessed via the component indices; for example:
+ * <pre>
+ * goog.uri.utils.split(someStr)[goog.uri.utils.CompontentIndex.QUERY_DATA];
+ * </pre>
+ *
+ * @param uri The URI string to examine.
+ * @return Each component still URI-encoded.
+ *     Each component that is present will contain the encoded value, whereas
+ *     components that are not present will be undefined or empty, depending
+ *     on the browser's regular expression implementation.  Never null, since
+ *     arbitrary strings may still look like path names.
+ */
+function _split(uri: string): Array<string|any> {
+  return uri.match(_splitRe) !;
+}
+
+/**
+  * Removes dot segments in given path component, as described in
+  * RFC 3986, section 5.2.4.
+  *
+  * @param path A non-empty path component.
+  * @return Path component with removed dot segments.
+  */
+function _removeDotSegments(path: string): string {
+  if (path == '/') return '/';
+
+  const leadingSlash = path[0] == '/' ? '/' : '';
+  const trailingSlash = path[path.length - 1] === '/' ? '/' : '';
+  const segments = path.split('/');
+
+  const out: string[] = [];
+  let up = 0;
+  for (let pos = 0; pos < segments.length; pos++) {
+    const segment = segments[pos];
+    switch (segment) {
+      case '':
+      case '.':
+        break;
+      case '..':
+        if (out.length > 0) {
+          out.pop();
+        } else {
+          up++;
+        }
+        break;
+      default:
+        out.push(segment);
+    }
+  }
+
+  if (leadingSlash == '') {
+    while (up-- > 0) {
+      out.unshift('..');
+    }
+
+    if (out.length === 0) out.push('.');
+  }
+
+  return leadingSlash + out.join('/') + trailingSlash;
+}
+
+/**
+ * Takes an array of the parts from split and canonicalizes the path part
+ * and then joins all the parts.
+ */
+function _joinAndCanonicalizePath(parts: any[]): string {
+  let path = parts[_ComponentIndex.Path];
+  path = path == null ? '' : _removeDotSegments(path);
+  parts[_ComponentIndex.Path] = path;
+
+  return _buildFromEncodedParts(
+      parts[_ComponentIndex.Scheme], parts[_ComponentIndex.UserInfo], parts[_ComponentIndex.Domain],
+      parts[_ComponentIndex.Port], path, parts[_ComponentIndex.QueryData],
+      parts[_ComponentIndex.Fragment]);
+}
+
+/**
+ * Resolves a URL.
+ * @param base The URL acting as the base URL.
+ * @param to The URL to resolve.
+ */
+function _resolveUrl(base: string, url: string): string {
+  const parts = _split(encodeURI(url));
+  const baseParts = _split(base);
+
+  if (parts[_ComponentIndex.Scheme] != null) {
+    return _joinAndCanonicalizePath(parts);
+  } else {
+    parts[_ComponentIndex.Scheme] = baseParts[_ComponentIndex.Scheme];
+  }
+
+  for (let i = _ComponentIndex.Scheme; i <= _ComponentIndex.Port; i++) {
+    if (parts[i] == null) {
+      parts[i] = baseParts[i];
+    }
+  }
+
+  if (parts[_ComponentIndex.Path][0] == '/') {
+    return _joinAndCanonicalizePath(parts);
+  }
+
+  let path = baseParts[_ComponentIndex.Path];
+  if (path == null) path = '/';
+  const index = path.lastIndexOf('/');
+  path = path.substring(0, index + 1) + parts[_ComponentIndex.Path];
+  parts[_ComponentIndex.Path] = path;
+  return _joinAndCanonicalizePath(parts);
+}
diff --git a/angular/compiler/src/util.ts b/angular/compiler/src/util.ts
new file mode 100644
index 0000000..8ca94c6
--- /dev/null
+++ b/angular/compiler/src/util.ts
@@ -0,0 +1,227 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as o from './output/output_ast';
+import {ParseError} from './parse_util';
+
+const CAMEL_CASE_REGEXP = /([A-Z])/g;
+const DASH_CASE_REGEXP = /-+([a-z0-9])/g;
+
+export function camelCaseToDashCase(input: string): string {
+  return input.replace(CAMEL_CASE_REGEXP, (...m: any[]) => '-' + m[1].toLowerCase());
+}
+
+export function dashCaseToCamelCase(input: string): string {
+  return input.replace(DASH_CASE_REGEXP, (...m: any[]) => m[1].toUpperCase());
+}
+
+export function splitAtColon(input: string, defaultValues: string[]): string[] {
+  return _splitAt(input, ':', defaultValues);
+}
+
+export function splitAtPeriod(input: string, defaultValues: string[]): string[] {
+  return _splitAt(input, '.', defaultValues);
+}
+
+function _splitAt(input: string, character: string, defaultValues: string[]): string[] {
+  const characterIndex = input.indexOf(character);
+  if (characterIndex == -1) return defaultValues;
+  return [input.slice(0, characterIndex).trim(), input.slice(characterIndex + 1).trim()];
+}
+
+export function visitValue(value: any, visitor: ValueVisitor, context: any): any {
+  if (Array.isArray(value)) {
+    return visitor.visitArray(<any[]>value, context);
+  }
+
+  if (isStrictStringMap(value)) {
+    return visitor.visitStringMap(<{[key: string]: any}>value, context);
+  }
+
+  if (value == null || typeof value == 'string' || typeof value == 'number' ||
+      typeof value == 'boolean') {
+    return visitor.visitPrimitive(value, context);
+  }
+
+  return visitor.visitOther(value, context);
+}
+
+export function isDefined(val: any): boolean {
+  return val !== null && val !== undefined;
+}
+
+export function noUndefined<T>(val: T | undefined): T {
+  return val === undefined ? null ! : val;
+}
+
+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 {
+    const result: {[key: string]: any} = {};
+    Object.keys(map).forEach(key => { result[key] = visitValue(map[key], this, context); });
+    return result;
+  }
+  visitPrimitive(value: any, context: any): any { return value; }
+  visitOther(value: any, context: any): any { return value; }
+}
+
+export type SyncAsync<T> = T | Promise<T>;
+
+export const SyncAsync = {
+  assertSync: <T>(value: SyncAsync<T>): T => {
+    if (isPromise(value)) {
+      throw new Error(`Illegal state: value cannot be a promise`);
+    }
+    return value;
+  },
+  then: <T, R>(value: SyncAsync<T>, cb: (value: T) => R | Promise<R>| SyncAsync<R>):
+            SyncAsync<R> => { return isPromise(value) ? value.then(cb) : cb(value);},
+  all: <T>(syncAsyncValues: SyncAsync<T>[]): SyncAsync<T[]> => {
+    return syncAsyncValues.some(isPromise) ? Promise.all(syncAsyncValues) : syncAsyncValues as T[];
+  }
+};
+
+export function syntaxError(msg: string, parseErrors?: ParseError[]): Error {
+  const error = Error(msg);
+  (error as any)[ERROR_SYNTAX_ERROR] = true;
+  if (parseErrors) (error as any)[ERROR_PARSE_ERRORS] = parseErrors;
+  return error;
+}
+
+const ERROR_SYNTAX_ERROR = 'ngSyntaxError';
+const ERROR_PARSE_ERRORS = 'ngParseErrors';
+
+export function isSyntaxError(error: Error): boolean {
+  return (error as any)[ERROR_SYNTAX_ERROR];
+}
+
+export function getParseErrors(error: Error): ParseError[] {
+  return (error as any)[ERROR_PARSE_ERRORS] || [];
+}
+
+export function escapeRegExp(s: string): string {
+  return s.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
+}
+
+const STRING_MAP_PROTO = Object.getPrototypeOf({});
+function isStrictStringMap(obj: any): boolean {
+  return typeof obj === 'object' && obj !== null && Object.getPrototypeOf(obj) === STRING_MAP_PROTO;
+}
+
+export function utf8Encode(str: string): string {
+  let encoded = '';
+  for (let index = 0; index < str.length; index++) {
+    let codePoint = str.charCodeAt(index);
+
+    // decode surrogate
+    // see https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+    if (codePoint >= 0xd800 && codePoint <= 0xdbff && str.length > (index + 1)) {
+      const low = str.charCodeAt(index + 1);
+      if (low >= 0xdc00 && low <= 0xdfff) {
+        index++;
+        codePoint = ((codePoint - 0xd800) << 10) + low - 0xdc00 + 0x10000;
+      }
+    }
+
+    if (codePoint <= 0x7f) {
+      encoded += String.fromCharCode(codePoint);
+    } else if (codePoint <= 0x7ff) {
+      encoded += String.fromCharCode(((codePoint >> 6) & 0x1F) | 0xc0, (codePoint & 0x3f) | 0x80);
+    } else if (codePoint <= 0xffff) {
+      encoded += String.fromCharCode(
+          (codePoint >> 12) | 0xe0, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);
+    } else if (codePoint <= 0x1fffff) {
+      encoded += String.fromCharCode(
+          ((codePoint >> 18) & 0x07) | 0xf0, ((codePoint >> 12) & 0x3f) | 0x80,
+          ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);
+    }
+  }
+
+  return encoded;
+}
+
+export interface OutputContext {
+  genFilePath: string;
+  statements: o.Statement[];
+  importExpr(reference: any, typeParams?: o.Type[]|null): o.Expression;
+}
+
+export function stringify(token: any): string {
+  if (typeof token === 'string') {
+    return token;
+  }
+
+  if (token instanceof Array) {
+    return '[' + token.map(stringify).join(', ') + ']';
+  }
+
+  if (token == null) {
+    return '' + token;
+  }
+
+  if (token.overriddenName) {
+    return `${token.overriddenName}`;
+  }
+
+  if (token.name) {
+    return `${token.name}`;
+  }
+
+  const res = token.toString();
+
+  if (res == null) {
+    return '' + res;
+  }
+
+  const newLineIndex = res.indexOf('\n');
+  return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
+}
+
+/**
+ * Lazily retrieves the reference value from a forwardRef.
+ */
+export function resolveForwardRef(type: any): any {
+  if (typeof type === 'function' && type.hasOwnProperty('__forward_ref__')) {
+    return type();
+  } else {
+    return type;
+  }
+}
+
+/**
+ * Determine if the argument is shaped like a Promise
+ */
+export function isPromise(obj: any): obj is Promise<any> {
+  // allow any Promise/A+ compliant thenable.
+  // It's up to the caller to ensure that obj.then conforms to the spec
+  return !!obj && typeof obj.then === 'function';
+}
+
+export class Version {
+  constructor(public full: string) {}
+
+  get major(): string { return this.full.split('.')[0]; }
+
+  get minor(): string { return this.full.split('.')[1]; }
+
+  get patch(): string { return this.full.split('.').slice(2).join('.'); }
+}
+
+export interface Console {
+  log(message: string): void;
+  warn(message: string): void;
+}
diff --git a/angular/compiler/src/version.ts b/angular/compiler/src/version.ts
new file mode 100644
index 0000000..e7ed88c
--- /dev/null
+++ b/angular/compiler/src/version.ts
@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the common package.
+ */
+
+import {Version} from './util';
+/**
+ * @stable
+ */
+export const VERSION = new Version('0.0.0-PLACEHOLDER');
diff --git a/angular/compiler/src/view_compiler/provider_compiler.ts b/angular/compiler/src/view_compiler/provider_compiler.ts
new file mode 100644
index 0000000..0babaf5
--- /dev/null
+++ b/angular/compiler/src/view_compiler/provider_compiler.ts
@@ -0,0 +1,202 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileDiDependencyMetadata, CompileEntryComponentMetadata, CompileProviderMetadata, CompileTokenMetadata} from '../compile_metadata';
+import {CompileReflector} from '../compile_reflector';
+import {DepFlags, NodeFlags} from '../core';
+import {Identifiers, createTokenForExternalReference} from '../identifiers';
+import {LifecycleHooks} from '../lifecycle_reflector';
+import * as o from '../output/output_ast';
+import {convertValueToOutputAst} from '../output/value_util';
+import {ProviderAst, ProviderAstType} from '../template_parser/template_ast';
+import {OutputContext} from '../util';
+
+export function providerDef(ctx: OutputContext, providerAst: ProviderAst): {
+  providerExpr: o.Expression,
+  flags: NodeFlags,
+  depsExpr: o.Expression,
+  tokenExpr: o.Expression
+} {
+  let flags = NodeFlags.None;
+  if (!providerAst.eager) {
+    flags |= NodeFlags.LazyProvider;
+  }
+  if (providerAst.providerType === ProviderAstType.PrivateService) {
+    flags |= NodeFlags.PrivateProvider;
+  }
+  providerAst.lifecycleHooks.forEach((lifecycleHook) => {
+    // for regular providers, we only support ngOnDestroy
+    if (lifecycleHook === LifecycleHooks.OnDestroy ||
+        providerAst.providerType === ProviderAstType.Directive ||
+        providerAst.providerType === ProviderAstType.Component) {
+      flags |= lifecycleHookToNodeFlag(lifecycleHook);
+    }
+  });
+  const {providerExpr, flags: providerFlags, depsExpr} = providerAst.multiProvider ?
+      multiProviderDef(ctx, flags, providerAst.providers) :
+      singleProviderDef(ctx, flags, providerAst.providerType, providerAst.providers[0]);
+  return {
+    providerExpr,
+    flags: providerFlags, depsExpr,
+    tokenExpr: tokenExpr(ctx, providerAst.token),
+  };
+}
+
+function multiProviderDef(
+    ctx: OutputContext, flags: NodeFlags, providers: CompileProviderMetadata[]):
+    {providerExpr: o.Expression, flags: NodeFlags, depsExpr: o.Expression} {
+  const allDepDefs: o.Expression[] = [];
+  const allParams: o.FnParam[] = [];
+  const exprs = providers.map((provider, providerIndex) => {
+    let expr: o.Expression;
+    if (provider.useClass) {
+      const depExprs = convertDeps(providerIndex, provider.deps || provider.useClass.diDeps);
+      expr = ctx.importExpr(provider.useClass.reference).instantiate(depExprs);
+    } else if (provider.useFactory) {
+      const depExprs = convertDeps(providerIndex, provider.deps || provider.useFactory.diDeps);
+      expr = ctx.importExpr(provider.useFactory.reference).callFn(depExprs);
+    } else if (provider.useExisting) {
+      const depExprs = convertDeps(providerIndex, [{token: provider.useExisting}]);
+      expr = depExprs[0];
+    } else {
+      expr = convertValueToOutputAst(ctx, provider.useValue);
+    }
+    return expr;
+  });
+  const providerExpr =
+      o.fn(allParams, [new o.ReturnStatement(o.literalArr(exprs))], o.INFERRED_TYPE);
+  return {
+    providerExpr,
+    flags: flags | NodeFlags.TypeFactoryProvider,
+    depsExpr: o.literalArr(allDepDefs)
+  };
+
+  function convertDeps(providerIndex: number, deps: CompileDiDependencyMetadata[]) {
+    return deps.map((dep, depIndex) => {
+      const paramName = `p${providerIndex}_${depIndex}`;
+      allParams.push(new o.FnParam(paramName, o.DYNAMIC_TYPE));
+      allDepDefs.push(depDef(ctx, dep));
+      return o.variable(paramName);
+    });
+  }
+}
+
+function singleProviderDef(
+    ctx: OutputContext, flags: NodeFlags, providerType: ProviderAstType,
+    providerMeta: CompileProviderMetadata):
+    {providerExpr: o.Expression, flags: NodeFlags, depsExpr: o.Expression} {
+  let providerExpr: o.Expression;
+  let deps: CompileDiDependencyMetadata[];
+  if (providerType === ProviderAstType.Directive || providerType === ProviderAstType.Component) {
+    providerExpr = ctx.importExpr(providerMeta.useClass !.reference);
+    flags |= NodeFlags.TypeDirective;
+    deps = providerMeta.deps || providerMeta.useClass !.diDeps;
+  } else {
+    if (providerMeta.useClass) {
+      providerExpr = ctx.importExpr(providerMeta.useClass.reference);
+      flags |= NodeFlags.TypeClassProvider;
+      deps = providerMeta.deps || providerMeta.useClass.diDeps;
+    } else if (providerMeta.useFactory) {
+      providerExpr = ctx.importExpr(providerMeta.useFactory.reference);
+      flags |= NodeFlags.TypeFactoryProvider;
+      deps = providerMeta.deps || providerMeta.useFactory.diDeps;
+    } else if (providerMeta.useExisting) {
+      providerExpr = o.NULL_EXPR;
+      flags |= NodeFlags.TypeUseExistingProvider;
+      deps = [{token: providerMeta.useExisting}];
+    } else {
+      providerExpr = convertValueToOutputAst(ctx, providerMeta.useValue);
+      flags |= NodeFlags.TypeValueProvider;
+      deps = [];
+    }
+  }
+  const depsExpr = o.literalArr(deps.map(dep => depDef(ctx, dep)));
+  return {providerExpr, flags, depsExpr};
+}
+
+function tokenExpr(ctx: OutputContext, tokenMeta: CompileTokenMetadata): o.Expression {
+  return tokenMeta.identifier ? ctx.importExpr(tokenMeta.identifier.reference) :
+                                o.literal(tokenMeta.value);
+}
+
+export function depDef(ctx: OutputContext, dep: CompileDiDependencyMetadata): o.Expression {
+  // Note: the following fields have already been normalized out by provider_analyzer:
+  // - isAttribute, isSelf, isHost
+  const expr = dep.isValue ? convertValueToOutputAst(ctx, dep.value) : tokenExpr(ctx, dep.token !);
+  let flags = DepFlags.None;
+  if (dep.isSkipSelf) {
+    flags |= DepFlags.SkipSelf;
+  }
+  if (dep.isOptional) {
+    flags |= DepFlags.Optional;
+  }
+  if (dep.isValue) {
+    flags |= DepFlags.Value;
+  }
+  return flags === DepFlags.None ? expr : o.literalArr([o.literal(flags), expr]);
+}
+
+export function lifecycleHookToNodeFlag(lifecycleHook: LifecycleHooks): NodeFlags {
+  let nodeFlag = NodeFlags.None;
+  switch (lifecycleHook) {
+    case LifecycleHooks.AfterContentChecked:
+      nodeFlag = NodeFlags.AfterContentChecked;
+      break;
+    case LifecycleHooks.AfterContentInit:
+      nodeFlag = NodeFlags.AfterContentInit;
+      break;
+    case LifecycleHooks.AfterViewChecked:
+      nodeFlag = NodeFlags.AfterViewChecked;
+      break;
+    case LifecycleHooks.AfterViewInit:
+      nodeFlag = NodeFlags.AfterViewInit;
+      break;
+    case LifecycleHooks.DoCheck:
+      nodeFlag = NodeFlags.DoCheck;
+      break;
+    case LifecycleHooks.OnChanges:
+      nodeFlag = NodeFlags.OnChanges;
+      break;
+    case LifecycleHooks.OnDestroy:
+      nodeFlag = NodeFlags.OnDestroy;
+      break;
+    case LifecycleHooks.OnInit:
+      nodeFlag = NodeFlags.OnInit;
+      break;
+  }
+  return nodeFlag;
+}
+
+export function componentFactoryResolverProviderDef(
+    reflector: CompileReflector, ctx: OutputContext, flags: NodeFlags,
+    entryComponents: CompileEntryComponentMetadata[]): {
+  providerExpr: o.Expression,
+  flags: NodeFlags,
+  depsExpr: o.Expression,
+  tokenExpr: o.Expression
+} {
+  const entryComponentFactories =
+      entryComponents.map((entryComponent) => ctx.importExpr(entryComponent.componentFactory));
+  const token = createTokenForExternalReference(reflector, Identifiers.ComponentFactoryResolver);
+  const classMeta = {
+    diDeps: [
+      {isValue: true, value: o.literalArr(entryComponentFactories)},
+      {token: token, isSkipSelf: true, isOptional: true},
+      {token: createTokenForExternalReference(reflector, Identifiers.NgModuleRef)},
+    ],
+    lifecycleHooks: [],
+    reference: reflector.resolveExternalReference(Identifiers.CodegenComponentFactoryResolver)
+  };
+  const {providerExpr, flags: providerFlags, depsExpr} =
+      singleProviderDef(ctx, flags, ProviderAstType.PrivateService, {
+        token,
+        multi: false,
+        useClass: classMeta,
+      });
+  return {providerExpr, flags: providerFlags, depsExpr, tokenExpr: tokenExpr(ctx, token)};
+}
diff --git a/angular/compiler/src/view_compiler/view_compiler.ts b/angular/compiler/src/view_compiler/view_compiler.ts
new file mode 100644
index 0000000..fbf3d80
--- /dev/null
+++ b/angular/compiler/src/view_compiler/view_compiler.ts
@@ -0,0 +1,1075 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileDiDependencyMetadata, CompileDirectiveMetadata, CompilePipeSummary, CompileProviderMetadata, CompileTokenMetadata, CompileTypeMetadata, rendererTypeName, tokenReference, viewClassName} from '../compile_metadata';
+import {CompileReflector} from '../compile_reflector';
+import {BuiltinConverter, EventHandlerVars, LocalResolver, convertActionBinding, convertPropertyBinding, convertPropertyBindingBuiltins} from '../compiler_util/expression_converter';
+import {CompilerConfig} from '../config';
+import {ArgumentType, BindingFlags, ChangeDetectionStrategy, DepFlags, NodeFlags, QueryBindingType, QueryValueType, ViewFlags} from '../core';
+import {AST, ASTWithSource, Interpolation} from '../expression_parser/ast';
+import {Identifiers} from '../identifiers';
+import {LifecycleHooks} from '../lifecycle_reflector';
+import {isNgContainer} from '../ml_parser/tags';
+import * as o from '../output/output_ast';
+import {convertValueToOutputAst} from '../output/value_util';
+import {ParseSourceSpan} from '../parse_util';
+import {ElementSchemaRegistry} from '../schema/element_schema_registry';
+import {AttrAst, BoundDirectivePropertyAst, BoundElementPropertyAst, BoundEventAst, BoundTextAst, DirectiveAst, ElementAst, EmbeddedTemplateAst, NgContentAst, PropertyBindingType, ProviderAst, ProviderAstType, QueryMatch, ReferenceAst, TemplateAst, TemplateAstVisitor, TextAst, VariableAst, templateVisitAll} from '../template_parser/template_ast';
+import {OutputContext} from '../util';
+
+import {componentFactoryResolverProviderDef, depDef, lifecycleHookToNodeFlag, providerDef} from './provider_compiler';
+
+const CLASS_ATTR = 'class';
+const STYLE_ATTR = 'style';
+const IMPLICIT_TEMPLATE_VAR = '\$implicit';
+const NG_CONTAINER_TAG = 'ng-container';
+
+export class ViewCompileResult {
+  constructor(public viewClassVar: string, public rendererTypeVar: string) {}
+}
+
+export class ViewCompiler {
+  constructor(
+      private _config: CompilerConfig, private _reflector: CompileReflector,
+      private _schemaRegistry: ElementSchemaRegistry) {}
+
+  compileComponent(
+      outputCtx: OutputContext, component: CompileDirectiveMetadata, template: TemplateAst[],
+      styles: o.Expression, usedPipes: CompilePipeSummary[]): ViewCompileResult {
+    let embeddedViewCount = 0;
+    const staticQueryIds = findStaticQueryIds(template);
+
+    let renderComponentVarName: string = undefined !;
+    if (!component.isHost) {
+      const template = component.template !;
+      const customRenderData: o.LiteralMapEntry[] = [];
+      if (template.animations && template.animations.length) {
+        customRenderData.push(new o.LiteralMapEntry(
+            'animation', convertValueToOutputAst(outputCtx, template.animations), true));
+      }
+
+      const renderComponentVar = o.variable(rendererTypeName(component.type.reference));
+      renderComponentVarName = renderComponentVar.name !;
+      outputCtx.statements.push(
+          renderComponentVar
+              .set(o.importExpr(Identifiers.createRendererType2).callFn([new o.LiteralMapExpr([
+                new o.LiteralMapEntry('encapsulation', o.literal(template.encapsulation), false),
+                new o.LiteralMapEntry('styles', styles, false),
+                new o.LiteralMapEntry('data', new o.LiteralMapExpr(customRenderData), false)
+              ])]))
+              .toDeclStmt(
+                  o.importType(Identifiers.RendererType2),
+                  [o.StmtModifier.Final, o.StmtModifier.Exported]));
+    }
+
+    const viewBuilderFactory = (parent: ViewBuilder | null): ViewBuilder => {
+      const embeddedViewIndex = embeddedViewCount++;
+      return new ViewBuilder(
+          this._reflector, outputCtx, parent, component, embeddedViewIndex, usedPipes,
+          staticQueryIds, viewBuilderFactory);
+    };
+
+    const visitor = viewBuilderFactory(null);
+    visitor.visitAll([], template);
+
+    outputCtx.statements.push(...visitor.build());
+
+    return new ViewCompileResult(visitor.viewName, renderComponentVarName);
+  }
+}
+
+interface ViewBuilderFactory {
+  (parent: ViewBuilder): ViewBuilder;
+}
+
+interface UpdateExpression {
+  context: o.Expression;
+  nodeIndex: number;
+  bindingIndex: number;
+  sourceSpan: ParseSourceSpan;
+  value: AST;
+}
+
+const LOG_VAR = o.variable('_l');
+const VIEW_VAR = o.variable('_v');
+const CHECK_VAR = o.variable('_ck');
+const COMP_VAR = o.variable('_co');
+const EVENT_NAME_VAR = o.variable('en');
+const ALLOW_DEFAULT_VAR = o.variable(`ad`);
+
+class ViewBuilder implements TemplateAstVisitor, LocalResolver {
+  private compType: o.Type;
+  private nodes: (() => {
+    sourceSpan: ParseSourceSpan | null,
+    nodeDef: o.Expression,
+    nodeFlags: NodeFlags, updateDirectives?: UpdateExpression[], updateRenderer?: UpdateExpression[]
+  })[] = [];
+  private purePipeNodeIndices: {[pipeName: string]: number} = Object.create(null);
+  // Need Object.create so that we don't have builtin values...
+  private refNodeIndices: {[refName: string]: number} = Object.create(null);
+  private variables: VariableAst[] = [];
+  private children: ViewBuilder[] = [];
+
+  constructor(
+      private reflector: CompileReflector, private outputCtx: OutputContext,
+      private parent: ViewBuilder|null, private component: CompileDirectiveMetadata,
+      private embeddedViewIndex: number, private usedPipes: CompilePipeSummary[],
+      private staticQueryIds: Map<TemplateAst, StaticAndDynamicQueryIds>,
+      private viewBuilderFactory: ViewBuilderFactory) {
+    // TODO(tbosch): The old view compiler used to use an `any` type
+    // for the context in any embedded view. We keep this behaivor for now
+    // to be able to introduce the new view compiler without too many errors.
+    this.compType = this.embeddedViewIndex > 0 ?
+        o.DYNAMIC_TYPE :
+        o.expressionType(outputCtx.importExpr(this.component.type.reference)) !;
+  }
+
+  get viewName(): string {
+    return viewClassName(this.component.type.reference, this.embeddedViewIndex);
+  }
+
+  visitAll(variables: VariableAst[], astNodes: TemplateAst[]) {
+    this.variables = variables;
+    // create the pipes for the pure pipes immediately, so that we know their indices.
+    if (!this.parent) {
+      this.usedPipes.forEach((pipe) => {
+        if (pipe.pure) {
+          this.purePipeNodeIndices[pipe.name] = this._createPipe(null, pipe);
+        }
+      });
+    }
+
+    if (!this.parent) {
+      const queryIds = staticViewQueryIds(this.staticQueryIds);
+      this.component.viewQueries.forEach((query, queryIndex) => {
+        // Note: queries start with id 1 so we can use the number in a Bloom filter!
+        const queryId = queryIndex + 1;
+        const bindingType = query.first ? QueryBindingType.First : QueryBindingType.All;
+        const flags =
+            NodeFlags.TypeViewQuery | calcStaticDynamicQueryFlags(queryIds, queryId, query.first);
+        this.nodes.push(() => ({
+                          sourceSpan: null,
+                          nodeFlags: flags,
+                          nodeDef: o.importExpr(Identifiers.queryDef).callFn([
+                            o.literal(flags), o.literal(queryId),
+                            new o.LiteralMapExpr([new o.LiteralMapEntry(
+                                query.propertyName, o.literal(bindingType), false)])
+                          ])
+                        }));
+      });
+    }
+    templateVisitAll(this, astNodes);
+    if (this.parent && (astNodes.length === 0 || needsAdditionalRootNode(astNodes))) {
+      // if the view is an embedded view, then we need to add an additional root node in some cases
+      this.nodes.push(() => ({
+                        sourceSpan: null,
+                        nodeFlags: NodeFlags.TypeElement,
+                        nodeDef: o.importExpr(Identifiers.anchorDef).callFn([
+                          o.literal(NodeFlags.None), o.NULL_EXPR, o.NULL_EXPR, o.literal(0)
+                        ])
+                      }));
+    }
+  }
+
+  build(targetStatements: o.Statement[] = []): o.Statement[] {
+    this.children.forEach((child) => child.build(targetStatements));
+
+    const {updateRendererStmts, updateDirectivesStmts, nodeDefExprs} =
+        this._createNodeExpressions();
+
+    const updateRendererFn = this._createUpdateFn(updateRendererStmts);
+    const updateDirectivesFn = this._createUpdateFn(updateDirectivesStmts);
+
+
+    let viewFlags = ViewFlags.None;
+    if (!this.parent && this.component.changeDetection === ChangeDetectionStrategy.OnPush) {
+      viewFlags |= ViewFlags.OnPush;
+    }
+    const viewFactory = new o.DeclareFunctionStmt(
+        this.viewName, [new o.FnParam(LOG_VAR.name !)],
+        [new o.ReturnStatement(o.importExpr(Identifiers.viewDef).callFn([
+          o.literal(viewFlags),
+          o.literalArr(nodeDefExprs),
+          updateDirectivesFn,
+          updateRendererFn,
+        ]))],
+        o.importType(Identifiers.ViewDefinition),
+        this.embeddedViewIndex === 0 ? [o.StmtModifier.Exported] : []);
+
+    targetStatements.push(viewFactory);
+    return targetStatements;
+  }
+
+  private _createUpdateFn(updateStmts: o.Statement[]): o.Expression {
+    let updateFn: o.Expression;
+    if (updateStmts.length > 0) {
+      const preStmts: o.Statement[] = [];
+      if (!this.component.isHost && o.findReadVarNames(updateStmts).has(COMP_VAR.name !)) {
+        preStmts.push(COMP_VAR.set(VIEW_VAR.prop('component')).toDeclStmt(this.compType));
+      }
+      updateFn = o.fn(
+          [
+            new o.FnParam(CHECK_VAR.name !, o.INFERRED_TYPE),
+            new o.FnParam(VIEW_VAR.name !, o.INFERRED_TYPE)
+          ],
+          [...preStmts, ...updateStmts], o.INFERRED_TYPE);
+    } else {
+      updateFn = o.NULL_EXPR;
+    }
+    return updateFn;
+  }
+
+  visitNgContent(ast: NgContentAst, context: any): any {
+    // ngContentDef(ngContentIndex: number, index: number): NodeDef;
+    this.nodes.push(() => ({
+                      sourceSpan: ast.sourceSpan,
+                      nodeFlags: NodeFlags.TypeNgContent,
+                      nodeDef: o.importExpr(Identifiers.ngContentDef).callFn([
+                        o.literal(ast.ngContentIndex), o.literal(ast.index)
+                      ])
+                    }));
+  }
+
+  visitText(ast: TextAst, context: any): any {
+    // textDef(ngContentIndex: number, constants: string[]): NodeDef;
+    this.nodes.push(() => ({
+                      sourceSpan: ast.sourceSpan,
+                      nodeFlags: NodeFlags.TypeText,
+                      nodeDef: o.importExpr(Identifiers.textDef).callFn([
+                        o.literal(ast.ngContentIndex), o.literalArr([o.literal(ast.value)])
+                      ])
+                    }));
+  }
+
+  visitBoundText(ast: BoundTextAst, context: any): any {
+    const nodeIndex = this.nodes.length;
+    // reserve the space in the nodeDefs array
+    this.nodes.push(null !);
+
+    const astWithSource = <ASTWithSource>ast.value;
+    const inter = <Interpolation>astWithSource.ast;
+
+    const updateRendererExpressions = inter.expressions.map(
+        (expr, bindingIndex) => this._preprocessUpdateExpression(
+            {nodeIndex, bindingIndex, sourceSpan: ast.sourceSpan, context: COMP_VAR, value: expr}));
+
+    // textDef(ngContentIndex: number, constants: string[]): NodeDef;
+    this.nodes[nodeIndex] = () => ({
+      sourceSpan: ast.sourceSpan,
+      nodeFlags: NodeFlags.TypeText,
+      nodeDef: o.importExpr(Identifiers.textDef).callFn([
+        o.literal(ast.ngContentIndex), o.literalArr(inter.strings.map(s => o.literal(s)))
+      ]),
+      updateRenderer: updateRendererExpressions
+    });
+  }
+
+  visitEmbeddedTemplate(ast: EmbeddedTemplateAst, context: any): any {
+    const nodeIndex = this.nodes.length;
+    // reserve the space in the nodeDefs array
+    this.nodes.push(null !);
+
+    const {flags, queryMatchesExpr, hostEvents} = this._visitElementOrTemplate(nodeIndex, ast);
+
+    const childVisitor = this.viewBuilderFactory(this);
+    this.children.push(childVisitor);
+    childVisitor.visitAll(ast.variables, ast.children);
+
+    const childCount = this.nodes.length - nodeIndex - 1;
+
+    // anchorDef(
+    //   flags: NodeFlags, matchedQueries: [string, QueryValueType][], ngContentIndex: number,
+    //   childCount: number, handleEventFn?: ElementHandleEventFn, templateFactory?:
+    //   ViewDefinitionFactory): NodeDef;
+    this.nodes[nodeIndex] = () => ({
+      sourceSpan: ast.sourceSpan,
+      nodeFlags: NodeFlags.TypeElement | flags,
+      nodeDef: o.importExpr(Identifiers.anchorDef).callFn([
+        o.literal(flags),
+        queryMatchesExpr,
+        o.literal(ast.ngContentIndex),
+        o.literal(childCount),
+        this._createElementHandleEventFn(nodeIndex, hostEvents),
+        o.variable(childVisitor.viewName),
+      ])
+    });
+  }
+
+  visitElement(ast: ElementAst, context: any): any {
+    const nodeIndex = this.nodes.length;
+    // reserve the space in the nodeDefs array so we can add children
+    this.nodes.push(null !);
+
+    // Using a null element name creates an anchor.
+    const elName: string|null = isNgContainer(ast.name) ? null : ast.name;
+
+    const {flags, usedEvents, queryMatchesExpr, hostBindings: dirHostBindings, hostEvents} =
+        this._visitElementOrTemplate(nodeIndex, ast);
+
+    let inputDefs: o.Expression[] = [];
+    let updateRendererExpressions: UpdateExpression[] = [];
+    let outputDefs: o.Expression[] = [];
+    if (elName) {
+      const hostBindings: any[] = ast.inputs
+                                      .map((inputAst) => ({
+                                             context: COMP_VAR as o.Expression,
+                                             inputAst,
+                                             dirAst: null as any,
+                                           }))
+                                      .concat(dirHostBindings);
+      if (hostBindings.length) {
+        updateRendererExpressions =
+            hostBindings.map((hostBinding, bindingIndex) => this._preprocessUpdateExpression({
+              context: hostBinding.context,
+              nodeIndex,
+              bindingIndex,
+              sourceSpan: hostBinding.inputAst.sourceSpan,
+              value: hostBinding.inputAst.value
+            }));
+        inputDefs = hostBindings.map(
+            hostBinding => elementBindingDef(hostBinding.inputAst, hostBinding.dirAst));
+      }
+      outputDefs = usedEvents.map(
+          ([target, eventName]) => o.literalArr([o.literal(target), o.literal(eventName)]));
+    }
+
+    templateVisitAll(this, ast.children);
+
+    const childCount = this.nodes.length - nodeIndex - 1;
+
+    const compAst = ast.directives.find(dirAst => dirAst.directive.isComponent);
+    let compRendererType = o.NULL_EXPR as o.Expression;
+    let compView = o.NULL_EXPR as o.Expression;
+    if (compAst) {
+      compView = this.outputCtx.importExpr(compAst.directive.componentViewType);
+      compRendererType = this.outputCtx.importExpr(compAst.directive.rendererType);
+    }
+
+    // elementDef(
+    //   flags: NodeFlags, matchedQueriesDsl: [string | number, QueryValueType][],
+    //   ngContentIndex: number, childCount: number, namespaceAndName: string,
+    //   fixedAttrs: [string, string][] = [],
+    //   bindings?: [BindingFlags, string, string | SecurityContext][],
+    //   outputs?: ([OutputType.ElementOutput | OutputType.DirectiveHostOutput, string, string])[],
+    //   handleEvent?: ElementHandleEventFn,
+    //   componentView?: () => ViewDefinition, componentRendererType?: RendererType2): NodeDef;
+    this.nodes[nodeIndex] = () => ({
+      sourceSpan: ast.sourceSpan,
+      nodeFlags: NodeFlags.TypeElement | flags,
+      nodeDef: o.importExpr(Identifiers.elementDef).callFn([
+        o.literal(flags),
+        queryMatchesExpr,
+        o.literal(ast.ngContentIndex),
+        o.literal(childCount),
+        o.literal(elName),
+        elName ? fixedAttrsDef(ast) : o.NULL_EXPR,
+        inputDefs.length ? o.literalArr(inputDefs) : o.NULL_EXPR,
+        outputDefs.length ? o.literalArr(outputDefs) : o.NULL_EXPR,
+        this._createElementHandleEventFn(nodeIndex, hostEvents),
+        compView,
+        compRendererType,
+      ]),
+      updateRenderer: updateRendererExpressions
+    });
+  }
+
+  private _visitElementOrTemplate(nodeIndex: number, ast: {
+    hasViewContainer: boolean,
+    outputs: BoundEventAst[],
+    directives: DirectiveAst[],
+    providers: ProviderAst[],
+    references: ReferenceAst[],
+    queryMatches: QueryMatch[]
+  }): {
+    flags: NodeFlags,
+    usedEvents: [string | null, string][],
+    queryMatchesExpr: o.Expression,
+    hostBindings:
+        {context: o.Expression, inputAst: BoundElementPropertyAst, dirAst: DirectiveAst}[],
+    hostEvents: {context: o.Expression, eventAst: BoundEventAst, dirAst: DirectiveAst}[],
+  } {
+    let flags = NodeFlags.None;
+    if (ast.hasViewContainer) {
+      flags |= NodeFlags.EmbeddedViews;
+    }
+    const usedEvents = new Map<string, [string | null, string]>();
+    ast.outputs.forEach((event) => {
+      const {name, target} = elementEventNameAndTarget(event, null);
+      usedEvents.set(elementEventFullName(target, name), [target, name]);
+    });
+    ast.directives.forEach((dirAst) => {
+      dirAst.hostEvents.forEach((event) => {
+        const {name, target} = elementEventNameAndTarget(event, dirAst);
+        usedEvents.set(elementEventFullName(target, name), [target, name]);
+      });
+    });
+    const hostBindings:
+        {context: o.Expression, inputAst: BoundElementPropertyAst, dirAst: DirectiveAst}[] = [];
+    const hostEvents: {context: o.Expression, eventAst: BoundEventAst, dirAst: DirectiveAst}[] = [];
+    this._visitComponentFactoryResolverProvider(ast.directives);
+
+    ast.providers.forEach((providerAst, providerIndex) => {
+      let dirAst: DirectiveAst = undefined !;
+      let dirIndex: number = undefined !;
+      ast.directives.forEach((localDirAst, i) => {
+        if (localDirAst.directive.type.reference === tokenReference(providerAst.token)) {
+          dirAst = localDirAst;
+          dirIndex = i;
+        }
+      });
+      if (dirAst) {
+        const {hostBindings: dirHostBindings, hostEvents: dirHostEvents} = this._visitDirective(
+            providerAst, dirAst, dirIndex, nodeIndex, ast.references, ast.queryMatches, usedEvents,
+            this.staticQueryIds.get(<any>ast) !);
+        hostBindings.push(...dirHostBindings);
+        hostEvents.push(...dirHostEvents);
+      } else {
+        this._visitProvider(providerAst, ast.queryMatches);
+      }
+    });
+
+    let queryMatchExprs: o.Expression[] = [];
+    ast.queryMatches.forEach((match) => {
+      let valueType: QueryValueType = undefined !;
+      if (tokenReference(match.value) ===
+          this.reflector.resolveExternalReference(Identifiers.ElementRef)) {
+        valueType = QueryValueType.ElementRef;
+      } else if (
+          tokenReference(match.value) ===
+          this.reflector.resolveExternalReference(Identifiers.ViewContainerRef)) {
+        valueType = QueryValueType.ViewContainerRef;
+      } else if (
+          tokenReference(match.value) ===
+          this.reflector.resolveExternalReference(Identifiers.TemplateRef)) {
+        valueType = QueryValueType.TemplateRef;
+      }
+      if (valueType != null) {
+        queryMatchExprs.push(o.literalArr([o.literal(match.queryId), o.literal(valueType)]));
+      }
+    });
+    ast.references.forEach((ref) => {
+      let valueType: QueryValueType = undefined !;
+      if (!ref.value) {
+        valueType = QueryValueType.RenderElement;
+      } else if (
+          tokenReference(ref.value) ===
+          this.reflector.resolveExternalReference(Identifiers.TemplateRef)) {
+        valueType = QueryValueType.TemplateRef;
+      }
+      if (valueType != null) {
+        this.refNodeIndices[ref.name] = nodeIndex;
+        queryMatchExprs.push(o.literalArr([o.literal(ref.name), o.literal(valueType)]));
+      }
+    });
+    ast.outputs.forEach((outputAst) => {
+      hostEvents.push({context: COMP_VAR, eventAst: outputAst, dirAst: null !});
+    });
+
+    return {
+      flags,
+      usedEvents: Array.from(usedEvents.values()),
+      queryMatchesExpr: queryMatchExprs.length ? o.literalArr(queryMatchExprs) : o.NULL_EXPR,
+      hostBindings,
+      hostEvents: hostEvents
+    };
+  }
+
+  private _visitDirective(
+      providerAst: ProviderAst, dirAst: DirectiveAst, directiveIndex: number,
+      elementNodeIndex: number, refs: ReferenceAst[], queryMatches: QueryMatch[],
+      usedEvents: Map<string, any>, queryIds: StaticAndDynamicQueryIds): {
+    hostBindings:
+        {context: o.Expression, inputAst: BoundElementPropertyAst, dirAst: DirectiveAst}[],
+    hostEvents: {context: o.Expression, eventAst: BoundEventAst, dirAst: DirectiveAst}[]
+  } {
+    const nodeIndex = this.nodes.length;
+    // reserve the space in the nodeDefs array so we can add children
+    this.nodes.push(null !);
+
+    dirAst.directive.queries.forEach((query, queryIndex) => {
+      const queryId = dirAst.contentQueryStartId + queryIndex;
+      const flags =
+          NodeFlags.TypeContentQuery | calcStaticDynamicQueryFlags(queryIds, queryId, query.first);
+      const bindingType = query.first ? QueryBindingType.First : QueryBindingType.All;
+      this.nodes.push(() => ({
+                        sourceSpan: dirAst.sourceSpan,
+                        nodeFlags: flags,
+                        nodeDef: o.importExpr(Identifiers.queryDef).callFn([
+                          o.literal(flags), o.literal(queryId),
+                          new o.LiteralMapExpr([new o.LiteralMapEntry(
+                              query.propertyName, o.literal(bindingType), false)])
+                        ]),
+                      }));
+    });
+
+    // Note: the operation below might also create new nodeDefs,
+    // but we don't want them to be a child of a directive,
+    // as they might be a provider/pipe on their own.
+    // I.e. we only allow queries as children of directives nodes.
+    const childCount = this.nodes.length - nodeIndex - 1;
+
+    let {flags, queryMatchExprs, providerExpr, depsExpr} =
+        this._visitProviderOrDirective(providerAst, queryMatches);
+
+    refs.forEach((ref) => {
+      if (ref.value && tokenReference(ref.value) === tokenReference(providerAst.token)) {
+        this.refNodeIndices[ref.name] = nodeIndex;
+        queryMatchExprs.push(
+            o.literalArr([o.literal(ref.name), o.literal(QueryValueType.Provider)]));
+      }
+    });
+
+    if (dirAst.directive.isComponent) {
+      flags |= NodeFlags.Component;
+    }
+
+    const inputDefs = dirAst.inputs.map((inputAst, inputIndex) => {
+      const mapValue = o.literalArr([o.literal(inputIndex), o.literal(inputAst.directiveName)]);
+      // Note: it's important to not quote the key so that we can capture renames by minifiers!
+      return new o.LiteralMapEntry(inputAst.directiveName, mapValue, false);
+    });
+
+    const outputDefs: o.LiteralMapEntry[] = [];
+    const dirMeta = dirAst.directive;
+    Object.keys(dirMeta.outputs).forEach((propName) => {
+      const eventName = dirMeta.outputs[propName];
+      if (usedEvents.has(eventName)) {
+        // Note: it's important to not quote the key so that we can capture renames by minifiers!
+        outputDefs.push(new o.LiteralMapEntry(propName, o.literal(eventName), false));
+      }
+    });
+    let updateDirectiveExpressions: UpdateExpression[] = [];
+    if (dirAst.inputs.length || (flags & (NodeFlags.DoCheck | NodeFlags.OnInit)) > 0) {
+      updateDirectiveExpressions =
+          dirAst.inputs.map((input, bindingIndex) => this._preprocessUpdateExpression({
+            nodeIndex,
+            bindingIndex,
+            sourceSpan: input.sourceSpan,
+            context: COMP_VAR,
+            value: input.value
+          }));
+    }
+
+    const dirContextExpr =
+        o.importExpr(Identifiers.nodeValue).callFn([VIEW_VAR, o.literal(nodeIndex)]);
+    const hostBindings = dirAst.hostProperties.map((inputAst) => ({
+                                                     context: dirContextExpr,
+                                                     dirAst,
+                                                     inputAst,
+                                                   }));
+    const hostEvents = dirAst.hostEvents.map((hostEventAst) => ({
+                                               context: dirContextExpr,
+                                               eventAst: hostEventAst, dirAst,
+                                             }));
+
+
+    // directiveDef(
+    //   flags: NodeFlags, matchedQueries: [string, QueryValueType][], childCount: number, ctor:
+    //   any,
+    //   deps: ([DepFlags, any] | any)[], props?: {[name: string]: [number, string]},
+    //   outputs?: {[name: string]: string}, component?: () => ViewDefinition): NodeDef;
+    this.nodes[nodeIndex] = () => ({
+      sourceSpan: dirAst.sourceSpan,
+      nodeFlags: NodeFlags.TypeDirective | flags,
+      nodeDef: o.importExpr(Identifiers.directiveDef).callFn([
+        o.literal(flags), queryMatchExprs.length ? o.literalArr(queryMatchExprs) : o.NULL_EXPR,
+        o.literal(childCount), providerExpr, depsExpr,
+        inputDefs.length ? new o.LiteralMapExpr(inputDefs) : o.NULL_EXPR,
+        outputDefs.length ? new o.LiteralMapExpr(outputDefs) : o.NULL_EXPR
+      ]),
+      updateDirectives: updateDirectiveExpressions,
+      directive: dirAst.directive.type,
+    });
+
+    return {hostBindings, hostEvents};
+  }
+
+  private _visitProvider(providerAst: ProviderAst, queryMatches: QueryMatch[]): void {
+    this._addProviderNode(this._visitProviderOrDirective(providerAst, queryMatches));
+  }
+
+  private _visitComponentFactoryResolverProvider(directives: DirectiveAst[]) {
+    const componentDirMeta = directives.find(dirAst => dirAst.directive.isComponent);
+    if (componentDirMeta && componentDirMeta.directive.entryComponents.length) {
+      const {providerExpr, depsExpr, flags, tokenExpr} = componentFactoryResolverProviderDef(
+          this.reflector, this.outputCtx, NodeFlags.PrivateProvider,
+          componentDirMeta.directive.entryComponents);
+      this._addProviderNode({
+        providerExpr,
+        depsExpr,
+        flags,
+        tokenExpr,
+        queryMatchExprs: [],
+        sourceSpan: componentDirMeta.sourceSpan
+      });
+    }
+  }
+
+  private _addProviderNode(data: {
+    flags: NodeFlags,
+    queryMatchExprs: o.Expression[],
+    providerExpr: o.Expression,
+    depsExpr: o.Expression,
+    tokenExpr: o.Expression,
+    sourceSpan: ParseSourceSpan
+  }) {
+    const nodeIndex = this.nodes.length;
+    // providerDef(
+    //   flags: NodeFlags, matchedQueries: [string, QueryValueType][], token:any,
+    //   value: any, deps: ([DepFlags, any] | any)[]): NodeDef;
+    this.nodes.push(
+        () => ({
+          sourceSpan: data.sourceSpan,
+          nodeFlags: data.flags,
+          nodeDef: o.importExpr(Identifiers.providerDef).callFn([
+            o.literal(data.flags),
+            data.queryMatchExprs.length ? o.literalArr(data.queryMatchExprs) : o.NULL_EXPR,
+            data.tokenExpr, data.providerExpr, data.depsExpr
+          ])
+        }));
+  }
+
+  private _visitProviderOrDirective(providerAst: ProviderAst, queryMatches: QueryMatch[]): {
+    flags: NodeFlags,
+    tokenExpr: o.Expression,
+    sourceSpan: ParseSourceSpan,
+    queryMatchExprs: o.Expression[],
+    providerExpr: o.Expression,
+    depsExpr: o.Expression
+  } {
+    let flags = NodeFlags.None;
+    let queryMatchExprs: o.Expression[] = [];
+
+    queryMatches.forEach((match) => {
+      if (tokenReference(match.value) === tokenReference(providerAst.token)) {
+        queryMatchExprs.push(
+            o.literalArr([o.literal(match.queryId), o.literal(QueryValueType.Provider)]));
+      }
+    });
+    const {providerExpr, depsExpr, flags: providerFlags, tokenExpr} =
+        providerDef(this.outputCtx, providerAst);
+    return {
+      flags: flags | providerFlags,
+      queryMatchExprs,
+      providerExpr,
+      depsExpr,
+      tokenExpr,
+      sourceSpan: providerAst.sourceSpan
+    };
+  }
+
+  getLocal(name: string): o.Expression|null {
+    if (name == EventHandlerVars.event.name) {
+      return EventHandlerVars.event;
+    }
+    let currViewExpr: o.Expression = VIEW_VAR;
+    for (let currBuilder: ViewBuilder|null = this; currBuilder; currBuilder = currBuilder.parent,
+                          currViewExpr = currViewExpr.prop('parent').cast(o.DYNAMIC_TYPE)) {
+      // check references
+      const refNodeIndex = currBuilder.refNodeIndices[name];
+      if (refNodeIndex != null) {
+        return o.importExpr(Identifiers.nodeValue).callFn([currViewExpr, o.literal(refNodeIndex)]);
+      }
+
+      // check variables
+      const varAst = currBuilder.variables.find((varAst) => varAst.name === name);
+      if (varAst) {
+        const varValue = varAst.value || IMPLICIT_TEMPLATE_VAR;
+        return currViewExpr.prop('context').prop(varValue);
+      }
+    }
+    return null;
+  }
+
+  createLiteralArrayConverter(sourceSpan: ParseSourceSpan, argCount: number): BuiltinConverter {
+    if (argCount === 0) {
+      const valueExpr = o.importExpr(Identifiers.EMPTY_ARRAY);
+      return () => valueExpr;
+    }
+
+    const nodeIndex = this.nodes.length;
+    // pureArrayDef(argCount: number): NodeDef;
+    this.nodes.push(() => ({
+                      sourceSpan,
+                      nodeFlags: NodeFlags.TypePureArray,
+                      nodeDef: o.importExpr(Identifiers.pureArrayDef).callFn([o.literal(argCount)])
+                    }));
+
+    return (args: o.Expression[]) => callCheckStmt(nodeIndex, args);
+  }
+
+  createLiteralMapConverter(sourceSpan: ParseSourceSpan, keys: {key: string, quoted: boolean}[]):
+      BuiltinConverter {
+    if (keys.length === 0) {
+      const valueExpr = o.importExpr(Identifiers.EMPTY_MAP);
+      return () => valueExpr;
+    }
+
+    // function pureObjectDef(propToIndex: {[p: string]: number}): NodeDef
+    const map = o.literalMap(keys.map((e, i) => ({...e, value: o.literal(i)})));
+    const nodeIndex = this.nodes.length;
+    this.nodes.push(() => ({
+                      sourceSpan,
+                      nodeFlags: NodeFlags.TypePureObject,
+                      nodeDef: o.importExpr(Identifiers.pureObjectDef).callFn([map])
+                    }));
+
+    return (args: o.Expression[]) => callCheckStmt(nodeIndex, args);
+  }
+
+  createPipeConverter(expression: UpdateExpression, name: string, argCount: number):
+      BuiltinConverter {
+    const pipe = this.usedPipes.find((pipeSummary) => pipeSummary.name === name) !;
+    if (pipe.pure) {
+      const nodeIndex = this.nodes.length;
+      // function purePipeDef(argCount: number): NodeDef;
+      this.nodes.push(() => ({
+                        sourceSpan: expression.sourceSpan,
+                        nodeFlags: NodeFlags.TypePurePipe,
+                        nodeDef: o.importExpr(Identifiers.purePipeDef).callFn([o.literal(argCount)])
+                      }));
+
+      // find underlying pipe in the component view
+      let compViewExpr: o.Expression = VIEW_VAR;
+      let compBuilder: ViewBuilder = this;
+      while (compBuilder.parent) {
+        compBuilder = compBuilder.parent;
+        compViewExpr = compViewExpr.prop('parent').cast(o.DYNAMIC_TYPE);
+      }
+      const pipeNodeIndex = compBuilder.purePipeNodeIndices[name];
+      const pipeValueExpr: o.Expression =
+          o.importExpr(Identifiers.nodeValue).callFn([compViewExpr, o.literal(pipeNodeIndex)]);
+
+      return (args: o.Expression[]) => callUnwrapValue(
+                 expression.nodeIndex, expression.bindingIndex,
+                 callCheckStmt(nodeIndex, [pipeValueExpr].concat(args)));
+    } else {
+      const nodeIndex = this._createPipe(expression.sourceSpan, pipe);
+      const nodeValueExpr =
+          o.importExpr(Identifiers.nodeValue).callFn([VIEW_VAR, o.literal(nodeIndex)]);
+
+      return (args: o.Expression[]) => callUnwrapValue(
+                 expression.nodeIndex, expression.bindingIndex,
+                 nodeValueExpr.callMethod('transform', args));
+    }
+  }
+
+  private _createPipe(sourceSpan: ParseSourceSpan|null, pipe: CompilePipeSummary): number {
+    const nodeIndex = this.nodes.length;
+    let flags = NodeFlags.None;
+    pipe.type.lifecycleHooks.forEach((lifecycleHook) => {
+      // for pipes, we only support ngOnDestroy
+      if (lifecycleHook === LifecycleHooks.OnDestroy) {
+        flags |= lifecycleHookToNodeFlag(lifecycleHook);
+      }
+    });
+
+    const depExprs = pipe.type.diDeps.map((diDep) => depDef(this.outputCtx, diDep));
+    // function pipeDef(
+    //   flags: NodeFlags, ctor: any, deps: ([DepFlags, any] | any)[]): NodeDef
+    this.nodes.push(
+        () => ({
+          sourceSpan,
+          nodeFlags: NodeFlags.TypePipe,
+          nodeDef: o.importExpr(Identifiers.pipeDef).callFn([
+            o.literal(flags), this.outputCtx.importExpr(pipe.type.reference), o.literalArr(depExprs)
+          ])
+        }));
+    return nodeIndex;
+  }
+
+  // Attention: This might create new nodeDefs (for pipes and literal arrays and literal maps)!
+  private _preprocessUpdateExpression(expression: UpdateExpression): UpdateExpression {
+    return {
+      nodeIndex: expression.nodeIndex,
+      bindingIndex: expression.bindingIndex,
+      sourceSpan: expression.sourceSpan,
+      context: expression.context,
+      value: convertPropertyBindingBuiltins(
+          {
+            createLiteralArrayConverter: (argCount: number) => this.createLiteralArrayConverter(
+                                             expression.sourceSpan, argCount),
+            createLiteralMapConverter:
+                (keys: {key: string, quoted: boolean}[]) =>
+                    this.createLiteralMapConverter(expression.sourceSpan, keys),
+            createPipeConverter: (name: string, argCount: number) =>
+                                     this.createPipeConverter(expression, name, argCount)
+          },
+          expression.value)
+    };
+  }
+
+  private _createNodeExpressions(): {
+    updateRendererStmts: o.Statement[],
+    updateDirectivesStmts: o.Statement[],
+    nodeDefExprs: o.Expression[]
+  } {
+    const self = this;
+    let updateBindingCount = 0;
+    const updateRendererStmts: o.Statement[] = [];
+    const updateDirectivesStmts: o.Statement[] = [];
+    const nodeDefExprs = this.nodes.map((factory, nodeIndex) => {
+      const {nodeDef, nodeFlags, updateDirectives, updateRenderer, sourceSpan} = factory();
+      if (updateRenderer) {
+        updateRendererStmts.push(
+            ...createUpdateStatements(nodeIndex, sourceSpan, updateRenderer, false));
+      }
+      if (updateDirectives) {
+        updateDirectivesStmts.push(...createUpdateStatements(
+            nodeIndex, sourceSpan, updateDirectives,
+            (nodeFlags & (NodeFlags.DoCheck | NodeFlags.OnInit)) > 0));
+      }
+      // We use a comma expression to call the log function before
+      // the nodeDef function, but still use the result of the nodeDef function
+      // as the value.
+      // Note: We only add the logger to elements / text nodes,
+      // so we don't generate too much code.
+      const logWithNodeDef = nodeFlags & NodeFlags.CatRenderNode ?
+          new o.CommaExpr([LOG_VAR.callFn([]).callFn([]), nodeDef]) :
+          nodeDef;
+      return o.applySourceSpanToExpressionIfNeeded(logWithNodeDef, sourceSpan);
+    });
+    return {updateRendererStmts, updateDirectivesStmts, nodeDefExprs};
+
+    function createUpdateStatements(
+        nodeIndex: number, sourceSpan: ParseSourceSpan | null, expressions: UpdateExpression[],
+        allowEmptyExprs: boolean): o.Statement[] {
+      const updateStmts: o.Statement[] = [];
+      const exprs = expressions.map(({sourceSpan, context, value}) => {
+        const bindingId = `${updateBindingCount++}`;
+        const nameResolver = context === COMP_VAR ? self : null;
+        const {stmts, currValExpr} =
+            convertPropertyBinding(nameResolver, context, value, bindingId);
+        updateStmts.push(...stmts.map(
+            (stmt: o.Statement) => o.applySourceSpanToStatementIfNeeded(stmt, sourceSpan)));
+        return o.applySourceSpanToExpressionIfNeeded(currValExpr, sourceSpan);
+      });
+      if (expressions.length || allowEmptyExprs) {
+        updateStmts.push(o.applySourceSpanToStatementIfNeeded(
+            callCheckStmt(nodeIndex, exprs).toStmt(), sourceSpan));
+      }
+      return updateStmts;
+    }
+  }
+
+  private _createElementHandleEventFn(
+      nodeIndex: number,
+      handlers: {context: o.Expression, eventAst: BoundEventAst, dirAst: DirectiveAst}[]) {
+    const handleEventStmts: o.Statement[] = [];
+    let handleEventBindingCount = 0;
+    handlers.forEach(({context, eventAst, dirAst}) => {
+      const bindingId = `${handleEventBindingCount++}`;
+      const nameResolver = context === COMP_VAR ? this : null;
+      const {stmts, allowDefault} =
+          convertActionBinding(nameResolver, context, eventAst.handler, bindingId);
+      const trueStmts = stmts;
+      if (allowDefault) {
+        trueStmts.push(ALLOW_DEFAULT_VAR.set(allowDefault.and(ALLOW_DEFAULT_VAR)).toStmt());
+      }
+      const {target: eventTarget, name: eventName} = elementEventNameAndTarget(eventAst, dirAst);
+      const fullEventName = elementEventFullName(eventTarget, eventName);
+      handleEventStmts.push(o.applySourceSpanToStatementIfNeeded(
+          new o.IfStmt(o.literal(fullEventName).identical(EVENT_NAME_VAR), trueStmts),
+          eventAst.sourceSpan));
+    });
+    let handleEventFn: o.Expression;
+    if (handleEventStmts.length > 0) {
+      const preStmts: o.Statement[] =
+          [ALLOW_DEFAULT_VAR.set(o.literal(true)).toDeclStmt(o.BOOL_TYPE)];
+      if (!this.component.isHost && o.findReadVarNames(handleEventStmts).has(COMP_VAR.name !)) {
+        preStmts.push(COMP_VAR.set(VIEW_VAR.prop('component')).toDeclStmt(this.compType));
+      }
+      handleEventFn = o.fn(
+          [
+            new o.FnParam(VIEW_VAR.name !, o.INFERRED_TYPE),
+            new o.FnParam(EVENT_NAME_VAR.name !, o.INFERRED_TYPE),
+            new o.FnParam(EventHandlerVars.event.name !, o.INFERRED_TYPE)
+          ],
+          [...preStmts, ...handleEventStmts, new o.ReturnStatement(ALLOW_DEFAULT_VAR)],
+          o.INFERRED_TYPE);
+    } else {
+      handleEventFn = o.NULL_EXPR;
+    }
+    return handleEventFn;
+  }
+
+  visitDirective(ast: DirectiveAst, context: {usedEvents: Set<string>}): any {}
+  visitDirectiveProperty(ast: BoundDirectivePropertyAst, context: any): any {}
+  visitReference(ast: ReferenceAst, context: any): any {}
+  visitVariable(ast: VariableAst, context: any): any {}
+  visitEvent(ast: BoundEventAst, context: any): any {}
+  visitElementProperty(ast: BoundElementPropertyAst, context: any): any {}
+  visitAttr(ast: AttrAst, context: any): any {}
+}
+
+function needsAdditionalRootNode(astNodes: TemplateAst[]): boolean {
+  const lastAstNode = astNodes[astNodes.length - 1];
+  if (lastAstNode instanceof EmbeddedTemplateAst) {
+    return lastAstNode.hasViewContainer;
+  }
+
+  if (lastAstNode instanceof ElementAst) {
+    if (isNgContainer(lastAstNode.name) && lastAstNode.children.length) {
+      return needsAdditionalRootNode(lastAstNode.children);
+    }
+    return lastAstNode.hasViewContainer;
+  }
+
+  return lastAstNode instanceof NgContentAst;
+}
+
+
+function elementBindingDef(inputAst: BoundElementPropertyAst, dirAst: DirectiveAst): o.Expression {
+  switch (inputAst.type) {
+    case PropertyBindingType.Attribute:
+      return o.literalArr([
+        o.literal(BindingFlags.TypeElementAttribute), o.literal(inputAst.name),
+        o.literal(inputAst.securityContext)
+      ]);
+    case PropertyBindingType.Property:
+      return o.literalArr([
+        o.literal(BindingFlags.TypeProperty), o.literal(inputAst.name),
+        o.literal(inputAst.securityContext)
+      ]);
+    case PropertyBindingType.Animation:
+      const bindingType = BindingFlags.TypeProperty |
+          (dirAst && dirAst.directive.isComponent ? BindingFlags.SyntheticHostProperty :
+                                                    BindingFlags.SyntheticProperty);
+      return o.literalArr([
+        o.literal(bindingType), o.literal('@' + inputAst.name), o.literal(inputAst.securityContext)
+      ]);
+    case PropertyBindingType.Class:
+      return o.literalArr(
+          [o.literal(BindingFlags.TypeElementClass), o.literal(inputAst.name), o.NULL_EXPR]);
+    case PropertyBindingType.Style:
+      return o.literalArr([
+        o.literal(BindingFlags.TypeElementStyle), o.literal(inputAst.name), o.literal(inputAst.unit)
+      ]);
+  }
+}
+
+
+function fixedAttrsDef(elementAst: ElementAst): o.Expression {
+  const mapResult: {[key: string]: string} = Object.create(null);
+  elementAst.attrs.forEach(attrAst => { mapResult[attrAst.name] = attrAst.value; });
+  elementAst.directives.forEach(dirAst => {
+    Object.keys(dirAst.directive.hostAttributes).forEach(name => {
+      const value = dirAst.directive.hostAttributes[name];
+      const prevValue = mapResult[name];
+      mapResult[name] = prevValue != null ? mergeAttributeValue(name, prevValue, value) : value;
+    });
+  });
+  // Note: We need to sort to get a defined output order
+  // for tests and for caching generated artifacts...
+  return o.literalArr(Object.keys(mapResult).sort().map(
+      (attrName) => o.literalArr([o.literal(attrName), o.literal(mapResult[attrName])])));
+}
+
+function mergeAttributeValue(attrName: string, attrValue1: string, attrValue2: string): string {
+  if (attrName == CLASS_ATTR || attrName == STYLE_ATTR) {
+    return `${attrValue1} ${attrValue2}`;
+  } else {
+    return attrValue2;
+  }
+}
+
+function callCheckStmt(nodeIndex: number, exprs: o.Expression[]): o.Expression {
+  if (exprs.length > 10) {
+    return CHECK_VAR.callFn(
+        [VIEW_VAR, o.literal(nodeIndex), o.literal(ArgumentType.Dynamic), o.literalArr(exprs)]);
+  } else {
+    return CHECK_VAR.callFn(
+        [VIEW_VAR, o.literal(nodeIndex), o.literal(ArgumentType.Inline), ...exprs]);
+  }
+}
+
+function callUnwrapValue(nodeIndex: number, bindingIdx: number, expr: o.Expression): o.Expression {
+  return o.importExpr(Identifiers.unwrapValue).callFn([
+    VIEW_VAR, o.literal(nodeIndex), o.literal(bindingIdx), expr
+  ]);
+}
+
+interface StaticAndDynamicQueryIds {
+  staticQueryIds: Set<number>;
+  dynamicQueryIds: Set<number>;
+}
+
+
+function findStaticQueryIds(
+    nodes: TemplateAst[], result = new Map<TemplateAst, StaticAndDynamicQueryIds>()):
+    Map<TemplateAst, StaticAndDynamicQueryIds> {
+  nodes.forEach((node) => {
+    const staticQueryIds = new Set<number>();
+    const dynamicQueryIds = new Set<number>();
+    let queryMatches: QueryMatch[] = undefined !;
+    if (node instanceof ElementAst) {
+      findStaticQueryIds(node.children, result);
+      node.children.forEach((child) => {
+        const childData = result.get(child) !;
+        childData.staticQueryIds.forEach(queryId => staticQueryIds.add(queryId));
+        childData.dynamicQueryIds.forEach(queryId => dynamicQueryIds.add(queryId));
+      });
+      queryMatches = node.queryMatches;
+    } else if (node instanceof EmbeddedTemplateAst) {
+      findStaticQueryIds(node.children, result);
+      node.children.forEach((child) => {
+        const childData = result.get(child) !;
+        childData.staticQueryIds.forEach(queryId => dynamicQueryIds.add(queryId));
+        childData.dynamicQueryIds.forEach(queryId => dynamicQueryIds.add(queryId));
+      });
+      queryMatches = node.queryMatches;
+    }
+    if (queryMatches) {
+      queryMatches.forEach((match) => staticQueryIds.add(match.queryId));
+    }
+    dynamicQueryIds.forEach(queryId => staticQueryIds.delete(queryId));
+    result.set(node, {staticQueryIds, dynamicQueryIds});
+  });
+  return result;
+}
+
+function staticViewQueryIds(nodeStaticQueryIds: Map<TemplateAst, StaticAndDynamicQueryIds>):
+    StaticAndDynamicQueryIds {
+  const staticQueryIds = new Set<number>();
+  const dynamicQueryIds = new Set<number>();
+  Array.from(nodeStaticQueryIds.values()).forEach((entry) => {
+    entry.staticQueryIds.forEach(queryId => staticQueryIds.add(queryId));
+    entry.dynamicQueryIds.forEach(queryId => dynamicQueryIds.add(queryId));
+  });
+  dynamicQueryIds.forEach(queryId => staticQueryIds.delete(queryId));
+  return {staticQueryIds, dynamicQueryIds};
+}
+
+function elementEventNameAndTarget(
+    eventAst: BoundEventAst, dirAst: DirectiveAst | null): {name: string, target: string | null} {
+  if (eventAst.isAnimation) {
+    return {
+      name: `@${eventAst.name}.${eventAst.phase}`,
+      target: dirAst && dirAst.directive.isComponent ? 'component' : null
+    };
+  } else {
+    return eventAst;
+  }
+}
+
+function calcStaticDynamicQueryFlags(
+    queryIds: StaticAndDynamicQueryIds, queryId: number, isFirst: boolean) {
+  let flags = NodeFlags.None;
+  // Note: We only make queries static that query for a single item.
+  // This is because of backwards compatibility with the old view compiler...
+  if (isFirst && (queryIds.staticQueryIds.has(queryId) || !queryIds.dynamicQueryIds.has(queryId))) {
+    flags |= NodeFlags.StaticQuery;
+  } else {
+    flags |= NodeFlags.DynamicQuery;
+  }
+  return flags;
+}
+
+export function elementEventFullName(target: string | null, name: string): string {
+  return target ? `${target}:${name}` : name;
+}
diff --git a/angular/core/index.ts b/angular/core/index.ts
new file mode 100644
index 0000000..e727e2e
--- /dev/null
+++ b/angular/core/index.ts
@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+// This file is not used to build this module. It is only used during editing
+// by the TypeScript language service and during build for verification. `ngc`
+// replaces this file with production index.ts when it rewrites private symbol
+// names.
+
+export * from './public_api';
diff --git a/angular/core/public_api.ts b/angular/core/public_api.ts
new file mode 100644
index 0000000..ede0762
--- /dev/null
+++ b/angular/core/public_api.ts
@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the core package.
+ */
+export * from './src/core';
+
+// This file only reexports content of the `src` folder. Keep it that way.
diff --git a/angular/core/src/application_init.ts b/angular/core/src/application_init.ts
new file mode 100644
index 0000000..b801ab2
--- /dev/null
+++ b/angular/core/src/application_init.ts
@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {isPromise} from '../src/util/lang';
+
+import {Inject, Injectable, InjectionToken, Optional} from './di';
+
+
+/**
+ * A function that will be executed when an application is initialized.
+ * @experimental
+ */
+export const APP_INITIALIZER = new InjectionToken<Array<() => void>>('Application Initializer');
+
+/**
+ * A class that reflects the state of running {@link APP_INITIALIZER}s.
+ *
+ * @experimental
+ */
+@Injectable()
+export class ApplicationInitStatus {
+  private resolve: Function;
+  private reject: Function;
+  private initialized = false;
+  private _donePromise: Promise<any>;
+  private _done = false;
+
+  constructor(@Inject(APP_INITIALIZER) @Optional() private appInits: (() => any)[]) {
+    this._donePromise = new Promise((res, rej) => {
+      this.resolve = res;
+      this.reject = rej;
+    });
+  }
+
+  /** @internal */
+  runInitializers() {
+    if (this.initialized) {
+      return;
+    }
+
+    const asyncInitPromises: Promise<any>[] = [];
+
+    const complete = () => {
+      this._done = true;
+      this.resolve();
+    };
+
+    if (this.appInits) {
+      for (let i = 0; i < this.appInits.length; i++) {
+        const initResult = this.appInits[i]();
+        if (isPromise(initResult)) {
+          asyncInitPromises.push(initResult);
+        }
+      }
+    }
+
+    Promise.all(asyncInitPromises).then(() => { complete(); }).catch(e => { this.reject(e); });
+
+    if (asyncInitPromises.length === 0) {
+      complete();
+    }
+    this.initialized = true;
+  }
+
+  get done(): boolean { return this._done; }
+
+  get donePromise(): Promise<any> { return this._donePromise; }
+}
diff --git a/angular/core/src/application_module.ts b/angular/core/src/application_module.ts
new file mode 100644
index 0000000..5c4b359
--- /dev/null
+++ b/angular/core/src/application_module.ts
@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ApplicationInitStatus} from './application_init';
+import {ApplicationRef, ApplicationRef_} from './application_ref';
+import {APP_ID_RANDOM_PROVIDER} from './application_tokens';
+import {IterableDiffers, KeyValueDiffers, defaultIterableDiffers, defaultKeyValueDiffers} from './change_detection/change_detection';
+import {Inject, Optional, SkipSelf} from './di/metadata';
+import {LOCALE_ID} from './i18n/tokens';
+import {Compiler} from './linker/compiler';
+import {NgModule} from './metadata';
+
+export function _iterableDiffersFactory() {
+  return defaultIterableDiffers;
+}
+
+export function _keyValueDiffersFactory() {
+  return defaultKeyValueDiffers;
+}
+
+export function _localeFactory(locale?: string): string {
+  return locale || 'en-US';
+}
+
+/**
+ * This module includes the providers of @angular/core that are needed
+ * to bootstrap components via `ApplicationRef`.
+ *
+ * @experimental
+ */
+@NgModule({
+  providers: [
+    ApplicationRef_,
+    {provide: ApplicationRef, useExisting: ApplicationRef_},
+    ApplicationInitStatus,
+    Compiler,
+    APP_ID_RANDOM_PROVIDER,
+    {provide: IterableDiffers, useFactory: _iterableDiffersFactory},
+    {provide: KeyValueDiffers, useFactory: _keyValueDiffersFactory},
+    {
+      provide: LOCALE_ID,
+      useFactory: _localeFactory,
+      deps: [[new Inject(LOCALE_ID), new Optional(), new SkipSelf()]]
+    },
+  ]
+})
+export class ApplicationModule {
+  // Inject ApplicationRef to make it eager...
+  constructor(appRef: ApplicationRef) {}
+}
diff --git a/angular/core/src/application_ref.ts b/angular/core/src/application_ref.ts
new file mode 100644
index 0000000..a3dd39d
--- /dev/null
+++ b/angular/core/src/application_ref.ts
@@ -0,0 +1,593 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Observable} from 'rxjs/Observable';
+import {Observer} from 'rxjs/Observer';
+import {Subscription} from 'rxjs/Subscription';
+import {merge} from 'rxjs/observable/merge';
+import {share} from 'rxjs/operator/share';
+
+import {ErrorHandler} from '../src/error_handler';
+import {scheduleMicroTask, stringify} from '../src/util';
+import {isPromise} from '../src/util/lang';
+
+import {ApplicationInitStatus} from './application_init';
+import {APP_BOOTSTRAP_LISTENER, PLATFORM_INITIALIZER} from './application_tokens';
+import {Console} from './console';
+import {Injectable, InjectionToken, Injector, StaticProvider} from './di';
+import {CompilerFactory, CompilerOptions} from './linker/compiler';
+import {ComponentFactory, ComponentRef} from './linker/component_factory';
+import {ComponentFactoryBoundToModule, ComponentFactoryResolver} from './linker/component_factory_resolver';
+import {InternalNgModuleRef, NgModuleFactory, NgModuleRef} from './linker/ng_module_factory';
+import {InternalViewRef, ViewRef} from './linker/view_ref';
+import {WtfScopeFn, wtfCreateScope, wtfLeave} from './profile/profile';
+import {Testability, TestabilityRegistry} from './testability/testability';
+import {Type} from './type';
+import {NgZone} from './zone/ng_zone';
+
+let _devMode: boolean = true;
+let _runModeLocked: boolean = false;
+let _platform: PlatformRef;
+
+export const ALLOW_MULTIPLE_PLATFORMS = new InjectionToken<boolean>('AllowMultipleToken');
+
+/**
+ * Disable Angular's development mode, which turns off assertions and other
+ * checks within the framework.
+ *
+ * One important assertion this disables verifies that a change detection pass
+ * does not result in additional changes to any bindings (also known as
+ * unidirectional data flow).
+ *
+ * @stable
+ */
+export function enableProdMode(): void {
+  if (_runModeLocked) {
+    throw new Error('Cannot enable prod mode after platform setup.');
+  }
+  _devMode = false;
+}
+
+/**
+ * Returns whether Angular is in development mode. After called once,
+ * the value is locked and won't change any more.
+ *
+ * By default, this is true, unless a user calls `enableProdMode` before calling this.
+ *
+ * @experimental APIs related to application bootstrap are currently under review.
+ */
+export function isDevMode(): boolean {
+  _runModeLocked = true;
+  return _devMode;
+}
+
+/**
+ * A token for third-party components that can register themselves with NgProbe.
+ *
+ * @experimental
+ */
+export class NgProbeToken {
+  constructor(public name: string, public token: any) {}
+}
+
+/**
+ * Creates a platform.
+ * Platforms have to be eagerly created via this function.
+ *
+ * @experimental APIs related to application bootstrap are currently under review.
+ */
+export function createPlatform(injector: Injector): PlatformRef {
+  if (_platform && !_platform.destroyed &&
+      !_platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {
+    throw new Error(
+        'There can be only one platform. Destroy the previous one to create a new one.');
+  }
+  _platform = injector.get(PlatformRef);
+  const inits = injector.get(PLATFORM_INITIALIZER, null);
+  if (inits) inits.forEach((init: any) => init());
+  return _platform;
+}
+
+/**
+ * Creates a factory for a platform
+ *
+ * @experimental APIs related to application bootstrap are currently under review.
+ */
+export function createPlatformFactory(
+    parentPlatformFactory: ((extraProviders?: StaticProvider[]) => PlatformRef) | null,
+    name: string, providers: StaticProvider[] = []): (extraProviders?: StaticProvider[]) =>
+    PlatformRef {
+  const marker = new InjectionToken(`Platform: ${name}`);
+  return (extraProviders: StaticProvider[] = []) => {
+    let platform = getPlatform();
+    if (!platform || platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {
+      if (parentPlatformFactory) {
+        parentPlatformFactory(
+            providers.concat(extraProviders).concat({provide: marker, useValue: true}));
+      } else {
+        createPlatform(Injector.create(
+            providers.concat(extraProviders).concat({provide: marker, useValue: true})));
+      }
+    }
+    return assertPlatform(marker);
+  };
+}
+
+/**
+ * Checks that there currently is a platform which contains the given token as a provider.
+ *
+ * @experimental APIs related to application bootstrap are currently under review.
+ */
+export function assertPlatform(requiredToken: any): PlatformRef {
+  const platform = getPlatform();
+
+  if (!platform) {
+    throw new Error('No platform exists!');
+  }
+
+  if (!platform.injector.get(requiredToken, null)) {
+    throw new Error(
+        'A platform with a different configuration has been created. Please destroy it first.');
+  }
+
+  return platform;
+}
+
+/**
+ * Destroy the existing platform.
+ *
+ * @experimental APIs related to application bootstrap are currently under review.
+ */
+export function destroyPlatform(): void {
+  if (_platform && !_platform.destroyed) {
+    _platform.destroy();
+  }
+}
+
+/**
+ * Returns the current platform.
+ *
+ * @experimental APIs related to application bootstrap are currently under review.
+ */
+export function getPlatform(): PlatformRef|null {
+  return _platform && !_platform.destroyed ? _platform : null;
+}
+
+/**
+ * The Angular platform is the entry point for Angular on a web page. Each page
+ * has exactly one platform, and services (such as reflection) which are common
+ * to every Angular application running on the page are bound in its scope.
+ *
+ * A page's platform is initialized implicitly when a platform is created via a platform factory
+ * (e.g. {@link platformBrowser}), or explicitly by calling the {@link createPlatform} function.
+ *
+ * @stable
+ */
+export abstract class PlatformRef {
+  /**
+   * Creates an instance of an `@NgModule` for the given platform
+   * for offline compilation.
+   *
+   * ## Simple Example
+   *
+   * ```typescript
+   * my_module.ts:
+   *
+   * @NgModule({
+   *   imports: [BrowserModule]
+   * })
+   * class MyModule {}
+   *
+   * main.ts:
+   * import {MyModuleNgFactory} from './my_module.ngfactory';
+   * import {platformBrowser} from '@angular/platform-browser';
+   *
+   * let moduleRef = platformBrowser().bootstrapModuleFactory(MyModuleNgFactory);
+   * ```
+   *
+   * @experimental APIs related to application bootstrap are currently under review.
+   */
+  abstract bootstrapModuleFactory<M>(moduleFactory: NgModuleFactory<M>): Promise<NgModuleRef<M>>;
+
+  /**
+   * Creates an instance of an `@NgModule` for a given platform using the given runtime compiler.
+   *
+   * ## Simple Example
+   *
+   * ```typescript
+   * @NgModule({
+   *   imports: [BrowserModule]
+   * })
+   * class MyModule {}
+   *
+   * let moduleRef = platformBrowser().bootstrapModule(MyModule);
+   * ```
+   * @stable
+   */
+  abstract bootstrapModule<M>(
+      moduleType: Type<M>,
+      compilerOptions?: CompilerOptions|CompilerOptions[]): Promise<NgModuleRef<M>>;
+
+  /**
+   * Register a listener to be called when the platform is disposed.
+   */
+  abstract onDestroy(callback: () => void): void;
+
+  /**
+   * Retrieve the platform {@link Injector}, which is the parent injector for
+   * every Angular application on the page and provides singleton providers.
+   */
+  abstract get injector(): Injector;
+
+  /**
+   * Destroy the Angular platform and all Angular applications on the page.
+   */
+  abstract destroy(): void;
+
+  abstract get destroyed(): boolean;
+}
+
+function _callAndReportToErrorHandler(
+    errorHandler: ErrorHandler, ngZone: NgZone, callback: () => any): any {
+  try {
+    const result = callback();
+    if (isPromise(result)) {
+      return result.catch((e: any) => {
+        ngZone.runOutsideAngular(() => errorHandler.handleError(e));
+        // rethrow as the exception handler might not do it
+        throw e;
+      });
+    }
+
+    return result;
+  } catch (e) {
+    ngZone.runOutsideAngular(() => errorHandler.handleError(e));
+    // rethrow as the exception handler might not do it
+    throw e;
+  }
+}
+
+/**
+ * workaround https://github.com/angular/tsickle/issues/350
+ * @suppress {checkTypes}
+ */
+@Injectable()
+export class PlatformRef_ extends PlatformRef {
+  private _modules: NgModuleRef<any>[] = [];
+  private _destroyListeners: Function[] = [];
+  private _destroyed: boolean = false;
+
+  constructor(private _injector: Injector) { super(); }
+
+  onDestroy(callback: () => void): void { this._destroyListeners.push(callback); }
+
+  get injector(): Injector { return this._injector; }
+
+  get destroyed() { return this._destroyed; }
+
+  destroy() {
+    if (this._destroyed) {
+      throw new Error('The platform has already been destroyed!');
+    }
+    this._modules.slice().forEach(module => module.destroy());
+    this._destroyListeners.forEach(listener => listener());
+    this._destroyed = true;
+  }
+
+  bootstrapModuleFactory<M>(moduleFactory: NgModuleFactory<M>): Promise<NgModuleRef<M>> {
+    return this._bootstrapModuleFactoryWithZone(moduleFactory);
+  }
+
+  private _bootstrapModuleFactoryWithZone<M>(moduleFactory: NgModuleFactory<M>, ngZone?: NgZone):
+      Promise<NgModuleRef<M>> {
+    // Note: We need to create the NgZone _before_ we instantiate the module,
+    // as instantiating the module creates some providers eagerly.
+    // So we create a mini parent injector that just contains the new NgZone and
+    // pass that as parent to the NgModuleFactory.
+    if (!ngZone) ngZone = new NgZone({enableLongStackTrace: isDevMode()});
+    // Attention: Don't use ApplicationRef.run here,
+    // as we want to be sure that all possible constructor calls are inside `ngZone.run`!
+    return ngZone.run(() => {
+      const ngZoneInjector = Injector.create([{provide: NgZone, useValue: ngZone}], this.injector);
+      const moduleRef = <InternalNgModuleRef<M>>moduleFactory.create(ngZoneInjector);
+      const exceptionHandler: ErrorHandler = moduleRef.injector.get(ErrorHandler, null);
+      if (!exceptionHandler) {
+        throw new Error('No ErrorHandler. Is platform module (BrowserModule) included?');
+      }
+      moduleRef.onDestroy(() => remove(this._modules, moduleRef));
+      ngZone !.runOutsideAngular(
+          () => ngZone !.onError.subscribe(
+              {next: (error: any) => { exceptionHandler.handleError(error); }}));
+      return _callAndReportToErrorHandler(exceptionHandler, ngZone !, () => {
+        const initStatus: ApplicationInitStatus = moduleRef.injector.get(ApplicationInitStatus);
+        initStatus.runInitializers();
+        return initStatus.donePromise.then(() => {
+          this._moduleDoBootstrap(moduleRef);
+          return moduleRef;
+        });
+      });
+    });
+  }
+
+  bootstrapModule<M>(moduleType: Type<M>, compilerOptions: CompilerOptions|CompilerOptions[] = []):
+      Promise<NgModuleRef<M>> {
+    return this._bootstrapModuleWithZone(moduleType, compilerOptions);
+  }
+
+  private _bootstrapModuleWithZone<M>(
+      moduleType: Type<M>, compilerOptions: CompilerOptions|CompilerOptions[] = [],
+      ngZone?: NgZone): Promise<NgModuleRef<M>> {
+    const compilerFactory: CompilerFactory = this.injector.get(CompilerFactory);
+    const compiler = compilerFactory.createCompiler(
+        Array.isArray(compilerOptions) ? compilerOptions : [compilerOptions]);
+
+    return compiler.compileModuleAsync(moduleType)
+        .then((moduleFactory) => this._bootstrapModuleFactoryWithZone(moduleFactory, ngZone));
+  }
+
+  private _moduleDoBootstrap(moduleRef: InternalNgModuleRef<any>): void {
+    const appRef = moduleRef.injector.get(ApplicationRef) as ApplicationRef;
+    if (moduleRef._bootstrapComponents.length > 0) {
+      moduleRef._bootstrapComponents.forEach(f => appRef.bootstrap(f));
+    } else if (moduleRef.instance.ngDoBootstrap) {
+      moduleRef.instance.ngDoBootstrap(appRef);
+    } else {
+      throw new Error(
+          `The module ${stringify(moduleRef.instance.constructor)} was bootstrapped, but it does not declare "@NgModule.bootstrap" components nor a "ngDoBootstrap" method. ` +
+          `Please define one of these.`);
+    }
+    this._modules.push(moduleRef);
+  }
+}
+
+/**
+ * A reference to an Angular application running on a page.
+ *
+ * @stable
+ */
+export abstract class ApplicationRef {
+  /**
+   * Bootstrap a new component at the root level of the application.
+   *
+   * ### Bootstrap process
+   *
+   * When bootstrapping a new root component into an application, Angular mounts the
+   * specified application component onto DOM elements identified by the [componentType]'s
+   * selector and kicks off automatic change detection to finish initializing the component.
+   *
+   * Optionally, a component can be mounted onto a DOM element that does not match the
+   * [componentType]'s selector.
+   *
+   * ### Example
+   * {@example core/ts/platform/platform.ts region='longform'}
+   */
+  abstract bootstrap<C>(
+      componentFactory: ComponentFactory<C>|Type<C>,
+      rootSelectorOrNode?: string|any): ComponentRef<C>;
+
+  /**
+   * Invoke this method to explicitly process change detection and its side-effects.
+   *
+   * In development mode, `tick()` also performs a second change detection cycle to ensure that no
+   * further changes are detected. If additional changes are picked up during this second cycle,
+   * bindings in the app have side-effects that cannot be resolved in a single change detection
+   * pass.
+   * In this case, Angular throws an error, since an Angular application can only have one change
+   * detection pass during which all change detection must complete.
+   */
+  abstract tick(): void;
+
+  /**
+   * Get a list of component types registered to this application.
+   * This list is populated even before the component is created.
+   */
+  abstract get componentTypes(): Type<any>[];
+
+  /**
+   * Get a list of components registered to this application.
+   */
+  abstract get components(): ComponentRef<any>[];
+
+  /**
+   * Attaches a view so that it will be dirty checked.
+   * The view will be automatically detached when it is destroyed.
+   * This will throw if the view is already attached to a ViewContainer.
+   */
+  abstract attachView(view: ViewRef): void;
+
+  /**
+   * Detaches a view from dirty checking again.
+   */
+  abstract detachView(view: ViewRef): void;
+
+  /**
+   * Returns the number of attached views.
+   */
+  abstract get viewCount(): number;
+
+  /**
+   * Returns an Observable that indicates when the application is stable or unstable.
+   */
+  abstract get isStable(): Observable<boolean>;
+}
+
+/**
+ * workaround https://github.com/angular/tsickle/issues/350
+ * @suppress {checkTypes}
+ */
+@Injectable()
+export class ApplicationRef_ extends ApplicationRef {
+  /** @internal */
+  static _tickScope: WtfScopeFn = wtfCreateScope('ApplicationRef#tick()');
+
+  private _bootstrapListeners: ((compRef: ComponentRef<any>) => void)[] = [];
+  private _rootComponents: ComponentRef<any>[] = [];
+  private _rootComponentTypes: Type<any>[] = [];
+  private _views: InternalViewRef[] = [];
+  private _runningTick: boolean = false;
+  private _enforceNoNewChanges: boolean = false;
+  private _isStable: Observable<boolean>;
+  private _stable = true;
+
+  constructor(
+      private _zone: NgZone, private _console: Console, private _injector: Injector,
+      private _exceptionHandler: ErrorHandler,
+      private _componentFactoryResolver: ComponentFactoryResolver,
+      private _initStatus: ApplicationInitStatus) {
+    super();
+    this._enforceNoNewChanges = isDevMode();
+
+    this._zone.onMicrotaskEmpty.subscribe(
+        {next: () => { this._zone.run(() => { this.tick(); }); }});
+
+    const isCurrentlyStable = new Observable<boolean>((observer: Observer<boolean>) => {
+      this._stable = this._zone.isStable && !this._zone.hasPendingMacrotasks &&
+          !this._zone.hasPendingMicrotasks;
+      this._zone.runOutsideAngular(() => {
+        observer.next(this._stable);
+        observer.complete();
+      });
+    });
+
+    const isStable = new Observable<boolean>((observer: Observer<boolean>) => {
+      const stableSub: Subscription = this._zone.onStable.subscribe(() => {
+        NgZone.assertNotInAngularZone();
+
+        // Check whether there are no pending macro/micro tasks in the next tick
+        // to allow for NgZone to update the state.
+        scheduleMicroTask(() => {
+          if (!this._stable && !this._zone.hasPendingMacrotasks &&
+              !this._zone.hasPendingMicrotasks) {
+            this._stable = true;
+            observer.next(true);
+          }
+        });
+      });
+
+      const unstableSub: Subscription = this._zone.onUnstable.subscribe(() => {
+        NgZone.assertInAngularZone();
+        if (this._stable) {
+          this._stable = false;
+          this._zone.runOutsideAngular(() => { observer.next(false); });
+        }
+      });
+
+      return () => {
+        stableSub.unsubscribe();
+        unstableSub.unsubscribe();
+      };
+    });
+
+    this._isStable = merge(isCurrentlyStable, share.call(isStable));
+  }
+
+  attachView(viewRef: ViewRef): void {
+    const view = (viewRef as InternalViewRef);
+    this._views.push(view);
+    view.attachToAppRef(this);
+  }
+
+  detachView(viewRef: ViewRef): void {
+    const view = (viewRef as InternalViewRef);
+    remove(this._views, view);
+    view.detachFromAppRef();
+  }
+
+  bootstrap<C>(componentOrFactory: ComponentFactory<C>|Type<C>, rootSelectorOrNode?: string|any):
+      ComponentRef<C> {
+    if (!this._initStatus.done) {
+      throw new Error(
+          'Cannot bootstrap as there are still asynchronous initializers running. Bootstrap components in the `ngDoBootstrap` method of the root module.');
+    }
+    let componentFactory: ComponentFactory<C>;
+    if (componentOrFactory instanceof ComponentFactory) {
+      componentFactory = componentOrFactory;
+    } else {
+      componentFactory =
+          this._componentFactoryResolver.resolveComponentFactory(componentOrFactory) !;
+    }
+    this._rootComponentTypes.push(componentFactory.componentType);
+
+    // Create a factory associated with the current module if it's not bound to some other
+    const ngModule = componentFactory instanceof ComponentFactoryBoundToModule ?
+        null :
+        this._injector.get(NgModuleRef);
+    const selectorOrNode = rootSelectorOrNode || componentFactory.selector;
+    const compRef = componentFactory.create(Injector.NULL, [], selectorOrNode, ngModule);
+
+    compRef.onDestroy(() => { this._unloadComponent(compRef); });
+    const testability = compRef.injector.get(Testability, null);
+    if (testability) {
+      compRef.injector.get(TestabilityRegistry)
+          .registerApplication(compRef.location.nativeElement, testability);
+    }
+
+    this._loadComponent(compRef);
+    if (isDevMode()) {
+      this._console.log(
+          `Angular is running in the development mode. Call enableProdMode() to enable the production mode.`);
+    }
+    return compRef;
+  }
+
+  private _loadComponent(componentRef: ComponentRef<any>): void {
+    this.attachView(componentRef.hostView);
+    this.tick();
+    this._rootComponents.push(componentRef);
+    // Get the listeners lazily to prevent DI cycles.
+    const listeners =
+        this._injector.get(APP_BOOTSTRAP_LISTENER, []).concat(this._bootstrapListeners);
+    listeners.forEach((listener) => listener(componentRef));
+  }
+
+  private _unloadComponent(componentRef: ComponentRef<any>): void {
+    this.detachView(componentRef.hostView);
+    remove(this._rootComponents, componentRef);
+  }
+
+  tick(): void {
+    if (this._runningTick) {
+      throw new Error('ApplicationRef.tick is called recursively');
+    }
+
+    const scope = ApplicationRef_._tickScope();
+    try {
+      this._runningTick = true;
+      this._views.forEach((view) => view.detectChanges());
+      if (this._enforceNoNewChanges) {
+        this._views.forEach((view) => view.checkNoChanges());
+      }
+    } catch (e) {
+      // Attention: Don't rethrow as it could cancel subscriptions to Observables!
+      this._zone.runOutsideAngular(() => this._exceptionHandler.handleError(e));
+    } finally {
+      this._runningTick = false;
+      wtfLeave(scope);
+    }
+  }
+
+  ngOnDestroy() {
+    // TODO(alxhub): Dispose of the NgZone.
+    this._views.slice().forEach((view) => view.destroy());
+  }
+
+  get viewCount() { return this._views.length; }
+
+  get componentTypes(): Type<any>[] { return this._rootComponentTypes; }
+
+  get components(): ComponentRef<any>[] { return this._rootComponents; }
+
+  get isStable(): Observable<boolean> { return this._isStable; }
+}
+
+function remove<T>(list: T[], el: T): void {
+  const index = list.indexOf(el);
+  if (index > -1) {
+    list.splice(index, 1);
+  }
+}
diff --git a/angular/core/src/application_tokens.ts b/angular/core/src/application_tokens.ts
new file mode 100644
index 0000000..88aaac1
--- /dev/null
+++ b/angular/core/src/application_tokens.ts
@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {InjectionToken} from './di';
+import {ComponentRef} from './linker/component_factory';
+
+
+/**
+ * A DI Token representing a unique string id assigned to the application by Angular and used
+ * primarily for prefixing application attributes and CSS styles when
+ * {@link ViewEncapsulation#Emulated} is being used.
+ *
+ * If you need to avoid randomly generated value to be used as an application id, you can provide
+ * a custom value via a DI provider <!-- TODO: provider --> configuring the root {@link Injector}
+ * using this token.
+ * @experimental
+ */
+export const APP_ID = new InjectionToken<string>('AppId');
+
+export function _appIdRandomProviderFactory() {
+  return `${_randomChar()}${_randomChar()}${_randomChar()}`;
+}
+
+/**
+ * Providers that will generate a random APP_ID_TOKEN.
+ * @experimental
+ */
+export const APP_ID_RANDOM_PROVIDER = {
+  provide: APP_ID,
+  useFactory: _appIdRandomProviderFactory,
+  deps: <any[]>[],
+};
+
+function _randomChar(): string {
+  return String.fromCharCode(97 + Math.floor(Math.random() * 25));
+}
+
+/**
+ * A function that will be executed when a platform is initialized.
+ * @experimental
+ */
+export const PLATFORM_INITIALIZER = new InjectionToken<Array<() => void>>('Platform Initializer');
+
+/**
+ * A token that indicates an opaque platform id.
+ * @experimental
+ */
+export const PLATFORM_ID = new InjectionToken<Object>('Platform ID');
+
+/**
+ * All callbacks provided via this token will be called for every component that is bootstrapped.
+ * Signature of the callback:
+ *
+ * `(componentRef: ComponentRef) => void`.
+ *
+ * @experimental
+ */
+export const APP_BOOTSTRAP_LISTENER =
+    new InjectionToken<Array<(compRef: ComponentRef<any>) => void>>('appBootstrapListener');
+
+/**
+ * A token which indicates the root directory of the application
+ * @experimental
+ */
+export const PACKAGE_ROOT_URL = new InjectionToken<string>('Application Packages Root URL');
diff --git a/angular/core/src/change_detection.ts b/angular/core/src/change_detection.ts
new file mode 100644
index 0000000..d543d08
--- /dev/null
+++ b/angular/core/src/change_detection.ts
@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Change detection enables data binding in Angular.
+ */
+
+export {ChangeDetectionStrategy, ChangeDetectorRef, CollectionChangeRecord, DefaultIterableDiffer, IterableChangeRecord, IterableChanges, IterableDiffer, IterableDifferFactory, IterableDiffers, KeyValueChangeRecord, KeyValueChanges, KeyValueDiffer, KeyValueDifferFactory, KeyValueDiffers, NgIterable, PipeTransform, SimpleChange, SimpleChanges, TrackByFn, TrackByFunction, WrappedValue} from './change_detection/change_detection';
diff --git a/angular/core/src/change_detection/change_detection.ts b/angular/core/src/change_detection/change_detection.ts
new file mode 100644
index 0000000..db43f81
--- /dev/null
+++ b/angular/core/src/change_detection/change_detection.ts
@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {DefaultIterableDifferFactory} from './differs/default_iterable_differ';
+import {DefaultKeyValueDifferFactory} from './differs/default_keyvalue_differ';
+import {IterableDifferFactory, IterableDiffers} from './differs/iterable_differs';
+import {KeyValueDifferFactory, KeyValueDiffers} from './differs/keyvalue_differs';
+
+export {SimpleChanges} from '../metadata/lifecycle_hooks';
+export {SimpleChange, ValueUnwrapper, WrappedValue, devModeEqual} from './change_detection_util';
+export {ChangeDetectorRef} from './change_detector_ref';
+export {ChangeDetectionStrategy, ChangeDetectorStatus, isDefaultChangeDetectionStrategy} from './constants';
+export {DefaultIterableDifferFactory} from './differs/default_iterable_differ';
+export {DefaultIterableDiffer} from './differs/default_iterable_differ';
+export {DefaultKeyValueDifferFactory} from './differs/default_keyvalue_differ';
+export {CollectionChangeRecord, IterableChangeRecord, IterableChanges, IterableDiffer, IterableDifferFactory, IterableDiffers, NgIterable, TrackByFn, TrackByFunction} from './differs/iterable_differs';
+export {KeyValueChangeRecord, KeyValueChanges, KeyValueDiffer, KeyValueDifferFactory, KeyValueDiffers} from './differs/keyvalue_differs';
+export {PipeTransform} from './pipe_transform';
+
+
+
+/**
+ * Structural diffing for `Object`s and `Map`s.
+ */
+const keyValDiff: KeyValueDifferFactory[] = [new DefaultKeyValueDifferFactory()];
+
+/**
+ * Structural diffing for `Iterable` types such as `Array`s.
+ */
+const iterableDiff: IterableDifferFactory[] = [new DefaultIterableDifferFactory()];
+
+export const defaultIterableDiffers = new IterableDiffers(iterableDiff);
+
+export const defaultKeyValueDiffers = new KeyValueDiffers(keyValDiff);
diff --git a/angular/core/src/change_detection/change_detection_util.ts b/angular/core/src/change_detection/change_detection_util.ts
new file mode 100644
index 0000000..9f68ba4
--- /dev/null
+++ b/angular/core/src/change_detection/change_detection_util.ts
@@ -0,0 +1,119 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {getSymbolIterator, looseIdentical} from '../util';
+
+export function devModeEqual(a: any, b: any): boolean {
+  const isListLikeIterableA = isListLikeIterable(a);
+  const isListLikeIterableB = isListLikeIterable(b);
+  if (isListLikeIterableA && isListLikeIterableB) {
+    return areIterablesEqual(a, b, devModeEqual);
+  } else {
+    const isAObject = a && (typeof a === 'object' || typeof a === 'function');
+    const isBObject = b && (typeof b === 'object' || typeof b === 'function');
+    if (!isListLikeIterableA && isAObject && !isListLikeIterableB && isBObject) {
+      return true;
+    } else {
+      return looseIdentical(a, b);
+    }
+  }
+}
+
+/**
+ * Indicates that the result of a {@link Pipe} transformation has changed even though the
+ * reference
+ * has not changed.
+ *
+ * The wrapped value will be unwrapped by change detection, and the unwrapped value will be stored.
+ *
+ * Example:
+ *
+ * ```
+ * if (this._latestValue === this._latestReturnedValue) {
+ *    return this._latestReturnedValue;
+ *  } else {
+ *    this._latestReturnedValue = this._latestValue;
+ *    return WrappedValue.wrap(this._latestValue); // this will force update
+ *  }
+ * ```
+ * @stable
+ */
+export class WrappedValue {
+  constructor(public wrapped: any) {}
+
+  static wrap(value: any): WrappedValue { return new WrappedValue(value); }
+}
+
+/**
+ * Helper class for unwrapping WrappedValue s
+ */
+export class ValueUnwrapper {
+  public hasWrappedValue = false;
+
+  unwrap(value: any): any {
+    if (value instanceof WrappedValue) {
+      this.hasWrappedValue = true;
+      return value.wrapped;
+    }
+    return value;
+  }
+
+  reset() { this.hasWrappedValue = false; }
+}
+
+/**
+ * Represents a basic change from a previous to a new value.
+ * @stable
+ */
+export class SimpleChange {
+  constructor(public previousValue: any, public currentValue: any, public firstChange: boolean) {}
+
+  /**
+   * Check whether the new value is the first value assigned.
+   */
+  isFirstChange(): boolean { return this.firstChange; }
+}
+
+export function isListLikeIterable(obj: any): boolean {
+  if (!isJsObject(obj)) return false;
+  return Array.isArray(obj) ||
+      (!(obj instanceof Map) &&      // JS Map are iterables but return entries as [k, v]
+       getSymbolIterator() in obj);  // JS Iterable have a Symbol.iterator prop
+}
+
+export function areIterablesEqual(
+    a: any, b: any, comparator: (a: any, b: any) => boolean): boolean {
+  const iterator1 = a[getSymbolIterator()]();
+  const iterator2 = b[getSymbolIterator()]();
+
+  while (true) {
+    const item1 = iterator1.next();
+    const item2 = iterator2.next();
+    if (item1.done && item2.done) return true;
+    if (item1.done || item2.done) return false;
+    if (!comparator(item1.value, item2.value)) return false;
+  }
+}
+
+export function iterateListLike(obj: any, fn: (p: any) => any) {
+  if (Array.isArray(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      fn(obj[i]);
+    }
+  } else {
+    const iterator = obj[getSymbolIterator()]();
+    let item: any;
+    while (!((item = iterator.next()).done)) {
+      fn(item.value);
+    }
+  }
+}
+
+export function isJsObject(o: any): boolean {
+  return o !== null && (typeof o === 'function' || typeof o === 'object');
+}
diff --git a/angular/core/src/change_detection/change_detector_ref.ts b/angular/core/src/change_detection/change_detector_ref.ts
new file mode 100644
index 0000000..a5dcd55
--- /dev/null
+++ b/angular/core/src/change_detection/change_detector_ref.ts
@@ -0,0 +1,194 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @stable
+ */
+export abstract class ChangeDetectorRef {
+  /**
+   * Marks all {@link ChangeDetectionStrategy#OnPush} ancestors as to be checked.
+   *
+   * <!-- TODO: Add a link to a chapter on OnPush components -->
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/GC512b?p=preview))
+   *
+   * ```typescript
+   * @Component({
+   *   selector: 'cmp',
+   *   changeDetection: ChangeDetectionStrategy.OnPush,
+   *   template: `Number of ticks: {{numberOfTicks}}`
+   * })
+   * class Cmp {
+   *   numberOfTicks = 0;
+   *
+   *   constructor(private ref: ChangeDetectorRef) {
+   *     setInterval(() => {
+   *       this.numberOfTicks++;
+   *       // the following is required, otherwise the view will not be updated
+   *       this.ref.markForCheck();
+   *     }, 1000);
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'app',
+   *   changeDetection: ChangeDetectionStrategy.OnPush,
+   *   template: `
+   *     <cmp><cmp>
+   *   `,
+   * })
+   * class App {
+   * }
+   * ```
+   */
+  abstract markForCheck(): void;
+
+  /**
+   * Detaches the change detector from the change detector tree.
+   *
+   * The detached change detector will not be checked until it is reattached.
+   *
+   * This can also be used in combination with {@link ChangeDetectorRef#detectChanges} to implement
+   * local change
+   * detection checks.
+   *
+   * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
+   * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
+   *
+   * ### Example
+   *
+   * The following example defines a component with a large list of readonly data.
+   * Imagine the data changes constantly, many times per second. For performance reasons,
+   * we want to check and update the list every five seconds. We can do that by detaching
+   * the component's change detector and doing a local check every five seconds.
+   *
+   * ```typescript
+   * class DataProvider {
+   *   // in a real application the returned data will be different every time
+   *   get data() {
+   *     return [1,2,3,4,5];
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'giant-list',
+   *   template: `
+   *     <li *ngFor="let d of dataProvider.data">Data {{d}}</li>
+   *   `,
+   * })
+   * class GiantList {
+   *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {
+   *     ref.detach();
+   *     setInterval(() => {
+   *       this.ref.detectChanges();
+   *     }, 5000);
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'app',
+   *   providers: [DataProvider],
+   *   template: `
+   *     <giant-list><giant-list>
+   *   `,
+   * })
+   * class App {
+   * }
+   * ```
+   */
+  abstract detach(): void;
+
+  /**
+   * Checks the change detector and its children.
+   *
+   * This can also be used in combination with {@link ChangeDetectorRef#detach} to implement local
+   * change detection
+   * checks.
+   *
+   * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
+   * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
+   *
+   * ### Example
+   *
+   * The following example defines a component with a large list of readonly data.
+   * Imagine, the data changes constantly, many times per second. For performance reasons,
+   * we want to check and update the list every five seconds.
+   *
+   * We can do that by detaching the component's change detector and doing a local change detection
+   * check
+   * every five seconds.
+   *
+   * See {@link ChangeDetectorRef#detach} for more information.
+   */
+  abstract detectChanges(): void;
+
+  /**
+   * Checks the change detector and its children, and throws if any changes are detected.
+   *
+   * This is used in development mode to verify that running change detection doesn't introduce
+   * other changes.
+   */
+  abstract checkNoChanges(): void;
+
+  /**
+   * Reattach the change detector to the change detector tree.
+   *
+   * This also marks OnPush ancestors as to be checked. This reattached change detector will be
+   * checked during the next change detection run.
+   *
+   * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/aUhZha?p=preview))
+   *
+   * The following example creates a component displaying `live` data. The component will detach
+   * its change detector from the main change detector tree when the component's live property
+   * is set to false.
+   *
+   * ```typescript
+   * class DataProvider {
+   *   data = 1;
+   *
+   *   constructor() {
+   *     setInterval(() => {
+   *       this.data = this.data * 2;
+   *     }, 500);
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'live-data',
+   *   inputs: ['live'],
+   *   template: 'Data: {{dataProvider.data}}'
+   * })
+   * class LiveData {
+   *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}
+   *
+   *   set live(value) {
+   *     if (value) {
+   *       this.ref.reattach();
+   *     } else {
+   *       this.ref.detach();
+   *     }
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'app',
+   *   providers: [DataProvider],
+   *   template: `
+   *     Live Update: <input type="checkbox" [(ngModel)]="live">
+   *     <live-data [live]="live"><live-data>
+   *   `,
+   * })
+   * class App {
+   *   live = true;
+   * }
+   * ```
+   */
+  abstract reattach(): void;
+}
diff --git a/angular/core/src/change_detection/constants.ts b/angular/core/src/change_detection/constants.ts
new file mode 100644
index 0000000..2112948
--- /dev/null
+++ b/angular/core/src/change_detection/constants.ts
@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+/**
+ * Describes within the change detector which strategy will be used the next time change
+ * detection is triggered.
+ * @stable
+ */
+export enum ChangeDetectionStrategy {
+  /**
+   * `OnPush` means that the change detector's mode will be set to `CheckOnce` during hydration.
+   */
+  OnPush = 0,
+
+  /**
+   * `Default` means that the change detector's mode will be set to `CheckAlways` during hydration.
+   */
+  Default = 1,
+}
+
+/**
+ * Describes the status of the detector.
+ */
+export enum ChangeDetectorStatus {
+  /**
+   * `CheckOnce` means that after calling detectChanges the mode of the change detector
+   * will become `Checked`.
+   */
+  CheckOnce,
+
+  /**
+   * `Checked` means that the change detector should be skipped until its mode changes to
+   * `CheckOnce`.
+   */
+  Checked,
+
+  /**
+   * `CheckAlways` means that after calling detectChanges the mode of the change detector
+   * will remain `CheckAlways`.
+   */
+  CheckAlways,
+
+  /**
+   * `Detached` means that the change detector sub tree is not a part of the main tree and
+   * should be skipped.
+   */
+  Detached,
+
+  /**
+   * `Errored` means that the change detector encountered an error checking a binding
+   * or calling a directive lifecycle method and is now in an inconsistent state. Change
+   * detectors in this state will no longer detect changes.
+   */
+  Errored,
+
+  /**
+   * `Destroyed` means that the change detector is destroyed.
+   */
+  Destroyed,
+}
+
+export function isDefaultChangeDetectionStrategy(changeDetectionStrategy: ChangeDetectionStrategy):
+    boolean {
+  return changeDetectionStrategy == null ||
+      changeDetectionStrategy === ChangeDetectionStrategy.Default;
+}
diff --git a/angular/core/src/change_detection/differs/default_iterable_differ.ts b/angular/core/src/change_detection/differs/default_iterable_differ.ts
new file mode 100644
index 0000000..1c083a8
--- /dev/null
+++ b/angular/core/src/change_detection/differs/default_iterable_differ.ts
@@ -0,0 +1,732 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {looseIdentical, stringify} from '../../util';
+import {isListLikeIterable, iterateListLike} from '../change_detection_util';
+import {ChangeDetectorRef} from '../change_detector_ref';
+
+import {IterableChangeRecord, IterableChanges, IterableDiffer, IterableDifferFactory, NgIterable, TrackByFunction} from './iterable_differs';
+
+
+export class DefaultIterableDifferFactory implements IterableDifferFactory {
+  constructor() {}
+  supports(obj: Object|null|undefined): boolean { return isListLikeIterable(obj); }
+
+  create<V>(trackByFn?: TrackByFunction<V>): DefaultIterableDiffer<V>;
+
+  /**
+   * @deprecated v4.0.0 - ChangeDetectorRef is not used and is no longer a parameter
+   */
+  create<V>(cdRefOrTrackBy?: ChangeDetectorRef|TrackByFunction<V>, trackByFn?: TrackByFunction<V>):
+      DefaultIterableDiffer<V> {
+    return new DefaultIterableDiffer<V>(trackByFn || <TrackByFunction<any>>cdRefOrTrackBy);
+  }
+}
+
+const trackByIdentity = (index: number, item: any) => item;
+
+/**
+ * @deprecated v4.0.0 - Should not be part of public API.
+ */
+export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChanges<V> {
+  private _length: number = 0;
+  private _collection: NgIterable<V>|null = null;
+  // Keeps track of the used records at any point in time (during & across `_check()` calls)
+  private _linkedRecords: _DuplicateMap<V>|null = null;
+  // Keeps track of the removed records at any point in time during `_check()` calls.
+  private _unlinkedRecords: _DuplicateMap<V>|null = null;
+  private _previousItHead: IterableChangeRecord_<V>|null = null;
+  private _itHead: IterableChangeRecord_<V>|null = null;
+  private _itTail: IterableChangeRecord_<V>|null = null;
+  private _additionsHead: IterableChangeRecord_<V>|null = null;
+  private _additionsTail: IterableChangeRecord_<V>|null = null;
+  private _movesHead: IterableChangeRecord_<V>|null = null;
+  private _movesTail: IterableChangeRecord_<V>|null = null;
+  private _removalsHead: IterableChangeRecord_<V>|null = null;
+  private _removalsTail: IterableChangeRecord_<V>|null = null;
+  // Keeps track of records where custom track by is the same, but item identity has changed
+  private _identityChangesHead: IterableChangeRecord_<V>|null = null;
+  private _identityChangesTail: IterableChangeRecord_<V>|null = null;
+  private _trackByFn: TrackByFunction<V>;
+
+  constructor(trackByFn?: TrackByFunction<V>) { this._trackByFn = trackByFn || trackByIdentity; }
+
+  get collection() { return this._collection; }
+
+  get length(): number { return this._length; }
+
+  forEachItem(fn: (record: IterableChangeRecord_<V>) => void) {
+    let record: IterableChangeRecord_<V>|null;
+    for (record = this._itHead; record !== null; record = record._next) {
+      fn(record);
+    }
+  }
+
+  forEachOperation(
+      fn: (item: IterableChangeRecord<V>, previousIndex: number|null, currentIndex: number|null) =>
+          void) {
+    let nextIt = this._itHead;
+    let nextRemove = this._removalsHead;
+    let addRemoveOffset = 0;
+    let moveOffsets: number[]|null = null;
+    while (nextIt || nextRemove) {
+      // Figure out which is the next record to process
+      // Order: remove, add, move
+      const record: IterableChangeRecord<V> = !nextRemove ||
+              nextIt &&
+                  nextIt.currentIndex ! <
+                      getPreviousIndex(nextRemove, addRemoveOffset, moveOffsets) ?
+          nextIt ! :
+          nextRemove;
+      const adjPreviousIndex = getPreviousIndex(record, addRemoveOffset, moveOffsets);
+      const currentIndex = record.currentIndex;
+
+      // consume the item, and adjust the addRemoveOffset and update moveDistance if necessary
+      if (record === nextRemove) {
+        addRemoveOffset--;
+        nextRemove = nextRemove._nextRemoved;
+      } else {
+        nextIt = nextIt !._next;
+        if (record.previousIndex == null) {
+          addRemoveOffset++;
+        } else {
+          // INVARIANT:  currentIndex < previousIndex
+          if (!moveOffsets) moveOffsets = [];
+          const localMovePreviousIndex = adjPreviousIndex - addRemoveOffset;
+          const localCurrentIndex = currentIndex ! - addRemoveOffset;
+          if (localMovePreviousIndex != localCurrentIndex) {
+            for (let i = 0; i < localMovePreviousIndex; i++) {
+              const offset = i < moveOffsets.length ? moveOffsets[i] : (moveOffsets[i] = 0);
+              const index = offset + i;
+              if (localCurrentIndex <= index && index < localMovePreviousIndex) {
+                moveOffsets[i] = offset + 1;
+              }
+            }
+            const previousIndex = record.previousIndex;
+            moveOffsets[previousIndex] = localCurrentIndex - localMovePreviousIndex;
+          }
+        }
+      }
+
+      if (adjPreviousIndex !== currentIndex) {
+        fn(record, adjPreviousIndex, currentIndex);
+      }
+    }
+  }
+
+  forEachPreviousItem(fn: (record: IterableChangeRecord_<V>) => void) {
+    let record: IterableChangeRecord_<V>|null;
+    for (record = this._previousItHead; record !== null; record = record._nextPrevious) {
+      fn(record);
+    }
+  }
+
+  forEachAddedItem(fn: (record: IterableChangeRecord_<V>) => void) {
+    let record: IterableChangeRecord_<V>|null;
+    for (record = this._additionsHead; record !== null; record = record._nextAdded) {
+      fn(record);
+    }
+  }
+
+  forEachMovedItem(fn: (record: IterableChangeRecord_<V>) => void) {
+    let record: IterableChangeRecord_<V>|null;
+    for (record = this._movesHead; record !== null; record = record._nextMoved) {
+      fn(record);
+    }
+  }
+
+  forEachRemovedItem(fn: (record: IterableChangeRecord_<V>) => void) {
+    let record: IterableChangeRecord_<V>|null;
+    for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
+      fn(record);
+    }
+  }
+
+  forEachIdentityChange(fn: (record: IterableChangeRecord_<V>) => void) {
+    let record: IterableChangeRecord_<V>|null;
+    for (record = this._identityChangesHead; record !== null; record = record._nextIdentityChange) {
+      fn(record);
+    }
+  }
+
+  diff(collection: NgIterable<V>): DefaultIterableDiffer<V>|null {
+    if (collection == null) collection = [];
+    if (!isListLikeIterable(collection)) {
+      throw new Error(
+          `Error trying to diff '${stringify(collection)}'. Only arrays and iterables are allowed`);
+    }
+
+    if (this.check(collection)) {
+      return this;
+    } else {
+      return null;
+    }
+  }
+
+  onDestroy() {}
+
+  check(collection: NgIterable<V>): boolean {
+    this._reset();
+
+    let record: IterableChangeRecord_<V>|null = this._itHead;
+    let mayBeDirty: boolean = false;
+    let index: number;
+    let item: V;
+    let itemTrackBy: any;
+    if (Array.isArray(collection)) {
+      this._length = collection.length;
+
+      for (let index = 0; index < this._length; index++) {
+        item = collection[index];
+        itemTrackBy = this._trackByFn(index, item);
+        if (record === null || !looseIdentical(record.trackById, itemTrackBy)) {
+          record = this._mismatch(record, item, itemTrackBy, index);
+          mayBeDirty = true;
+        } else {
+          if (mayBeDirty) {
+            // TODO(misko): can we limit this to duplicates only?
+            record = this._verifyReinsertion(record, item, itemTrackBy, index);
+          }
+          if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);
+        }
+
+        record = record._next;
+      }
+    } else {
+      index = 0;
+      iterateListLike(collection, (item: V) => {
+        itemTrackBy = this._trackByFn(index, item);
+        if (record === null || !looseIdentical(record.trackById, itemTrackBy)) {
+          record = this._mismatch(record, item, itemTrackBy, index);
+          mayBeDirty = true;
+        } else {
+          if (mayBeDirty) {
+            // TODO(misko): can we limit this to duplicates only?
+            record = this._verifyReinsertion(record, item, itemTrackBy, index);
+          }
+          if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);
+        }
+        record = record._next;
+        index++;
+      });
+      this._length = index;
+    }
+
+    this._truncate(record);
+    this._collection = collection;
+    return this.isDirty;
+  }
+
+  /* CollectionChanges is considered dirty if it has any additions, moves, removals, or identity
+   * changes.
+   */
+  get isDirty(): boolean {
+    return this._additionsHead !== null || this._movesHead !== null ||
+        this._removalsHead !== null || this._identityChangesHead !== null;
+  }
+
+  /**
+   * Reset the state of the change objects to show no changes. This means set previousKey to
+   * currentKey, and clear all of the queues (additions, moves, removals).
+   * Set the previousIndexes of moved and added items to their currentIndexes
+   * Reset the list of additions, moves and removals
+   *
+   * @internal
+   */
+  _reset() {
+    if (this.isDirty) {
+      let record: IterableChangeRecord_<V>|null;
+      let nextRecord: IterableChangeRecord_<V>|null;
+
+      for (record = this._previousItHead = this._itHead; record !== null; record = record._next) {
+        record._nextPrevious = record._next;
+      }
+
+      for (record = this._additionsHead; record !== null; record = record._nextAdded) {
+        record.previousIndex = record.currentIndex;
+      }
+      this._additionsHead = this._additionsTail = null;
+
+      for (record = this._movesHead; record !== null; record = nextRecord) {
+        record.previousIndex = record.currentIndex;
+        nextRecord = record._nextMoved;
+      }
+      this._movesHead = this._movesTail = null;
+      this._removalsHead = this._removalsTail = null;
+      this._identityChangesHead = this._identityChangesTail = null;
+
+      // todo(vicb) when assert gets supported
+      // assert(!this.isDirty);
+    }
+  }
+
+  /**
+   * This is the core function which handles differences between collections.
+   *
+   * - `record` is the record which we saw at this position last time. If null then it is a new
+   *   item.
+   * - `item` is the current item in the collection
+   * - `index` is the position of the item in the collection
+   *
+   * @internal
+   */
+  _mismatch(record: IterableChangeRecord_<V>|null, item: V, itemTrackBy: any, index: number):
+      IterableChangeRecord_<V> {
+    // The previous record after which we will append the current one.
+    let previousRecord: IterableChangeRecord_<V>|null;
+
+    if (record === null) {
+      previousRecord = this._itTail;
+    } else {
+      previousRecord = record._prev;
+      // Remove the record from the collection since we know it does not match the item.
+      this._remove(record);
+    }
+
+    // Attempt to see if we have seen the item before.
+    record = this._linkedRecords === null ? null : this._linkedRecords.get(itemTrackBy, index);
+    if (record !== null) {
+      // We have seen this before, we need to move it forward in the collection.
+      // But first we need to check if identity changed, so we can update in view if necessary
+      if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);
+
+      this._moveAfter(record, previousRecord, index);
+    } else {
+      // Never seen it, check evicted list.
+      record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);
+      if (record !== null) {
+        // It is an item which we have evicted earlier: reinsert it back into the list.
+        // But first we need to check if identity changed, so we can update in view if necessary
+        if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);
+
+        this._reinsertAfter(record, previousRecord, index);
+      } else {
+        // It is a new item: add it.
+        record =
+            this._addAfter(new IterableChangeRecord_<V>(item, itemTrackBy), previousRecord, index);
+      }
+    }
+    return record;
+  }
+
+  /**
+   * This check is only needed if an array contains duplicates. (Short circuit of nothing dirty)
+   *
+   * Use case: `[a, a]` => `[b, a, a]`
+   *
+   * If we did not have this check then the insertion of `b` would:
+   *   1) evict first `a`
+   *   2) insert `b` at `0` index.
+   *   3) leave `a` at index `1` as is. <-- this is wrong!
+   *   3) reinsert `a` at index 2. <-- this is wrong!
+   *
+   * The correct behavior is:
+   *   1) evict first `a`
+   *   2) insert `b` at `0` index.
+   *   3) reinsert `a` at index 1.
+   *   3) move `a` at from `1` to `2`.
+   *
+   *
+   * Double check that we have not evicted a duplicate item. We need to check if the item type may
+   * have already been removed:
+   * The insertion of b will evict the first 'a'. If we don't reinsert it now it will be reinserted
+   * at the end. Which will show up as the two 'a's switching position. This is incorrect, since a
+   * better way to think of it is as insert of 'b' rather then switch 'a' with 'b' and then add 'a'
+   * at the end.
+   *
+   * @internal
+   */
+  _verifyReinsertion(record: IterableChangeRecord_<V>, item: V, itemTrackBy: any, index: number):
+      IterableChangeRecord_<V> {
+    let reinsertRecord: IterableChangeRecord_<V>|null =
+        this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);
+    if (reinsertRecord !== null) {
+      record = this._reinsertAfter(reinsertRecord, record._prev !, index);
+    } else if (record.currentIndex != index) {
+      record.currentIndex = index;
+      this._addToMoves(record, index);
+    }
+    return record;
+  }
+
+  /**
+   * Get rid of any excess {@link IterableChangeRecord_}s from the previous collection
+   *
+   * - `record` The first excess {@link IterableChangeRecord_}.
+   *
+   * @internal
+   */
+  _truncate(record: IterableChangeRecord_<V>|null) {
+    // Anything after that needs to be removed;
+    while (record !== null) {
+      const nextRecord: IterableChangeRecord_<V>|null = record._next;
+      this._addToRemovals(this._unlink(record));
+      record = nextRecord;
+    }
+    if (this._unlinkedRecords !== null) {
+      this._unlinkedRecords.clear();
+    }
+
+    if (this._additionsTail !== null) {
+      this._additionsTail._nextAdded = null;
+    }
+    if (this._movesTail !== null) {
+      this._movesTail._nextMoved = null;
+    }
+    if (this._itTail !== null) {
+      this._itTail._next = null;
+    }
+    if (this._removalsTail !== null) {
+      this._removalsTail._nextRemoved = null;
+    }
+    if (this._identityChangesTail !== null) {
+      this._identityChangesTail._nextIdentityChange = null;
+    }
+  }
+
+  /** @internal */
+  _reinsertAfter(
+      record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>|null,
+      index: number): IterableChangeRecord_<V> {
+    if (this._unlinkedRecords !== null) {
+      this._unlinkedRecords.remove(record);
+    }
+    const prev = record._prevRemoved;
+    const next = record._nextRemoved;
+
+    if (prev === null) {
+      this._removalsHead = next;
+    } else {
+      prev._nextRemoved = next;
+    }
+    if (next === null) {
+      this._removalsTail = prev;
+    } else {
+      next._prevRemoved = prev;
+    }
+
+    this._insertAfter(record, prevRecord, index);
+    this._addToMoves(record, index);
+    return record;
+  }
+
+  /** @internal */
+  _moveAfter(
+      record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>|null,
+      index: number): IterableChangeRecord_<V> {
+    this._unlink(record);
+    this._insertAfter(record, prevRecord, index);
+    this._addToMoves(record, index);
+    return record;
+  }
+
+  /** @internal */
+  _addAfter(
+      record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>|null,
+      index: number): IterableChangeRecord_<V> {
+    this._insertAfter(record, prevRecord, index);
+
+    if (this._additionsTail === null) {
+      // todo(vicb)
+      // assert(this._additionsHead === null);
+      this._additionsTail = this._additionsHead = record;
+    } else {
+      // todo(vicb)
+      // assert(_additionsTail._nextAdded === null);
+      // assert(record._nextAdded === null);
+      this._additionsTail = this._additionsTail._nextAdded = record;
+    }
+    return record;
+  }
+
+  /** @internal */
+  _insertAfter(
+      record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>|null,
+      index: number): IterableChangeRecord_<V> {
+    // todo(vicb)
+    // assert(record != prevRecord);
+    // assert(record._next === null);
+    // assert(record._prev === null);
+
+    const next: IterableChangeRecord_<V>|null =
+        prevRecord === null ? this._itHead : prevRecord._next;
+    // todo(vicb)
+    // assert(next != record);
+    // assert(prevRecord != record);
+    record._next = next;
+    record._prev = prevRecord;
+    if (next === null) {
+      this._itTail = record;
+    } else {
+      next._prev = record;
+    }
+    if (prevRecord === null) {
+      this._itHead = record;
+    } else {
+      prevRecord._next = record;
+    }
+
+    if (this._linkedRecords === null) {
+      this._linkedRecords = new _DuplicateMap<V>();
+    }
+    this._linkedRecords.put(record);
+
+    record.currentIndex = index;
+    return record;
+  }
+
+  /** @internal */
+  _remove(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {
+    return this._addToRemovals(this._unlink(record));
+  }
+
+  /** @internal */
+  _unlink(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {
+    if (this._linkedRecords !== null) {
+      this._linkedRecords.remove(record);
+    }
+
+    const prev = record._prev;
+    const next = record._next;
+
+    // todo(vicb)
+    // assert((record._prev = null) === null);
+    // assert((record._next = null) === null);
+
+    if (prev === null) {
+      this._itHead = next;
+    } else {
+      prev._next = next;
+    }
+    if (next === null) {
+      this._itTail = prev;
+    } else {
+      next._prev = prev;
+    }
+
+    return record;
+  }
+
+  /** @internal */
+  _addToMoves(record: IterableChangeRecord_<V>, toIndex: number): IterableChangeRecord_<V> {
+    // todo(vicb)
+    // assert(record._nextMoved === null);
+
+    if (record.previousIndex === toIndex) {
+      return record;
+    }
+
+    if (this._movesTail === null) {
+      // todo(vicb)
+      // assert(_movesHead === null);
+      this._movesTail = this._movesHead = record;
+    } else {
+      // todo(vicb)
+      // assert(_movesTail._nextMoved === null);
+      this._movesTail = this._movesTail._nextMoved = record;
+    }
+
+    return record;
+  }
+
+  private _addToRemovals(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {
+    if (this._unlinkedRecords === null) {
+      this._unlinkedRecords = new _DuplicateMap<V>();
+    }
+    this._unlinkedRecords.put(record);
+    record.currentIndex = null;
+    record._nextRemoved = null;
+
+    if (this._removalsTail === null) {
+      // todo(vicb)
+      // assert(_removalsHead === null);
+      this._removalsTail = this._removalsHead = record;
+      record._prevRemoved = null;
+    } else {
+      // todo(vicb)
+      // assert(_removalsTail._nextRemoved === null);
+      // assert(record._nextRemoved === null);
+      record._prevRemoved = this._removalsTail;
+      this._removalsTail = this._removalsTail._nextRemoved = record;
+    }
+    return record;
+  }
+
+  /** @internal */
+  _addIdentityChange(record: IterableChangeRecord_<V>, item: V) {
+    record.item = item;
+    if (this._identityChangesTail === null) {
+      this._identityChangesTail = this._identityChangesHead = record;
+    } else {
+      this._identityChangesTail = this._identityChangesTail._nextIdentityChange = record;
+    }
+    return record;
+  }
+}
+
+/**
+ * @stable
+ */
+export class IterableChangeRecord_<V> implements IterableChangeRecord<V> {
+  currentIndex: number|null = null;
+  previousIndex: number|null = null;
+
+  /** @internal */
+  _nextPrevious: IterableChangeRecord_<V>|null = null;
+  /** @internal */
+  _prev: IterableChangeRecord_<V>|null = null;
+  /** @internal */
+  _next: IterableChangeRecord_<V>|null = null;
+  /** @internal */
+  _prevDup: IterableChangeRecord_<V>|null = null;
+  /** @internal */
+  _nextDup: IterableChangeRecord_<V>|null = null;
+  /** @internal */
+  _prevRemoved: IterableChangeRecord_<V>|null = null;
+  /** @internal */
+  _nextRemoved: IterableChangeRecord_<V>|null = null;
+  /** @internal */
+  _nextAdded: IterableChangeRecord_<V>|null = null;
+  /** @internal */
+  _nextMoved: IterableChangeRecord_<V>|null = null;
+  /** @internal */
+  _nextIdentityChange: IterableChangeRecord_<V>|null = null;
+
+
+  constructor(public item: V, public trackById: any) {}
+}
+
+// A linked list of CollectionChangeRecords with the same IterableChangeRecord_.item
+class _DuplicateItemRecordList<V> {
+  /** @internal */
+  _head: IterableChangeRecord_<V>|null = null;
+  /** @internal */
+  _tail: IterableChangeRecord_<V>|null = null;
+
+  /**
+   * Append the record to the list of duplicates.
+   *
+   * Note: by design all records in the list of duplicates hold the same value in record.item.
+   */
+  add(record: IterableChangeRecord_<V>): void {
+    if (this._head === null) {
+      this._head = this._tail = record;
+      record._nextDup = null;
+      record._prevDup = null;
+    } else {
+      // todo(vicb)
+      // assert(record.item ==  _head.item ||
+      //       record.item is num && record.item.isNaN && _head.item is num && _head.item.isNaN);
+      this._tail !._nextDup = record;
+      record._prevDup = this._tail;
+      record._nextDup = null;
+      this._tail = record;
+    }
+  }
+
+  // Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and
+  // IterableChangeRecord_.currentIndex >= atOrAfterIndex
+  get(trackById: any, atOrAfterIndex: number|null): IterableChangeRecord_<V>|null {
+    let record: IterableChangeRecord_<V>|null;
+    for (record = this._head; record !== null; record = record._nextDup) {
+      if ((atOrAfterIndex === null || atOrAfterIndex <= record.currentIndex !) &&
+          looseIdentical(record.trackById, trackById)) {
+        return record;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Remove one {@link IterableChangeRecord_} from the list of duplicates.
+   *
+   * Returns whether the list of duplicates is empty.
+   */
+  remove(record: IterableChangeRecord_<V>): boolean {
+    // todo(vicb)
+    // assert(() {
+    //  // verify that the record being removed is in the list.
+    //  for (IterableChangeRecord_ cursor = _head; cursor != null; cursor = cursor._nextDup) {
+    //    if (identical(cursor, record)) return true;
+    //  }
+    //  return false;
+    //});
+
+    const prev: IterableChangeRecord_<V>|null = record._prevDup;
+    const next: IterableChangeRecord_<V>|null = record._nextDup;
+    if (prev === null) {
+      this._head = next;
+    } else {
+      prev._nextDup = next;
+    }
+    if (next === null) {
+      this._tail = prev;
+    } else {
+      next._prevDup = prev;
+    }
+    return this._head === null;
+  }
+}
+
+class _DuplicateMap<V> {
+  map = new Map<any, _DuplicateItemRecordList<V>>();
+
+  put(record: IterableChangeRecord_<V>) {
+    const key = record.trackById;
+
+    let duplicates = this.map.get(key);
+    if (!duplicates) {
+      duplicates = new _DuplicateItemRecordList<V>();
+      this.map.set(key, duplicates);
+    }
+    duplicates.add(record);
+  }
+
+  /**
+   * Retrieve the `value` using key. Because the IterableChangeRecord_ value may be one which we
+   * have already iterated over, we use the `atOrAfterIndex` to pretend it is not there.
+   *
+   * Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we
+   * have any more `a`s needs to return the second `a`.
+   */
+  get(trackById: any, atOrAfterIndex: number|null): IterableChangeRecord_<V>|null {
+    const key = trackById;
+    const recordList = this.map.get(key);
+    return recordList ? recordList.get(trackById, atOrAfterIndex) : null;
+  }
+
+  /**
+   * Removes a {@link IterableChangeRecord_} from the list of duplicates.
+   *
+   * The list of duplicates also is removed from the map if it gets empty.
+   */
+  remove(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {
+    const key = record.trackById;
+    const recordList: _DuplicateItemRecordList<V> = this.map.get(key) !;
+    // Remove the list of duplicates when it gets empty
+    if (recordList.remove(record)) {
+      this.map.delete(key);
+    }
+    return record;
+  }
+
+  get isEmpty(): boolean { return this.map.size === 0; }
+
+  clear() { this.map.clear(); }
+}
+
+function getPreviousIndex(
+    item: any, addRemoveOffset: number, moveOffsets: number[] | null): number {
+  const previousIndex = item.previousIndex;
+  if (previousIndex === null) return previousIndex;
+  let moveOffset = 0;
+  if (moveOffsets && previousIndex < moveOffsets.length) {
+    moveOffset = moveOffsets[previousIndex];
+  }
+  return previousIndex + addRemoveOffset + moveOffset;
+}
diff --git a/angular/core/src/change_detection/differs/default_keyvalue_differ.ts b/angular/core/src/change_detection/differs/default_keyvalue_differ.ts
new file mode 100644
index 0000000..c2f3e63
--- /dev/null
+++ b/angular/core/src/change_detection/differs/default_keyvalue_differ.ts
@@ -0,0 +1,292 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {looseIdentical, stringify} from '../../util';
+import {isJsObject} from '../change_detection_util';
+import {ChangeDetectorRef} from '../change_detector_ref';
+import {KeyValueChangeRecord, KeyValueChanges, KeyValueDiffer, KeyValueDifferFactory} from './keyvalue_differs';
+
+
+export class DefaultKeyValueDifferFactory<K, V> implements KeyValueDifferFactory {
+  constructor() {}
+  supports(obj: any): boolean { return obj instanceof Map || isJsObject(obj); }
+
+  create<K, V>(): DefaultKeyValueDiffer<K, V>;
+
+  /**
+   * @deprecated v4.0.0 - ChangeDetectorRef is not used and is no longer a parameter
+   */
+  create<K, V>(cd?: ChangeDetectorRef): KeyValueDiffer<K, V> {
+    return new DefaultKeyValueDiffer<K, V>();
+  }
+}
+
+export class DefaultKeyValueDiffer<K, V> implements KeyValueDiffer<K, V>, KeyValueChanges<K, V> {
+  private _records = new Map<K, KeyValueChangeRecord_<K, V>>();
+  private _mapHead: KeyValueChangeRecord_<K, V>|null = null;
+  // _appendAfter is used in the check loop
+  private _appendAfter: KeyValueChangeRecord_<K, V>|null = null;
+  private _previousMapHead: KeyValueChangeRecord_<K, V>|null = null;
+  private _changesHead: KeyValueChangeRecord_<K, V>|null = null;
+  private _changesTail: KeyValueChangeRecord_<K, V>|null = null;
+  private _additionsHead: KeyValueChangeRecord_<K, V>|null = null;
+  private _additionsTail: KeyValueChangeRecord_<K, V>|null = null;
+  private _removalsHead: KeyValueChangeRecord_<K, V>|null = null;
+  private _removalsTail: KeyValueChangeRecord_<K, V>|null = null;
+
+  get isDirty(): boolean {
+    return this._additionsHead !== null || this._changesHead !== null ||
+        this._removalsHead !== null;
+  }
+
+  forEachItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {
+    let record: KeyValueChangeRecord_<K, V>|null;
+    for (record = this._mapHead; record !== null; record = record._next) {
+      fn(record);
+    }
+  }
+
+  forEachPreviousItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {
+    let record: KeyValueChangeRecord_<K, V>|null;
+    for (record = this._previousMapHead; record !== null; record = record._nextPrevious) {
+      fn(record);
+    }
+  }
+
+  forEachChangedItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {
+    let record: KeyValueChangeRecord_<K, V>|null;
+    for (record = this._changesHead; record !== null; record = record._nextChanged) {
+      fn(record);
+    }
+  }
+
+  forEachAddedItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {
+    let record: KeyValueChangeRecord_<K, V>|null;
+    for (record = this._additionsHead; record !== null; record = record._nextAdded) {
+      fn(record);
+    }
+  }
+
+  forEachRemovedItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {
+    let record: KeyValueChangeRecord_<K, V>|null;
+    for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
+      fn(record);
+    }
+  }
+
+  diff(map?: Map<any, any>|{[k: string]: any}|null): any {
+    if (!map) {
+      map = new Map();
+    } else if (!(map instanceof Map || isJsObject(map))) {
+      throw new Error(
+          `Error trying to diff '${stringify(map)}'. Only maps and objects are allowed`);
+    }
+
+    return this.check(map) ? this : null;
+  }
+
+  onDestroy() {}
+
+  /**
+   * Check the current state of the map vs the previous.
+   * The algorithm is optimised for when the keys do no change.
+   */
+  check(map: Map<any, any>|{[k: string]: any}): boolean {
+    this._reset();
+
+    let insertBefore = this._mapHead;
+    this._appendAfter = null;
+
+    this._forEach(map, (value: any, key: any) => {
+      if (insertBefore && insertBefore.key === key) {
+        this._maybeAddToChanges(insertBefore, value);
+        this._appendAfter = insertBefore;
+        insertBefore = insertBefore._next;
+      } else {
+        const record = this._getOrCreateRecordForKey(key, value);
+        insertBefore = this._insertBeforeOrAppend(insertBefore, record);
+      }
+    });
+
+    // Items remaining at the end of the list have been deleted
+    if (insertBefore) {
+      if (insertBefore._prev) {
+        insertBefore._prev._next = null;
+      }
+
+      this._removalsHead = insertBefore;
+
+      for (let record: KeyValueChangeRecord_<K, V>|null = insertBefore; record !== null;
+           record = record._nextRemoved) {
+        if (record === this._mapHead) {
+          this._mapHead = null;
+        }
+        this._records.delete(record.key);
+        record._nextRemoved = record._next;
+        record.previousValue = record.currentValue;
+        record.currentValue = null;
+        record._prev = null;
+        record._next = null;
+      }
+    }
+
+    // Make sure tails have no next records from previous runs
+    if (this._changesTail) this._changesTail._nextChanged = null;
+    if (this._additionsTail) this._additionsTail._nextAdded = null;
+
+    return this.isDirty;
+  }
+
+  /**
+   * Inserts a record before `before` or append at the end of the list when `before` is null.
+   *
+   * Notes:
+   * - This method appends at `this._appendAfter`,
+   * - This method updates `this._appendAfter`,
+   * - The return value is the new value for the insertion pointer.
+   */
+  private _insertBeforeOrAppend(
+      before: KeyValueChangeRecord_<K, V>|null,
+      record: KeyValueChangeRecord_<K, V>): KeyValueChangeRecord_<K, V>|null {
+    if (before) {
+      const prev = before._prev;
+      record._next = before;
+      record._prev = prev;
+      before._prev = record;
+      if (prev) {
+        prev._next = record;
+      }
+      if (before === this._mapHead) {
+        this._mapHead = record;
+      }
+
+      this._appendAfter = before;
+      return before;
+    }
+
+    if (this._appendAfter) {
+      this._appendAfter._next = record;
+      record._prev = this._appendAfter;
+    } else {
+      this._mapHead = record;
+    }
+
+    this._appendAfter = record;
+    return null;
+  }
+
+  private _getOrCreateRecordForKey(key: K, value: V): KeyValueChangeRecord_<K, V> {
+    if (this._records.has(key)) {
+      const record = this._records.get(key) !;
+      this._maybeAddToChanges(record, value);
+      const prev = record._prev;
+      const next = record._next;
+      if (prev) {
+        prev._next = next;
+      }
+      if (next) {
+        next._prev = prev;
+      }
+      record._next = null;
+      record._prev = null;
+
+      return record;
+    }
+
+    const record = new KeyValueChangeRecord_<K, V>(key);
+    this._records.set(key, record);
+    record.currentValue = value;
+    this._addToAdditions(record);
+    return record;
+  }
+
+  /** @internal */
+  _reset() {
+    if (this.isDirty) {
+      let record: KeyValueChangeRecord_<K, V>|null;
+      // let `_previousMapHead` contain the state of the map before the changes
+      this._previousMapHead = this._mapHead;
+      for (record = this._previousMapHead; record !== null; record = record._next) {
+        record._nextPrevious = record._next;
+      }
+
+      // Update `record.previousValue` with the value of the item before the changes
+      // We need to update all changed items (that's those which have been added and changed)
+      for (record = this._changesHead; record !== null; record = record._nextChanged) {
+        record.previousValue = record.currentValue;
+      }
+      for (record = this._additionsHead; record != null; record = record._nextAdded) {
+        record.previousValue = record.currentValue;
+      }
+
+      this._changesHead = this._changesTail = null;
+      this._additionsHead = this._additionsTail = null;
+      this._removalsHead = null;
+    }
+  }
+
+  // Add the record or a given key to the list of changes only when the value has actually changed
+  private _maybeAddToChanges(record: KeyValueChangeRecord_<K, V>, newValue: any): void {
+    if (!looseIdentical(newValue, record.currentValue)) {
+      record.previousValue = record.currentValue;
+      record.currentValue = newValue;
+      this._addToChanges(record);
+    }
+  }
+
+  private _addToAdditions(record: KeyValueChangeRecord_<K, V>) {
+    if (this._additionsHead === null) {
+      this._additionsHead = this._additionsTail = record;
+    } else {
+      this._additionsTail !._nextAdded = record;
+      this._additionsTail = record;
+    }
+  }
+
+  private _addToChanges(record: KeyValueChangeRecord_<K, V>) {
+    if (this._changesHead === null) {
+      this._changesHead = this._changesTail = record;
+    } else {
+      this._changesTail !._nextChanged = record;
+      this._changesTail = record;
+    }
+  }
+
+  /** @internal */
+  private _forEach<K, V>(obj: Map<K, V>|{[k: string]: V}, fn: (v: V, k: any) => void) {
+    if (obj instanceof Map) {
+      obj.forEach(fn);
+    } else {
+      Object.keys(obj).forEach(k => fn(obj[k], k));
+    }
+  }
+}
+
+
+/**
+ * @stable
+ */
+class KeyValueChangeRecord_<K, V> implements KeyValueChangeRecord<K, V> {
+  previousValue: V|null = null;
+  currentValue: V|null = null;
+
+  /** @internal */
+  _nextPrevious: KeyValueChangeRecord_<K, V>|null = null;
+  /** @internal */
+  _next: KeyValueChangeRecord_<K, V>|null = null;
+  /** @internal */
+  _prev: KeyValueChangeRecord_<K, V>|null = null;
+  /** @internal */
+  _nextAdded: KeyValueChangeRecord_<K, V>|null = null;
+  /** @internal */
+  _nextRemoved: KeyValueChangeRecord_<K, V>|null = null;
+  /** @internal */
+  _nextChanged: KeyValueChangeRecord_<K, V>|null = null;
+
+  constructor(public key: K) {}
+}
diff --git a/angular/core/src/change_detection/differs/iterable_differs.ts b/angular/core/src/change_detection/differs/iterable_differs.ts
new file mode 100644
index 0000000..d1daadc
--- /dev/null
+++ b/angular/core/src/change_detection/differs/iterable_differs.ts
@@ -0,0 +1,215 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Optional, SkipSelf, StaticProvider} from '../../di';
+import {ChangeDetectorRef} from '../change_detector_ref';
+
+
+/**
+ * A type describing supported iterable types.
+ *
+ * @stable
+ */
+export type NgIterable<T> = Array<T>| Iterable<T>;
+
+/**
+ * A strategy for tracking changes over time to an iterable. Used by {@link NgFor} to
+ * respond to changes in an iterable by effecting equivalent changes in the DOM.
+ *
+ * @stable
+ */
+export interface IterableDiffer<V> {
+  /**
+   * Compute a difference between the previous state and the new `object` state.
+   *
+   * @param object containing the new value.
+   * @returns an object describing the difference. The return value is only valid until the next
+   * `diff()` invocation.
+   */
+  diff(object: NgIterable<V>): IterableChanges<V>|null;
+}
+
+/**
+ * An object describing the changes in the `Iterable` collection since last time
+ * `IterableDiffer#diff()` was invoked.
+ *
+ * @stable
+ */
+export interface IterableChanges<V> {
+  /**
+   * Iterate over all changes. `IterableChangeRecord` will contain information about changes
+   * to each item.
+   */
+  forEachItem(fn: (record: IterableChangeRecord<V>) => void): void;
+
+  /**
+   * Iterate over a set of operations which when applied to the original `Iterable` will produce the
+   * new `Iterable`.
+   *
+   * NOTE: These are not necessarily the actual operations which were applied to the original
+   * `Iterable`, rather these are a set of computed operations which may not be the same as the
+   * ones applied.
+   *
+   * @param record A change which needs to be applied
+   * @param previousIndex The `IterableChangeRecord#previousIndex` of the `record` refers to the
+   *        original `Iterable` location, where as `previousIndex` refers to the transient location
+   *        of the item, after applying the operations up to this point.
+   * @param currentIndex The `IterableChangeRecord#currentIndex` of the `record` refers to the
+   *        original `Iterable` location, where as `currentIndex` refers to the transient location
+   *        of the item, after applying the operations up to this point.
+   */
+  forEachOperation(
+      fn: (record: IterableChangeRecord<V>, previousIndex: number, currentIndex: number) => void):
+      void;
+
+  /**
+   * Iterate over changes in the order of original `Iterable` showing where the original items
+   * have moved.
+   */
+  forEachPreviousItem(fn: (record: IterableChangeRecord<V>) => void): void;
+
+  /** Iterate over all added items. */
+  forEachAddedItem(fn: (record: IterableChangeRecord<V>) => void): void;
+
+  /** Iterate over all moved items. */
+  forEachMovedItem(fn: (record: IterableChangeRecord<V>) => void): void;
+
+  /** Iterate over all removed items. */
+  forEachRemovedItem(fn: (record: IterableChangeRecord<V>) => void): void;
+
+  /** Iterate over all items which had their identity (as computed by the `trackByFn`) changed. */
+  forEachIdentityChange(fn: (record: IterableChangeRecord<V>) => void): void;
+}
+
+/**
+ * Record representing the item change information.
+ *
+ * @stable
+ */
+export interface IterableChangeRecord<V> {
+  /** Current index of the item in `Iterable` or null if removed. */
+  readonly currentIndex: number|null;
+
+  /** Previous index of the item in `Iterable` or null if added. */
+  readonly previousIndex: number|null;
+
+  /** The item. */
+  readonly item: V;
+
+  /** Track by identity as computed by the `trackByFn`. */
+  readonly trackById: any;
+}
+
+/**
+ * @deprecated v4.0.0 - Use IterableChangeRecord instead.
+ */
+export interface CollectionChangeRecord<V> extends IterableChangeRecord<V> {}
+
+
+/**
+ * Nolonger used.
+ *
+ * @deprecated v4.0.0 - Use TrackByFunction instead
+ */
+export interface TrackByFn { (index: number, item: any): any; }
+
+/**
+ * An optional function passed into {@link NgForOf} that defines how to track
+ * items in an iterable (e.g. fby index or id)
+ *
+ * @stable
+ */
+export interface TrackByFunction<T> { (index: number, item: T): any; }
+
+/**
+ * Provides a factory for {@link IterableDiffer}.
+ *
+ * @stable
+ */
+export interface IterableDifferFactory {
+  supports(objects: any): boolean;
+  create<V>(trackByFn?: TrackByFunction<V>): IterableDiffer<V>;
+
+  /**
+   * @deprecated v4.0.0 - ChangeDetectorRef is not used and is no longer a parameter
+   */
+  create<V>(_cdr?: ChangeDetectorRef|TrackByFunction<V>, trackByFn?: TrackByFunction<V>):
+      IterableDiffer<V>;
+}
+
+/**
+ * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.
+ * @stable
+ */
+export class IterableDiffers {
+  /**
+   * @deprecated v4.0.0 - Should be private
+   */
+  factories: IterableDifferFactory[];
+  constructor(factories: IterableDifferFactory[]) { this.factories = factories; }
+
+  static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers {
+    if (parent != null) {
+      const copied = parent.factories.slice();
+      factories = factories.concat(copied);
+      return new IterableDiffers(factories);
+    } else {
+      return new IterableDiffers(factories);
+    }
+  }
+
+  /**
+   * Takes an array of {@link IterableDifferFactory} and returns a provider used to extend the
+   * inherited {@link IterableDiffers} instance with the provided factories and return a new
+   * {@link IterableDiffers} instance.
+   *
+   * The following example shows how to extend an existing list of factories,
+   * which will only be applied to the injector for this component and its children.
+   * This step is all that's required to make a new {@link IterableDiffer} available.
+   *
+   * ### Example
+   *
+   * ```
+   * @Component({
+   *   viewProviders: [
+   *     IterableDiffers.extend([new ImmutableListDiffer()])
+   *   ]
+   * })
+   * ```
+   */
+  static extend(factories: IterableDifferFactory[]): StaticProvider {
+    return {
+      provide: IterableDiffers,
+      useFactory: (parent: IterableDiffers) => {
+        if (!parent) {
+          // Typically would occur when calling IterableDiffers.extend inside of dependencies passed
+          // to
+          // bootstrap(), which would override default pipes instead of extending them.
+          throw new Error('Cannot extend IterableDiffers without a parent injector');
+        }
+        return IterableDiffers.create(factories, parent);
+      },
+      // Dependency technically isn't optional, but we can provide a better error message this way.
+      deps: [[IterableDiffers, new SkipSelf(), new Optional()]]
+    };
+  }
+
+  find(iterable: any): IterableDifferFactory {
+    const factory = this.factories.find(f => f.supports(iterable));
+    if (factory != null) {
+      return factory;
+    } else {
+      throw new Error(
+          `Cannot find a differ supporting object '${iterable}' of type '${getTypeNameForDebugging(iterable)}'`);
+    }
+  }
+}
+
+export function getTypeNameForDebugging(type: any): string {
+  return type['name'] || typeof type;
+}
diff --git a/angular/core/src/change_detection/differs/keyvalue_differs.ts b/angular/core/src/change_detection/differs/keyvalue_differs.ts
new file mode 100644
index 0000000..c6637ec
--- /dev/null
+++ b/angular/core/src/change_detection/differs/keyvalue_differs.ts
@@ -0,0 +1,182 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Optional, SkipSelf, StaticProvider} from '../../di';
+import {ChangeDetectorRef} from '../change_detector_ref';
+
+
+
+/**
+ * A differ that tracks changes made to an object over time.
+ *
+ * @stable
+ */
+export interface KeyValueDiffer<K, V> {
+  /**
+   * Compute a difference between the previous state and the new `object` state.
+   *
+   * @param object containing the new value.
+   * @returns an object describing the difference. The return value is only valid until the next
+   * `diff()` invocation.
+   */
+  diff(object: Map<K, V>): KeyValueChanges<K, V>;
+
+  /**
+   * Compute a difference between the previous state and the new `object` state.
+   *
+   * @param object containing the new value.
+   * @returns an object describing the difference. The return value is only valid until the next
+   * `diff()` invocation.
+   */
+  diff(object: {[key: string]: V}): KeyValueChanges<string, V>;
+  // TODO(TS2.1): diff<KP extends string>(this: KeyValueDiffer<KP, V>, object: Record<KP, V>):
+  // KeyValueDiffer<KP, V>;
+}
+
+/**
+ * An object describing the changes in the `Map` or `{[k:string]: string}` since last time
+ * `KeyValueDiffer#diff()` was invoked.
+ *
+ * @stable
+ */
+export interface KeyValueChanges<K, V> {
+  /**
+   * Iterate over all changes. `KeyValueChangeRecord` will contain information about changes
+   * to each item.
+   */
+  forEachItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;
+
+  /**
+   * Iterate over changes in the order of original Map showing where the original items
+   * have moved.
+   */
+  forEachPreviousItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;
+
+  /**
+   * Iterate over all keys for which values have changed.
+   */
+  forEachChangedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;
+
+  /**
+   * Iterate over all added items.
+   */
+  forEachAddedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;
+
+  /**
+   * Iterate over all removed items.
+   */
+  forEachRemovedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;
+}
+
+/**
+ * Record representing the item change information.
+ *
+ * @stable
+ */
+export interface KeyValueChangeRecord<K, V> {
+  /**
+   * Current key in the Map.
+   */
+  readonly key: K;
+
+  /**
+   * Current value for the key or `null` if removed.
+   */
+  readonly currentValue: V|null;
+
+  /**
+   * Previous value for the key or `null` if added.
+   */
+  readonly previousValue: V|null;
+}
+
+/**
+ * Provides a factory for {@link KeyValueDiffer}.
+ *
+ * @stable
+ */
+export interface KeyValueDifferFactory {
+  /**
+   * Test to see if the differ knows how to diff this kind of object.
+   */
+  supports(objects: any): boolean;
+
+  /**
+   * Create a `KeyValueDiffer`.
+   */
+  create<K, V>(): KeyValueDiffer<K, V>;
+
+  /**
+   * @deprecated v4.0.0 - ChangeDetectorRef is not used and is no longer a parameter
+   */
+  create<K, V>(_cdr?: ChangeDetectorRef): KeyValueDiffer<K, V>;
+}
+
+/**
+ * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
+ * @stable
+ */
+export class KeyValueDiffers {
+  /**
+   * @deprecated v4.0.0 - Should be private.
+   */
+  factories: KeyValueDifferFactory[];
+
+  constructor(factories: KeyValueDifferFactory[]) { this.factories = factories; }
+
+  static create<S>(factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers {
+    if (parent) {
+      const copied = parent.factories.slice();
+      factories = factories.concat(copied);
+    }
+    return new KeyValueDiffers(factories);
+  }
+
+  /**
+   * Takes an array of {@link KeyValueDifferFactory} and returns a provider used to extend the
+   * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
+   * {@link KeyValueDiffers} instance.
+   *
+   * The following example shows how to extend an existing list of factories,
+         * which will only be applied to the injector for this component and its children.
+         * This step is all that's required to make a new {@link KeyValueDiffer} available.
+   *
+   * ### Example
+   *
+   * ```
+   * @Component({
+   *   viewProviders: [
+   *     KeyValueDiffers.extend([new ImmutableMapDiffer()])
+   *   ]
+   * })
+   * ```
+   */
+  static extend<S>(factories: KeyValueDifferFactory[]): StaticProvider {
+    return {
+      provide: KeyValueDiffers,
+      useFactory: (parent: KeyValueDiffers) => {
+        if (!parent) {
+          // Typically would occur when calling KeyValueDiffers.extend inside of dependencies passed
+          // to bootstrap(), which would override default pipes instead of extending them.
+          throw new Error('Cannot extend KeyValueDiffers without a parent injector');
+        }
+        return KeyValueDiffers.create(factories, parent);
+      },
+      // Dependency technically isn't optional, but we can provide a better error message this way.
+      deps: [[KeyValueDiffers, new SkipSelf(), new Optional()]]
+    };
+  }
+
+  find(kv: any): KeyValueDifferFactory {
+    const factory = this.factories.find(f => f.supports(kv));
+    if (factory) {
+      return factory;
+    }
+    throw new Error(`Cannot find a differ supporting object '${kv}'`);
+  }
+}
diff --git a/angular/core/src/change_detection/pipe_transform.ts b/angular/core/src/change_detection/pipe_transform.ts
new file mode 100644
index 0000000..d5a4605
--- /dev/null
+++ b/angular/core/src/change_detection/pipe_transform.ts
@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * To create a Pipe, you must implement this interface.
+ *
+ * Angular invokes the `transform` method with the value of a binding
+ * as the first argument, and any parameters as the second argument in list form.
+ *
+ * ## Syntax
+ *
+ * `value | pipeName[:arg0[:arg1...]]`
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/f5oyIked9M2cKzvZNKHV?p=preview))
+ *
+ * The `RepeatPipe` below repeats the value as many times as indicated by the first argument:
+ *
+ * ```
+ * import {Pipe, PipeTransform} from '@angular/core';
+ *
+ * @Pipe({name: 'repeat'})
+ * export class RepeatPipe implements PipeTransform {
+ *   transform(value: any, times: number) {
+ *     return value.repeat(times);
+ *   }
+ * }
+ * ```
+ *
+ * Invoking `{{ 'ok' | repeat:3 }}` in a template produces `okokok`.
+ *
+ * @stable
+ */
+export interface PipeTransform { transform(value: any, ...args: any[]): any; }
diff --git a/angular/core/src/codegen_private_exports.ts b/angular/core/src/codegen_private_exports.ts
new file mode 100644
index 0000000..bddc41e
--- /dev/null
+++ b/angular/core/src/codegen_private_exports.ts
@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export {CodegenComponentFactoryResolver as ɵCodegenComponentFactoryResolver} from './linker/component_factory_resolver';
+export {registerModuleFactory as ɵregisterModuleFactory} from './linker/ng_module_factory_loader';
+export {ArgumentType as ɵArgumentType, BindingFlags as ɵBindingFlags, DepFlags as ɵDepFlags, EMPTY_ARRAY as ɵEMPTY_ARRAY, EMPTY_MAP as ɵEMPTY_MAP, NodeFlags as ɵNodeFlags, QueryBindingType as ɵQueryBindingType, QueryValueType as ɵQueryValueType, ViewDefinition as ɵViewDefinition, ViewFlags as ɵViewFlags, anchorDef as ɵand, createComponentFactory as ɵccf, createNgModuleFactory as ɵcmf, createRendererType2 as ɵcrt, directiveDef as ɵdid, elementDef as ɵeld, elementEventFullName as ɵelementEventFullName, getComponentViewDefinitionFactory as ɵgetComponentViewDefinitionFactory, inlineInterpolate as ɵinlineInterpolate, interpolate as ɵinterpolate, moduleDef as ɵmod, moduleProvideDef as ɵmpd, ngContentDef as ɵncd, nodeValue as ɵnov, pipeDef as ɵpid, providerDef as ɵprd, pureArrayDef as ɵpad, pureObjectDef as ɵpod, purePipeDef as ɵppd, queryDef as ɵqud, textDef as ɵted, unwrapValue as ɵunv, viewDef as ɵvid} from './view/index';
diff --git a/angular/core/src/console.ts b/angular/core/src/console.ts
new file mode 100644
index 0000000..bc30a29
--- /dev/null
+++ b/angular/core/src/console.ts
@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injectable} from './di';
+
+@Injectable()
+export class Console {
+  log(message: string): void {
+    // tslint:disable-next-line:no-console
+    console.log(message);
+  }
+  // Note: for reporting errors use `DOM.logError()` as it is platform specific
+  warn(message: string): void {
+    // tslint:disable-next-line:no-console
+    console.warn(message);
+  }
+}
diff --git a/angular/core/src/core.ts b/angular/core/src/core.ts
new file mode 100644
index 0000000..16ca67f
--- /dev/null
+++ b/angular/core/src/core.ts
@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point from which you should import all public core APIs.
+ */
+export * from './metadata';
+export * from './version';
+export {TypeDecorator} from './util/decorators';
+export * from './di';
+export {createPlatform, assertPlatform, destroyPlatform, getPlatform, PlatformRef, ApplicationRef, enableProdMode, isDevMode, createPlatformFactory, NgProbeToken} from './application_ref';
+export {APP_ID, PACKAGE_ROOT_URL, PLATFORM_INITIALIZER, PLATFORM_ID, APP_BOOTSTRAP_LISTENER} from './application_tokens';
+export {APP_INITIALIZER, ApplicationInitStatus} from './application_init';
+export * from './zone';
+export * from './render';
+export * from './linker';
+export {DebugElement, DebugNode, asNativeElements, getDebugNode, Predicate} from './debug/debug_node';
+export {GetTestability, Testability, TestabilityRegistry, setTestabilityGetter} from './testability/testability';
+export * from './change_detection';
+export * from './platform_core_providers';
+export {TRANSLATIONS, TRANSLATIONS_FORMAT, LOCALE_ID, MissingTranslationStrategy} from './i18n/tokens';
+export {ApplicationModule} from './application_module';
+export {wtfCreateScope, wtfLeave, wtfStartTimeRange, wtfEndTimeRange, WtfScopeFn} from './profile/profile';
+export {Type} from './type';
+export {EventEmitter} from './event_emitter';
+export {ErrorHandler} from './error_handler';
+export * from './core_private_export';
+export {Sanitizer, SecurityContext} from './security';
+export * from './codegen_private_exports';
+
+
+// For backwards compatibility.
+/**
+ * @deprecated from v4
+ */
+export type AnimationEntryMetadata = any;
+/**
+ * @deprecated from v4
+ */
+export type AnimationStateTransitionMetadata = any;
+/**
+ * @deprecated from v4
+ */
+export type AnimationPlayer = any;
+/**
+ * @deprecated from v4
+ */
+export type AnimationStyles = any;
+/**
+ * @deprecated from v4
+ */
+export type AnimationKeyframe = any;
diff --git a/angular/core/src/core_private_export.ts b/angular/core/src/core_private_export.ts
new file mode 100644
index 0000000..33d36d7
--- /dev/null
+++ b/angular/core/src/core_private_export.ts
@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export {ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS} from './application_ref';
+export {APP_ID_RANDOM_PROVIDER as ɵAPP_ID_RANDOM_PROVIDER} from './application_tokens';
+export {ValueUnwrapper as ɵValueUnwrapper, devModeEqual as ɵdevModeEqual} from './change_detection/change_detection_util';
+export {isListLikeIterable as ɵisListLikeIterable} from './change_detection/change_detection_util';
+export {ChangeDetectorStatus as ɵChangeDetectorStatus, isDefaultChangeDetectionStrategy as ɵisDefaultChangeDetectionStrategy} from './change_detection/constants';
+export {Console as ɵConsole} from './console';
+export {ComponentFactory as ɵComponentFactory} from './linker/component_factory';
+export {CodegenComponentFactoryResolver as ɵCodegenComponentFactoryResolver} from './linker/component_factory_resolver';
+export {ReflectionCapabilities as ɵReflectionCapabilities} from './reflection/reflection_capabilities';
+export {GetterFn as ɵGetterFn, MethodFn as ɵMethodFn, SetterFn as ɵSetterFn} from './reflection/types';
+export {DirectRenderer as ɵDirectRenderer, RenderDebugInfo as ɵRenderDebugInfo} from './render/api';
+export {global as ɵglobal, looseIdentical as ɵlooseIdentical, stringify as ɵstringify} from './util';
+export {makeDecorator as ɵmakeDecorator} from './util/decorators';
+export {isObservable as ɵisObservable, isPromise as ɵisPromise} from './util/lang';
+export {clearProviderOverrides as ɵclearProviderOverrides, overrideProvider as ɵoverrideProvider} from './view/index';
+export {NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR} from './view/provider';
diff --git a/angular/core/src/debug/debug_node.ts b/angular/core/src/debug/debug_node.ts
new file mode 100644
index 0000000..6c76020
--- /dev/null
+++ b/angular/core/src/debug/debug_node.ts
@@ -0,0 +1,202 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injector} from '../di';
+import {DebugContext} from '../view/index';
+
+export class EventListener { constructor(public name: string, public callback: Function){}; }
+
+/**
+ * @experimental All debugging apis are currently experimental.
+ */
+export class DebugNode {
+  nativeNode: any;
+  listeners: EventListener[];
+  parent: DebugElement|null;
+
+  constructor(nativeNode: any, parent: DebugNode|null, private _debugContext: DebugContext) {
+    this.nativeNode = nativeNode;
+    if (parent && parent instanceof DebugElement) {
+      parent.addChild(this);
+    } else {
+      this.parent = null;
+    }
+    this.listeners = [];
+  }
+
+  get injector(): Injector { return this._debugContext.injector; }
+
+  get componentInstance(): any { return this._debugContext.component; }
+
+  get context(): any { return this._debugContext.context; }
+
+  get references(): {[key: string]: any} { return this._debugContext.references; }
+
+  get providerTokens(): any[] { return this._debugContext.providerTokens; }
+
+  /**
+   * @deprecated since v4
+   */
+  get source(): string { return 'Deprecated since v4'; }
+}
+
+/**
+ * @experimental All debugging apis are currently experimental.
+ */
+export class DebugElement extends DebugNode {
+  name: string;
+  properties: {[key: string]: any};
+  attributes: {[key: string]: string | null};
+  classes: {[key: string]: boolean};
+  styles: {[key: string]: string | null};
+  childNodes: DebugNode[];
+  nativeElement: any;
+
+  constructor(nativeNode: any, parent: any, _debugContext: DebugContext) {
+    super(nativeNode, parent, _debugContext);
+    this.properties = {};
+    this.attributes = {};
+    this.classes = {};
+    this.styles = {};
+    this.childNodes = [];
+    this.nativeElement = nativeNode;
+  }
+
+  addChild(child: DebugNode) {
+    if (child) {
+      this.childNodes.push(child);
+      child.parent = this;
+    }
+  }
+
+  removeChild(child: DebugNode) {
+    const childIndex = this.childNodes.indexOf(child);
+    if (childIndex !== -1) {
+      child.parent = null;
+      this.childNodes.splice(childIndex, 1);
+    }
+  }
+
+  insertChildrenAfter(child: DebugNode, newChildren: DebugNode[]) {
+    const siblingIndex = this.childNodes.indexOf(child);
+    if (siblingIndex !== -1) {
+      this.childNodes.splice(siblingIndex + 1, 0, ...newChildren);
+      newChildren.forEach(c => {
+        if (c.parent) {
+          c.parent.removeChild(c);
+        }
+        c.parent = this;
+      });
+    }
+  }
+
+  insertBefore(refChild: DebugNode, newChild: DebugNode): void {
+    const refIndex = this.childNodes.indexOf(refChild);
+    if (refIndex === -1) {
+      this.addChild(newChild);
+    } else {
+      if (newChild.parent) {
+        newChild.parent.removeChild(newChild);
+      }
+      newChild.parent = this;
+      this.childNodes.splice(refIndex, 0, newChild);
+    }
+  }
+
+  query(predicate: Predicate<DebugElement>): DebugElement {
+    const results = this.queryAll(predicate);
+    return results[0] || null;
+  }
+
+  queryAll(predicate: Predicate<DebugElement>): DebugElement[] {
+    const matches: DebugElement[] = [];
+    _queryElementChildren(this, predicate, matches);
+    return matches;
+  }
+
+  queryAllNodes(predicate: Predicate<DebugNode>): DebugNode[] {
+    const matches: DebugNode[] = [];
+    _queryNodeChildren(this, predicate, matches);
+    return matches;
+  }
+
+  get children(): DebugElement[] {
+    return this.childNodes.filter((node) => node instanceof DebugElement) as DebugElement[];
+  }
+
+  triggerEventHandler(eventName: string, eventObj: any) {
+    this.listeners.forEach((listener) => {
+      if (listener.name == eventName) {
+        listener.callback(eventObj);
+      }
+    });
+  }
+}
+
+/**
+ * @experimental
+ */
+export function asNativeElements(debugEls: DebugElement[]): any {
+  return debugEls.map((el) => el.nativeElement);
+}
+
+function _queryElementChildren(
+    element: DebugElement, predicate: Predicate<DebugElement>, matches: DebugElement[]) {
+  element.childNodes.forEach(node => {
+    if (node instanceof DebugElement) {
+      if (predicate(node)) {
+        matches.push(node);
+      }
+      _queryElementChildren(node, predicate, matches);
+    }
+  });
+}
+
+function _queryNodeChildren(
+    parentNode: DebugNode, predicate: Predicate<DebugNode>, matches: DebugNode[]) {
+  if (parentNode instanceof DebugElement) {
+    parentNode.childNodes.forEach(node => {
+      if (predicate(node)) {
+        matches.push(node);
+      }
+      if (node instanceof DebugElement) {
+        _queryNodeChildren(node, predicate, matches);
+      }
+    });
+  }
+}
+
+// Need to keep the nodes in a global Map so that multiple angular apps are supported.
+const _nativeNodeToDebugNode = new Map<any, DebugNode>();
+
+/**
+ * @experimental
+ */
+export function getDebugNode(nativeNode: any): DebugNode|null {
+  return _nativeNodeToDebugNode.get(nativeNode) || null;
+}
+
+export function getAllDebugNodes(): DebugNode[] {
+  return Array.from(_nativeNodeToDebugNode.values());
+}
+
+export function indexDebugNode(node: DebugNode) {
+  _nativeNodeToDebugNode.set(node.nativeNode, node);
+}
+
+export function removeDebugNodeFromIndex(node: DebugNode) {
+  _nativeNodeToDebugNode.delete(node.nativeNode);
+}
+
+/**
+ * A boolean-valued function over a value, possibly including context information
+ * regarding that value's position in an array.
+ *
+ * @experimental All debugging apis are currently experimental.
+ */
+export interface Predicate<T> { (value: T): boolean; }
diff --git a/angular/core/src/di.ts b/angular/core/src/di.ts
new file mode 100644
index 0000000..976fd3f
--- /dev/null
+++ b/angular/core/src/di.ts
@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * The `di` module provides dependency injection container services.
+ */
+
+export * from './di/metadata';
+
+export {forwardRef, resolveForwardRef, ForwardRefFn} from './di/forward_ref';
+
+export {Injector} from './di/injector';
+export {ReflectiveInjector} from './di/reflective_injector';
+export {StaticProvider, ValueProvider, ExistingProvider, FactoryProvider, Provider, TypeProvider, ClassProvider} from './di/provider';
+export {ResolvedReflectiveFactory, ResolvedReflectiveProvider} from './di/reflective_provider';
+export {ReflectiveKey} from './di/reflective_key';
+export {InjectionToken, OpaqueToken} from './di/injection_token';
diff --git a/angular/core/src/di/forward_ref.ts b/angular/core/src/di/forward_ref.ts
new file mode 100644
index 0000000..8800543
--- /dev/null
+++ b/angular/core/src/di/forward_ref.ts
@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Type} from '../type';
+import {stringify} from '../util';
+
+
+
+/**
+ * An interface that a function passed into {@link forwardRef} has to implement.
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref_fn'}
+ * @experimental
+ */
+export interface ForwardRefFn { (): any; }
+
+/**
+ * Allows to refer to references which are not yet defined.
+ *
+ * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of
+ * DI is declared,
+ * but not yet defined. It is also used when the `token` which we use when creating a query is not
+ * yet defined.
+ *
+ * ### Example
+ * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}
+ * @experimental
+ */
+export function forwardRef(forwardRefFn: ForwardRefFn): Type<any> {
+  (<any>forwardRefFn).__forward_ref__ = forwardRef;
+  (<any>forwardRefFn).toString = function() { return stringify(this()); };
+  return (<Type<any>><any>forwardRefFn);
+}
+
+/**
+ * Lazily retrieves the reference value from a forwardRef.
+ *
+ * Acts as the identity function when given a non-forward-ref value.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/GU72mJrk1fiodChcmiDR?p=preview))
+ *
+ * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}
+ *
+ * See: {@link forwardRef}
+ * @experimental
+ */
+export function resolveForwardRef(type: any): any {
+  if (typeof type === 'function' && type.hasOwnProperty('__forward_ref__') &&
+      type.__forward_ref__ === forwardRef) {
+    return (<ForwardRefFn>type)();
+  } else {
+    return type;
+  }
+}
diff --git a/angular/core/src/di/injection_token.ts b/angular/core/src/di/injection_token.ts
new file mode 100644
index 0000000..6f05a8c
--- /dev/null
+++ b/angular/core/src/di/injection_token.ts
@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * Creates a token that can be used in a DI Provider.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/Ys9ezXpj2Mnoy3Uc8KBp?p=preview))
+ *
+ * ```typescript
+ * var t = new OpaqueToken("value");
+ *
+ * var injector = Injector.resolveAndCreate([
+ *   {provide: t, useValue: "bindingValue"}
+ * ]);
+ *
+ * expect(injector.get(t)).toEqual("bindingValue");
+ * ```
+ *
+ * Using an `OpaqueToken` is preferable to using strings as tokens because of possible collisions
+ * caused by multiple providers using the same string as two different tokens.
+ *
+ * Using an `OpaqueToken` is preferable to using an `Object` as tokens because it provides better
+ * error messages.
+ * @deprecated since v4.0.0 because it does not support type information, use `InjectionToken<?>`
+ * instead.
+ */
+export class OpaqueToken {
+  constructor(protected _desc: string) {}
+
+  toString(): string { return `Token ${this._desc}`; }
+}
+
+/**
+ * Creates a token that can be used in a DI Provider.
+ *
+ * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a
+ * runtime representation) such as when injecting an interface, callable type, array or
+ * parametrized type.
+ *
+ * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
+ * the `Injector`. This provides additional level of type safety.
+ *
+ * ```
+ * interface MyInterface {...}
+ * var myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
+ * // myInterface is inferred to be MyInterface.
+ * ```
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/injector_spec.ts region='InjectionToken'}
+ *
+ * @stable
+ */
+export class InjectionToken<T> extends OpaqueToken {
+  // This unused property is needed here so that TS can differentiate InjectionToken from
+  // OpaqueToken since otherwise they would have the same shape and be treated as equivalent.
+  private _differentiate_from_OpaqueToken_structurally: any;
+  constructor(desc: string) { super(desc); }
+
+  toString(): string { return `InjectionToken ${this._desc}`; }
+
+  /** @internal */
+  get ngMetadataName() { return 'InjectionToken'; }
+}
diff --git a/angular/core/src/di/injector.ts b/angular/core/src/di/injector.ts
new file mode 100644
index 0000000..a0a380a
--- /dev/null
+++ b/angular/core/src/di/injector.ts
@@ -0,0 +1,369 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Type} from '../type';
+import {stringify} from '../util';
+
+import {resolveForwardRef} from './forward_ref';
+import {InjectionToken} from './injection_token';
+import {Inject, Optional, Self, SkipSelf} from './metadata';
+import {ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, StaticProvider, ValueProvider} from './provider';
+
+const _THROW_IF_NOT_FOUND = new Object();
+export const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
+
+class _NullInjector implements Injector {
+  get(token: any, notFoundValue: any = _THROW_IF_NOT_FOUND): any {
+    if (notFoundValue === _THROW_IF_NOT_FOUND) {
+      throw new Error(`NullInjectorError: No provider for ${stringify(token)}!`);
+    }
+    return notFoundValue;
+  }
+}
+
+/**
+ * @whatItDoes Injector interface
+ * @howToUse
+ * ```
+ * const injector: Injector = ...;
+ * injector.get(...);
+ * ```
+ *
+ * @description
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/injector_spec.ts region='Injector'}
+ *
+ * `Injector` returns itself when given `Injector` as a token:
+ * {@example core/di/ts/injector_spec.ts region='injectInjector'}
+ *
+ * @stable
+ */
+export abstract class Injector {
+  static THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
+  static NULL: Injector = new _NullInjector();
+
+  /**
+   * Retrieves an instance from the injector based on the provided token.
+   * If not found:
+   * - Throws an error if no `notFoundValue` that is not equal to
+   * Injector.THROW_IF_NOT_FOUND is given
+   * - Returns the `notFoundValue` otherwise
+   */
+  abstract get<T>(token: Type<T>|InjectionToken<T>, notFoundValue?: T): T;
+  /**
+   * @deprecated from v4.0.0 use Type<T> or InjectionToken<T>
+   * @suppress {duplicate}
+   */
+  abstract get(token: any, notFoundValue?: any): any;
+
+  /**
+   * Create a new Injector which is configure using `StaticProvider`s.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
+   */
+  static create(providers: StaticProvider[], parent?: Injector): Injector {
+    return new StaticInjector(providers, parent);
+  }
+}
+
+
+
+const IDENT = function<T>(value: T): T {
+  return value;
+};
+const EMPTY = <any[]>[];
+const CIRCULAR = IDENT;
+const MULTI_PROVIDER_FN = function(): any[] {
+  return Array.prototype.slice.call(arguments);
+};
+const GET_PROPERTY_NAME = {} as any;
+const USE_VALUE =
+    getClosureSafeProperty<ValueProvider>({provide: String, useValue: GET_PROPERTY_NAME});
+const NG_TOKEN_PATH = 'ngTokenPath';
+const NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';
+const enum OptionFlags {
+  Optional = 1 << 0,
+  CheckSelf = 1 << 1,
+  CheckParent = 1 << 2,
+  Default = CheckSelf | CheckParent
+}
+const NULL_INJECTOR = Injector.NULL;
+const NEW_LINE = /\n/gm;
+const NO_NEW_LINE = 'ɵ';
+
+export class StaticInjector implements Injector {
+  readonly parent: Injector;
+
+  private _records: Map<any, Record>;
+
+  constructor(providers: StaticProvider[], parent: Injector = NULL_INJECTOR) {
+    this.parent = parent;
+    const records = this._records = new Map<any, Record>();
+    records.set(
+        Injector, <Record>{token: Injector, fn: IDENT, deps: EMPTY, value: this, useNew: false});
+    recursivelyProcessProviders(records, providers);
+  }
+
+  get<T>(token: Type<T>|InjectionToken<T>, notFoundValue?: T): T;
+  get(token: any, notFoundValue?: any): any;
+  get(token: any, notFoundValue?: any): any {
+    const record = this._records.get(token);
+    try {
+      return tryResolveToken(token, record, this._records, this.parent, notFoundValue);
+    } catch (e) {
+      const tokenPath: any[] = e[NG_TEMP_TOKEN_PATH];
+      e.message = formatError('\n' + e.message, tokenPath);
+      e[NG_TOKEN_PATH] = tokenPath;
+      e[NG_TEMP_TOKEN_PATH] = null;
+      throw e;
+    }
+  }
+
+  toString() {
+    const tokens = <string[]>[], records = this._records;
+    records.forEach((v, token) => tokens.push(stringify(token)));
+    return `StaticInjector[${tokens.join(', ')}]`;
+  }
+}
+
+type SupportedProvider =
+    ValueProvider | ExistingProvider | StaticClassProvider | ConstructorProvider | FactoryProvider;
+
+interface Record {
+  fn: Function;
+  useNew: boolean;
+  deps: DependencyRecord[];
+  value: any;
+}
+
+interface DependencyRecord {
+  token: any;
+  options: number;
+}
+
+type TokenPath = Array<any>;
+
+function resolveProvider(provider: SupportedProvider): Record {
+  const deps = computeDeps(provider);
+  let fn: Function = IDENT;
+  let value: any = EMPTY;
+  let useNew: boolean = false;
+  let provide = resolveForwardRef(provider.provide);
+  if (USE_VALUE in provider) {
+    // We need to use USE_VALUE in provider since provider.useValue could be defined as undefined.
+    value = (provider as ValueProvider).useValue;
+  } else if ((provider as FactoryProvider).useFactory) {
+    fn = (provider as FactoryProvider).useFactory;
+  } else if ((provider as ExistingProvider).useExisting) {
+    // Just use IDENT
+  } else if ((provider as StaticClassProvider).useClass) {
+    useNew = true;
+    fn = resolveForwardRef((provider as StaticClassProvider).useClass);
+  } else if (typeof provide == 'function') {
+    useNew = true;
+    fn = provide;
+  } else {
+    throw staticError(
+        'StaticProvider does not have [useValue|useFactory|useExisting|useClass] or [provide] is not newable',
+        provider);
+  }
+  return {deps, fn, useNew, value};
+}
+
+function multiProviderMixError(token: any) {
+  return staticError('Cannot mix multi providers and regular providers', token);
+}
+
+function recursivelyProcessProviders(records: Map<any, Record>, provider: StaticProvider) {
+  if (provider) {
+    provider = resolveForwardRef(provider);
+    if (provider instanceof Array) {
+      // if we have an array recurse into the array
+      for (let i = 0; i < provider.length; i++) {
+        recursivelyProcessProviders(records, provider[i]);
+      }
+    } else if (typeof provider === 'function') {
+      // Functions were supported in ReflectiveInjector, but are not here. For safety give useful
+      // error messages
+      throw staticError('Function/Class not supported', provider);
+    } else if (provider && typeof provider === 'object' && provider.provide) {
+      // At this point we have what looks like a provider: {provide: ?, ....}
+      let token = resolveForwardRef(provider.provide);
+      const resolvedProvider = resolveProvider(provider);
+      if (provider.multi === true) {
+        // This is a multi provider.
+        let multiProvider: Record|undefined = records.get(token);
+        if (multiProvider) {
+          if (multiProvider.fn !== MULTI_PROVIDER_FN) {
+            throw multiProviderMixError(token);
+          }
+        } else {
+          // Create a placeholder factory which will look up the constituents of the multi provider.
+          records.set(token, multiProvider = <Record>{
+            token: provider.provide,
+            deps: [],
+            useNew: false,
+            fn: MULTI_PROVIDER_FN,
+            value: EMPTY
+          });
+        }
+        // Treat the provider as the token.
+        token = provider;
+        multiProvider.deps.push({token, options: OptionFlags.Default});
+      }
+      const record = records.get(token);
+      if (record && record.fn == MULTI_PROVIDER_FN) {
+        throw multiProviderMixError(token);
+      }
+      records.set(token, resolvedProvider);
+    } else {
+      throw staticError('Unexpected provider', provider);
+    }
+  }
+}
+
+function tryResolveToken(
+    token: any, record: Record | undefined, records: Map<any, Record>, parent: Injector,
+    notFoundValue: any): any {
+  try {
+    return resolveToken(token, record, records, parent, notFoundValue);
+  } catch (e) {
+    // ensure that 'e' is of type Error.
+    if (!(e instanceof Error)) {
+      e = new Error(e);
+    }
+    const path: any[] = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];
+    path.unshift(token);
+    if (record && record.value == CIRCULAR) {
+      // Reset the Circular flag.
+      record.value = EMPTY;
+    }
+    throw e;
+  }
+}
+
+function resolveToken(
+    token: any, record: Record | undefined, records: Map<any, Record>, parent: Injector,
+    notFoundValue: any): any {
+  let value;
+  if (record) {
+    // If we don't have a record, this implies that we don't own the provider hence don't know how
+    // to resolve it.
+    value = record.value;
+    if (value == CIRCULAR) {
+      throw Error(NO_NEW_LINE + 'Circular dependency');
+    } else if (value === EMPTY) {
+      record.value = CIRCULAR;
+      let obj = undefined;
+      let useNew = record.useNew;
+      let fn = record.fn;
+      let depRecords = record.deps;
+      let deps = EMPTY;
+      if (depRecords.length) {
+        deps = [];
+        for (let i = 0; i < depRecords.length; i++) {
+          const depRecord: DependencyRecord = depRecords[i];
+          const options = depRecord.options;
+          const childRecord =
+              options & OptionFlags.CheckSelf ? records.get(depRecord.token) : undefined;
+          deps.push(tryResolveToken(
+              // Current Token to resolve
+              depRecord.token,
+              // A record which describes how to resolve the token.
+              // If undefined, this means we don't have such a record
+              childRecord,
+              // Other records we know about.
+              records,
+              // If we don't know how to resolve dependency and we should not check parent for it,
+              // than pass in Null injector.
+              !childRecord && !(options & OptionFlags.CheckParent) ? NULL_INJECTOR : parent,
+              options & OptionFlags.Optional ? null : Injector.THROW_IF_NOT_FOUND));
+        }
+      }
+      record.value = value = useNew ? new (fn as any)(...deps) : fn.apply(obj, deps);
+    }
+  } else {
+    value = parent.get(token, notFoundValue);
+  }
+  return value;
+}
+
+
+function computeDeps(provider: StaticProvider): DependencyRecord[] {
+  let deps: DependencyRecord[] = EMPTY;
+  const providerDeps: any[] =
+      (provider as ExistingProvider & StaticClassProvider & ConstructorProvider).deps;
+  if (providerDeps && providerDeps.length) {
+    deps = [];
+    for (let i = 0; i < providerDeps.length; i++) {
+      let options = OptionFlags.Default;
+      let token = resolveForwardRef(providerDeps[i]);
+      if (token instanceof Array) {
+        for (let j = 0, annotations = token; j < annotations.length; j++) {
+          const annotation = annotations[j];
+          if (annotation instanceof Optional || annotation == Optional) {
+            options = options | OptionFlags.Optional;
+          } else if (annotation instanceof SkipSelf || annotation == SkipSelf) {
+            options = options & ~OptionFlags.CheckSelf;
+          } else if (annotation instanceof Self || annotation == Self) {
+            options = options & ~OptionFlags.CheckParent;
+          } else if (annotation instanceof Inject) {
+            token = (annotation as Inject).token;
+          } else {
+            token = resolveForwardRef(annotation);
+          }
+        }
+      }
+      deps.push({token, options});
+    }
+  } else if ((provider as ExistingProvider).useExisting) {
+    const token = resolveForwardRef((provider as ExistingProvider).useExisting);
+    deps = [{token, options: OptionFlags.Default}];
+  } else if (!providerDeps && !(USE_VALUE in provider)) {
+    // useValue & useExisting are the only ones which are exempt from deps all others need it.
+    throw staticError('\'deps\' required', provider);
+  }
+  return deps;
+}
+
+function formatError(text: string, obj: any): string {
+  text = text && text.charAt(0) === '\n' && text.charAt(1) == NO_NEW_LINE ? text.substr(2) : text;
+  let context = stringify(obj);
+  if (obj instanceof Array) {
+    context = obj.map(stringify).join(' -> ');
+  } else if (typeof obj === 'object') {
+    let parts = <string[]>[];
+    for (let key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        let value = obj[key];
+        parts.push(
+            key + ':' + (typeof value === 'string' ? JSON.stringify(value) : stringify(value)));
+      }
+    }
+    context = `{${parts.join(', ')}}`;
+  }
+  return `StaticInjectorError[${context}]: ${text.replace(NEW_LINE, '\n  ')}`;
+}
+
+function staticError(text: string, obj: any): Error {
+  return new Error(formatError(text, obj));
+}
+
+function getClosureSafeProperty<T>(objWithPropertyToExtract: T): string {
+  for (let key in objWithPropertyToExtract) {
+    if (objWithPropertyToExtract[key] === GET_PROPERTY_NAME) {
+      return key;
+    }
+  }
+  throw Error('!prop');
+}
diff --git a/angular/core/src/di/metadata.ts b/angular/core/src/di/metadata.ts
new file mode 100644
index 0000000..d367785
--- /dev/null
+++ b/angular/core/src/di/metadata.ts
@@ -0,0 +1,288 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {makeDecorator, makeParamDecorator} from '../util/decorators';
+
+
+/**
+ * Type of the Inject decorator / constructor function.
+ *
+ * @stable
+ */
+export interface InjectDecorator {
+  /**
+   * @whatItDoes A parameter decorator that specifies a dependency.
+   * @howToUse
+   * ```
+   * @Injectable()
+   * class Car {
+   *   constructor(@Inject("MyEngine") public engine:Engine) {}
+   * }
+   * ```
+   *
+   * @description
+   * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/metadata_spec.ts region='Inject'}
+   *
+   * When `@Inject()` is not present, {@link Injector} will use the type annotation of the
+   * parameter.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/metadata_spec.ts region='InjectWithoutDecorator'}
+   *
+   * @stable
+   */
+  (token: any): any;
+  new (token: any): Inject;
+}
+
+/**
+ * Type of the Inject metadata.
+ *
+ * @stable
+ */
+export interface Inject { token: any; }
+
+/**
+ * Inject decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const Inject: InjectDecorator = makeParamDecorator('Inject', (token: any) => ({token}));
+
+
+/**
+ * Type of the Optional decorator / constructor function.
+ *
+ * @stable
+ */
+export interface OptionalDecorator {
+  /**
+   * @whatItDoes A parameter metadata that marks a dependency as optional.
+   * {@link Injector} provides `null` if the dependency is not found.
+   * @howToUse
+   * ```
+   * @Injectable()
+   * class Car {
+   *   constructor(@Optional() public engine:Engine) {}
+   * }
+   * ```
+   *
+   * @description
+   * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/metadata_spec.ts region='Optional'}
+   *
+   * @stable
+   */
+  (): any;
+  new (): Optional;
+}
+
+/**
+ * Type of the Optional metadata.
+ *
+ * @stable
+ */
+export interface Optional {}
+
+/**
+ * Optional decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const Optional: OptionalDecorator = makeParamDecorator('Optional');
+
+/**
+ * Type of the Injectable decorator / constructor function.
+ *
+ * @stable
+ */
+export interface InjectableDecorator {
+  /**
+   * @whatItDoes A marker metadata that marks a class as available to {@link Injector} for creation.
+   * @howToUse
+   * ```
+   * @Injectable()
+   * class Car {}
+   * ```
+   *
+   * @description
+   * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/metadata_spec.ts region='Injectable'}
+   *
+   * {@link Injector} will throw an error when trying to instantiate a class that
+   * does not have `@Injectable` marker, as shown in the example below.
+   *
+   * {@example core/di/ts/metadata_spec.ts region='InjectableThrows'}
+   *
+   * @stable
+   */
+  (): any;
+  new (): Injectable;
+}
+
+/**
+ * Type of the Injectable metadata.
+ *
+ * @stable
+ */
+export interface Injectable {}
+
+/**
+ * Injectable decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const Injectable: InjectableDecorator = makeDecorator('Injectable');
+
+/**
+ * Type of the Self decorator / constructor function.
+ *
+ * @stable
+ */
+export interface SelfDecorator {
+  /**
+   * @whatItDoes Specifies that an {@link Injector} should retrieve a dependency only from itself.
+   * @howToUse
+   * ```
+   * @Injectable()
+   * class Car {
+   *   constructor(@Self() public engine:Engine) {}
+   * }
+   * ```
+   *
+   * @description
+   * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/metadata_spec.ts region='Self'}
+   *
+   * @stable
+   */
+  (): any;
+  new (): Self;
+}
+
+/**
+ * Type of the Self metadata.
+ *
+ * @stable
+ */
+export interface Self {}
+
+/**
+ * Self decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const Self: SelfDecorator = makeParamDecorator('Self');
+
+
+/**
+ * Type of the SkipSelf decorator / constructor function.
+ *
+ * @stable
+ */
+export interface SkipSelfDecorator {
+  /**
+   * @whatItDoes Specifies that the dependency resolution should start from the parent injector.
+   * @howToUse
+   * ```
+   * @Injectable()
+   * class Car {
+   *   constructor(@SkipSelf() public engine:Engine) {}
+   * }
+   * ```
+   *
+   * @description
+   * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/metadata_spec.ts region='SkipSelf'}
+   *
+   * @stable
+   */
+  (): any;
+  new (): SkipSelf;
+}
+
+/**
+ * Type of the SkipSelf metadata.
+ *
+ * @stable
+ */
+export interface SkipSelf {}
+
+/**
+ * SkipSelf decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const SkipSelf: SkipSelfDecorator = makeParamDecorator('SkipSelf');
+
+/**
+ * Type of the Host decorator / constructor function.
+ *
+ * @stable
+ */
+export interface HostDecorator {
+  /**
+   * @whatItDoes Specifies that an injector should retrieve a dependency from any injector until
+   * reaching the host element of the current component.
+   * @howToUse
+   * ```
+   * @Injectable()
+   * class Car {
+   *   constructor(@Host() public engine:Engine) {}
+   * }
+   * ```
+   *
+   * @description
+   * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/metadata_spec.ts region='Host'}
+   *
+   * @stable
+   */
+  (): any;
+  new (): Host;
+}
+
+/**
+ * Type of the Host metadata.
+ *
+ * @stable
+ */
+export interface Host {}
+
+/**
+ * Host decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const Host: HostDecorator = makeParamDecorator('Host');
diff --git a/angular/core/src/di/provider.ts b/angular/core/src/di/provider.ts
new file mode 100644
index 0000000..9ad449e
--- /dev/null
+++ b/angular/core/src/di/provider.ts
@@ -0,0 +1,328 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Type} from '../type';
+
+/**
+ * @whatItDoes Configures the {@link Injector} to return a value for a token.
+ * @howToUse
+ * ```
+ * const provider: ValueProvider = {provide: 'someToken', useValue: 'someValue'};
+ * ```
+ *
+ * @description
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='ValueProvider'}
+ *
+ * @stable
+ */
+export interface ValueProvider {
+  /**
+   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+   */
+  provide: any;
+
+  /**
+   * The value to inject.
+   */
+  useValue: any;
+
+  /**
+   * If true, then injector returns an array of instances. This is useful to allow multiple
+   * providers spread across many files to provide configuration information to a common token.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+   */
+  multi?: boolean;
+}
+
+/**
+ * @whatItDoes Configures the {@link Injector} to return an instance of `useClass` for a token.
+ * @howToUse
+ * ```
+ * @Injectable()
+ * class MyService {}
+ *
+ * const provider: ClassProvider = {provide: 'someToken', useClass: MyService, deps: []};
+ * ```
+ *
+ * @description
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='StaticClassProvider'}
+ *
+ * Note that following two providers are not equal:
+ * {@example core/di/ts/provider_spec.ts region='StaticClassProviderDifference'}
+ *
+ * @stable
+ */
+export interface StaticClassProvider {
+  /**
+   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+   */
+  provide: any;
+
+  /**
+   * An optional class to instantiate for the `token`. (If not provided `provide` is assumed to be a
+   * class to
+   * instantiate)
+   */
+  useClass: Type<any>;
+
+  /**
+   * A list of `token`s which need to be resolved by the injector. The list of values is then
+   * used as arguments to the `useClass` constructor.
+   */
+  deps: any[];
+
+  /**
+   * If true, then injector returns an array of instances. This is useful to allow multiple
+   * providers spread across many files to provide configuration information to a common token.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+   */
+  multi?: boolean;
+}
+
+/**
+ * @whatItDoes Configures the {@link Injector} to return an instance of a token.
+ * @howToUse
+ * ```
+ * @Injectable()
+ * class MyService {}
+ *
+ * const provider: ClassProvider = {provide: MyClass, deps: []};
+ * ```
+ *
+ * @description
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
+ *
+ * @stable
+ */
+export interface ConstructorProvider {
+  /**
+   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+   */
+  provide: Type<any>;
+
+  /**
+   * A list of `token`s which need to be resolved by the injector. The list of values is then
+   * used as arguments to the `useClass` constructor.
+   */
+  deps: any[];
+
+  /**
+   * If true, then injector returns an array of instances. This is useful to allow multiple
+   * providers spread across many files to provide configuration information to a common token.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+   */
+  multi?: boolean;
+}
+
+/**
+ * @whatItDoes Configures the {@link Injector} to return a value of another `useExisting` token.
+ * @howToUse
+ * ```
+ * const provider: ExistingProvider = {provide: 'someToken', useExisting: 'someOtherToken'};
+ * ```
+ *
+ * @description
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='ExistingProvider'}
+ *
+ * @stable
+ */
+export interface ExistingProvider {
+  /**
+   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+   */
+  provide: any;
+
+  /**
+   * Existing `token` to return. (equivalent to `injector.get(useExisting)`)
+   */
+  useExisting: any;
+
+  /**
+   * If true, then injector returns an array of instances. This is useful to allow multiple
+   * providers spread across many files to provide configuration information to a common token.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+   */
+  multi?: boolean;
+}
+
+/**
+ * @whatItDoes Configures the {@link Injector} to return a value by invoking a `useFactory`
+ * function.
+ * @howToUse
+ * ```
+ * function serviceFactory() { ... }
+ *
+ * const provider: FactoryProvider = {provide: 'someToken', useFactory: serviceFactory, deps: []};
+ * ```
+ *
+ * @description
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='FactoryProvider'}
+ *
+ * Dependencies can also be marked as optional:
+ * {@example core/di/ts/provider_spec.ts region='FactoryProviderOptionalDeps'}
+ *
+ * @stable
+ */
+export interface FactoryProvider {
+  /**
+   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+   */
+  provide: any;
+
+  /**
+   * A function to invoke to create a value for this `token`. The function is invoked with
+   * resolved values of `token`s in the `deps` field.
+   */
+  useFactory: Function;
+
+  /**
+   * A list of `token`s which need to be resolved by the injector. The list of values is then
+   * used as arguments to the `useFactory` function.
+   */
+  deps?: any[];
+
+  /**
+   * If true, then injector returns an array of instances. This is useful to allow multiple
+   * providers spread across many files to provide configuration information to a common token.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+   */
+  multi?: boolean;
+}
+
+/**
+ * @whatItDoes Describes how the {@link Injector} should be configured in a static way (Without
+ * reflection).
+ * @howToUse
+ * See {@link ValueProvider}, {@link ExistingProvider}, {@link FactoryProvider}.
+ *
+ * @description
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * @stable
+ */
+export type StaticProvider = ValueProvider | ExistingProvider | StaticClassProvider |
+    ConstructorProvider | FactoryProvider | any[];
+
+
+/**
+ * @whatItDoes Configures the {@link Injector} to return an instance of `Type` when `Type' is used
+ * as token.
+ * @howToUse
+ * ```
+ * @Injectable()
+ * class MyService {}
+ *
+ * const provider: TypeProvider = MyService;
+ * ```
+ *
+ * @description
+ *
+ * Create an instance by invoking the `new` operator and supplying additional arguments.
+ * This form is a short form of `TypeProvider`;
+ *
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='TypeProvider'}
+ *
+ * @stable
+ */
+export interface TypeProvider extends Type<any> {}
+
+/**
+ * @whatItDoes Configures the {@link Injector} to return an instance of `useClass` for a token.
+ * @howToUse
+ * ```
+ * @Injectable()
+ * class MyService {}
+ *
+ * const provider: ClassProvider = {provide: 'someToken', useClass: MyService};
+ * ```
+ *
+ * @description
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='ClassProvider'}
+ *
+ * Note that following two providers are not equal:
+ * {@example core/di/ts/provider_spec.ts region='ClassProviderDifference'}
+ *
+ * @stable
+ */
+export interface ClassProvider {
+  /**
+   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+   */
+  provide: any;
+
+  /**
+   * Class to instantiate for the `token`.
+   */
+  useClass: Type<any>;
+
+  /**
+   * If true, then injector returns an array of instances. This is useful to allow multiple
+   * providers spread across many files to provide configuration information to a common token.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+   */
+  multi?: boolean;
+}
+
+/**
+ * @whatItDoes Describes how the {@link Injector} should be configured.
+ * @howToUse
+ * See {@link TypeProvider}, {@link ClassProvider}, {@link StaticProvider}.
+ *
+ * @description
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * @stable
+ */
+export type Provider =
+    TypeProvider | ValueProvider | ClassProvider | ExistingProvider | FactoryProvider | any[];
diff --git a/angular/core/src/di/reflective_errors.ts b/angular/core/src/di/reflective_errors.ts
new file mode 100644
index 0000000..4eaf4be
--- /dev/null
+++ b/angular/core/src/di/reflective_errors.ts
@@ -0,0 +1,243 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {wrappedError} from '../error_handler';
+import {ERROR_ORIGINAL_ERROR, getOriginalError} from '../errors';
+import {Type} from '../type';
+import {stringify} from '../util';
+
+import {ReflectiveInjector} from './reflective_injector';
+import {ReflectiveKey} from './reflective_key';
+
+function findFirstClosedCycle(keys: any[]): any[] {
+  const res: any[] = [];
+  for (let i = 0; i < keys.length; ++i) {
+    if (res.indexOf(keys[i]) > -1) {
+      res.push(keys[i]);
+      return res;
+    }
+    res.push(keys[i]);
+  }
+  return res;
+}
+
+function constructResolvingPath(keys: any[]): string {
+  if (keys.length > 1) {
+    const reversed = findFirstClosedCycle(keys.slice().reverse());
+    const tokenStrs = reversed.map(k => stringify(k.token));
+    return ' (' + tokenStrs.join(' -> ') + ')';
+  }
+
+  return '';
+}
+
+export interface InjectionError extends Error {
+  keys: ReflectiveKey[];
+  injectors: ReflectiveInjector[];
+  constructResolvingMessage: (keys: ReflectiveKey[]) => string;
+  addKey(injector: ReflectiveInjector, key: ReflectiveKey): void;
+}
+
+function injectionError(
+    injector: ReflectiveInjector, key: ReflectiveKey,
+    constructResolvingMessage: (keys: ReflectiveKey[]) => string,
+    originalError?: Error): InjectionError {
+  const keys = [key];
+  const errMsg = constructResolvingMessage(keys);
+  const error =
+      (originalError ? wrappedError(errMsg, originalError) : Error(errMsg)) as InjectionError;
+  error.addKey = addKey;
+  error.keys = keys;
+  error.injectors = [injector];
+  error.constructResolvingMessage = constructResolvingMessage;
+  (error as any)[ERROR_ORIGINAL_ERROR] = originalError;
+  return error;
+}
+
+function addKey(this: InjectionError, injector: ReflectiveInjector, key: ReflectiveKey): void {
+  this.injectors.push(injector);
+  this.keys.push(key);
+  // Note: This updated message won't be reflected in the `.stack` property
+  this.message = this.constructResolvingMessage(this.keys);
+}
+
+/**
+ * Thrown when trying to retrieve a dependency by key from {@link Injector}, but the
+ * {@link Injector} does not have a {@link Provider} for the given key.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/vq8D3FRB9aGbnWJqtEPE?p=preview))
+ *
+ * ```typescript
+ * class A {
+ *   constructor(b:B) {}
+ * }
+ *
+ * expect(() => Injector.resolveAndCreate([A])).toThrowError();
+ * ```
+ */
+export function noProviderError(injector: ReflectiveInjector, key: ReflectiveKey): InjectionError {
+  return injectionError(injector, key, function(keys: ReflectiveKey[]) {
+    const first = stringify(keys[0].token);
+    return `No provider for ${first}!${constructResolvingPath(keys)}`;
+  });
+}
+
+/**
+ * Thrown when dependencies form a cycle.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/wYQdNos0Tzql3ei1EV9j?p=info))
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([
+ *   {provide: "one", useFactory: (two) => "two", deps: [[new Inject("two")]]},
+ *   {provide: "two", useFactory: (one) => "one", deps: [[new Inject("one")]]}
+ * ]);
+ *
+ * expect(() => injector.get("one")).toThrowError();
+ * ```
+ *
+ * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
+ */
+export function cyclicDependencyError(
+    injector: ReflectiveInjector, key: ReflectiveKey): InjectionError {
+  return injectionError(injector, key, function(keys: ReflectiveKey[]) {
+    return `Cannot instantiate cyclic dependency!${constructResolvingPath(keys)}`;
+  });
+}
+
+/**
+ * Thrown when a constructing type returns with an Error.
+ *
+ * The `InstantiationError` class contains the original error plus the dependency graph which caused
+ * this object to be instantiated.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/7aWYdcqTQsP0eNqEdUAf?p=preview))
+ *
+ * ```typescript
+ * class A {
+ *   constructor() {
+ *     throw new Error('message');
+ *   }
+ * }
+ *
+ * var injector = Injector.resolveAndCreate([A]);
+
+ * try {
+ *   injector.get(A);
+ * } catch (e) {
+ *   expect(e instanceof InstantiationError).toBe(true);
+ *   expect(e.originalException.message).toEqual("message");
+ *   expect(e.originalStack).toBeDefined();
+ * }
+ * ```
+ */
+export function instantiationError(
+    injector: ReflectiveInjector, originalException: any, originalStack: any,
+    key: ReflectiveKey): InjectionError {
+  return injectionError(injector, key, function(keys: ReflectiveKey[]) {
+    const first = stringify(keys[0].token);
+    return `${originalException.message}: Error during instantiation of ${first}!${constructResolvingPath(keys)}.`;
+  }, originalException);
+}
+
+/**
+ * Thrown when an object other then {@link Provider} (or `Type`) is passed to {@link Injector}
+ * creation.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/YatCFbPAMCL0JSSQ4mvH?p=preview))
+ *
+ * ```typescript
+ * expect(() => Injector.resolveAndCreate(["not a type"])).toThrowError();
+ * ```
+ */
+export function invalidProviderError(provider: any) {
+  return Error(
+      `Invalid provider - only instances of Provider and Type are allowed, got: ${provider}`);
+}
+
+/**
+ * Thrown when the class has no annotation information.
+ *
+ * Lack of annotation information prevents the {@link Injector} from determining which dependencies
+ * need to be injected into the constructor.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/rHnZtlNS7vJOPQ6pcVkm?p=preview))
+ *
+ * ```typescript
+ * class A {
+ *   constructor(b) {}
+ * }
+ *
+ * expect(() => Injector.resolveAndCreate([A])).toThrowError();
+ * ```
+ *
+ * This error is also thrown when the class not marked with {@link Injectable} has parameter types.
+ *
+ * ```typescript
+ * class B {}
+ *
+ * class A {
+ *   constructor(b:B) {} // no information about the parameter types of A is available at runtime.
+ * }
+ *
+ * expect(() => Injector.resolveAndCreate([A,B])).toThrowError();
+ * ```
+ * @stable
+ */
+export function noAnnotationError(typeOrFunc: Type<any>| Function, params: any[][]): Error {
+  const signature: string[] = [];
+  for (let i = 0, ii = params.length; i < ii; i++) {
+    const parameter = params[i];
+    if (!parameter || parameter.length == 0) {
+      signature.push('?');
+    } else {
+      signature.push(parameter.map(stringify).join(' '));
+    }
+  }
+  return Error(
+      'Cannot resolve all parameters for \'' + stringify(typeOrFunc) + '\'(' +
+      signature.join(', ') + '). ' +
+      'Make sure that all the parameters are decorated with Inject or have valid type annotations and that \'' +
+      stringify(typeOrFunc) + '\' is decorated with Injectable.');
+}
+
+/**
+ * Thrown when getting an object by index.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/bRs0SX2OTQiJzqvjgl8P?p=preview))
+ *
+ * ```typescript
+ * class A {}
+ *
+ * var injector = Injector.resolveAndCreate([A]);
+ *
+ * expect(() => injector.getAt(100)).toThrowError();
+ * ```
+ * @stable
+ */
+export function outOfBoundsError(index: number) {
+  return Error(`Index ${index} is out-of-bounds.`);
+}
+
+// TODO: add a working example after alpha38 is released
+/**
+ * Thrown when a multi provider and a regular provider are bound to the same token.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * expect(() => Injector.resolveAndCreate([
+ *   { provide: "Strings", useValue: "string1", multi: true},
+ *   { provide: "Strings", useValue: "string2", multi: false}
+ * ])).toThrowError();
+ * ```
+ */
+export function mixingMultiProvidersWithRegularProvidersError(
+    provider1: any, provider2: any): Error {
+  return Error(`Cannot mix multi providers and regular providers, got: ${provider1} ${provider2}`);
+}
diff --git a/angular/core/src/di/reflective_injector.ts b/angular/core/src/di/reflective_injector.ts
new file mode 100644
index 0000000..6b7f4c4
--- /dev/null
+++ b/angular/core/src/di/reflective_injector.ts
@@ -0,0 +1,473 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injector, THROW_IF_NOT_FOUND} from './injector';
+import {Self, SkipSelf} from './metadata';
+import {Provider} from './provider';
+import {cyclicDependencyError, instantiationError, noProviderError, outOfBoundsError} from './reflective_errors';
+import {ReflectiveKey} from './reflective_key';
+import {ReflectiveDependency, ResolvedReflectiveFactory, ResolvedReflectiveProvider, resolveReflectiveProviders} from './reflective_provider';
+
+// Threshold for the dynamic version
+const UNDEFINED = new Object();
+
+/**
+ * A ReflectiveDependency injection container used for instantiating objects and resolving
+ * dependencies.
+ *
+ * An `Injector` is a replacement for a `new` operator, which can automatically resolve the
+ * constructor dependencies.
+ *
+ * In typical use, application code asks for the dependencies in the constructor and they are
+ * resolved by the `Injector`.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/jzjec0?p=preview))
+ *
+ * The following example creates an `Injector` configured to create `Engine` and `Car`.
+ *
+ * ```typescript
+ * @Injectable()
+ * class Engine {
+ * }
+ *
+ * @Injectable()
+ * class Car {
+ *   constructor(public engine:Engine) {}
+ * }
+ *
+ * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
+ * var car = injector.get(Car);
+ * expect(car instanceof Car).toBe(true);
+ * expect(car.engine instanceof Engine).toBe(true);
+ * ```
+ *
+ * Notice, we don't use the `new` operator because we explicitly want to have the `Injector`
+ * resolve all of the object's dependencies automatically.
+ *
+ * @deprecated from v5 - slow and brings in a lot of code, Use `Injector.create` instead.
+ */
+export abstract class ReflectiveInjector implements Injector {
+  /**
+   * Turns an array of provider definitions into an array of resolved providers.
+   *
+   * A resolution is a process of flattening multiple nested arrays and converting individual
+   * providers into an array of {@link ResolvedReflectiveProvider}s.
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/AiXTHi?p=preview))
+   *
+   * ```typescript
+   * @Injectable()
+   * class Engine {
+   * }
+   *
+   * @Injectable()
+   * class Car {
+   *   constructor(public engine:Engine) {}
+   * }
+   *
+   * var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);
+   *
+   * expect(providers.length).toEqual(2);
+   *
+   * expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);
+   * expect(providers[0].key.displayName).toBe("Car");
+   * expect(providers[0].dependencies.length).toEqual(1);
+   * expect(providers[0].factory).toBeDefined();
+   *
+   * expect(providers[1].key.displayName).toBe("Engine");
+   * });
+   * ```
+   *
+   * See {@link ReflectiveInjector#fromResolvedProviders} for more info.
+   */
+  static resolve(providers: Provider[]): ResolvedReflectiveProvider[] {
+    return resolveReflectiveProviders(providers);
+  }
+
+  /**
+   * Resolves an array of providers and creates an injector from those providers.
+   *
+   * The passed-in providers can be an array of `Type`, {@link Provider},
+   * or a recursive array of more providers.
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/ePOccA?p=preview))
+   *
+   * ```typescript
+   * @Injectable()
+   * class Engine {
+   * }
+   *
+   * @Injectable()
+   * class Car {
+   *   constructor(public engine:Engine) {}
+   * }
+   *
+   * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
+   * expect(injector.get(Car) instanceof Car).toBe(true);
+   * ```
+   *
+   * This function is slower than the corresponding `fromResolvedProviders`
+   * because it needs to resolve the passed-in providers first.
+   * See {@link ReflectiveInjector#resolve} and {@link ReflectiveInjector#fromResolvedProviders}.
+   */
+  static resolveAndCreate(providers: Provider[], parent?: Injector): ReflectiveInjector {
+    const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
+    return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);
+  }
+
+  /**
+   * Creates an injector from previously resolved providers.
+   *
+   * This API is the recommended way to construct injectors in performance-sensitive parts.
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/KrSMci?p=preview))
+   *
+   * ```typescript
+   * @Injectable()
+   * class Engine {
+   * }
+   *
+   * @Injectable()
+   * class Car {
+   *   constructor(public engine:Engine) {}
+   * }
+   *
+   * var providers = ReflectiveInjector.resolve([Car, Engine]);
+   * var injector = ReflectiveInjector.fromResolvedProviders(providers);
+   * expect(injector.get(Car) instanceof Car).toBe(true);
+   * ```
+   * @experimental
+   */
+  static fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent?: Injector):
+      ReflectiveInjector {
+    return new ReflectiveInjector_(providers, parent);
+  }
+
+
+  /**
+   * Parent of this injector.
+   *
+   * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.
+   * -->
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/eosMGo?p=preview))
+   *
+   * ```typescript
+   * var parent = ReflectiveInjector.resolveAndCreate([]);
+   * var child = parent.resolveAndCreateChild([]);
+   * expect(child.parent).toBe(parent);
+   * ```
+   */
+  abstract get parent(): Injector|null;
+
+  /**
+   * Resolves an array of providers and creates a child injector from those providers.
+   *
+   * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.
+   * -->
+   *
+   * The passed-in providers can be an array of `Type`, {@link Provider},
+   * or a recursive array of more providers.
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/opB3T4?p=preview))
+   *
+   * ```typescript
+   * class ParentProvider {}
+   * class ChildProvider {}
+   *
+   * var parent = ReflectiveInjector.resolveAndCreate([ParentProvider]);
+   * var child = parent.resolveAndCreateChild([ChildProvider]);
+   *
+   * expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
+   * expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
+   * expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));
+   * ```
+   *
+   * This function is slower than the corresponding `createChildFromResolved`
+   * because it needs to resolve the passed-in providers first.
+   * See {@link ReflectiveInjector#resolve} and {@link ReflectiveInjector#createChildFromResolved}.
+   */
+  abstract resolveAndCreateChild(providers: Provider[]): ReflectiveInjector;
+
+  /**
+   * Creates a child injector from previously resolved providers.
+   *
+   * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.
+   * -->
+   *
+   * This API is the recommended way to construct injectors in performance-sensitive parts.
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/VhyfjN?p=preview))
+   *
+   * ```typescript
+   * class ParentProvider {}
+   * class ChildProvider {}
+   *
+   * var parentProviders = ReflectiveInjector.resolve([ParentProvider]);
+   * var childProviders = ReflectiveInjector.resolve([ChildProvider]);
+   *
+   * var parent = ReflectiveInjector.fromResolvedProviders(parentProviders);
+   * var child = parent.createChildFromResolved(childProviders);
+   *
+   * expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
+   * expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
+   * expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));
+   * ```
+   */
+  abstract createChildFromResolved(providers: ResolvedReflectiveProvider[]): ReflectiveInjector;
+
+  /**
+   * Resolves a provider and instantiates an object in the context of the injector.
+   *
+   * The created object does not get cached by the injector.
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/yvVXoB?p=preview))
+   *
+   * ```typescript
+   * @Injectable()
+   * class Engine {
+   * }
+   *
+   * @Injectable()
+   * class Car {
+   *   constructor(public engine:Engine) {}
+   * }
+   *
+   * var injector = ReflectiveInjector.resolveAndCreate([Engine]);
+   *
+   * var car = injector.resolveAndInstantiate(Car);
+   * expect(car.engine).toBe(injector.get(Engine));
+   * expect(car).not.toBe(injector.resolveAndInstantiate(Car));
+   * ```
+   */
+  abstract resolveAndInstantiate(provider: Provider): any;
+
+  /**
+   * Instantiates an object using a resolved provider in the context of the injector.
+   *
+   * The created object does not get cached by the injector.
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/ptCImQ?p=preview))
+   *
+   * ```typescript
+   * @Injectable()
+   * class Engine {
+   * }
+   *
+   * @Injectable()
+   * class Car {
+   *   constructor(public engine:Engine) {}
+   * }
+   *
+   * var injector = ReflectiveInjector.resolveAndCreate([Engine]);
+   * var carProvider = ReflectiveInjector.resolve([Car])[0];
+   * var car = injector.instantiateResolved(carProvider);
+   * expect(car.engine).toBe(injector.get(Engine));
+   * expect(car).not.toBe(injector.instantiateResolved(carProvider));
+   * ```
+   */
+  abstract instantiateResolved(provider: ResolvedReflectiveProvider): any;
+
+  abstract get(token: any, notFoundValue?: any): any;
+}
+
+export class ReflectiveInjector_ implements ReflectiveInjector {
+  private static INJECTOR_KEY = ReflectiveKey.get(Injector);
+  /** @internal */
+  _constructionCounter: number = 0;
+  /** @internal */
+  public _providers: ResolvedReflectiveProvider[];
+  /** @internal */
+  public _parent: Injector|null;
+
+  keyIds: number[];
+  objs: any[];
+  /**
+   * Private
+   */
+  constructor(_providers: ResolvedReflectiveProvider[], _parent?: Injector) {
+    this._providers = _providers;
+    this._parent = _parent || null;
+
+    const len = _providers.length;
+
+    this.keyIds = new Array(len);
+    this.objs = new Array(len);
+
+    for (let i = 0; i < len; i++) {
+      this.keyIds[i] = _providers[i].key.id;
+      this.objs[i] = UNDEFINED;
+    }
+  }
+
+  get(token: any, notFoundValue: any = THROW_IF_NOT_FOUND): any {
+    return this._getByKey(ReflectiveKey.get(token), null, notFoundValue);
+  }
+
+  get parent(): Injector|null { return this._parent; }
+
+  resolveAndCreateChild(providers: Provider[]): ReflectiveInjector {
+    const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
+    return this.createChildFromResolved(ResolvedReflectiveProviders);
+  }
+
+  createChildFromResolved(providers: ResolvedReflectiveProvider[]): ReflectiveInjector {
+    const inj = new ReflectiveInjector_(providers);
+    inj._parent = this;
+    return inj;
+  }
+
+  resolveAndInstantiate(provider: Provider): any {
+    return this.instantiateResolved(ReflectiveInjector.resolve([provider])[0]);
+  }
+
+  instantiateResolved(provider: ResolvedReflectiveProvider): any {
+    return this._instantiateProvider(provider);
+  }
+
+  getProviderAtIndex(index: number): ResolvedReflectiveProvider {
+    if (index < 0 || index >= this._providers.length) {
+      throw outOfBoundsError(index);
+    }
+    return this._providers[index];
+  }
+
+  /** @internal */
+  _new(provider: ResolvedReflectiveProvider): any {
+    if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {
+      throw cyclicDependencyError(this, provider.key);
+    }
+    return this._instantiateProvider(provider);
+  }
+
+  private _getMaxNumberOfObjects(): number { return this.objs.length; }
+
+  private _instantiateProvider(provider: ResolvedReflectiveProvider): any {
+    if (provider.multiProvider) {
+      const res = new Array(provider.resolvedFactories.length);
+      for (let i = 0; i < provider.resolvedFactories.length; ++i) {
+        res[i] = this._instantiate(provider, provider.resolvedFactories[i]);
+      }
+      return res;
+    } else {
+      return this._instantiate(provider, provider.resolvedFactories[0]);
+    }
+  }
+
+  private _instantiate(
+      provider: ResolvedReflectiveProvider,
+      ResolvedReflectiveFactory: ResolvedReflectiveFactory): any {
+    const factory = ResolvedReflectiveFactory.factory;
+
+    let deps: any[];
+    try {
+      deps =
+          ResolvedReflectiveFactory.dependencies.map(dep => this._getByReflectiveDependency(dep));
+    } catch (e) {
+      if (e.addKey) {
+        e.addKey(this, provider.key);
+      }
+      throw e;
+    }
+
+    let obj: any;
+    try {
+      obj = factory(...deps);
+    } catch (e) {
+      throw instantiationError(this, e, e.stack, provider.key);
+    }
+
+    return obj;
+  }
+
+  private _getByReflectiveDependency(dep: ReflectiveDependency): any {
+    return this._getByKey(dep.key, dep.visibility, dep.optional ? null : THROW_IF_NOT_FOUND);
+  }
+
+  private _getByKey(key: ReflectiveKey, visibility: Self|SkipSelf|null, notFoundValue: any): any {
+    if (key === ReflectiveInjector_.INJECTOR_KEY) {
+      return this;
+    }
+
+    if (visibility instanceof Self) {
+      return this._getByKeySelf(key, notFoundValue);
+
+    } else {
+      return this._getByKeyDefault(key, notFoundValue, visibility);
+    }
+  }
+
+  private _getObjByKeyId(keyId: number): any {
+    for (let i = 0; i < this.keyIds.length; i++) {
+      if (this.keyIds[i] === keyId) {
+        if (this.objs[i] === UNDEFINED) {
+          this.objs[i] = this._new(this._providers[i]);
+        }
+
+        return this.objs[i];
+      }
+    }
+
+    return UNDEFINED;
+  }
+
+  /** @internal */
+  _throwOrNull(key: ReflectiveKey, notFoundValue: any): any {
+    if (notFoundValue !== THROW_IF_NOT_FOUND) {
+      return notFoundValue;
+    } else {
+      throw noProviderError(this, key);
+    }
+  }
+
+  /** @internal */
+  _getByKeySelf(key: ReflectiveKey, notFoundValue: any): any {
+    const obj = this._getObjByKeyId(key.id);
+    return (obj !== UNDEFINED) ? obj : this._throwOrNull(key, notFoundValue);
+  }
+
+  /** @internal */
+  _getByKeyDefault(key: ReflectiveKey, notFoundValue: any, visibility: Self|SkipSelf|null): any {
+    let inj: Injector|null;
+
+    if (visibility instanceof SkipSelf) {
+      inj = this._parent;
+    } else {
+      inj = this;
+    }
+
+    while (inj instanceof ReflectiveInjector_) {
+      const inj_ = <ReflectiveInjector_>inj;
+      const obj = inj_._getObjByKeyId(key.id);
+      if (obj !== UNDEFINED) return obj;
+      inj = inj_._parent;
+    }
+    if (inj !== null) {
+      return inj.get(key.token, notFoundValue);
+    } else {
+      return this._throwOrNull(key, notFoundValue);
+    }
+  }
+
+  get displayName(): string {
+    const providers =
+        _mapProviders(this, (b: ResolvedReflectiveProvider) => ' "' + b.key.displayName + '" ')
+            .join(', ');
+    return `ReflectiveInjector(providers: [${providers}])`;
+  }
+
+  toString(): string { return this.displayName; }
+}
+
+function _mapProviders(injector: ReflectiveInjector_, fn: Function): any[] {
+  const res: any[] = new Array(injector._providers.length);
+  for (let i = 0; i < injector._providers.length; ++i) {
+    res[i] = fn(injector.getProviderAtIndex(i));
+  }
+  return res;
+}
diff --git a/angular/core/src/di/reflective_key.ts b/angular/core/src/di/reflective_key.ts
new file mode 100644
index 0000000..765f3fd
--- /dev/null
+++ b/angular/core/src/di/reflective_key.ts
@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {stringify} from '../util';
+import {resolveForwardRef} from './forward_ref';
+
+
+/**
+ * A unique object used for retrieving items from the {@link ReflectiveInjector}.
+ *
+ * Keys have:
+ * - a system-wide unique `id`.
+ * - a `token`.
+ *
+ * `Key` is used internally by {@link ReflectiveInjector} because its system-wide unique `id` allows
+ * the
+ * injector to store created objects in a more efficient way.
+ *
+ * `Key` should not be created directly. {@link ReflectiveInjector} creates keys automatically when
+ * resolving
+ * providers.
+ * @deprecated No replacement
+ */
+export class ReflectiveKey {
+  /**
+   * Private
+   */
+  constructor(public token: Object, public id: number) {
+    if (!token) {
+      throw new Error('Token must be defined!');
+    }
+  }
+
+  /**
+   * Returns a stringified token.
+   */
+  get displayName(): string { return stringify(this.token); }
+
+  /**
+   * Retrieves a `Key` for a token.
+   */
+  static get(token: Object): ReflectiveKey {
+    return _globalKeyRegistry.get(resolveForwardRef(token));
+  }
+
+  /**
+   * @returns the number of keys registered in the system.
+   */
+  static get numberOfKeys(): number { return _globalKeyRegistry.numberOfKeys; }
+}
+
+/**
+ * @internal
+ */
+export class KeyRegistry {
+  private _allKeys = new Map<Object, ReflectiveKey>();
+
+  get(token: Object): ReflectiveKey {
+    if (token instanceof ReflectiveKey) return token;
+
+    if (this._allKeys.has(token)) {
+      return this._allKeys.get(token) !;
+    }
+
+    const newKey = new ReflectiveKey(token, ReflectiveKey.numberOfKeys);
+    this._allKeys.set(token, newKey);
+    return newKey;
+  }
+
+  get numberOfKeys(): number { return this._allKeys.size; }
+}
+
+const _globalKeyRegistry = new KeyRegistry();
diff --git a/angular/core/src/di/reflective_provider.ts b/angular/core/src/di/reflective_provider.ts
new file mode 100644
index 0000000..1243d8c
--- /dev/null
+++ b/angular/core/src/di/reflective_provider.ts
@@ -0,0 +1,267 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {reflector} from '../reflection/reflection';
+import {Type} from '../type';
+
+import {resolveForwardRef} from './forward_ref';
+import {InjectionToken} from './injection_token';
+import {Inject, Optional, Self, SkipSelf} from './metadata';
+import {ClassProvider, ExistingProvider, FactoryProvider, Provider, TypeProvider, ValueProvider} from './provider';
+import {invalidProviderError, mixingMultiProvidersWithRegularProvidersError, noAnnotationError} from './reflective_errors';
+import {ReflectiveKey} from './reflective_key';
+
+
+interface NormalizedProvider extends TypeProvider, ValueProvider, ClassProvider, ExistingProvider,
+    FactoryProvider {}
+
+/**
+ * `Dependency` is used by the framework to extend DI.
+ * This is internal to Angular and should not be used directly.
+ */
+export class ReflectiveDependency {
+  constructor(
+      public key: ReflectiveKey, public optional: boolean, public visibility: Self|SkipSelf|null) {}
+
+  static fromKey(key: ReflectiveKey): ReflectiveDependency {
+    return new ReflectiveDependency(key, false, null);
+  }
+}
+
+const _EMPTY_LIST: any[] = [];
+
+/**
+ * An internal resolved representation of a {@link Provider} used by the {@link Injector}.
+ *
+ * It is usually created automatically by `Injector.resolveAndCreate`.
+ *
+ * It can be created manually, as follows:
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/RfEnhh8kUEI0G3qsnIeT?p%3Dpreview&p=preview))
+ *
+ * ```typescript
+ * var resolvedProviders = Injector.resolve([{ provide: 'message', useValue: 'Hello' }]);
+ * var injector = Injector.fromResolvedProviders(resolvedProviders);
+ *
+ * expect(injector.get('message')).toEqual('Hello');
+ * ```
+ *
+ * @experimental
+ */
+export interface ResolvedReflectiveProvider {
+  /**
+   * A key, usually a `Type<any>`.
+   */
+  key: ReflectiveKey;
+
+  /**
+   * Factory function which can return an instance of an object represented by a key.
+   */
+  resolvedFactories: ResolvedReflectiveFactory[];
+
+  /**
+   * Indicates if the provider is a multi-provider or a regular provider.
+   */
+  multiProvider: boolean;
+}
+
+export class ResolvedReflectiveProvider_ implements ResolvedReflectiveProvider {
+  constructor(
+      public key: ReflectiveKey, public resolvedFactories: ResolvedReflectiveFactory[],
+      public multiProvider: boolean) {}
+
+  get resolvedFactory(): ResolvedReflectiveFactory { return this.resolvedFactories[0]; }
+}
+
+/**
+ * An internal resolved representation of a factory function created by resolving {@link
+ * Provider}.
+ * @experimental
+ */
+export class ResolvedReflectiveFactory {
+  constructor(
+      /**
+       * Factory function which can return an instance of an object represented by a key.
+       */
+      public factory: Function,
+
+      /**
+       * Arguments (dependencies) to the `factory` function.
+       */
+      public dependencies: ReflectiveDependency[]) {}
+}
+
+
+/**
+ * Resolve a single provider.
+ */
+function resolveReflectiveFactory(provider: NormalizedProvider): ResolvedReflectiveFactory {
+  let factoryFn: Function;
+  let resolvedDeps: ReflectiveDependency[];
+  if (provider.useClass) {
+    const useClass = resolveForwardRef(provider.useClass);
+    factoryFn = reflector.factory(useClass);
+    resolvedDeps = _dependenciesFor(useClass);
+  } else if (provider.useExisting) {
+    factoryFn = (aliasInstance: any) => aliasInstance;
+    resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];
+  } else if (provider.useFactory) {
+    factoryFn = provider.useFactory;
+    resolvedDeps = constructDependencies(provider.useFactory, provider.deps);
+  } else {
+    factoryFn = () => provider.useValue;
+    resolvedDeps = _EMPTY_LIST;
+  }
+  return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);
+}
+
+/**
+ * Converts the {@link Provider} into {@link ResolvedProvider}.
+ *
+ * {@link Injector} internally only uses {@link ResolvedProvider}, {@link Provider} contains
+ * convenience provider syntax.
+ */
+function resolveReflectiveProvider(provider: NormalizedProvider): ResolvedReflectiveProvider {
+  return new ResolvedReflectiveProvider_(
+      ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)],
+      provider.multi || false);
+}
+
+/**
+ * Resolve a list of Providers.
+ */
+export function resolveReflectiveProviders(providers: Provider[]): ResolvedReflectiveProvider[] {
+  const normalized = _normalizeProviders(providers, []);
+  const resolved = normalized.map(resolveReflectiveProvider);
+  const resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map());
+  return Array.from(resolvedProviderMap.values());
+}
+
+/**
+ * Merges a list of ResolvedProviders into a list where
+ * each key is contained exactly once and multi providers
+ * have been merged.
+ */
+export function mergeResolvedReflectiveProviders(
+    providers: ResolvedReflectiveProvider[],
+    normalizedProvidersMap: Map<number, ResolvedReflectiveProvider>):
+    Map<number, ResolvedReflectiveProvider> {
+  for (let i = 0; i < providers.length; i++) {
+    const provider = providers[i];
+    const existing = normalizedProvidersMap.get(provider.key.id);
+    if (existing) {
+      if (provider.multiProvider !== existing.multiProvider) {
+        throw mixingMultiProvidersWithRegularProvidersError(existing, provider);
+      }
+      if (provider.multiProvider) {
+        for (let j = 0; j < provider.resolvedFactories.length; j++) {
+          existing.resolvedFactories.push(provider.resolvedFactories[j]);
+        }
+      } else {
+        normalizedProvidersMap.set(provider.key.id, provider);
+      }
+    } else {
+      let resolvedProvider: ResolvedReflectiveProvider;
+      if (provider.multiProvider) {
+        resolvedProvider = new ResolvedReflectiveProvider_(
+            provider.key, provider.resolvedFactories.slice(), provider.multiProvider);
+      } else {
+        resolvedProvider = provider;
+      }
+      normalizedProvidersMap.set(provider.key.id, resolvedProvider);
+    }
+  }
+  return normalizedProvidersMap;
+}
+
+function _normalizeProviders(providers: Provider[], res: Provider[]): Provider[] {
+  providers.forEach(b => {
+    if (b instanceof Type) {
+      res.push({provide: b, useClass: b});
+
+    } else if (b && typeof b == 'object' && (b as any).provide !== undefined) {
+      res.push(b as NormalizedProvider);
+
+    } else if (b instanceof Array) {
+      _normalizeProviders(b, res);
+
+    } else {
+      throw invalidProviderError(b);
+    }
+  });
+
+  return res;
+}
+
+export function constructDependencies(
+    typeOrFunc: any, dependencies?: any[]): ReflectiveDependency[] {
+  if (!dependencies) {
+    return _dependenciesFor(typeOrFunc);
+  } else {
+    const params: any[][] = dependencies.map(t => [t]);
+    return dependencies.map(t => _extractToken(typeOrFunc, t, params));
+  }
+}
+
+function _dependenciesFor(typeOrFunc: any): ReflectiveDependency[] {
+  const params = reflector.parameters(typeOrFunc);
+
+  if (!params) return [];
+  if (params.some(p => p == null)) {
+    throw noAnnotationError(typeOrFunc, params);
+  }
+  return params.map(p => _extractToken(typeOrFunc, p, params));
+}
+
+function _extractToken(
+    typeOrFunc: any, metadata: any[] | any, params: any[][]): ReflectiveDependency {
+  let token: any = null;
+  let optional = false;
+
+  if (!Array.isArray(metadata)) {
+    if (metadata instanceof Inject) {
+      return _createDependency(metadata.token, optional, null);
+    } else {
+      return _createDependency(metadata, optional, null);
+    }
+  }
+
+  let visibility: Self|SkipSelf|null = null;
+
+  for (let i = 0; i < metadata.length; ++i) {
+    const paramMetadata = metadata[i];
+
+    if (paramMetadata instanceof Type) {
+      token = paramMetadata;
+
+    } else if (paramMetadata instanceof Inject) {
+      token = paramMetadata.token;
+
+    } else if (paramMetadata instanceof Optional) {
+      optional = true;
+
+    } else if (paramMetadata instanceof Self || paramMetadata instanceof SkipSelf) {
+      visibility = paramMetadata;
+    } else if (paramMetadata instanceof InjectionToken) {
+      token = paramMetadata;
+    }
+  }
+
+  token = resolveForwardRef(token);
+
+  if (token != null) {
+    return _createDependency(token, optional, visibility);
+  } else {
+    throw noAnnotationError(typeOrFunc, params);
+  }
+}
+
+function _createDependency(
+    token: any, optional: boolean, visibility: Self | SkipSelf | null): ReflectiveDependency {
+  return new ReflectiveDependency(ReflectiveKey.get(token), optional, visibility);
+}
diff --git a/angular/core/src/error_handler.ts b/angular/core/src/error_handler.ts
new file mode 100644
index 0000000..decb716
--- /dev/null
+++ b/angular/core/src/error_handler.ts
@@ -0,0 +1,95 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ERROR_ORIGINAL_ERROR, getDebugContext, getErrorLogger, getOriginalError} from './errors';
+
+
+
+/**
+ * @whatItDoes Provides a hook for centralized exception handling.
+ *
+ * @description
+ *
+ * The default implementation of `ErrorHandler` prints error messages to the `console`. To
+ * intercept error handling, write a custom exception handler that replaces this default as
+ * appropriate for your app.
+ *
+ * ### Example
+ *
+ * ```
+ * class MyErrorHandler implements ErrorHandler {
+ *   handleError(error) {
+ *     // do something with the exception
+ *   }
+ * }
+ *
+ * @NgModule({
+ *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]
+ * })
+ * class MyModule {}
+ * ```
+ *
+ * @stable
+ */
+export class ErrorHandler {
+  /**
+   * @internal
+   */
+  _console: Console = console;
+
+  constructor(
+      /**
+       * @deprecated since v4.0 parameter no longer has an effect, as ErrorHandler will never
+       * rethrow.
+       */
+      deprecatedParameter?: boolean) {}
+
+  handleError(error: any): void {
+    const originalError = this._findOriginalError(error);
+    const context = this._findContext(error);
+    // Note: Browser consoles show the place from where console.error was called.
+    // We can use this to give users additional information about the error.
+    const errorLogger = getErrorLogger(error);
+
+    errorLogger(this._console, `ERROR`, error);
+    if (originalError) {
+      errorLogger(this._console, `ORIGINAL ERROR`, originalError);
+    }
+    if (context) {
+      errorLogger(this._console, 'ERROR CONTEXT', context);
+    }
+  }
+
+  /** @internal */
+  _findContext(error: any): any {
+    if (error) {
+      return getDebugContext(error) ? getDebugContext(error) :
+                                      this._findContext(getOriginalError(error));
+    }
+
+    return null;
+  }
+
+  /** @internal */
+  _findOriginalError(error: Error): any {
+    let e = getOriginalError(error);
+    while (e && getOriginalError(e)) {
+      e = getOriginalError(e);
+    }
+
+    return e;
+  }
+}
+
+export function wrappedError(message: string, originalError: any): Error {
+  const msg =
+      `${message} caused by: ${originalError instanceof Error ? originalError.message: originalError }`;
+  const error = Error(msg);
+  (error as any)[ERROR_ORIGINAL_ERROR] = originalError;
+  return error;
+}
diff --git a/angular/core/src/errors.ts b/angular/core/src/errors.ts
new file mode 100644
index 0000000..002dbe9
--- /dev/null
+++ b/angular/core/src/errors.ts
@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {DebugContext} from './view';
+
+export const ERROR_TYPE = 'ngType';
+export const ERROR_DEBUG_CONTEXT = 'ngDebugContext';
+export const ERROR_ORIGINAL_ERROR = 'ngOriginalError';
+export const ERROR_LOGGER = 'ngErrorLogger';
+
+
+export function getType(error: Error): Function {
+  return (error as any)[ERROR_TYPE];
+}
+
+export function getDebugContext(error: Error): DebugContext {
+  return (error as any)[ERROR_DEBUG_CONTEXT];
+}
+
+export function getOriginalError(error: Error): Error {
+  return (error as any)[ERROR_ORIGINAL_ERROR];
+}
+
+export function getErrorLogger(error: Error): (console: Console, ...values: any[]) => void {
+  return (error as any)[ERROR_LOGGER] || defaultErrorLogger;
+}
+
+
+function defaultErrorLogger(console: Console, ...values: any[]) {
+  (<any>console.error)(...values);
+}
\ No newline at end of file
diff --git a/angular/core/src/event_emitter.ts b/angular/core/src/event_emitter.ts
new file mode 100644
index 0000000..86d170d
--- /dev/null
+++ b/angular/core/src/event_emitter.ts
@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Subject} from 'rxjs/Subject';
+
+/**
+ * Use by directives and components to emit custom Events.
+ *
+ * ### Examples
+ *
+ * In the following example, `Zippy` alternatively emits `open` and `close` events when its
+ * title gets clicked:
+ *
+ * ```
+ * @Component({
+ *   selector: 'zippy',
+ *   template: `
+ *   <div class="zippy">
+ *     <div (click)="toggle()">Toggle</div>
+ *     <div [hidden]="!visible">
+ *       <ng-content></ng-content>
+ *     </div>
+ *  </div>`})
+ * export class Zippy {
+ *   visible: boolean = true;
+ *   @Output() open: EventEmitter<any> = new EventEmitter();
+ *   @Output() close: EventEmitter<any> = new EventEmitter();
+ *
+ *   toggle() {
+ *     this.visible = !this.visible;
+ *     if (this.visible) {
+ *       this.open.emit(null);
+ *     } else {
+ *       this.close.emit(null);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The events payload can be accessed by the parameter `$event` on the components output event
+ * handler:
+ *
+ * ```
+ * <zippy (open)="onOpen($event)" (close)="onClose($event)"></zippy>
+ * ```
+ *
+ * Uses Rx.Observable but provides an adapter to make it work as specified here:
+ * https://github.com/jhusain/observable-spec
+ *
+ * Once a reference implementation of the spec is available, switch to it.
+ * @stable
+ */
+export class EventEmitter<T> extends Subject<T> {
+  // TODO: mark this as internal once all the facades are gone
+  // we can't mark it as internal now because EventEmitter exported via @angular/core would not
+  // contain this property making it incompatible with all the code that uses EventEmitter via
+  // facades, which are local to the code and do not have this property stripped.
+  // tslint:disable-next-line
+  __isAsync: boolean;
+
+  /**
+   * Creates an instance of {@link EventEmitter}, which depending on `isAsync`,
+   * delivers events synchronously or asynchronously.
+   *
+   * @param isAsync By default, events are delivered synchronously (default value: `false`).
+   * Set to `true` for asynchronous event delivery.
+   */
+  constructor(isAsync: boolean = false) {
+    super();
+    this.__isAsync = isAsync;
+  }
+
+  emit(value?: T) { super.next(value); }
+
+  subscribe(generatorOrNext?: any, error?: any, complete?: any): any {
+    let schedulerFn: (t: any) => any;
+    let errorFn = (err: any): any => null;
+    let completeFn = (): any => null;
+
+    if (generatorOrNext && typeof generatorOrNext === 'object') {
+      schedulerFn = this.__isAsync ? (value: any) => {
+        setTimeout(() => generatorOrNext.next(value));
+      } : (value: any) => { generatorOrNext.next(value); };
+
+      if (generatorOrNext.error) {
+        errorFn = this.__isAsync ? (err) => { setTimeout(() => generatorOrNext.error(err)); } :
+                                   (err) => { generatorOrNext.error(err); };
+      }
+
+      if (generatorOrNext.complete) {
+        completeFn = this.__isAsync ? () => { setTimeout(() => generatorOrNext.complete()); } :
+                                      () => { generatorOrNext.complete(); };
+      }
+    } else {
+      schedulerFn = this.__isAsync ? (value: any) => { setTimeout(() => generatorOrNext(value)); } :
+                                     (value: any) => { generatorOrNext(value); };
+
+      if (error) {
+        errorFn =
+            this.__isAsync ? (err) => { setTimeout(() => error(err)); } : (err) => { error(err); };
+      }
+
+      if (complete) {
+        completeFn =
+            this.__isAsync ? () => { setTimeout(() => complete()); } : () => { complete(); };
+      }
+    }
+
+    return super.subscribe(schedulerFn, errorFn, completeFn);
+  }
+}
diff --git a/angular/core/src/i18n/tokens.ts b/angular/core/src/i18n/tokens.ts
new file mode 100644
index 0000000..da156b7
--- /dev/null
+++ b/angular/core/src/i18n/tokens.ts
@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {InjectionToken} from '../di/injection_token';
+
+/**
+ * @experimental i18n support is experimental.
+ */
+export const LOCALE_ID = new InjectionToken<string>('LocaleId');
+
+/**
+ * @experimental i18n support is experimental.
+ */
+export const TRANSLATIONS = new InjectionToken<string>('Translations');
+
+/**
+ * @experimental i18n support is experimental.
+ */
+export const TRANSLATIONS_FORMAT = new InjectionToken<string>('TranslationsFormat');
+
+/**
+ * @experimental i18n support is experimental.
+ */
+export enum MissingTranslationStrategy {
+  Error = 0,
+  Warning = 1,
+  Ignore = 2,
+}
diff --git a/angular/core/src/linker.ts b/angular/core/src/linker.ts
new file mode 100644
index 0000000..b3b25b2
--- /dev/null
+++ b/angular/core/src/linker.ts
@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+// Public API for compiler
+export {COMPILER_OPTIONS, Compiler, CompilerFactory, CompilerOptions, ModuleWithComponentFactories} from './linker/compiler';
+export {ComponentFactory, ComponentRef} from './linker/component_factory';
+export {ComponentFactoryResolver} from './linker/component_factory_resolver';
+export {ElementRef} from './linker/element_ref';
+export {NgModuleFactory, NgModuleRef} from './linker/ng_module_factory';
+export {NgModuleFactoryLoader, getModuleFactory} from './linker/ng_module_factory_loader';
+export {QueryList} from './linker/query_list';
+export {SystemJsNgModuleLoader, SystemJsNgModuleLoaderConfig} from './linker/system_js_ng_module_factory_loader';
+export {TemplateRef} from './linker/template_ref';
+export {ViewContainerRef} from './linker/view_container_ref';
+export {EmbeddedViewRef, ViewRef} from './linker/view_ref';
diff --git a/angular/core/src/linker/compiler.ts b/angular/core/src/linker/compiler.ts
new file mode 100644
index 0000000..5770e1f
--- /dev/null
+++ b/angular/core/src/linker/compiler.ts
@@ -0,0 +1,127 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injectable, InjectionToken, StaticProvider} from '../di';
+import {MissingTranslationStrategy} from '../i18n/tokens';
+import {ViewEncapsulation} from '../metadata';
+import {Type} from '../type';
+
+import {ComponentFactory} from './component_factory';
+import {NgModuleFactory} from './ng_module_factory';
+
+
+/**
+ * Combination of NgModuleFactory and ComponentFactorys.
+ *
+ * @experimental
+ */
+export class ModuleWithComponentFactories<T> {
+  constructor(
+      public ngModuleFactory: NgModuleFactory<T>,
+      public componentFactories: ComponentFactory<any>[]) {}
+}
+
+
+function _throwError() {
+  throw new Error(`Runtime compiler is not loaded`);
+}
+
+/**
+ * Low-level service for running the angular compiler during runtime
+ * to create {@link ComponentFactory}s, which
+ * can later be used to create and render a Component instance.
+ *
+ * Each `@NgModule` provides an own `Compiler` to its injector,
+ * that will use the directives/pipes of the ng module for compilation
+ * of components.
+ * @stable
+ */
+@Injectable()
+export class Compiler {
+  /**
+   * Compiles the given NgModule and all of its components. All templates of the components listed
+   * in `entryComponents` have to be inlined.
+   */
+  compileModuleSync<T>(moduleType: Type<T>): NgModuleFactory<T> { throw _throwError(); }
+
+  /**
+   * Compiles the given NgModule and all of its components
+   */
+  compileModuleAsync<T>(moduleType: Type<T>): Promise<NgModuleFactory<T>> { throw _throwError(); }
+
+  /**
+   * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.
+   */
+  compileModuleAndAllComponentsSync<T>(moduleType: Type<T>): ModuleWithComponentFactories<T> {
+    throw _throwError();
+  }
+
+  /**
+   * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.
+   */
+  compileModuleAndAllComponentsAsync<T>(moduleType: Type<T>):
+      Promise<ModuleWithComponentFactories<T>> {
+    throw _throwError();
+  }
+
+  /**
+   * Exposes the CSS-style selectors that have been used in `ngContent` directives within
+   * the template of the given component.
+   * This is used by the `upgrade` library to compile the appropriate transclude content
+   * in the AngularJS wrapper component.
+   *
+   * @deprecated since v4. Use ComponentFactory.ngContentSelectors instead.
+   */
+  getNgContentSelectors(component: Type<any>): string[] { throw _throwError(); }
+
+  /**
+   * Clears all caches.
+   */
+  clearCache(): void {}
+
+  /**
+   * Clears the cache for the given component/ngModule.
+   */
+  clearCacheFor(type: Type<any>) {}
+}
+
+/**
+ * Options for creating a compiler
+ *
+ * @experimental
+ */
+export type CompilerOptions = {
+  /**
+   * @deprecated since v4 this option has no effect anymore.
+   */
+  useDebug?: boolean,
+  useJit?: boolean,
+  defaultEncapsulation?: ViewEncapsulation,
+  providers?: StaticProvider[],
+  missingTranslation?: MissingTranslationStrategy,
+  // Whether to support the `<template>` tag and the `template` attribute to define angular
+  // templates. They have been deprecated in 4.x, `<ng-template>` should be used instead.
+  enableLegacyTemplate?: boolean,
+  preserveWhitespaces?: boolean,
+};
+
+/**
+ * Token to provide CompilerOptions in the platform injector.
+ *
+ * @experimental
+ */
+export const COMPILER_OPTIONS = new InjectionToken<CompilerOptions[]>('compilerOptions');
+
+/**
+ * A factory for creating a Compiler
+ *
+ * @experimental
+ */
+export abstract class CompilerFactory {
+  abstract createCompiler(options?: CompilerOptions[]): Compiler;
+}
diff --git a/angular/core/src/linker/component_factory.ts b/angular/core/src/linker/component_factory.ts
new file mode 100644
index 0000000..7e7ac7c
--- /dev/null
+++ b/angular/core/src/linker/component_factory.ts
@@ -0,0 +1,91 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ChangeDetectorRef} from '../change_detection/change_detection';
+import {Injector} from '../di/injector';
+import {Type} from '../type';
+
+import {ElementRef} from './element_ref';
+import {NgModuleRef} from './ng_module_factory';
+import {ViewRef} from './view_ref';
+
+/**
+ * Represents an instance of a Component created via a {@link ComponentFactory}.
+ *
+ * `ComponentRef` provides access to the Component Instance as well other objects related to this
+ * Component Instance and allows you to destroy the Component Instance via the {@link #destroy}
+ * method.
+ * @stable
+ */
+export abstract class ComponentRef<C> {
+  /**
+   * Location of the Host Element of this Component Instance.
+   */
+  abstract get location(): ElementRef;
+
+  /**
+   * The injector on which the component instance exists.
+   */
+  abstract get injector(): Injector;
+
+  /**
+   * The instance of the Component.
+   */
+  abstract get instance(): C;
+
+  /**
+   * The {@link ViewRef} of the Host View of this Component instance.
+   */
+  abstract get hostView(): ViewRef;
+
+  /**
+   * The {@link ChangeDetectorRef} of the Component instance.
+   */
+  abstract get changeDetectorRef(): ChangeDetectorRef;
+
+  /**
+   * The component type.
+   */
+  abstract get componentType(): Type<any>;
+
+  /**
+   * Destroys the component instance and all of the data structures associated with it.
+   */
+  abstract destroy(): void;
+
+  /**
+   * Allows to register a callback that will be called when the component is destroyed.
+   */
+  abstract onDestroy(callback: Function): void;
+}
+
+/**
+ * @stable
+ */
+export abstract class ComponentFactory<C> {
+  abstract get selector(): string;
+  abstract get componentType(): Type<any>;
+  /**
+   * selector for all <ng-content> elements in the component.
+   */
+  abstract get ngContentSelectors(): string[];
+  /**
+   * the inputs of the component.
+   */
+  abstract get inputs(): {propName: string, templateName: string}[];
+  /**
+   * the outputs of the component.
+   */
+  abstract get outputs(): {propName: string, templateName: string}[];
+  /**
+   * Creates a new component.
+   */
+  abstract create(
+      injector: Injector, projectableNodes?: any[][], rootSelectorOrNode?: string|any,
+      ngModule?: NgModuleRef<any>): ComponentRef<C>;
+}
diff --git a/angular/core/src/linker/component_factory_resolver.ts b/angular/core/src/linker/component_factory_resolver.ts
new file mode 100644
index 0000000..32c3a84
--- /dev/null
+++ b/angular/core/src/linker/component_factory_resolver.ts
@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injector} from '../di/injector';
+import {Type} from '../type';
+import {stringify} from '../util';
+
+import {ComponentFactory, ComponentRef} from './component_factory';
+import {NgModuleRef} from './ng_module_factory';
+
+export function noComponentFactoryError(component: Function) {
+  const error = Error(
+      `No component factory found for ${stringify(component)}. Did you add it to @NgModule.entryComponents?`);
+  (error as any)[ERROR_COMPONENT] = component;
+  return error;
+}
+
+const ERROR_COMPONENT = 'ngComponent';
+
+export function getComponent(error: Error): Type<any> {
+  return (error as any)[ERROR_COMPONENT];
+}
+
+
+class _NullComponentFactoryResolver implements ComponentFactoryResolver {
+  resolveComponentFactory<T>(component: {new (...args: any[]): T}): ComponentFactory<T> {
+    throw noComponentFactoryError(component);
+  }
+}
+
+/**
+ * @stable
+ */
+export abstract class ComponentFactoryResolver {
+  static NULL: ComponentFactoryResolver = new _NullComponentFactoryResolver();
+  abstract resolveComponentFactory<T>(component: Type<T>): ComponentFactory<T>;
+}
+
+export class CodegenComponentFactoryResolver implements ComponentFactoryResolver {
+  private _factories = new Map<any, ComponentFactory<any>>();
+
+  constructor(
+      factories: ComponentFactory<any>[], private _parent: ComponentFactoryResolver,
+      private _ngModule: NgModuleRef<any>) {
+    for (let i = 0; i < factories.length; i++) {
+      const factory = factories[i];
+      this._factories.set(factory.componentType, factory);
+    }
+  }
+
+  resolveComponentFactory<T>(component: {new (...args: any[]): T}): ComponentFactory<T> {
+    let factory = this._factories.get(component);
+    if (!factory && this._parent) {
+      factory = this._parent.resolveComponentFactory(component);
+    }
+    if (!factory) {
+      throw noComponentFactoryError(component);
+    }
+    return new ComponentFactoryBoundToModule(factory, this._ngModule);
+  }
+}
+
+export class ComponentFactoryBoundToModule<C> extends ComponentFactory<C> {
+  constructor(private factory: ComponentFactory<C>, private ngModule: NgModuleRef<any>) { super(); }
+
+  get selector() { return this.factory.selector; }
+  get componentType() { return this.factory.componentType; }
+  get ngContentSelectors() { return this.factory.ngContentSelectors; }
+  get inputs() { return this.factory.inputs; }
+  get outputs() { return this.factory.outputs; }
+
+  create(
+      injector: Injector, projectableNodes?: any[][], rootSelectorOrNode?: string|any,
+      ngModule?: NgModuleRef<any>): ComponentRef<C> {
+    return this.factory.create(
+        injector, projectableNodes, rootSelectorOrNode, ngModule || this.ngModule);
+  }
+}
diff --git a/angular/core/src/linker/element_ref.ts b/angular/core/src/linker/element_ref.ts
new file mode 100644
index 0000000..f61cd6b
--- /dev/null
+++ b/angular/core/src/linker/element_ref.ts
@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * A wrapper around a native element inside of a View.
+ *
+ * An `ElementRef` is backed by a render-specific element. In the browser, this is usually a DOM
+ * element.
+ *
+ * @security Permitting direct access to the DOM can make your application more vulnerable to
+ * XSS attacks. Carefully review any use of `ElementRef` in your code. For more detail, see the
+ * [Security Guide](http://g.co/ng/security).
+ *
+ * @stable
+ */
+// Note: We don't expose things like `Injector`, `ViewContainer`, ... here,
+// i.e. users have to ask for what they need. With that, we can build better analysis tools
+// and could do better codegen in the future.
+export class ElementRef {
+  /**
+   * The underlying native element or `null` if direct access to native elements is not supported
+   * (e.g. when the application runs in a web worker).
+   *
+   * <div class="callout is-critical">
+   *   <header>Use with caution</header>
+   *   <p>
+   *    Use this API as the last resort when direct access to DOM is needed. Use templating and
+   *    data-binding provided by Angular instead. Alternatively you take a look at {@link Renderer}
+   *    which provides API that can safely be used even when direct access to native elements is not
+   *    supported.
+   *   </p>
+   *   <p>
+   *    Relying on direct DOM access creates tight coupling between your application and rendering
+   *    layers which will make it impossible to separate the two and deploy your application into a
+   *    web worker.
+   *   </p>
+   * </div>
+   * @stable
+   */
+  public nativeElement: any;
+
+  constructor(nativeElement: any) { this.nativeElement = nativeElement; }
+}
diff --git a/angular/core/src/linker/ng_module_factory.ts b/angular/core/src/linker/ng_module_factory.ts
new file mode 100644
index 0000000..0e4925f
--- /dev/null
+++ b/angular/core/src/linker/ng_module_factory.ts
@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injector} from '../di/injector';
+import {Type} from '../type';
+
+import {ComponentFactoryResolver} from './component_factory_resolver';
+
+
+/**
+ * Represents an instance of an NgModule created via a {@link NgModuleFactory}.
+ *
+ * `NgModuleRef` provides access to the NgModule Instance as well other objects related to this
+ * NgModule Instance.
+ *
+ * @stable
+ */
+export abstract class NgModuleRef<T> {
+  /**
+   * The injector that contains all of the providers of the NgModule.
+   */
+  abstract get injector(): Injector;
+
+  /**
+   * The ComponentFactoryResolver to get hold of the ComponentFactories
+   * declared in the `entryComponents` property of the module.
+   */
+  abstract get componentFactoryResolver(): ComponentFactoryResolver;
+
+  /**
+   * The NgModule instance.
+   */
+  abstract get instance(): T;
+
+  /**
+   * Destroys the module instance and all of the data structures associated with it.
+   */
+  abstract destroy(): void;
+
+  /**
+   * Allows to register a callback that will be called when the module is destroyed.
+   */
+  abstract onDestroy(callback: () => void): void;
+}
+
+export interface InternalNgModuleRef<T> extends NgModuleRef<T> {
+  // Note: we are using the prefix _ as NgModuleData is an NgModuleRef and therefore directly
+  // exposed to the user.
+  _bootstrapComponents: Type<any>[];
+}
+
+/**
+ * @experimental
+ */
+export abstract class NgModuleFactory<T> {
+  abstract get moduleType(): Type<T>;
+  abstract create(parentInjector: Injector|null): NgModuleRef<T>;
+}
diff --git a/angular/core/src/linker/ng_module_factory_loader.ts b/angular/core/src/linker/ng_module_factory_loader.ts
new file mode 100644
index 0000000..8f0e8d7
--- /dev/null
+++ b/angular/core/src/linker/ng_module_factory_loader.ts
@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {NgModuleFactory} from './ng_module_factory';
+
+/**
+ * Used to load ng module factories.
+ * @stable
+ */
+export abstract class NgModuleFactoryLoader {
+  abstract load(path: string): Promise<NgModuleFactory<any>>;
+}
+
+let moduleFactories = new Map<string, NgModuleFactory<any>>();
+
+/**
+ * Registers a loaded module. Should only be called from generated NgModuleFactory code.
+ * @experimental
+ */
+export function registerModuleFactory(id: string, factory: NgModuleFactory<any>) {
+  const existing = moduleFactories.get(id);
+  if (existing) {
+    throw new Error(`Duplicate module registered for ${id
+                    } - ${existing.moduleType.name} vs ${factory.moduleType.name}`);
+  }
+  moduleFactories.set(id, factory);
+}
+
+export function clearModulesForTest() {
+  moduleFactories = new Map<string, NgModuleFactory<any>>();
+}
+
+/**
+ * Returns the NgModuleFactory with the given id, if it exists and has been loaded.
+ * Factories for modules that do not specify an `id` cannot be retrieved. Throws if the module
+ * cannot be found.
+ * @experimental
+ */
+export function getModuleFactory(id: string): NgModuleFactory<any> {
+  const factory = moduleFactories.get(id);
+  if (!factory) throw new Error(`No module with ID ${id} loaded`);
+  return factory;
+}
diff --git a/angular/core/src/linker/query_list.ts b/angular/core/src/linker/query_list.ts
new file mode 100644
index 0000000..9abd01b
--- /dev/null
+++ b/angular/core/src/linker/query_list.ts
@@ -0,0 +1,118 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Observable} from 'rxjs/Observable';
+
+import {EventEmitter} from '../event_emitter';
+import {getSymbolIterator} from '../util';
+
+
+/**
+ * An unmodifiable list of items that Angular keeps up to date when the state
+ * of the application changes.
+ *
+ * The type of object that {@link ViewChildren}, {@link ContentChildren}, and {@link QueryList}
+ * provide.
+ *
+ * Implements an iterable interface, therefore it can be used in both ES6
+ * javascript `for (var i of items)` loops as well as in Angular templates with
+ * `*ngFor="let i of myList"`.
+ *
+ * Changes can be observed by subscribing to the changes `Observable`.
+ *
+ * NOTE: In the future this class will implement an `Observable` interface.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/RX8sJnQYl9FWuSCWme5z?p=preview))
+ * ```typescript
+ * @Component({...})
+ * class Container {
+ *   @ViewChildren(Item) items:QueryList<Item>;
+ * }
+ * ```
+ * @stable
+ */
+export class QueryList<T>/* implements Iterable<T> */ {
+  private _dirty = true;
+  private _results: Array<T> = [];
+  private _emitter = new EventEmitter();
+
+  get changes(): Observable<any> { return this._emitter; }
+  get length(): number { return this._results.length; }
+  get first(): T { return this._results[0]; }
+  get last(): T { return this._results[this.length - 1]; }
+
+  /**
+   * See
+   * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
+   */
+  map<U>(fn: (item: T, index: number, array: T[]) => U): U[] { return this._results.map(fn); }
+
+  /**
+   * See
+   * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
+   */
+  filter(fn: (item: T, index: number, array: T[]) => boolean): T[] {
+    return this._results.filter(fn);
+  }
+
+  /**
+   * See
+   * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
+   */
+  find(fn: (item: T, index: number, array: T[]) => boolean): T|undefined {
+    return this._results.find(fn);
+  }
+
+  /**
+   * See
+   * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
+   */
+  reduce<U>(fn: (prevValue: U, curValue: T, curIndex: number, array: T[]) => U, init: U): U {
+    return this._results.reduce(fn, init);
+  }
+
+  /**
+   * See
+   * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
+   */
+  forEach(fn: (item: T, index: number, array: T[]) => void): void { this._results.forEach(fn); }
+
+  /**
+   * See
+   * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
+   */
+  some(fn: (value: T, index: number, array: T[]) => boolean): boolean {
+    return this._results.some(fn);
+  }
+
+  toArray(): T[] { return this._results.slice(); }
+
+  [getSymbolIterator()](): Iterator<T> { return (this._results as any)[getSymbolIterator()](); }
+
+  toString(): string { return this._results.toString(); }
+
+  reset(res: Array<T|any[]>): void {
+    this._results = flatten(res);
+    this._dirty = false;
+  }
+
+  notifyOnChanges(): void { this._emitter.emit(this); }
+
+  /** internal */
+  setDirty() { this._dirty = true; }
+
+  /** internal */
+  get dirty() { return this._dirty; }
+}
+
+function flatten<T>(list: Array<T|T[]>): T[] {
+  return list.reduce((flat: any[], item: T | T[]): T[] => {
+    const flatItem = Array.isArray(item) ? flatten(item) : item;
+    return (<T[]>flat).concat(flatItem);
+  }, []);
+}
diff --git a/angular/core/src/linker/system_js_ng_module_factory_loader.ts b/angular/core/src/linker/system_js_ng_module_factory_loader.ts
new file mode 100644
index 0000000..d5540ac
--- /dev/null
+++ b/angular/core/src/linker/system_js_ng_module_factory_loader.ts
@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+import {Injectable, Optional} from '../di';
+
+import {Compiler} from './compiler';
+import {NgModuleFactory} from './ng_module_factory';
+import {NgModuleFactoryLoader} from './ng_module_factory_loader';
+
+const _SEPARATOR = '#';
+
+const FACTORY_CLASS_SUFFIX = 'NgFactory';
+declare var System: any;
+
+/**
+ * Configuration for SystemJsNgModuleLoader.
+ * token.
+ *
+ * @experimental
+ */
+export abstract class SystemJsNgModuleLoaderConfig {
+  /**
+   * Prefix to add when computing the name of the factory module for a given module name.
+   */
+  factoryPathPrefix: string;
+
+  /**
+   * Suffix to add when computing the name of the factory module for a given module name.
+   */
+  factoryPathSuffix: string;
+}
+
+const DEFAULT_CONFIG: SystemJsNgModuleLoaderConfig = {
+  factoryPathPrefix: '',
+  factoryPathSuffix: '.ngfactory',
+};
+
+/**
+ * NgModuleFactoryLoader that uses SystemJS to load NgModuleFactory
+ * @experimental
+ */
+@Injectable()
+export class SystemJsNgModuleLoader implements NgModuleFactoryLoader {
+  private _config: SystemJsNgModuleLoaderConfig;
+
+  constructor(private _compiler: Compiler, @Optional() config?: SystemJsNgModuleLoaderConfig) {
+    this._config = config || DEFAULT_CONFIG;
+  }
+
+  load(path: string): Promise<NgModuleFactory<any>> {
+    const offlineMode = this._compiler instanceof Compiler;
+    return offlineMode ? this.loadFactory(path) : this.loadAndCompile(path);
+  }
+
+  private loadAndCompile(path: string): Promise<NgModuleFactory<any>> {
+    let [module, exportName] = path.split(_SEPARATOR);
+    if (exportName === undefined) {
+      exportName = 'default';
+    }
+
+    return System.import(module)
+        .then((module: any) => module[exportName])
+        .then((type: any) => checkNotEmpty(type, module, exportName))
+        .then((type: any) => this._compiler.compileModuleAsync(type));
+  }
+
+  private loadFactory(path: string): Promise<NgModuleFactory<any>> {
+    let [module, exportName] = path.split(_SEPARATOR);
+    let factoryClassSuffix = FACTORY_CLASS_SUFFIX;
+    if (exportName === undefined) {
+      exportName = 'default';
+      factoryClassSuffix = '';
+    }
+
+    return System.import(this._config.factoryPathPrefix + module + this._config.factoryPathSuffix)
+        .then((module: any) => module[exportName + factoryClassSuffix])
+        .then((factory: any) => checkNotEmpty(factory, module, exportName));
+  }
+}
+
+function checkNotEmpty(value: any, modulePath: string, exportName: string): any {
+  if (!value) {
+    throw new Error(`Cannot find '${exportName}' in '${modulePath}'`);
+  }
+  return value;
+}
diff --git a/angular/core/src/linker/template_ref.ts b/angular/core/src/linker/template_ref.ts
new file mode 100644
index 0000000..748342e
--- /dev/null
+++ b/angular/core/src/linker/template_ref.ts
@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ElementRef} from './element_ref';
+import {EmbeddedViewRef} from './view_ref';
+
+
+/**
+ * Represents an Embedded Template that can be used to instantiate Embedded Views.
+ *
+ * You can access a `TemplateRef`, in two ways. Via a directive placed on a `<ng-template>` element
+ * (or directive prefixed with `*`) and have the `TemplateRef` for this Embedded View injected into
+ * the constructor of the directive using the `TemplateRef` Token. Alternatively you can query for
+ * the `TemplateRef` from a Component or a Directive via {@link Query}.
+ *
+ * To instantiate Embedded Views based on a Template, use
+ * {@link ViewContainerRef#createEmbeddedView}, which will create the View and attach it to the
+ * View Container.
+ * @stable
+ */
+export abstract class TemplateRef<C> {
+  /**
+   * The location in the View where the Embedded View logically belongs to.
+   *
+   * The data-binding and injection contexts of Embedded Views created from this `TemplateRef`
+   * inherit from the contexts of this location.
+   *
+   * Typically new Embedded Views are attached to the View Container of this location, but in
+   * advanced use-cases, the View can be attached to a different container while keeping the
+   * data-binding and injection context from the original location.
+   *
+   */
+  // TODO(i): rename to anchor or location
+  abstract get elementRef(): ElementRef;
+
+  abstract createEmbeddedView(context: C): EmbeddedViewRef<C>;
+}
diff --git a/angular/core/src/linker/view_container_ref.ts b/angular/core/src/linker/view_container_ref.ts
new file mode 100644
index 0000000..8a031f8
--- /dev/null
+++ b/angular/core/src/linker/view_container_ref.ts
@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injector} from '../di/injector';
+import {ComponentFactory, ComponentRef} from './component_factory';
+import {ElementRef} from './element_ref';
+import {NgModuleRef} from './ng_module_factory';
+import {TemplateRef} from './template_ref';
+import {EmbeddedViewRef, ViewRef} from './view_ref';
+
+
+/**
+ * Represents a container where one or more Views can be attached.
+ *
+ * The container can contain two kinds of Views. Host Views, created by instantiating a
+ * {@link Component} via {@link #createComponent}, and Embedded Views, created by instantiating an
+ * {@link TemplateRef Embedded Template} via {@link #createEmbeddedView}.
+ *
+ * The location of the View Container within the containing View is specified by the Anchor
+ * `element`. Each View Container can have only one Anchor Element and each Anchor Element can only
+ * have a single View Container.
+ *
+ * Root elements of Views attached to this container become siblings of the Anchor Element in
+ * the Rendered View.
+ *
+ * To access a `ViewContainerRef` of an Element, you can either place a {@link Directive} injected
+ * with `ViewContainerRef` on the Element, or you obtain it via a {@link ViewChild} query.
+ * @stable
+ */
+export abstract class ViewContainerRef {
+  /**
+   * Anchor element that specifies the location of this container in the containing View.
+   * <!-- TODO: rename to anchorElement -->
+   */
+  abstract get element(): ElementRef;
+
+  abstract get injector(): Injector;
+
+  abstract get parentInjector(): Injector;
+
+  /**
+   * Destroys all Views in this container.
+   */
+  abstract clear(): void;
+
+  /**
+   * Returns the {@link ViewRef} for the View located in this container at the specified index.
+   */
+  abstract get(index: number): ViewRef|null;
+
+  /**
+   * Returns the number of Views currently attached to this container.
+   */
+  abstract get length(): number;
+
+  /**
+   * Instantiates an Embedded View based on the {@link TemplateRef `templateRef`} and inserts it
+   * into this container at the specified `index`.
+   *
+   * If `index` is not specified, the new View will be inserted as the last View in the container.
+   *
+   * Returns the {@link ViewRef} for the newly created View.
+   */
+  abstract createEmbeddedView<C>(templateRef: TemplateRef<C>, context?: C, index?: number):
+      EmbeddedViewRef<C>;
+
+  /**
+   * Instantiates a single {@link Component} and inserts its Host View into this container at the
+   * specified `index`.
+   *
+   * The component is instantiated using its {@link ComponentFactory} which can be
+   * obtained via {@link ComponentFactoryResolver#resolveComponentFactory}.
+   *
+   * If `index` is not specified, the new View will be inserted as the last View in the container.
+   *
+   * You can optionally specify the {@link Injector} that will be used as parent for the Component.
+   *
+   * Returns the {@link ComponentRef} of the Host View created for the newly instantiated Component.
+   */
+  abstract createComponent<C>(
+      componentFactory: ComponentFactory<C>, index?: number, injector?: Injector,
+      projectableNodes?: any[][], ngModule?: NgModuleRef<any>): ComponentRef<C>;
+
+  /**
+   * Inserts a View identified by a {@link ViewRef} into the container at the specified `index`.
+   *
+   * If `index` is not specified, the new View will be inserted as the last View in the container.
+   *
+   * Returns the inserted {@link ViewRef}.
+   */
+  abstract insert(viewRef: ViewRef, index?: number): ViewRef;
+
+  /**
+   * Moves a View identified by a {@link ViewRef} into the container at the specified `index`.
+   *
+   * Returns the inserted {@link ViewRef}.
+   */
+  abstract move(viewRef: ViewRef, currentIndex: number): ViewRef;
+
+  /**
+   * Returns the index of the View, specified via {@link ViewRef}, within the current container or
+   * `-1` if this container doesn't contain the View.
+   */
+  abstract indexOf(viewRef: ViewRef): number;
+
+  /**
+   * Destroys a View attached to this container at the specified `index`.
+   *
+   * If `index` is not specified, the last View in the container will be removed.
+   */
+  abstract remove(index?: number): void;
+
+  /**
+   * Use along with {@link #insert} to move a View within the current container.
+   *
+   * If the `index` param is omitted, the last {@link ViewRef} is detached.
+   */
+  abstract detach(index?: number): ViewRef|null;
+}
diff --git a/angular/core/src/linker/view_ref.ts b/angular/core/src/linker/view_ref.ts
new file mode 100644
index 0000000..3f110bd
--- /dev/null
+++ b/angular/core/src/linker/view_ref.ts
@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ApplicationRef} from '../application_ref';
+import {ChangeDetectorRef} from '../change_detection/change_detector_ref';
+
+
+/**
+ * @stable
+ */
+export abstract class ViewRef extends ChangeDetectorRef {
+  /**
+   * Destroys the view and all of the data structures associated with it.
+   */
+  abstract destroy(): void;
+
+  abstract get destroyed(): boolean;
+
+  abstract onDestroy(callback: Function): any /** TODO #9100 */;
+}
+
+/**
+ * Represents an Angular View.
+ *
+ * <!-- TODO: move the next two paragraphs to the dev guide -->
+ * A View is a fundamental building block of the application UI. It is the smallest grouping of
+ * Elements which are created and destroyed together.
+ *
+ * Properties of elements in a View can change, but the structure (number and order) of elements in
+ * a View cannot. Changing the structure of Elements can only be done by inserting, moving or
+ * removing nested Views via a {@link ViewContainerRef}. Each View can contain many View Containers.
+ * <!-- /TODO -->
+ *
+ * ### Example
+ *
+ * Given this template...
+ *
+ * ```
+ * Count: {{items.length}}
+ * <ul>
+ *   <li *ngFor="let  item of items">{{item}}</li>
+ * </ul>
+ * ```
+ *
+ * We have two {@link TemplateRef}s:
+ *
+ * Outer {@link TemplateRef}:
+ * ```
+ * Count: {{items.length}}
+ * <ul>
+ *   <ng-template ngFor let-item [ngForOf]="items"></ng-template>
+ * </ul>
+ * ```
+ *
+ * Inner {@link TemplateRef}:
+ * ```
+ *   <li>{{item}}</li>
+ * ```
+ *
+ * Notice that the original template is broken down into two separate {@link TemplateRef}s.
+ *
+ * The outer/inner {@link TemplateRef}s are then assembled into views like so:
+ *
+ * ```
+ * <!-- ViewRef: outer-0 -->
+ * Count: 2
+ * <ul>
+ *   <ng-template view-container-ref></ng-template>
+ *   <!-- ViewRef: inner-1 --><li>first</li><!-- /ViewRef: inner-1 -->
+ *   <!-- ViewRef: inner-2 --><li>second</li><!-- /ViewRef: inner-2 -->
+ * </ul>
+ * <!-- /ViewRef: outer-0 -->
+ * ```
+ * @experimental
+ */
+export abstract class EmbeddedViewRef<C> extends ViewRef {
+  abstract get context(): C;
+
+  abstract get rootNodes(): any[];
+}
+
+export interface InternalViewRef extends ViewRef {
+  detachFromAppRef(): void;
+  attachToAppRef(appRef: ApplicationRef): void;
+}
diff --git a/angular/core/src/metadata.ts b/angular/core/src/metadata.ts
new file mode 100644
index 0000000..e606c12
--- /dev/null
+++ b/angular/core/src/metadata.ts
@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * This indirection is needed to free up Component, etc symbols in the public API
+ * to be used by the decorator versions of these annotations.
+ */
+
+import {Attribute, ContentChild, ContentChildren, Query, ViewChild, ViewChildren} from './metadata/di';
+import {Component, Directive, HostBinding, HostListener, Input, Output, Pipe} from './metadata/directives';
+import {ModuleWithProviders, NgModule, SchemaMetadata} from './metadata/ng_module';
+import {ViewEncapsulation} from './metadata/view';
+
+export {ANALYZE_FOR_ENTRY_COMPONENTS, Attribute, ContentChild, ContentChildDecorator, ContentChildren, ContentChildrenDecorator, Query, ViewChild, ViewChildDecorator, ViewChildren, ViewChildrenDecorator} from './metadata/di';
+export {Component, ComponentDecorator, Directive, DirectiveDecorator, HostBinding, HostListener, Input, Output, Pipe} from './metadata/directives';
+export {AfterContentChecked, AfterContentInit, AfterViewChecked, AfterViewInit, DoCheck, OnChanges, OnDestroy, OnInit} from './metadata/lifecycle_hooks';
+export {CUSTOM_ELEMENTS_SCHEMA, ModuleWithProviders, NO_ERRORS_SCHEMA, NgModule, SchemaMetadata} from './metadata/ng_module';
+export {ViewEncapsulation} from './metadata/view';
diff --git a/angular/core/src/metadata/di.ts b/angular/core/src/metadata/di.ts
new file mode 100644
index 0000000..e12522b
--- /dev/null
+++ b/angular/core/src/metadata/di.ts
@@ -0,0 +1,372 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {InjectionToken} from '../di/injection_token';
+import {Type} from '../type';
+import {makeParamDecorator, makePropDecorator} from '../util/decorators';
+
+/**
+ * This token can be used to create a virtual provider that will populate the
+ * `entryComponents` fields of components and ng modules based on its `useValue`.
+ * All components that are referenced in the `useValue` value (either directly
+ * or in a nested array or map) will be added to the `entryComponents` property.
+ *
+ * ### Example
+ * The following example shows how the router can populate the `entryComponents`
+ * field of an NgModule based on the router configuration which refers
+ * to components.
+ *
+ * ```typescript
+ * // helper function inside the router
+ * function provideRoutes(routes) {
+ *   return [
+ *     {provide: ROUTES, useValue: routes},
+ *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}
+ *   ];
+ * }
+ *
+ * // user code
+ * let routes = [
+ *   {path: '/root', component: RootComp},
+ *   {path: '/teams', component: TeamsComp}
+ * ];
+ *
+ * @NgModule({
+ *   providers: [provideRoutes(routes)]
+ * })
+ * class ModuleWithRoutes {}
+ * ```
+ *
+ * @experimental
+ */
+export const ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken<any>('AnalyzeForEntryComponents');
+
+/**
+ * Type of the Attribute decorator / constructor function.
+ *
+ * @stable
+ */
+export interface AttributeDecorator {
+  /**
+   * Specifies that a constant attribute value should be injected.
+   *
+   * The directive can inject constant string literals of host element attributes.
+   *
+   * ### Example
+   *
+   * Suppose we have an `<input>` element and want to know its `type`.
+   *
+   * ```html
+   * <input type="text">
+   * ```
+   *
+   * A decorator can inject string literal `text` like so:
+   *
+   * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}
+   *
+   * ### Example as TypeScript Decorator
+   *
+   * {@example core/ts/metadata/metadata.ts region='attributeFactory'}
+   *
+   * ### Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function(title) {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...})
+   * ]
+   * MyComponent.parameters = [
+   *   [new ng.Attribute('title')]
+   * ]
+   * ```
+   *
+   * @stable
+   */
+  (name: string): any;
+  new (name: string): Attribute;
+}
+
+
+/**
+ * Type of the Attribute metadata.
+ */
+export interface Attribute { attributeName?: string; }
+
+/**
+ * Attribute decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const Attribute: AttributeDecorator =
+    makeParamDecorator('Attribute', (attributeName?: string) => ({attributeName}));
+
+/**
+ * Type of the Query metadata.
+ *
+ * @stable
+ */
+export interface Query {
+  descendants: boolean;
+  first: boolean;
+  read: any;
+  isViewQuery: boolean;
+  selector: any;
+}
+
+/**
+ * Base class for query metadata.
+ *
+ * See {@link ContentChildren}, {@link ContentChild}, {@link ViewChildren}, {@link ViewChild} for
+ * more information.
+ *
+ * @stable
+ */
+export abstract class Query {}
+
+/**
+ * Type of the ContentChildren decorator / constructor function.
+ *
+ * See {@link ContentChildren}.
+ *
+ * @stable
+ */
+export interface ContentChildrenDecorator {
+  /**
+   * @whatItDoes Configures a content query.
+   *
+   * @howToUse
+   *
+   * {@example core/di/ts/contentChildren/content_children_howto.ts region='HowTo'}
+   *
+   * @description
+   *
+   * You can use ContentChildren to get the {@link QueryList} of elements or directives from the
+   * content DOM. Any time a child element is added, removed, or moved, the query list will be
+   * updated,
+   * and the changes observable of the query list will emit a new value.
+   *
+   * Content queries are set before the `ngAfterContentInit` callback is called.
+   *
+   * **Metadata Properties**:
+   *
+   * * **selector** - the directive type or the name used for querying.
+   * * **descendants** - include only direct children or all descendants.
+   * * **read** - read a different token from the queried elements.
+   *
+   * Let's look at an example:
+   *
+   * {@example core/di/ts/contentChildren/content_children_example.ts region='Component'}
+   *
+   * **npm package**: `@angular/core`
+   *
+   * @stable
+   * @Annotation
+   */
+  (selector: Type<any>|Function|string, opts?: {descendants?: boolean, read?: any}): any;
+  new (selector: Type<any>|Function|string, opts?: {descendants?: boolean, read?: any}): Query;
+}
+
+/**
+ * Type of the ContentChildren metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export type ContentChildren = Query;
+
+/**
+ * ContentChildren decorator and metadata.
+ *
+ *  @stable
+ *  @Annotation
+ */
+export const ContentChildren: ContentChildrenDecorator = makePropDecorator(
+    'ContentChildren',
+    (selector?: any, data: any = {}) =>
+        ({selector, first: false, isViewQuery: false, descendants: false, ...data}),
+    Query);
+
+/**
+ * Type of the ContentChild decorator / constructor function.
+ *
+ *
+ * @stable
+ */
+export interface ContentChildDecorator {
+  /**
+   * @whatItDoes Configures a content query.
+   *
+   * @howToUse
+   *
+   * {@example core/di/ts/contentChild/content_child_howto.ts region='HowTo'}
+   *
+   * @description
+   *
+   * You can use ContentChild to get the first element or the directive matching the selector from
+   * the content DOM. If the content DOM changes, and a new child matches the selector,
+   * the property will be updated.
+   *
+   * Content queries are set before the `ngAfterContentInit` callback is called.
+   *
+   * **Metadata Properties**:
+   *
+   * * **selector** - the directive type or the name used for querying.
+   * * **read** - read a different token from the queried element.
+   *
+   * Let's look at an example:
+   *
+   * {@example core/di/ts/contentChild/content_child_example.ts region='Component'}
+   *
+   * **npm package**: `@angular/core`
+   *
+   * @stable
+   * @Annotation
+   */
+  (selector: Type<any>|Function|string, opts?: {read?: any}): any;
+  new (selector: Type<any>|Function|string, opts?: {read?: any}): ContentChild;
+}
+
+/**
+ * Type of the ContentChild metadata.
+ *
+ * See {@link ContentChild}.
+ *
+ * @stable
+ */
+export type ContentChild = Query;
+
+/**
+ * ContentChild decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const ContentChild: ContentChildDecorator = makePropDecorator(
+    'ContentChild', (selector?: any, data: any = {}) =>
+                        ({selector, first: true, isViewQuery: false, descendants: true, ...data}),
+    Query);
+
+/**
+ * Type of the ViewChildren decorator / constructor function.
+ *
+ * See {@link ViewChildren}.
+ *
+ * @stable
+ */
+export interface ViewChildrenDecorator {
+  /**
+   * @whatItDoes Configures a view query.
+   *
+   * @howToUse
+   *
+   * {@example core/di/ts/viewChildren/view_children_howto.ts region='HowTo'}
+   *
+   * @description
+   *
+   * You can use ViewChildren to get the {@link QueryList} of elements or directives from the
+   * view DOM. Any time a child element is added, removed, or moved, the query list will be updated,
+   * and the changes observable of the query list will emit a new value.
+   *
+   * View queries are set before the `ngAfterViewInit` callback is called.
+   *
+   * **Metadata Properties**:
+   *
+   * * **selector** - the directive type or the name used for querying.
+   * * **read** - read a different token from the queried elements.
+   *
+   * Let's look at an example:
+   *
+   * {@example core/di/ts/viewChildren/view_children_example.ts region='Component'}
+   *
+   * **npm package**: `@angular/core`
+   *
+   * @stable
+   * @Annotation
+   */
+  (selector: Type<any>|Function|string, opts?: {read?: any}): any;
+  new (selector: Type<any>|Function|string, opts?: {read?: any}): ViewChildren;
+}
+
+/**
+ * Type of the ViewChildren metadata.
+ *
+ * @stable
+ */
+export type ViewChildren = Query;
+
+/**
+ * ViewChildren decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const ViewChildren: ViewChildrenDecorator = makePropDecorator(
+    'ViewChildren', (selector?: any, data: any = {}) =>
+                        ({selector, first: false, isViewQuery: true, descendants: true, ...data}),
+    Query);
+
+/**
+ * Type of the ViewChild decorator / constructor function.
+ *
+ * See {@link ViewChild}
+ *
+ * @stable
+ */
+export interface ViewChildDecorator {
+  /**
+   * @whatItDoes Configures a view query.
+   *
+   * @howToUse
+   *
+   * {@example core/di/ts/viewChild/view_child_howto.ts region='HowTo'}
+   *
+   * @description
+   *
+   * You can use ViewChild to get the first element or the directive matching the selector from the
+   * view DOM. If the view DOM changes, and a new child matches the selector,
+   * the property will be updated.
+   *
+   * View queries are set before the `ngAfterViewInit` callback is called.
+   *
+   * **Metadata Properties**:
+   *
+   * * **selector** - the directive type or the name used for querying.
+   * * **read** - read a different token from the queried elements.
+   *
+   * {@example core/di/ts/viewChild/view_child_example.ts region='Component'}
+   *
+   * **npm package**: `@angular/core`
+   *
+   * @stable
+   * @Annotation
+   */
+  (selector: Type<any>|Function|string, opts?: {read?: any}): any;
+  new (selector: Type<any>|Function|string, opts?: {read?: any}): ViewChild;
+}
+
+/**
+ * Type of the ViewChild metadata.
+ *
+ * @stable
+ */
+export type ViewChild = Query;
+
+/**
+ * ViewChild decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const ViewChild: ViewChildDecorator = makePropDecorator(
+    'ViewChild', (selector: any, data: any) =>
+                     ({selector, first: true, isViewQuery: true, descendants: true, ...data}),
+    Query);
diff --git a/angular/core/src/metadata/directives.ts b/angular/core/src/metadata/directives.ts
new file mode 100644
index 0000000..a884760
--- /dev/null
+++ b/angular/core/src/metadata/directives.ts
@@ -0,0 +1,998 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ChangeDetectionStrategy} from '../change_detection/constants';
+import {Provider} from '../di';
+import {Type} from '../type';
+import {TypeDecorator, makeDecorator, makePropDecorator} from '../util/decorators';
+
+import {ViewEncapsulation} from './view';
+
+
+/**
+ * Type of the Directive decorator / constructor function.
+ *
+ * @stable
+ */
+export interface DirectiveDecorator {
+  /**
+   * @whatItDoes Marks a class as an Angular directive and collects directive configuration
+   * metadata.
+   *
+   * @howToUse
+   *
+   * ```
+   * import {Directive} from '@angular/core';
+   *
+   * @Directive({
+   *   selector: 'my-directive',
+   * })
+   * export class MyDirective {
+   * }
+   * ```
+   *
+   * @description
+   *
+   * Directive decorator allows you to mark a class as an Angular directive and provide additional
+   * metadata that determines how the directive should be processed, instantiated and used at
+   * runtime.
+   *
+   * Directives allow you to attach behavior to elements in the DOM..
+   *
+   * A directive must belong to an NgModule in order for it to be usable
+   * by another directive, component, or application. To specify that a directive is a member of an
+   * NgModule,
+   * you should list it in the `declarations` field of that NgModule.
+   *
+   * In addition to the metadata configuration specified via the Directive decorator,
+   * directives can control their runtime behavior by implementing various Life-Cycle hooks.
+   *
+   * **Metadata Properties:**
+   *
+   * * **exportAs** - name under which the component instance is exported in a template. Can be
+   * given a single name or a comma-delimited list of names.
+   * * **host** - map of class property to host element bindings for events, properties and
+   * attributes
+   * * **inputs** - list of class property names to data-bind as component inputs
+   * * **outputs** - list of class property names that expose output events that others can
+   * subscribe to
+   * * **providers** - list of providers available to this component and its children
+   * * **queries** -  configure queries that can be injected into the component
+   * * **selector** - css selector that identifies this component in a template
+   *
+   * @stable
+   * @Annotation
+   */
+  (obj: Directive): TypeDecorator;
+
+  /**
+   * See the {@link Directive} decorator.
+   */
+  new (obj: Directive): Directive;
+}
+
+export interface Directive {
+  /**
+   * The CSS selector that triggers the instantiation of a directive.
+   *
+   * Angular only allows directives to trigger on CSS selectors that do not cross element
+   * boundaries.
+   *
+   * `selector` may be declared as one of the following:
+   *
+   * - `element-name`: select by element name.
+   * - `.class`: select by class name.
+   * - `[attribute]`: select by attribute name.
+   * - `[attribute=value]`: select by attribute name and value.
+   * - `:not(sub_selector)`: select only if the element does not match the `sub_selector`.
+   * - `selector1, selector2`: select if either `selector1` or `selector2` matches.
+   *
+   *
+   * ### Example
+   *
+   * Suppose we have a directive with an `input[type=text]` selector.
+   *
+   * And the following HTML:
+   *
+   * ```html
+   * <form>
+   *   <input type="text">
+   *   <input type="radio">
+   * <form>
+   * ```
+   *
+   * The directive would only be instantiated on the `<input type="text">` element.
+   *
+   */
+  selector?: string;
+
+  /**
+   * Enumerates the set of data-bound input properties for a directive
+   *
+   * Angular automatically updates input properties during change detection.
+   *
+   * The `inputs` property defines a set of `directiveProperty` to `bindingProperty`
+   * configuration:
+   *
+   * - `directiveProperty` specifies the component property where the value is written.
+   * - `bindingProperty` specifies the DOM property where the value is read from.
+   *
+   * When `bindingProperty` is not provided, it is assumed to be equal to `directiveProperty`.
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/ivhfXY?p=preview))
+   *
+   * The following example creates a component with two data-bound properties.
+   *
+   * ```typescript
+   * @Component({
+   *   selector: 'bank-account',
+   *   inputs: ['bankName', 'id: account-id'],
+   *   template: `
+   *     Bank Name: {{bankName}}
+   *     Account Id: {{id}}
+   *   `
+   * })
+   * class BankAccount {
+   *   bankName: string;
+   *   id: string;
+   *
+   *   // this property is not bound, and won't be automatically updated by Angular
+   *   normalizedBankName: string;
+   * }
+   *
+   * @Component({
+   *   selector: 'app',
+   *   template: `
+   *     <bank-account bank-name="RBC" account-id="4747"></bank-account>
+   *   `
+   * })
+   * class App {}
+   * ```
+   *
+   */
+  inputs?: string[];
+
+  /**
+   * Enumerates the set of event-bound output properties.
+   *
+   * When an output property emits an event, an event handler attached to that event
+   * the template is invoked.
+   *
+   * The `outputs` property defines a set of `directiveProperty` to `bindingProperty`
+   * configuration:
+   *
+   * - `directiveProperty` specifies the component property that emits events.
+   * - `bindingProperty` specifies the DOM property the event handler is attached to.
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/d5CNq7?p=preview))
+   *
+   * ```typescript
+   * @Directive({
+   *   selector: 'interval-dir',
+   *   outputs: ['everySecond', 'five5Secs: everyFiveSeconds']
+   * })
+   * class IntervalDir {
+   *   everySecond = new EventEmitter();
+   *   five5Secs = new EventEmitter();
+   *
+   *   constructor() {
+   *     setInterval(() => this.everySecond.emit("event"), 1000);
+   *     setInterval(() => this.five5Secs.emit("event"), 5000);
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'app',
+   *   template: `
+   *     <interval-dir (everySecond)="everySecond()" (everyFiveSeconds)="everyFiveSeconds()">
+   *     </interval-dir>
+   *   `
+   * })
+   * class App {
+   *   everySecond() { console.log('second'); }
+   *   everyFiveSeconds() { console.log('five seconds'); }
+   * }
+   * ```
+   *
+   */
+  outputs?: string[];
+
+  /**
+   * Specify the events, actions, properties and attributes related to the host element.
+   *
+   * ## Host Listeners
+   *
+   * Specifies which DOM events a directive listens to via a set of `(event)` to `method`
+   * key-value pairs:
+   *
+   * - `event`: the DOM event that the directive listens to.
+   * - `statement`: the statement to execute when the event occurs.
+   * If the evaluation of the statement returns `false`, then `preventDefault`is applied on the DOM
+   * event.
+   *
+   * To listen to global events, a target must be added to the event name.
+   * The target can be `window`, `document` or `body`.
+   *
+   * When writing a directive event binding, you can also refer to the $event local variable.
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/DlA5KU?p=preview))
+   *
+   * The following example declares a directive that attaches a click listener to the button and
+   * counts clicks.
+   *
+   * ```typescript
+   * @Directive({
+   *   selector: 'button[counting]',
+   *   host: {
+   *     '(click)': 'onClick($event.target)'
+   *   }
+   * })
+   * class CountClicks {
+   *   numberOfClicks = 0;
+   *
+   *   onClick(btn) {
+   *     console.log("button", btn, "number of clicks:", this.numberOfClicks++);
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'app',
+   *   template: `<button counting>Increment</button>`
+   * })
+   * class App {}
+   * ```
+   *
+   * ## Host Property Bindings
+   *
+   * Specifies which DOM properties a directive updates.
+   *
+   * Angular automatically checks host property bindings during change detection.
+   * If a binding changes, it will update the host element of the directive.
+   *
+   * ### Example ([live demo](http://plnkr.co/edit/gNg0ED?p=preview))
+   *
+   * The following example creates a directive that sets the `valid` and `invalid` classes
+   * on the DOM element that has ngModel directive on it.
+   *
+   * ```typescript
+   * @Directive({
+   *   selector: '[ngModel]',
+   *   host: {
+   *     '[class.valid]': 'valid',
+   *     '[class.invalid]': 'invalid'
+   *   }
+   * })
+   * class NgModelStatus {
+   *   constructor(public control:NgModel) {}
+   *   get valid { return this.control.valid; }
+   *   get invalid { return this.control.invalid; }
+   * }
+   *
+   * @Component({
+   *   selector: 'app',
+   *   template: `<input [(ngModel)]="prop">`
+   * })
+   * class App {
+   *   prop;
+   * }
+   * ```
+   *
+   * ## Attributes
+   *
+   * Specifies static attributes that should be propagated to a host element.
+   *
+   * ### Example
+   *
+   * In this example using `my-button` directive (ex.: `<div my-button></div>`) on a host element
+   * (here: `<div>` ) will ensure that this element will get the "button" role.
+   *
+   * ```typescript
+   * @Directive({
+   *   selector: '[my-button]',
+   *   host: {
+   *     'role': 'button'
+   *   }
+   * })
+   * class MyButton {
+   * }
+   * ```
+   */
+  host?: {[key: string]: string};
+
+  /**
+   * Defines the set of injectable objects that are visible to a Directive and its light DOM
+   * children.
+   *
+   * ## Simple Example
+   *
+   * Here is an example of a class that can be injected:
+   *
+   * ```
+   * class Greeter {
+   *    greet(name:string) {
+   *      return 'Hello ' + name + '!';
+   *    }
+   * }
+   *
+   * @Directive({
+   *   selector: 'greet',
+   *   providers: [
+   *     Greeter
+   *   ]
+   * })
+   * class HelloWorld {
+   *   greeter:Greeter;
+   *
+   *   constructor(greeter:Greeter) {
+   *     this.greeter = greeter;
+   *   }
+   * }
+   * ```
+   */
+  providers?: Provider[];
+
+  /**
+   * Defines the name that can be used in the template to assign this directive to a variable.
+   *
+   * ## Simple Example
+   *
+   * ```
+   * @Directive({
+   *   selector: 'child-dir',
+   *   exportAs: 'child'
+   * })
+   * class ChildDir {
+   * }
+   *
+   * @Component({
+   *   selector: 'main',
+   *   template: `<child-dir #c="child"></child-dir>`
+   * })
+   * class MainComponent {
+   * }
+   *
+   * ```
+   */
+  exportAs?: string;
+
+  /**
+   * Configures the queries that will be injected into the directive.
+   *
+   * Content queries are set before the `ngAfterContentInit` callback is called.
+   * View queries are set before the `ngAfterViewInit` callback is called.
+   *
+   * ### Example
+   *
+   * ```
+   * @Component({
+   *   selector: 'someDir',
+   *   queries: {
+   *     contentChildren: new ContentChildren(ChildDirective),
+   *     viewChildren: new ViewChildren(ChildDirective)
+   *   },
+   *   template: '<child-directive></child-directive>'
+   * })
+   * class SomeDir {
+   *   contentChildren: QueryList<ChildDirective>,
+   *   viewChildren: QueryList<ChildDirective>
+   *
+   *   ngAfterContentInit() {
+   *     // contentChildren is set
+   *   }
+   *
+   *   ngAfterViewInit() {
+   *     // viewChildren is set
+   *   }
+   * }
+   * ```
+   */
+  queries?: {[key: string]: any};
+}
+
+/**
+ * Directive decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const Directive: DirectiveDecorator =
+    makeDecorator('Directive', (dir: Directive = {}) => dir);
+
+/**
+ * Type of the Component decorator / constructor function.
+ *
+ * @stable
+ */
+export interface ComponentDecorator {
+  /**
+   * @whatItDoes Marks a class as an Angular component and collects component configuration
+   * metadata.
+   *
+   * @howToUse
+   *
+   * {@example core/ts/metadata/metadata.ts region='component'}
+   *
+   * @description
+   * Component decorator allows you to mark a class as an Angular component and provide additional
+   * metadata that determines how the component should be processed, instantiated and used at
+   * runtime.
+   *
+   * Components are the most basic building block of an UI in an Angular application.
+   * An Angular application is a tree of Angular components.
+   * Angular components are a subset of directives. Unlike directives, components always have
+   * a template and only one component can be instantiated per an element in a template.
+   *
+   * A component must belong to an NgModule in order for it to be usable
+   * by another component or application. To specify that a component is a member of an NgModule,
+   * you should list it in the `declarations` field of that NgModule.
+   *
+   * In addition to the metadata configuration specified via the Component decorator,
+   * components can control their runtime behavior by implementing various Life-Cycle hooks.
+   *
+   * **Metadata Properties:**
+   *
+   * * **animations** - list of animations of this component
+   * * **changeDetection** - change detection strategy used by this component
+   * * **encapsulation** - style encapsulation strategy used by this component
+   * * **entryComponents** - list of components that are dynamically inserted into the view of this
+   *   component
+   * * **exportAs** - name under which the component instance is exported in a template
+   * * **host** - map of class property to host element bindings for events, properties and
+   *   attributes
+   * * **inputs** - list of class property names to data-bind as component inputs
+   * * **interpolation** - custom interpolation markers used in this component's template
+   * * **moduleId** - ES/CommonJS module id of the file in which this component is defined
+   * * **outputs** - list of class property names that expose output events that others can
+   *   subscribe to
+   * * **providers** - list of providers available to this component and its children
+   * * **queries** -  configure queries that can be injected into the component
+   * * **selector** - css selector that identifies this component in a template
+   * * **styleUrls** - list of urls to stylesheets to be applied to this component's view
+   * * **styles** - inline-defined styles to be applied to this component's view
+   * * **template** - inline-defined template for the view
+   * * **templateUrl** - url to an external file containing a template for the view
+   * * **viewProviders** - list of providers available to this component and its view children
+   *
+   * ### Example
+   *
+   * {@example core/ts/metadata/metadata.ts region='component'}
+   *
+   * @stable
+   * @Annotation
+   */
+  (obj: Component): TypeDecorator;
+  /**
+   * See the {@link Component} decorator.
+   */
+  new (obj: Component): Component;
+}
+
+/**
+ * Type of the Component metadata.
+ *
+ * @stable
+ */
+export interface Component extends Directive {
+  /**
+   * Defines the used change detection strategy.
+   *
+   * When a component is instantiated, Angular creates a change detector, which is responsible for
+   * propagating the component's bindings.
+   *
+   * The `changeDetection` property defines, whether the change detection will be checked every time
+   * or only when the component tells it to do so.
+   */
+  changeDetection?: ChangeDetectionStrategy;
+
+  /**
+   * Defines the set of injectable objects that are visible to its view DOM children.
+   *
+   * ## Simple Example
+   *
+   * Here is an example of a class that can be injected:
+   *
+   * ```
+   * class Greeter {
+   *    greet(name:string) {
+   *      return 'Hello ' + name + '!';
+   *    }
+   * }
+   *
+   * @Directive({
+   *   selector: 'needs-greeter'
+   * })
+   * class NeedsGreeter {
+   *   greeter:Greeter;
+   *
+   *   constructor(greeter:Greeter) {
+   *     this.greeter = greeter;
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'greet',
+   *   viewProviders: [
+   *     Greeter
+   *   ],
+   *   template: `<needs-greeter></needs-greeter>`
+   * })
+   * class HelloWorld {
+   * }
+   *
+   * ```
+   */
+  viewProviders?: Provider[];
+
+  /**
+   * The module id of the module that contains the component.
+   * Needed to be able to resolve relative urls for templates and styles.
+   * In CommonJS, this can always be set to `module.id`, similarly SystemJS exposes `__moduleName`
+   * variable within each module.
+   *
+   *
+   * ## Simple Example
+   *
+   * ```
+   * @Directive({
+   *   selector: 'someDir',
+   *   moduleId: module.id
+   * })
+   * class SomeDir {
+   * }
+   *
+   * ```
+   */
+  moduleId?: string;
+
+  /**
+   * Specifies a template URL for an Angular component.
+   *
+   *Only one of `templateUrl` or `template` can be defined per View.
+   */
+  templateUrl?: string;
+
+  /**
+   * Specifies an inline template for an Angular component.
+   *
+   * Only one of `templateUrl` or `template` can be defined per Component.
+   */
+  template?: string;
+
+  /**
+   * Specifies stylesheet URLs for an Angular component.
+   */
+  styleUrls?: string[];
+
+  /**
+   * Specifies inline stylesheets for an Angular component.
+   */
+  styles?: string[];
+
+  /**
+   * Animations are defined on components via an animation-like DSL. This DSL approach to describing
+   * animations allows for a flexibility that both benefits developers and the framework.
+   *
+   * Animations work by listening on state changes that occur on an element within
+   * the template. When a state change occurs, Angular can then take advantage and animate the
+   * arc in between. This works similar to how CSS transitions work, however, by having a
+   * programmatic DSL, animations are not limited to environments that are DOM-specific.
+   * (Angular can also perform optimizations behind the scenes to make animations more performant.)
+   *
+   * For animations to be available for use, animation state changes are placed within
+   * {@link trigger animation triggers} which are housed inside of the `animations` annotation
+   * metadata. Within a trigger both {@link state state} and {@link transition transition} entries
+   * can be placed.
+   *
+   * ```typescript
+   * @Component({
+   *   selector: 'animation-cmp',
+   *   templateUrl: 'animation-cmp.html',
+   *   animations: [
+   *     // this here is our animation trigger that
+   *     // will contain our state change animations.
+   *     trigger('myTriggerName', [
+   *       // the styles defined for the `on` and `off`
+   *       // states declared below are persisted on the
+   *       // element once the animation completes.
+   *       state('on', style({ opacity: 1 }),
+   *       state('off', style({ opacity: 0 }),
+   *
+   *       // this here is our animation that kicks off when
+   *       // this state change jump is true
+   *       transition('on => off', [
+   *         animate("1s")
+   *       ])
+   *     ])
+   *   ]
+   * })
+   * ```
+   *
+   * As depicted in the code above, a group of related animation states are all contained within
+   * an animation `trigger` (the code example above called the trigger `myTriggerName`).
+   * When a trigger is created then it can be bound onto an element within the component's
+   * template via a property prefixed by an `@` symbol followed by trigger name and an expression
+   * that
+   * is used to determine the state value for that trigger.
+   *
+   * ```html
+   * <!-- animation-cmp.html -->
+   * <div @myTriggerName="expression">...</div>
+   * ```
+   *
+   * For state changes to be executed, the `expression` value must change value from its existing
+   * value
+   * to something that we have set an animation to animate on (in the example above we are listening
+   * to a change of state between `on` and `off`). The `expression` value attached to the trigger
+   * must be something that can be evaluated with the template/component context.
+   *
+   * ### DSL Animation Functions
+   *
+   * Please visit each of the animation DSL functions listed below to gain a better understanding
+   * of how and why they are used for crafting animations in Angular:
+   *
+   * - {@link trigger trigger()}
+   * - {@link state state()}
+   * - {@link transition transition()}
+   * - {@link group group()}
+   * - {@link sequence sequence()}
+   * - {@link style style()}
+   * - {@link animate animate()}
+   * - {@link keyframes keyframes()}
+   */
+  animations?: any[];
+
+  /**
+   * Specifies how the template and the styles should be encapsulated:
+   * - {@link ViewEncapsulation#Native `ViewEncapsulation.Native`} to use shadow roots - only works
+   *   if natively available on the platform,
+   * - {@link ViewEncapsulation#Emulated `ViewEncapsulation.Emulated`} to use shimmed CSS that
+   *   emulates the native behavior,
+   * - {@link ViewEncapsulation#None `ViewEncapsulation.None`} to use global CSS without any
+   *   encapsulation.
+   *
+   * When no `encapsulation` is defined for the component, the default value from the
+   * {@link CompilerOptions} is used. The default is `ViewEncapsulation.Emulated`}. Provide a new
+   * `CompilerOptions` to override this value.
+   *
+   * If the encapsulation is set to `ViewEncapsulation.Emulated` and the component has no `styles`
+   * nor `styleUrls` the encapsulation will automatically be switched to `ViewEncapsulation.None`.
+   */
+  encapsulation?: ViewEncapsulation;
+
+  /**
+   * Overrides the default encapsulation start and end delimiters (respectively `{{` and `}}`)
+   */
+  interpolation?: [string, string];
+
+  /**
+   * Defines the components that should be compiled as well when
+   * this component is defined. For each components listed here,
+   * Angular will create a {@link ComponentFactory} and store it in the
+   * {@link ComponentFactoryResolver}.
+   */
+  entryComponents?: Array<Type<any>|any[]>;
+
+  /**
+   * If preserveWhitespaces is set to `false` potentially superfluous blank characters (space, tab,
+   * new line) will be removed from compiled templates. This can greatly reduce generated code size
+   * as well as speed up components' creation. The whitespace removal algorithm will drop all
+   * the blank text nodes and collapse series of whitespaces to just one space.
+   * Those transformations can potentially influence layout of the generated markup so
+   * the `preserveWhitespaces` should be used with care.
+   */
+  preserveWhitespaces?: boolean;
+}
+
+/**
+ * Component decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const Component: ComponentDecorator = makeDecorator(
+    'Component', (c: Component = {}) => ({changeDetection: ChangeDetectionStrategy.Default, ...c}),
+    Directive);
+
+/**
+ * Type of the Pipe decorator / constructor function.
+ *
+ * @stable
+ */
+export interface PipeDecorator {
+  /**
+   * Declare reusable pipe function.
+   *
+   * A "pure" pipe is only re-evaluated when either the input or any of the arguments change.
+   *
+   * When not specified, pipes default to being pure.
+   */
+  (obj: Pipe): TypeDecorator;
+
+  /**
+   * See the {@link Pipe} decorator.
+   */
+  new (obj: Pipe): Pipe;
+}
+
+/**
+ * Type of the Pipe metadata.
+ *
+ * @stable
+ */
+export interface Pipe {
+  name: string;
+  pure?: boolean;
+}
+
+/**
+ * Pipe decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const Pipe: PipeDecorator = makeDecorator('Pipe', (p: Pipe) => ({pure: true, ...p}));
+
+
+/**
+ * Type of the Input decorator / constructor function.
+ *
+ * @stable
+ */
+export interface InputDecorator {
+  /**
+   * Declares a data-bound input property.
+   *
+   * Angular automatically updates data-bound properties during change detection.
+   *
+   * `Input` takes an optional parameter that specifies the name
+   * used when instantiating a component in the template. When not provided,
+   * the name of the decorated property is used.
+   *
+   * ### Example
+   *
+   * The following example creates a component with two input properties.
+   *
+   * ```typescript
+   * @Component({
+   *   selector: 'bank-account',
+   *   template: `
+   *     Bank Name: {{bankName}}
+   *     Account Id: {{id}}
+   *   `
+   * })
+   * class BankAccount {
+   *   @Input() bankName: string;
+   *   @Input('account-id') id: string;
+   *
+   *   // this property is not bound, and won't be automatically updated by Angular
+   *   normalizedBankName: string;
+   * }
+   *
+   * @Component({
+   *   selector: 'app',
+   *   template: `
+   *     <bank-account bank-name="RBC" account-id="4747"></bank-account>
+   *   `
+   * })
+   *
+   * class App {}
+   * ```
+   * @stable
+   */
+  (bindingPropertyName?: string): any;
+  new (bindingPropertyName?: string): any;
+}
+
+/**
+ * Type of the Input metadata.
+ *
+ * @stable
+ */
+export interface Input {
+  /**
+   * Name used when instantiating a component in the template.
+   */
+  bindingPropertyName?: string;
+}
+
+/**
+ * Input decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const Input: InputDecorator =
+    makePropDecorator('Input', (bindingPropertyName?: string) => ({bindingPropertyName}));
+
+/**
+ * Type of the Output decorator / constructor function.
+ *
+ * @stable
+ */
+export interface OutputDecorator {
+  /**
+   * Declares an event-bound output property.
+   *
+   * When an output property emits an event, an event handler attached to that event
+   * the template is invoked.
+   *
+   * `Output` takes an optional parameter that specifies the name
+   * used when instantiating a component in the template. When not provided,
+   * the name of the decorated property is used.
+   *
+   * ### Example
+   *
+   * ```typescript
+   * @Directive({
+   *   selector: 'interval-dir',
+   * })
+   * class IntervalDir {
+   *   @Output() everySecond = new EventEmitter();
+   *   @Output('everyFiveSeconds') five5Secs = new EventEmitter();
+   *
+   *   constructor() {
+   *     setInterval(() => this.everySecond.emit("event"), 1000);
+   *     setInterval(() => this.five5Secs.emit("event"), 5000);
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'app',
+   *   template: `
+   *     <interval-dir (everySecond)="everySecond()" (everyFiveSeconds)="everyFiveSeconds()">
+   *     </interval-dir>
+   *   `
+   * })
+   * class App {
+   *   everySecond() { console.log('second'); }
+   *   everyFiveSeconds() { console.log('five seconds'); }
+   * }
+   * ```
+   * @stable
+   */
+  (bindingPropertyName?: string): any;
+  new (bindingPropertyName?: string): any;
+}
+
+/**
+ * Type of the Output metadata.
+ *
+ * @stable
+ */
+export interface Output { bindingPropertyName?: string; }
+
+/**
+ * Output decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const Output: OutputDecorator =
+    makePropDecorator('Output', (bindingPropertyName?: string) => ({bindingPropertyName}));
+
+
+/**
+ * Type of the HostBinding decorator / constructor function.
+ *
+ * @stable
+ */
+export interface HostBindingDecorator {
+  /**
+   * Declares a host property binding.
+   *
+   * Angular automatically checks host property bindings during change detection.
+   * If a binding changes, it will update the host element of the directive.
+   *
+   * `HostBinding` takes an optional parameter that specifies the property
+   * name of the host element that will be updated. When not provided,
+   * the class property name is used.
+   *
+   * ### Example
+   *
+   * The following example creates a directive that sets the `valid` and `invalid` classes
+   * on the DOM element that has ngModel directive on it.
+   *
+   * ```typescript
+   * @Directive({selector: '[ngModel]'})
+   * class NgModelStatus {
+   *   constructor(public control:NgModel) {}
+   *   @HostBinding('class.valid') get valid() { return this.control.valid; }
+   *   @HostBinding('class.invalid') get invalid() { return this.control.invalid; }
+   * }
+   *
+   * @Component({
+   *   selector: 'app',
+   *   template: `<input [(ngModel)]="prop">`,
+   * })
+   * class App {
+   *   prop;
+   * }
+   * ```
+   * @stable
+   */
+  (hostPropertyName?: string): any;
+  new (hostPropertyName?: string): any;
+}
+
+/**
+ * Type of the HostBinding metadata.
+ *
+ * @stable
+ */
+export interface HostBinding { hostPropertyName?: string; }
+
+/**
+ * HostBinding decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const HostBinding: HostBindingDecorator =
+    makePropDecorator('HostBinding', (hostPropertyName?: string) => ({hostPropertyName}));
+
+
+/**
+ * Type of the HostListener decorator / constructor function.
+ *
+ * @stable
+ */
+export interface HostListenerDecorator {
+  /**
+   * Declares a host listener.
+   *
+   * Angular will invoke the decorated method when the host element emits the specified event.
+   *
+   * If the decorated method returns `false`, then `preventDefault` is applied on the DOM event.
+   *
+   * ### Example
+   *
+   * The following example declares a directive that attaches a click listener to the button and
+   * counts clicks.
+   *
+   * ```typescript
+   * @Directive({selector: 'button[counting]'})
+   * class CountClicks {
+   *   numberOfClicks = 0;
+   *
+   *   @HostListener('click', ['$event.target'])
+   *   onClick(btn) {
+   *     console.log('button', btn, 'number of clicks:', this.numberOfClicks++);
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'app',
+   *   template: '<button counting>Increment</button>',
+   * })
+   * class App {}
+   * ```
+   * @stable
+   * @Annotation
+   */
+  (eventName: string, args?: string[]): any;
+  new (eventName: string, args?: string[]): any;
+}
+
+/**
+ * Type of the HostListener metadata.
+ *
+ * @stable
+ */
+export interface HostListener {
+  eventName?: string;
+  args?: string[];
+}
+
+/**
+ * HostListener decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const HostListener: HostListenerDecorator =
+    makePropDecorator('HostListener', (eventName?: string, args?: string[]) => ({eventName, args}));
diff --git a/angular/core/src/metadata/lifecycle_hooks.ts b/angular/core/src/metadata/lifecycle_hooks.ts
new file mode 100644
index 0000000..6520bd5
--- /dev/null
+++ b/angular/core/src/metadata/lifecycle_hooks.ts
@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {SimpleChange} from '../change_detection/change_detection_util';
+
+
+/**
+ * A `changes` object whose keys are property names and
+ * values are instances of {@link SimpleChange}. See {@link OnChanges}
+ * @stable
+ */
+export interface SimpleChanges { [propName: string]: SimpleChange; }
+
+/**
+ * @whatItDoes Lifecycle hook that is called when any data-bound property of a directive changes.
+ * @howToUse
+ * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='OnChanges'}
+ *
+ * @description
+ * `ngOnChanges` is called right after the data-bound properties have been checked and before view
+ * and content children are checked if at least one of them has changed.
+ * The `changes` parameter contains the changed properties.
+ *
+ * See {@linkDocs guide/lifecycle-hooks#onchanges "Lifecycle Hooks Guide"}.
+ *
+ * @stable
+ */
+export interface OnChanges { ngOnChanges(changes: SimpleChanges): void; }
+
+/**
+ * @whatItDoes Lifecycle hook that is called after data-bound properties of a directive are
+ * initialized.
+ * @howToUse
+ * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='OnInit'}
+ *
+ * @description
+ * `ngOnInit` is called right after the directive's data-bound properties have been checked for the
+ * first time, and before any of its children have been checked. It is invoked only once when the
+ * directive is instantiated.
+ *
+ * See {@linkDocs guide/lifecycle-hooks "Lifecycle Hooks Guide"}.
+ *
+ * @stable
+ */
+export interface OnInit { ngOnInit(): void; }
+
+/**
+ * @whatItDoes Lifecycle hook that is called when Angular dirty checks a directive.
+ * @howToUse
+ * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='DoCheck'}
+ *
+ * @description
+ * `ngDoCheck` gets called to check the changes in the directives in addition to the default
+ * algorithm. The default change detection algorithm looks for differences by comparing
+ * bound-property values by reference across change detection runs.
+ *
+ * Note that a directive typically should not use both `DoCheck` and {@link OnChanges} to respond to
+ * changes on the same input, as `ngOnChanges` will continue to be called when the default change
+ * detector detects changes.
+ *
+ * See {@link KeyValueDiffers} and {@link IterableDiffers} for implementing custom dirty checking
+ * for collections.
+ *
+ * See {@linkDocs guide/lifecycle-hooks#docheck "Lifecycle Hooks Guide"}.
+ *
+ * @stable
+ */
+export interface DoCheck { ngDoCheck(): void; }
+
+/**
+ * @whatItDoes Lifecycle hook that is called when a directive, pipe or service is destroyed.
+ * @howToUse
+ * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='OnDestroy'}
+ *
+ * @description
+ * `ngOnDestroy` callback is typically used for any custom cleanup that needs to occur when the
+ * instance is destroyed.
+ *
+ * See {@linkDocs guide/lifecycle-hooks "Lifecycle Hooks Guide"}.
+ *
+ * @stable
+ */
+export interface OnDestroy { ngOnDestroy(): void; }
+
+/**
+ *
+ * @whatItDoes Lifecycle hook that is called after a directive's content has been fully
+ * initialized.
+ * @howToUse
+ * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterContentInit'}
+ *
+ * @description
+ * See {@linkDocs guide/lifecycle-hooks#aftercontent "Lifecycle Hooks Guide"}.
+ *
+ * @stable
+ */
+export interface AfterContentInit { ngAfterContentInit(): void; }
+
+/**
+ * @whatItDoes Lifecycle hook that is called after every check of a directive's content.
+ * @howToUse
+ * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterContentChecked'}
+ *
+ * @description
+ * See {@linkDocs guide/lifecycle-hooks#aftercontent "Lifecycle Hooks Guide"}.
+ *
+ * @stable
+ */
+export interface AfterContentChecked { ngAfterContentChecked(): void; }
+
+/**
+ * @whatItDoes Lifecycle hook that is called after a component's view has been fully
+ * initialized.
+ * @howToUse
+ * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterViewInit'}
+ *
+ * @description
+ * See {@linkDocs guide/lifecycle-hooks#afterview "Lifecycle Hooks Guide"}.
+ *
+ * @stable
+ */
+export interface AfterViewInit { ngAfterViewInit(): void; }
+
+/**
+ * @whatItDoes Lifecycle hook that is called after every check of a component's view.
+ * @howToUse
+ * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterViewChecked'}
+ *
+ * @description
+ * See {@linkDocs guide/lifecycle-hooks#afterview "Lifecycle Hooks Guide"}.
+ *
+ * @stable
+ */
+export interface AfterViewChecked { ngAfterViewChecked(): void; }
diff --git a/angular/core/src/metadata/ng_module.ts b/angular/core/src/metadata/ng_module.ts
new file mode 100644
index 0000000..c483766
--- /dev/null
+++ b/angular/core/src/metadata/ng_module.ts
@@ -0,0 +1,194 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Provider} from '../di';
+import {Type} from '../type';
+import {TypeDecorator, makeDecorator} from '../util/decorators';
+
+/**
+ * A wrapper around a module that also includes the providers.
+ *
+ * @stable
+ */
+export interface ModuleWithProviders {
+  ngModule: Type<any>;
+  providers?: Provider[];
+}
+
+/**
+ * Interface for schema definitions in @NgModules.
+ *
+ * @experimental
+ */
+export interface SchemaMetadata { name: string; }
+
+/**
+ * Defines a schema that will allow:
+ * - any non-Angular elements with a `-` in their name,
+ * - any properties on elements with a `-` in their name which is the common rule for custom
+ * elements.
+ *
+ * @stable
+ */
+export const CUSTOM_ELEMENTS_SCHEMA: SchemaMetadata = {
+  name: 'custom-elements'
+};
+
+/**
+ * Defines a schema that will allow any property on any element.
+ *
+ * @experimental
+ */
+export const NO_ERRORS_SCHEMA: SchemaMetadata = {
+  name: 'no-errors-schema'
+};
+
+
+/**
+ * Type of the NgModule decorator / constructor function.
+ *
+ * @stable
+ */
+export interface NgModuleDecorator {
+  /**
+   * Defines an NgModule.
+   */
+  (obj?: NgModule): TypeDecorator;
+  new (obj?: NgModule): NgModule;
+}
+
+/**
+ * Type of the NgModule metadata.
+ *
+ * @stable
+ */
+export interface NgModule {
+  /**
+   * Defines the set of injectable objects that are available in the injector
+   * of this module.
+   *
+   * ## Simple Example
+   *
+   * Here is an example of a class that can be injected:
+   *
+   * ```
+   * class Greeter {
+   *    greet(name:string) {
+   *      return 'Hello ' + name + '!';
+   *    }
+   * }
+   *
+   * @NgModule({
+   *   providers: [
+   *     Greeter
+   *   ]
+   * })
+   * class HelloWorld {
+   *   greeter:Greeter;
+   *
+   *   constructor(greeter:Greeter) {
+   *     this.greeter = greeter;
+   *   }
+   * }
+   * ```
+   */
+  providers?: Provider[];
+
+  /**
+   * Specifies a list of directives/pipes that belong to this module.
+   *
+   * ### Example
+   *
+   * ```javascript
+   * @NgModule({
+   *   declarations: [NgFor]
+   * })
+   * class CommonModule {
+   * }
+   * ```
+   */
+  declarations?: Array<Type<any>|any[]>;
+
+  /**
+   * Specifies a list of modules whose exported directives/pipes
+   * should be available to templates in this module.
+   * This can also contain {@link ModuleWithProviders}.
+   *
+   * ### Example
+   *
+   * ```javascript
+   * @NgModule({
+   *   imports: [CommonModule]
+   * })
+   * class MainModule {
+   * }
+   * ```
+   */
+  imports?: Array<Type<any>|ModuleWithProviders|any[]>;
+
+  /**
+   * Specifies a list of directives/pipes/modules that can be used within the template
+   * of any component that is part of an Angular module
+   * that imports this Angular module.
+   *
+   * ### Example
+   *
+   * ```javascript
+   * @NgModule({
+   *   exports: [NgFor]
+   * })
+   * class CommonModule {
+   * }
+   * ```
+   */
+  exports?: Array<Type<any>|any[]>;
+
+  /**
+   * Specifies a list of components that should be compiled when this module is defined.
+   * For each component listed here, Angular will create a {@link ComponentFactory}
+   * and store it in the {@link ComponentFactoryResolver}.
+   */
+  entryComponents?: Array<Type<any>|any[]>;
+
+  /**
+   * Defines the components that should be bootstrapped when
+   * this module is bootstrapped. The components listed here
+   * will automatically be added to `entryComponents`.
+   */
+  bootstrap?: Array<Type<any>|any[]>;
+
+  /**
+   * Elements and properties that are not Angular components nor directives have to be declared in
+   * the schema.
+   *
+   * Available schemas:
+   * - `NO_ERRORS_SCHEMA`: any elements and properties are allowed,
+   * - `CUSTOM_ELEMENTS_SCHEMA`: any custom elements (tag name has "-") with any properties are
+   *   allowed.
+   *
+   * @security When using one of `NO_ERRORS_SCHEMA` or `CUSTOM_ELEMENTS_SCHEMA` we're trusting that
+   * allowed elements (and its properties) securely escape inputs.
+   */
+  schemas?: Array<SchemaMetadata|any[]>;
+
+  /**
+   * An opaque ID for this module, e.g. a name or a path. Used to identify modules in
+   * `getModuleFactory`. If left `undefined`, the `NgModule` will not be registered with
+   * `getModuleFactory`.
+   */
+  id?: string;
+}
+
+/**
+ * NgModule decorator and metadata.
+ *
+ * @stable
+ * @Annotation
+ */
+export const NgModule: NgModuleDecorator =
+    makeDecorator('NgModule', (ngModule: NgModule) => ngModule);
diff --git a/angular/core/src/metadata/view.ts b/angular/core/src/metadata/view.ts
new file mode 100644
index 0000000..624d56d
--- /dev/null
+++ b/angular/core/src/metadata/view.ts
@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * Defines template and style encapsulation options available for Component's {@link Component}.
+ *
+ * See {@link Component#encapsulation}.
+ * @stable
+ */
+export enum ViewEncapsulation {
+  /**
+   * Emulate `Native` scoping of styles by adding an attribute containing surrogate id to the Host
+   * Element and pre-processing the style rules provided via
+   * {@link Component#styles} or {@link Component#styleUrls}, and adding the new Host Element
+   * attribute to all selectors.
+   *
+   * This is the default option.
+   */
+  Emulated = 0,
+  /**
+   * Use the native encapsulation mechanism of the renderer.
+   *
+   * For the DOM this means using [Shadow DOM](https://w3c.github.io/webcomponents/spec/shadow/) and
+   * creating a ShadowRoot for Component's Host Element.
+   */
+  Native = 1,
+  /**
+   * Don't provide any template or style encapsulation.
+   */
+  None = 2
+}
diff --git a/angular/core/src/platform_core_providers.ts b/angular/core/src/platform_core_providers.ts
new file mode 100644
index 0000000..6ff1967
--- /dev/null
+++ b/angular/core/src/platform_core_providers.ts
@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {PlatformRef, PlatformRef_, createPlatformFactory} from './application_ref';
+import {PLATFORM_ID} from './application_tokens';
+import {Console} from './console';
+import {Injector, StaticProvider} from './di';
+import {TestabilityRegistry} from './testability/testability';
+
+const _CORE_PLATFORM_PROVIDERS: StaticProvider[] = [
+  // Set a default platform name for platforms that don't set it explicitly.
+  {provide: PLATFORM_ID, useValue: 'unknown'},
+  {provide: PlatformRef_, deps: [Injector]},
+  {provide: PlatformRef, useExisting: PlatformRef_},
+  {provide: TestabilityRegistry, deps: []},
+  {provide: Console, deps: []},
+];
+
+/**
+ * This platform has to be included in any other platform
+ *
+ * @experimental
+ */
+export const platformCore = createPlatformFactory(null, 'core', _CORE_PLATFORM_PROVIDERS);
diff --git a/angular/core/src/profile/profile.ts b/angular/core/src/profile/profile.ts
new file mode 100644
index 0000000..d995ddb
--- /dev/null
+++ b/angular/core/src/profile/profile.ts
@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {WtfScopeFn, createScope, detectWTF, endTimeRange, leave, startTimeRange} from './wtf_impl';
+
+export {WtfScopeFn} from './wtf_impl';
+
+
+/**
+ * True if WTF is enabled.
+ */
+export const wtfEnabled = detectWTF();
+
+function noopScope(arg0?: any, arg1?: any): any {
+  return null;
+}
+
+/**
+ * Create trace scope.
+ *
+ * Scopes must be strictly nested and are analogous to stack frames, but
+ * do not have to follow the stack frames. Instead it is recommended that they follow logical
+ * nesting. You may want to use
+ * [Event
+ * Signatures](http://google.github.io/tracing-framework/instrumenting-code.html#custom-events)
+ * as they are defined in WTF.
+ *
+ * Used to mark scope entry. The return value is used to leave the scope.
+ *
+ *     var myScope = wtfCreateScope('MyClass#myMethod(ascii someVal)');
+ *
+ *     someMethod() {
+ *        var s = myScope('Foo'); // 'Foo' gets stored in tracing UI
+ *        // DO SOME WORK HERE
+ *        return wtfLeave(s, 123); // Return value 123
+ *     }
+ *
+ * Note, adding try-finally block around the work to ensure that `wtfLeave` gets called can
+ * negatively impact the performance of your application. For this reason we recommend that
+ * you don't add them to ensure that `wtfLeave` gets called. In production `wtfLeave` is a noop and
+ * so try-finally block has no value. When debugging perf issues, skipping `wtfLeave`, do to
+ * exception, will produce incorrect trace, but presence of exception signifies logic error which
+ * needs to be fixed before the app should be profiled. Add try-finally only when you expect that
+ * an exception is expected during normal execution while profiling.
+ *
+ * @experimental
+ */
+export const wtfCreateScope: (signature: string, flags?: any) => WtfScopeFn =
+    wtfEnabled ? createScope : (signature: string, flags?: any) => noopScope;
+
+/**
+ * Used to mark end of Scope.
+ *
+ * - `scope` to end.
+ * - `returnValue` (optional) to be passed to the WTF.
+ *
+ * Returns the `returnValue for easy chaining.
+ * @experimental
+ */
+export const wtfLeave: <T>(scope: any, returnValue?: T) => T =
+    wtfEnabled ? leave : (s: any, r?: any) => r;
+
+/**
+ * Used to mark Async start. Async are similar to scope but they don't have to be strictly nested.
+ * The return value is used in the call to [endAsync]. Async ranges only work if WTF has been
+ * enabled.
+ *
+ *     someMethod() {
+ *        var s = wtfStartTimeRange('HTTP:GET', 'some.url');
+ *        var future = new Future.delay(5).then((_) {
+ *          wtfEndTimeRange(s);
+ *        });
+ *     }
+ * @experimental
+ */
+export const wtfStartTimeRange: (rangeType: string, action: string) => any =
+    wtfEnabled ? startTimeRange : (rangeType: string, action: string) => null;
+
+/**
+ * Ends a async time range operation.
+ * [range] is the return value from [wtfStartTimeRange] Async ranges only work if WTF has been
+ * enabled.
+ * @experimental
+ */
+export const wtfEndTimeRange: (range: any) => void = wtfEnabled ? endTimeRange : (r: any) => null;
diff --git a/angular/core/src/profile/wtf_impl.ts b/angular/core/src/profile/wtf_impl.ts
new file mode 100644
index 0000000..02f3485
--- /dev/null
+++ b/angular/core/src/profile/wtf_impl.ts
@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {global} from '../util';
+
+/**
+ * A scope function for the Web Tracing Framework (WTF).
+ *
+ * @experimental
+ */
+export interface WtfScopeFn { (arg0?: any, arg1?: any): any; }
+
+interface WTF {
+  trace: Trace;
+}
+
+interface Trace {
+  events: Events;
+  leaveScope(scope: Scope, returnValue: any): any /** TODO #9100 */;
+  beginTimeRange(rangeType: string, action: string): Range;
+  endTimeRange(range: Range): any /** TODO #9100 */;
+}
+
+export interface Range {}
+
+interface Events {
+  createScope(signature: string, flags: any): Scope;
+}
+
+export interface Scope { (...args: any[] /** TODO #9100 */): any; }
+
+let trace: Trace;
+let events: Events;
+
+export function detectWTF(): boolean {
+  const wtf: WTF = (global as any /** TODO #9100 */)['wtf'];
+  if (wtf) {
+    trace = wtf['trace'];
+    if (trace) {
+      events = trace['events'];
+      return true;
+    }
+  }
+  return false;
+}
+
+export function createScope(signature: string, flags: any = null): any {
+  return events.createScope(signature, flags);
+}
+
+export function leave<T>(scope: Scope): void;
+export function leave<T>(scope: Scope, returnValue?: T): T;
+export function leave<T>(scope: Scope, returnValue?: any): any {
+  trace.leaveScope(scope, returnValue);
+  return returnValue;
+}
+
+export function startTimeRange(rangeType: string, action: string): Range {
+  return trace.beginTimeRange(rangeType, action);
+}
+
+export function endTimeRange(range: Range): void {
+  trace.endTimeRange(range);
+}
diff --git a/angular/core/src/reflection/platform_reflection_capabilities.ts b/angular/core/src/reflection/platform_reflection_capabilities.ts
new file mode 100644
index 0000000..8cc5b78
--- /dev/null
+++ b/angular/core/src/reflection/platform_reflection_capabilities.ts
@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Type} from '../type';
+import {GetterFn, MethodFn, SetterFn} from './types';
+
+export interface PlatformReflectionCapabilities {
+  isReflectionEnabled(): boolean;
+  factory(type: Type<any>): Function;
+  hasLifecycleHook(type: any, lcProperty: string): boolean;
+
+  /**
+   * Return a list of annotations/types for constructor parameters
+   */
+  parameters(type: Type<any>): any[][];
+
+  /**
+   * Return a list of annotations declared on the class
+   */
+  annotations(type: Type<any>): any[];
+
+  /**
+   * Return a object literal which describes the annotations on Class fields/properties.
+   */
+  propMetadata(typeOrFunc: Type<any>): {[key: string]: any[]};
+  getter(name: string): GetterFn;
+  setter(name: string): SetterFn;
+  method(name: string): MethodFn;
+  importUri(type: Type<any>): string;
+  resourceUri(type: Type<any>): string;
+  resolveIdentifier(name: string, moduleUrl: string, members: string[], runtime: any): any;
+  resolveEnum(enumIdentifier: any, name: string): any;
+}
diff --git a/angular/core/src/reflection/reflection.ts b/angular/core/src/reflection/reflection.ts
new file mode 100644
index 0000000..abbe872
--- /dev/null
+++ b/angular/core/src/reflection/reflection.ts
@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ReflectionCapabilities} from './reflection_capabilities';
+import {Reflector} from './reflector';
+
+export {Reflector} from './reflector';
+
+/**
+ * The {@link Reflector} used internally in Angular to access metadata
+ * about symbols.
+ */
+export const reflector = new Reflector(new ReflectionCapabilities());
diff --git a/angular/core/src/reflection/reflection_capabilities.ts b/angular/core/src/reflection/reflection_capabilities.ts
new file mode 100644
index 0000000..4f74baf
--- /dev/null
+++ b/angular/core/src/reflection/reflection_capabilities.ts
@@ -0,0 +1,258 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Type, isType} from '../type';
+import {global, stringify} from '../util';
+import {ANNOTATIONS, PARAMETERS, PROP_METADATA} from '../util/decorators';
+
+import {PlatformReflectionCapabilities} from './platform_reflection_capabilities';
+import {GetterFn, MethodFn, SetterFn} from './types';
+
+
+/**
+ * Attention: This regex has to hold even if the code is minified!
+ */
+export const DELEGATE_CTOR = /^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*arguments\)/;
+
+export class ReflectionCapabilities implements PlatformReflectionCapabilities {
+  private _reflect: any;
+
+  constructor(reflect?: any) { this._reflect = reflect || global['Reflect']; }
+
+  isReflectionEnabled(): boolean { return true; }
+
+  factory<T>(t: Type<T>): (args: any[]) => T { return (...args: any[]) => new t(...args); }
+
+  /** @internal */
+  _zipTypesAndAnnotations(paramTypes: any[], paramAnnotations: any[]): any[][] {
+    let result: any[][];
+
+    if (typeof paramTypes === 'undefined') {
+      result = new Array(paramAnnotations.length);
+    } else {
+      result = new Array(paramTypes.length);
+    }
+
+    for (let i = 0; i < result.length; i++) {
+      // TS outputs Object for parameters without types, while Traceur omits
+      // the annotations. For now we preserve the Traceur behavior to aid
+      // migration, but this can be revisited.
+      if (typeof paramTypes === 'undefined') {
+        result[i] = [];
+      } else if (paramTypes[i] != Object) {
+        result[i] = [paramTypes[i]];
+      } else {
+        result[i] = [];
+      }
+      if (paramAnnotations && paramAnnotations[i] != null) {
+        result[i] = result[i].concat(paramAnnotations[i]);
+      }
+    }
+    return result;
+  }
+
+  private _ownParameters(type: Type<any>, parentCtor: any): any[][]|null {
+    // If we have no decorators, we only have function.length as metadata.
+    // In that case, to detect whether a child class declared an own constructor or not,
+    // we need to look inside of that constructor to check whether it is
+    // just calling the parent.
+    // This also helps to work around for https://github.com/Microsoft/TypeScript/issues/12439
+    // that sets 'design:paramtypes' to []
+    // if a class inherits from another class but has no ctor declared itself.
+    if (DELEGATE_CTOR.exec(type.toString())) {
+      return null;
+    }
+
+    // Prefer the direct API.
+    if ((<any>type).parameters && (<any>type).parameters !== parentCtor.parameters) {
+      return (<any>type).parameters;
+    }
+
+    // API of tsickle for lowering decorators to properties on the class.
+    const tsickleCtorParams = (<any>type).ctorParameters;
+    if (tsickleCtorParams && tsickleCtorParams !== parentCtor.ctorParameters) {
+      // Newer tsickle uses a function closure
+      // Retain the non-function case for compatibility with older tsickle
+      const ctorParameters =
+          typeof tsickleCtorParams === 'function' ? tsickleCtorParams() : tsickleCtorParams;
+      const paramTypes = ctorParameters.map((ctorParam: any) => ctorParam && ctorParam.type);
+      const paramAnnotations = ctorParameters.map(
+          (ctorParam: any) =>
+              ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators));
+      return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);
+    }
+
+    // API for metadata created by invoking the decorators.
+    const paramAnnotations = type.hasOwnProperty(PARAMETERS) && (type as any)[PARAMETERS];
+    const paramTypes = this._reflect && this._reflect.getOwnMetadata &&
+        this._reflect.getOwnMetadata('design:paramtypes', type);
+    if (paramTypes || paramAnnotations) {
+      return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);
+    }
+
+    // If a class has no decorators, at least create metadata
+    // based on function.length.
+    // Note: We know that this is a real constructor as we checked
+    // the content of the constructor above.
+    return new Array((<any>type.length)).fill(undefined);
+  }
+
+  parameters(type: Type<any>): any[][] {
+    // Note: only report metadata if we have at least one class decorator
+    // to stay in sync with the static reflector.
+    if (!isType(type)) {
+      return [];
+    }
+    const parentCtor = getParentCtor(type);
+    let parameters = this._ownParameters(type, parentCtor);
+    if (!parameters && parentCtor !== Object) {
+      parameters = this.parameters(parentCtor);
+    }
+    return parameters || [];
+  }
+
+  private _ownAnnotations(typeOrFunc: Type<any>, parentCtor: any): any[]|null {
+    // Prefer the direct API.
+    if ((<any>typeOrFunc).annotations && (<any>typeOrFunc).annotations !== parentCtor.annotations) {
+      let annotations = (<any>typeOrFunc).annotations;
+      if (typeof annotations === 'function' && annotations.annotations) {
+        annotations = annotations.annotations;
+      }
+      return annotations;
+    }
+
+    // API of tsickle for lowering decorators to properties on the class.
+    if ((<any>typeOrFunc).decorators && (<any>typeOrFunc).decorators !== parentCtor.decorators) {
+      return convertTsickleDecoratorIntoMetadata((<any>typeOrFunc).decorators);
+    }
+
+    // API for metadata created by invoking the decorators.
+    if (typeOrFunc.hasOwnProperty(ANNOTATIONS)) {
+      return (typeOrFunc as any)[ANNOTATIONS];
+    }
+    return null;
+  }
+
+  annotations(typeOrFunc: Type<any>): any[] {
+    if (!isType(typeOrFunc)) {
+      return [];
+    }
+    const parentCtor = getParentCtor(typeOrFunc);
+    const ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];
+    const parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];
+    return parentAnnotations.concat(ownAnnotations);
+  }
+
+  private _ownPropMetadata(typeOrFunc: any, parentCtor: any): {[key: string]: any[]}|null {
+    // Prefer the direct API.
+    if ((<any>typeOrFunc).propMetadata &&
+        (<any>typeOrFunc).propMetadata !== parentCtor.propMetadata) {
+      let propMetadata = (<any>typeOrFunc).propMetadata;
+      if (typeof propMetadata === 'function' && propMetadata.propMetadata) {
+        propMetadata = propMetadata.propMetadata;
+      }
+      return propMetadata;
+    }
+
+    // API of tsickle for lowering decorators to properties on the class.
+    if ((<any>typeOrFunc).propDecorators &&
+        (<any>typeOrFunc).propDecorators !== parentCtor.propDecorators) {
+      const propDecorators = (<any>typeOrFunc).propDecorators;
+      const propMetadata = <{[key: string]: any[]}>{};
+      Object.keys(propDecorators).forEach(prop => {
+        propMetadata[prop] = convertTsickleDecoratorIntoMetadata(propDecorators[prop]);
+      });
+      return propMetadata;
+    }
+
+    // API for metadata created by invoking the decorators.
+    if (typeOrFunc.hasOwnProperty(PROP_METADATA)) {
+      return (typeOrFunc as any)[PROP_METADATA];
+    }
+    return null;
+  }
+
+  propMetadata(typeOrFunc: any): {[key: string]: any[]} {
+    if (!isType(typeOrFunc)) {
+      return {};
+    }
+    const parentCtor = getParentCtor(typeOrFunc);
+    const propMetadata: {[key: string]: any[]} = {};
+    if (parentCtor !== Object) {
+      const parentPropMetadata = this.propMetadata(parentCtor);
+      Object.keys(parentPropMetadata).forEach((propName) => {
+        propMetadata[propName] = parentPropMetadata[propName];
+      });
+    }
+    const ownPropMetadata = this._ownPropMetadata(typeOrFunc, parentCtor);
+    if (ownPropMetadata) {
+      Object.keys(ownPropMetadata).forEach((propName) => {
+        const decorators: any[] = [];
+        if (propMetadata.hasOwnProperty(propName)) {
+          decorators.push(...propMetadata[propName]);
+        }
+        decorators.push(...ownPropMetadata[propName]);
+        propMetadata[propName] = decorators;
+      });
+    }
+    return propMetadata;
+  }
+
+  hasLifecycleHook(type: any, lcProperty: string): boolean {
+    return type instanceof Type && lcProperty in type.prototype;
+  }
+
+  getter(name: string): GetterFn { return <GetterFn>new Function('o', 'return o.' + name + ';'); }
+
+  setter(name: string): SetterFn {
+    return <SetterFn>new Function('o', 'v', 'return o.' + name + ' = v;');
+  }
+
+  method(name: string): MethodFn {
+    const functionBody = `if (!o.${name}) throw new Error('"${name}" is undefined');
+        return o.${name}.apply(o, args);`;
+    return <MethodFn>new Function('o', 'args', functionBody);
+  }
+
+  // There is not a concept of import uri in Js, but this is useful in developing Dart applications.
+  importUri(type: any): string {
+    // StaticSymbol
+    if (typeof type === 'object' && type['filePath']) {
+      return type['filePath'];
+    }
+    // Runtime type
+    return `./${stringify(type)}`;
+  }
+
+  resourceUri(type: any): string { return `./${stringify(type)}`; }
+
+  resolveIdentifier(name: string, moduleUrl: string, members: string[], runtime: any): any {
+    return runtime;
+  }
+  resolveEnum(enumIdentifier: any, name: string): any { return enumIdentifier[name]; }
+}
+
+function convertTsickleDecoratorIntoMetadata(decoratorInvocations: any[]): any[] {
+  if (!decoratorInvocations) {
+    return [];
+  }
+  return decoratorInvocations.map(decoratorInvocation => {
+    const decoratorType = decoratorInvocation.type;
+    const annotationCls = decoratorType.annotationCls;
+    const annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];
+    return new annotationCls(...annotationArgs);
+  });
+}
+
+function getParentCtor(ctor: Function): Type<any> {
+  const parentProto = Object.getPrototypeOf(ctor.prototype);
+  const parentCtor = parentProto ? parentProto.constructor : null;
+  // Note: We always use `Object` as the null value
+  // to simplify checking later on.
+  return parentCtor || Object;
+}
diff --git a/angular/core/src/reflection/reflector.ts b/angular/core/src/reflection/reflector.ts
new file mode 100644
index 0000000..8115a14
--- /dev/null
+++ b/angular/core/src/reflection/reflector.ts
@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Type} from '../type';
+import {PlatformReflectionCapabilities} from './platform_reflection_capabilities';
+import {GetterFn, MethodFn, SetterFn} from './types';
+
+export {PlatformReflectionCapabilities} from './platform_reflection_capabilities';
+export {GetterFn, MethodFn, SetterFn} from './types';
+
+/**
+ * Provides access to reflection data about symbols. Used internally by Angular
+ * to power dependency injection and compilation.
+ */
+export class Reflector {
+  constructor(public reflectionCapabilities: PlatformReflectionCapabilities) {}
+
+  updateCapabilities(caps: PlatformReflectionCapabilities) { this.reflectionCapabilities = caps; }
+
+  factory(type: Type<any>): Function { return this.reflectionCapabilities.factory(type); }
+
+  parameters(typeOrFunc: Type<any>): any[][] {
+    return this.reflectionCapabilities.parameters(typeOrFunc);
+  }
+
+  annotations(typeOrFunc: Type<any>): any[] {
+    return this.reflectionCapabilities.annotations(typeOrFunc);
+  }
+
+  propMetadata(typeOrFunc: Type<any>): {[key: string]: any[]} {
+    return this.reflectionCapabilities.propMetadata(typeOrFunc);
+  }
+
+  hasLifecycleHook(type: any, lcProperty: string): boolean {
+    return this.reflectionCapabilities.hasLifecycleHook(type, lcProperty);
+  }
+
+  getter(name: string): GetterFn { return this.reflectionCapabilities.getter(name); }
+
+  setter(name: string): SetterFn { return this.reflectionCapabilities.setter(name); }
+
+  method(name: string): MethodFn { return this.reflectionCapabilities.method(name); }
+
+  importUri(type: any): string { return this.reflectionCapabilities.importUri(type); }
+
+  resourceUri(type: any): string { return this.reflectionCapabilities.resourceUri(type); }
+
+  resolveIdentifier(name: string, moduleUrl: string, members: string[], runtime: any): any {
+    return this.reflectionCapabilities.resolveIdentifier(name, moduleUrl, members, runtime);
+  }
+
+  resolveEnum(identifier: any, name: string): any {
+    return this.reflectionCapabilities.resolveEnum(identifier, name);
+  }
+}
diff --git a/angular/core/src/reflection/types.ts b/angular/core/src/reflection/types.ts
new file mode 100644
index 0000000..73297f9
--- /dev/null
+++ b/angular/core/src/reflection/types.ts
@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export type SetterFn = (obj: any, value: any) => void;
+export type GetterFn = (obj: any) => any;
+export type MethodFn = (obj: any, args: any[]) => any;
diff --git a/angular/core/src/render.ts b/angular/core/src/render.ts
new file mode 100644
index 0000000..9db56a4
--- /dev/null
+++ b/angular/core/src/render.ts
@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+// Public API for render
+export {RenderComponentType, Renderer, Renderer2, RendererFactory2, RendererStyleFlags2, RendererType2, RootRenderer} from './render/api';
diff --git a/angular/core/src/render/api.ts b/angular/core/src/render/api.ts
new file mode 100644
index 0000000..a741f52
--- /dev/null
+++ b/angular/core/src/render/api.ts
@@ -0,0 +1,191 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {InjectionToken, Injector} from '../di';
+import {ViewEncapsulation} from '../metadata/view';
+
+/**
+ * @deprecated Use `RendererType2` (and `Renderer2`) instead.
+ */
+export class RenderComponentType {
+  constructor(
+      public id: string, public templateUrl: string, public slotCount: number,
+      public encapsulation: ViewEncapsulation, public styles: Array<string|any[]>,
+      public animations: any) {}
+}
+
+/**
+ * @deprecated Debug info is handeled internally in the view engine now.
+ */
+export abstract class RenderDebugInfo {
+  abstract get injector(): Injector;
+  abstract get component(): any;
+  abstract get providerTokens(): any[];
+  abstract get references(): {[key: string]: any};
+  abstract get context(): any;
+  abstract get source(): string;
+}
+
+/**
+ * @deprecated Use the `Renderer2` instead.
+ */
+export interface DirectRenderer {
+  remove(node: any): void;
+  appendChild(node: any, parent: any): void;
+  insertBefore(node: any, refNode: any): void;
+  nextSibling(node: any): any;
+  parentElement(node: any): any;
+}
+
+/**
+ * @deprecated Use the `Renderer2` instead.
+ */
+export abstract class Renderer {
+  abstract selectRootElement(selectorOrNode: string|any, debugInfo?: RenderDebugInfo): any;
+
+  abstract createElement(parentElement: any, name: string, debugInfo?: RenderDebugInfo): any;
+
+  abstract createViewRoot(hostElement: any): any;
+
+  abstract createTemplateAnchor(parentElement: any, debugInfo?: RenderDebugInfo): any;
+
+  abstract createText(parentElement: any, value: string, debugInfo?: RenderDebugInfo): any;
+
+  abstract projectNodes(parentElement: any, nodes: any[]): void;
+
+  abstract attachViewAfter(node: any, viewRootNodes: any[]): void;
+
+  abstract detachView(viewRootNodes: any[]): void;
+
+  abstract destroyView(hostElement: any, viewAllNodes: any[]): void;
+
+  abstract listen(renderElement: any, name: string, callback: Function): Function;
+
+  abstract listenGlobal(target: string, name: string, callback: Function): Function;
+
+  abstract setElementProperty(renderElement: any, propertyName: string, propertyValue: any): void;
+
+  abstract setElementAttribute(renderElement: any, attributeName: string, attributeValue: string):
+      void;
+
+  /**
+   * Used only in debug mode to serialize property changes to dom nodes as attributes.
+   */
+  abstract setBindingDebugInfo(renderElement: any, propertyName: string, propertyValue: string):
+      void;
+
+  abstract setElementClass(renderElement: any, className: string, isAdd: boolean): void;
+
+  abstract setElementStyle(renderElement: any, styleName: string, styleValue: string): void;
+
+  abstract invokeElementMethod(renderElement: any, methodName: string, args?: any[]): void;
+
+  abstract setText(renderNode: any, text: string): void;
+
+  abstract animate(
+      element: any, startingStyles: any, keyframes: any[], duration: number, delay: number,
+      easing: string, previousPlayers?: any[]): any;
+}
+
+export const Renderer2Interceptor = new InjectionToken<Renderer2[]>('Renderer2Interceptor');
+
+/**
+ * Injectable service that provides a low-level interface for modifying the UI.
+ *
+ * Use this service to bypass Angular's templating and make custom UI changes that can't be
+ * expressed declaratively. For example if you need to set a property or an attribute whose name is
+ * not statically known, use {@link Renderer#setElementProperty} or {@link
+ * Renderer#setElementAttribute}
+ * respectively.
+ *
+ * If you are implementing a custom renderer, you must implement this interface.
+ *
+ * The default Renderer implementation is `DomRenderer`. Also available is `WebWorkerRenderer`.
+ *
+ * @deprecated Use `RendererFactory2` instead.
+ */
+export abstract class RootRenderer {
+  abstract renderComponent(componentType: RenderComponentType): Renderer;
+}
+
+/**
+ * @experimental
+ */
+export interface RendererType2 {
+  id: string;
+  encapsulation: ViewEncapsulation;
+  styles: (string|any[])[];
+  data: {[kind: string]: any};
+}
+
+/**
+ * @experimental
+ */
+export abstract class RendererFactory2 {
+  abstract createRenderer(hostElement: any, type: RendererType2|null): Renderer2;
+  abstract begin?(): void;
+  abstract end?(): void;
+  abstract whenRenderingDone?(): Promise<any>;
+}
+
+/**
+ * @experimental
+ */
+export enum RendererStyleFlags2 {
+  Important = 1 << 0,
+  DashCase = 1 << 1
+}
+
+/**
+ * @experimental
+ */
+export abstract class Renderer2 {
+  /**
+   * This field can be used to store arbitrary data on this renderer instance.
+   * This is useful for renderers that delegate to other renderers.
+   */
+  abstract get data(): {[key: string]: any};
+
+  abstract destroy(): void;
+  abstract createElement(name: string, namespace?: string|null): any;
+  abstract createComment(value: string): any;
+  abstract createText(value: string): any;
+  /**
+   * This property is allowed to be null / undefined,
+   * in which case the view engine won't call it.
+   * This is used as a performance optimization for production mode.
+   */
+  destroyNode: ((node: any) => void)|null;
+  abstract appendChild(parent: any, newChild: any): void;
+  abstract insertBefore(parent: any, newChild: any, refChild: any): void;
+  abstract removeChild(parent: any, oldChild: any): void;
+  abstract selectRootElement(selectorOrNode: string|any): any;
+  /**
+   * Attention: On WebWorkers, this will always return a value,
+   * as we are asking for a result synchronously. I.e.
+   * the caller can't rely on checking whether this is null or not.
+   */
+  abstract parentNode(node: any): any;
+  /**
+   * Attention: On WebWorkers, this will always return a value,
+   * as we are asking for a result synchronously. I.e.
+   * the caller can't rely on checking whether this is null or not.
+   */
+  abstract nextSibling(node: any): any;
+  abstract setAttribute(el: any, name: string, value: string, namespace?: string|null): void;
+  abstract removeAttribute(el: any, name: string, namespace?: string|null): void;
+  abstract addClass(el: any, name: string): void;
+  abstract removeClass(el: any, name: string): void;
+  abstract setStyle(el: any, style: string, value: any, flags?: RendererStyleFlags2): void;
+  abstract removeStyle(el: any, style: string, flags?: RendererStyleFlags2): void;
+  abstract setProperty(el: any, name: string, value: any): void;
+  abstract setValue(node: any, value: string): void;
+  abstract listen(
+      target: 'window'|'document'|'body'|any, eventName: string,
+      callback: (event: any) => boolean | void): () => void;
+}
diff --git a/angular/core/src/security.ts b/angular/core/src/security.ts
new file mode 100644
index 0000000..c47e30b
--- /dev/null
+++ b/angular/core/src/security.ts
@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property
+ * like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly
+ * handled.
+ *
+ * See DomSanitizer for more details on security in Angular applications.
+ *
+ * @stable
+ */
+export enum SecurityContext {
+  NONE = 0,
+  HTML = 1,
+  STYLE = 2,
+  SCRIPT = 3,
+  URL = 4,
+  RESOURCE_URL = 5,
+}
+
+/**
+ * Sanitizer is used by the views to sanitize potentially dangerous values.
+ *
+ * @stable
+ */
+export abstract class Sanitizer {
+  abstract sanitize(context: SecurityContext, value: {}|string|null): string|null;
+}
diff --git a/angular/core/src/testability/testability.ts b/angular/core/src/testability/testability.ts
new file mode 100644
index 0000000..3d5a22b
--- /dev/null
+++ b/angular/core/src/testability/testability.ts
@@ -0,0 +1,179 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injectable} from '../di';
+import {scheduleMicroTask} from '../util';
+import {NgZone} from '../zone/ng_zone';
+
+/**
+ * Testability API.
+ * `declare` keyword causes tsickle to generate externs, so these methods are
+ * not renamed by Closure Compiler.
+ * @experimental
+ */
+export declare interface PublicTestability {
+  isStable(): boolean;
+  whenStable(callback: Function): void;
+  findProviders(using: any, provider: string, exactMatch: boolean): any[];
+}
+
+/**
+ * The Testability service provides testing hooks that can be accessed from
+ * the browser and by services such as Protractor. Each bootstrapped Angular
+ * application on the page will have an instance of Testability.
+ * @experimental
+ */
+@Injectable()
+export class Testability implements PublicTestability {
+  /** @internal */
+  _pendingCount: number = 0;
+  /** @internal */
+  _isZoneStable: boolean = true;
+  /**
+   * Whether any work was done since the last 'whenStable' callback. This is
+   * useful to detect if this could have potentially destabilized another
+   * component while it is stabilizing.
+   * @internal
+   */
+  _didWork: boolean = false;
+  /** @internal */
+  _callbacks: Function[] = [];
+  constructor(private _ngZone: NgZone) { this._watchAngularEvents(); }
+
+  /** @internal */
+  _watchAngularEvents(): void {
+    this._ngZone.onUnstable.subscribe({
+      next: () => {
+        this._didWork = true;
+        this._isZoneStable = false;
+      }
+    });
+
+    this._ngZone.runOutsideAngular(() => {
+      this._ngZone.onStable.subscribe({
+        next: () => {
+          NgZone.assertNotInAngularZone();
+          scheduleMicroTask(() => {
+            this._isZoneStable = true;
+            this._runCallbacksIfReady();
+          });
+        }
+      });
+    });
+  }
+
+  increasePendingRequestCount(): number {
+    this._pendingCount += 1;
+    this._didWork = true;
+    return this._pendingCount;
+  }
+
+  decreasePendingRequestCount(): number {
+    this._pendingCount -= 1;
+    if (this._pendingCount < 0) {
+      throw new Error('pending async requests below zero');
+    }
+    this._runCallbacksIfReady();
+    return this._pendingCount;
+  }
+
+  isStable(): boolean {
+    return this._isZoneStable && this._pendingCount == 0 && !this._ngZone.hasPendingMacrotasks;
+  }
+
+  /** @internal */
+  _runCallbacksIfReady(): void {
+    if (this.isStable()) {
+      // Schedules the call backs in a new frame so that it is always async.
+      scheduleMicroTask(() => {
+        while (this._callbacks.length !== 0) {
+          (this._callbacks.pop() !)(this._didWork);
+        }
+        this._didWork = false;
+      });
+    } else {
+      // Not Ready
+      this._didWork = true;
+    }
+  }
+
+  whenStable(callback: Function): void {
+    this._callbacks.push(callback);
+    this._runCallbacksIfReady();
+  }
+
+  getPendingRequestCount(): number { return this._pendingCount; }
+
+  /** @deprecated use findProviders */
+  findBindings(using: any, provider: string, exactMatch: boolean): any[] {
+    // TODO(juliemr): implement.
+    return [];
+  }
+
+  findProviders(using: any, provider: string, exactMatch: boolean): any[] {
+    // TODO(juliemr): implement.
+    return [];
+  }
+}
+
+/**
+ * A global registry of {@link Testability} instances for specific elements.
+ * @experimental
+ */
+@Injectable()
+export class TestabilityRegistry {
+  /** @internal */
+  _applications = new Map<any, Testability>();
+
+  constructor() { _testabilityGetter.addToWindow(this); }
+
+  registerApplication(token: any, testability: Testability) {
+    this._applications.set(token, testability);
+  }
+
+  getTestability(elem: any): Testability|null { return this._applications.get(elem) || null; }
+
+  getAllTestabilities(): Testability[] { return Array.from(this._applications.values()); }
+
+  getAllRootElements(): any[] { return Array.from(this._applications.keys()); }
+
+  findTestabilityInTree(elem: Node, findInAncestors: boolean = true): Testability|null {
+    return _testabilityGetter.findTestabilityInTree(this, elem, findInAncestors);
+  }
+}
+
+/**
+ * Adapter interface for retrieving the `Testability` service associated for a
+ * particular context.
+ *
+ * @experimental Testability apis are primarily intended to be used by e2e test tool vendors like
+ * the Protractor team.
+ */
+export interface GetTestability {
+  addToWindow(registry: TestabilityRegistry): void;
+  findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean):
+      Testability|null;
+}
+
+class _NoopGetTestability implements GetTestability {
+  addToWindow(registry: TestabilityRegistry): void {}
+  findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean):
+      Testability|null {
+    return null;
+  }
+}
+
+/**
+ * Set the {@link GetTestability} implementation used by the Angular testing framework.
+ * @experimental
+ */
+export function setTestabilityGetter(getter: GetTestability): void {
+  _testabilityGetter = getter;
+}
+
+let _testabilityGetter: GetTestability = new _NoopGetTestability();
diff --git a/angular/core/src/type.ts b/angular/core/src/type.ts
new file mode 100644
index 0000000..72524fd
--- /dev/null
+++ b/angular/core/src/type.ts
@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @whatItDoes Represents a type that a Component or other object is instances of.
+ *
+ * @description
+ *
+ * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is be represented by
+ * the `MyCustomComponent` constructor function.
+ *
+ * @stable
+ */
+export const Type = Function;
+
+export function isType(v: any): v is Type<any> {
+  return typeof v === 'function';
+}
+
+export interface Type<T> extends Function { new (...args: any[]): T; }
diff --git a/angular/core/src/util.ts b/angular/core/src/util.ts
new file mode 100644
index 0000000..393cf40
--- /dev/null
+++ b/angular/core/src/util.ts
@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+// Import zero symbols from zone.js. This causes the zone ambient type to be
+// added to the type-checker, without emitting any runtime module load statement
+import {} from 'zone.js';
+
+// TODO(jteplitz602): Load WorkerGlobalScope from lib.webworker.d.ts file #3492
+declare var WorkerGlobalScope: any /** TODO #9100 */;
+// CommonJS / Node have global context exposed as "global" variable.
+// We don't want to include the whole node.d.ts this this compilation unit so we'll just fake
+// the global "global" var for now.
+declare var global: any /** TODO #9100 */;
+const __window = typeof window !== 'undefined' && window;
+const __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&
+    self instanceof WorkerGlobalScope && self;
+const __global = typeof global !== 'undefined' && global;
+const _global: {[name: string]: any} = __window || __global || __self;
+export {_global as global};
+
+// When Symbol.iterator doesn't exist, retrieves the key used in es6-shim
+declare const Symbol: any;
+let _symbolIterator: any = null;
+export function getSymbolIterator(): string|symbol {
+  if (!_symbolIterator) {
+    const Symbol = _global['Symbol'];
+    if (Symbol && Symbol.iterator) {
+      _symbolIterator = Symbol.iterator;
+    } else {
+      // es6-shim specific logic
+      const keys = Object.getOwnPropertyNames(Map.prototype);
+      for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        if (key !== 'entries' && key !== 'size' &&
+            (Map as any).prototype[key] === Map.prototype['entries']) {
+          _symbolIterator = key;
+        }
+      }
+    }
+  }
+  return _symbolIterator;
+}
+
+export function scheduleMicroTask(fn: Function) {
+  Zone.current.scheduleMicroTask('scheduleMicrotask', fn);
+}
+
+// JS has NaN !== NaN
+export function looseIdentical(a: any, b: any): boolean {
+  return a === b || typeof a === 'number' && typeof b === 'number' && isNaN(a) && isNaN(b);
+}
+
+export function stringify(token: any): string {
+  if (typeof token === 'string') {
+    return token;
+  }
+
+  if (token instanceof Array) {
+    return '[' + token.map(stringify).join(', ') + ']';
+  }
+
+  if (token == null) {
+    return '' + token;
+  }
+
+  if (token.overriddenName) {
+    return `${token.overriddenName}`;
+  }
+
+  if (token.name) {
+    return `${token.name}`;
+  }
+
+  const res = token.toString();
+
+  if (res == null) {
+    return '' + res;
+  }
+
+  const newLineIndex = res.indexOf('\n');
+  return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
+}
diff --git a/angular/core/src/util/decorators.ts b/angular/core/src/util/decorators.ts
new file mode 100644
index 0000000..868106b
--- /dev/null
+++ b/angular/core/src/util/decorators.ts
@@ -0,0 +1,159 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Type} from '../type';
+
+/**
+ * An interface implemented by all Angular type decorators, which allows them to be used as ES7
+ * decorators as well as
+ * Angular DSL syntax.
+ *
+ * ES7 syntax:
+ *
+ * ```
+ * @ng.Component({...})
+ * class MyClass {...}
+ * ```
+ * @stable
+ */
+export interface TypeDecorator {
+  /**
+   * Invoke as ES7 decorator.
+   */
+  <T extends Type<any>>(type: T): T;
+
+  // Make TypeDecorator assignable to built-in ParameterDecorator type.
+  // ParameterDecorator is declared in lib.d.ts as a `declare type`
+  // so we cannot declare this interface as a subtype.
+  // see https://github.com/angular/angular/issues/3379#issuecomment-126169417
+  (target: Object, propertyKey?: string|symbol, parameterIndex?: number): void;
+}
+
+export const ANNOTATIONS = '__annotations__';
+export const PARAMETERS = '__paramaters__';
+export const PROP_METADATA = '__prop__metadata__';
+
+/**
+ * @suppress {globalThis}
+ */
+export function makeDecorator(
+    name: string, props?: (...args: any[]) => any, parentClass?: any,
+    chainFn?: (fn: Function) => void):
+    {new (...args: any[]): any; (...args: any[]): any; (...args: any[]): (cls: any) => any;} {
+  const metaCtor = makeMetadataCtor(props);
+
+  function DecoratorFactory(objOrType: any): (cls: any) => any {
+    if (this instanceof DecoratorFactory) {
+      metaCtor.call(this, objOrType);
+      return this;
+    }
+
+    const annotationInstance = new (<any>DecoratorFactory)(objOrType);
+    const TypeDecorator: TypeDecorator = <TypeDecorator>function TypeDecorator(cls: Type<any>) {
+      // Use of Object.defineProperty is important since it creates non-enumerable property which
+      // prevents the property is copied during subclassing.
+      const annotations = cls.hasOwnProperty(ANNOTATIONS) ?
+          (cls as any)[ANNOTATIONS] :
+          Object.defineProperty(cls, ANNOTATIONS, {value: []})[ANNOTATIONS];
+      annotations.push(annotationInstance);
+      return cls;
+    };
+    if (chainFn) chainFn(TypeDecorator);
+    return TypeDecorator;
+  }
+
+  if (parentClass) {
+    DecoratorFactory.prototype = Object.create(parentClass.prototype);
+  }
+
+  DecoratorFactory.prototype.ngMetadataName = name;
+  (<any>DecoratorFactory).annotationCls = DecoratorFactory;
+  return DecoratorFactory as any;
+}
+
+function makeMetadataCtor(props?: (...args: any[]) => any): any {
+  return function ctor(...args: any[]) {
+    if (props) {
+      const values = props(...args);
+      for (const propName in values) {
+        this[propName] = values[propName];
+      }
+    }
+  };
+}
+
+export function makeParamDecorator(
+    name: string, props?: (...args: any[]) => any, parentClass?: any): any {
+  const metaCtor = makeMetadataCtor(props);
+  function ParamDecoratorFactory(...args: any[]): any {
+    if (this instanceof ParamDecoratorFactory) {
+      metaCtor.apply(this, args);
+      return this;
+    }
+    const annotationInstance = new (<any>ParamDecoratorFactory)(...args);
+
+    (<any>ParamDecorator).annotation = annotationInstance;
+    return ParamDecorator;
+
+    function ParamDecorator(cls: any, unusedKey: any, index: number): any {
+      // Use of Object.defineProperty is important since it creates non-enumerable property which
+      // prevents the property is copied during subclassing.
+      const parameters = cls.hasOwnProperty(PARAMETERS) ?
+          (cls as any)[PARAMETERS] :
+          Object.defineProperty(cls, PARAMETERS, {value: []})[PARAMETERS];
+
+      // there might be gaps if some in between parameters do not have annotations.
+      // we pad with nulls.
+      while (parameters.length <= index) {
+        parameters.push(null);
+      }
+
+      (parameters[index] = parameters[index] || []).push(annotationInstance);
+      return cls;
+    }
+  }
+  if (parentClass) {
+    ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);
+  }
+  ParamDecoratorFactory.prototype.ngMetadataName = name;
+  (<any>ParamDecoratorFactory).annotationCls = ParamDecoratorFactory;
+  return ParamDecoratorFactory;
+}
+
+export function makePropDecorator(
+    name: string, props?: (...args: any[]) => any, parentClass?: any): any {
+  const metaCtor = makeMetadataCtor(props);
+
+  function PropDecoratorFactory(...args: any[]): any {
+    if (this instanceof PropDecoratorFactory) {
+      metaCtor.apply(this, args);
+      return this;
+    }
+
+    const decoratorInstance = new (<any>PropDecoratorFactory)(...args);
+
+    return function PropDecorator(target: any, name: string) {
+      const constructor = target.constructor;
+      // Use of Object.defineProperty is important since it creates non-enumerable property which
+      // prevents the property is copied during subclassing.
+      const meta = constructor.hasOwnProperty(PROP_METADATA) ?
+          (constructor as any)[PROP_METADATA] :
+          Object.defineProperty(constructor, PROP_METADATA, {value: {}})[PROP_METADATA];
+      meta[name] = meta.hasOwnProperty(name) && meta[name] || [];
+      meta[name].unshift(decoratorInstance);
+    };
+  }
+
+  if (parentClass) {
+    PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
+  }
+
+  PropDecoratorFactory.prototype.ngMetadataName = name;
+  (<any>PropDecoratorFactory).annotationCls = PropDecoratorFactory;
+  return PropDecoratorFactory;
+}
diff --git a/angular/core/src/util/lang.ts b/angular/core/src/util/lang.ts
new file mode 100644
index 0000000..1d57731
--- /dev/null
+++ b/angular/core/src/util/lang.ts
@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Observable} from 'rxjs/Observable';
+
+/**
+ * Determine if the argument is shaped like a Promise
+ */
+export function isPromise(obj: any): obj is Promise<any> {
+  // allow any Promise/A+ compliant thenable.
+  // It's up to the caller to ensure that obj.then conforms to the spec
+  return !!obj && typeof obj.then === 'function';
+}
+
+/**
+ * Determine if the argument is an Observable
+ */
+export function isObservable(obj: any | Observable<any>): obj is Observable<any> {
+  // TODO use Symbol.observable when https://github.com/ReactiveX/rxjs/issues/2415 will be resolved
+  return !!obj && typeof obj.subscribe === 'function';
+}
diff --git a/angular/core/src/version.ts b/angular/core/src/version.ts
new file mode 100644
index 0000000..3a662a8
--- /dev/null
+++ b/angular/core/src/version.ts
@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @whatItDoes Represents the version of Angular
+ *
+ * @stable
+ */
+export class Version {
+  constructor(public full: string) {}
+
+  get major(): string { return this.full.split('.')[0]; }
+
+  get minor(): string { return this.full.split('.')[1]; }
+
+  get patch(): string { return this.full.split('.').slice(2).join('.'); }
+}
+
+/**
+ * @stable
+ */
+export const VERSION = new Version('0.0.0-PLACEHOLDER');
diff --git a/angular/core/src/view/element.ts b/angular/core/src/view/element.ts
new file mode 100644
index 0000000..ecc7c59
--- /dev/null
+++ b/angular/core/src/view/element.ts
@@ -0,0 +1,300 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {RendererType2} from '../render/api';
+import {SecurityContext} from '../security';
+
+import {BindingDef, BindingFlags, ElementData, ElementHandleEventFn, NodeDef, NodeFlags, OutputDef, OutputType, QueryValueType, ViewData, ViewDefinitionFactory, asElementData} from './types';
+import {NOOP, calcBindingFlags, checkAndUpdateBinding, dispatchEvent, elementEventFullName, getParentRenderElement, resolveDefinition, resolveRendererType2, splitMatchedQueriesDsl, splitNamespace} from './util';
+
+export function anchorDef(
+    flags: NodeFlags, matchedQueriesDsl: [string | number, QueryValueType][],
+    ngContentIndex: number, childCount: number, handleEvent?: ElementHandleEventFn,
+    templateFactory?: ViewDefinitionFactory): NodeDef {
+  flags |= NodeFlags.TypeElement;
+  const {matchedQueries, references, matchedQueryIds} = splitMatchedQueriesDsl(matchedQueriesDsl);
+  const template = templateFactory ? resolveDefinition(templateFactory) : null;
+
+  return {
+    // will bet set by the view definition
+    index: -1,
+    parent: null,
+    renderParent: null,
+    bindingIndex: -1,
+    outputIndex: -1,
+    // regular values
+    flags,
+    childFlags: 0,
+    directChildFlags: 0,
+    childMatchedQueries: 0, matchedQueries, matchedQueryIds, references, ngContentIndex, childCount,
+    bindings: [],
+    bindingFlags: 0,
+    outputs: [],
+    element: {
+      ns: null,
+      name: null,
+      attrs: null, template,
+      componentProvider: null,
+      componentView: null,
+      componentRendererType: null,
+      publicProviders: null,
+      allProviders: null,
+      handleEvent: handleEvent || NOOP
+    },
+    provider: null,
+    text: null,
+    query: null,
+    ngContent: null
+  };
+}
+
+export function elementDef(
+    flags: NodeFlags, matchedQueriesDsl: [string | number, QueryValueType][],
+    ngContentIndex: number, childCount: number, namespaceAndName: string,
+    fixedAttrs: [string, string][] = [],
+    bindings?: [BindingFlags, string, string | SecurityContext][], outputs?: ([string, string])[],
+    handleEvent?: ElementHandleEventFn, componentView?: ViewDefinitionFactory,
+    componentRendererType?: RendererType2 | null): NodeDef {
+  if (!handleEvent) {
+    handleEvent = NOOP;
+  }
+  const {matchedQueries, references, matchedQueryIds} = splitMatchedQueriesDsl(matchedQueriesDsl);
+  let ns: string = null !;
+  let name: string = null !;
+  if (namespaceAndName) {
+    [ns, name] = splitNamespace(namespaceAndName);
+  }
+  bindings = bindings || [];
+  const bindingDefs: BindingDef[] = new Array(bindings.length);
+  for (let i = 0; i < bindings.length; i++) {
+    const [bindingFlags, namespaceAndName, suffixOrSecurityContext] = bindings[i];
+
+    const [ns, name] = splitNamespace(namespaceAndName);
+    let securityContext: SecurityContext = undefined !;
+    let suffix: string = undefined !;
+    switch (bindingFlags & BindingFlags.Types) {
+      case BindingFlags.TypeElementStyle:
+        suffix = <string>suffixOrSecurityContext;
+        break;
+      case BindingFlags.TypeElementAttribute:
+      case BindingFlags.TypeProperty:
+        securityContext = <SecurityContext>suffixOrSecurityContext;
+        break;
+    }
+    bindingDefs[i] =
+        {flags: bindingFlags, ns, name, nonMinifiedName: name, securityContext, suffix};
+  }
+  outputs = outputs || [];
+  const outputDefs: OutputDef[] = new Array(outputs.length);
+  for (let i = 0; i < outputs.length; i++) {
+    const [target, eventName] = outputs[i];
+    outputDefs[i] = {
+      type: OutputType.ElementOutput,
+      target: <any>target, eventName,
+      propName: null
+    };
+  }
+  fixedAttrs = fixedAttrs || [];
+  const attrs = <[string, string, string][]>fixedAttrs.map(([namespaceAndName, value]) => {
+    const [ns, name] = splitNamespace(namespaceAndName);
+    return [ns, name, value];
+  });
+  componentRendererType = resolveRendererType2(componentRendererType);
+  if (componentView) {
+    flags |= NodeFlags.ComponentView;
+  }
+  flags |= NodeFlags.TypeElement;
+  return {
+    // will bet set by the view definition
+    index: -1,
+    parent: null,
+    renderParent: null,
+    bindingIndex: -1,
+    outputIndex: -1,
+    // regular values
+    flags,
+    childFlags: 0,
+    directChildFlags: 0,
+    childMatchedQueries: 0, matchedQueries, matchedQueryIds, references, ngContentIndex, childCount,
+    bindings: bindingDefs,
+    bindingFlags: calcBindingFlags(bindingDefs),
+    outputs: outputDefs,
+    element: {
+      ns,
+      name,
+      attrs,
+      template: null,
+      // will bet set by the view definition
+      componentProvider: null,
+      componentView: componentView || null,
+      componentRendererType: componentRendererType,
+      publicProviders: null,
+      allProviders: null,
+      handleEvent: handleEvent || NOOP,
+    },
+    provider: null,
+    text: null,
+    query: null,
+    ngContent: null
+  };
+}
+
+export function createElement(view: ViewData, renderHost: any, def: NodeDef): ElementData {
+  const elDef = def.element !;
+  const rootSelectorOrNode = view.root.selectorOrNode;
+  const renderer = view.renderer;
+  let el: any;
+  if (view.parent || !rootSelectorOrNode) {
+    if (elDef.name) {
+      el = renderer.createElement(elDef.name, elDef.ns);
+    } else {
+      el = renderer.createComment('');
+    }
+    const parentEl = getParentRenderElement(view, renderHost, def);
+    if (parentEl) {
+      renderer.appendChild(parentEl, el);
+    }
+  } else {
+    el = renderer.selectRootElement(rootSelectorOrNode);
+  }
+  if (elDef.attrs) {
+    for (let i = 0; i < elDef.attrs.length; i++) {
+      const [ns, name, value] = elDef.attrs[i];
+      renderer.setAttribute(el, name, value, ns);
+    }
+  }
+  return el;
+}
+
+export function listenToElementOutputs(view: ViewData, compView: ViewData, def: NodeDef, el: any) {
+  for (let i = 0; i < def.outputs.length; i++) {
+    const output = def.outputs[i];
+    const handleEventClosure = renderEventHandlerClosure(
+        view, def.index, elementEventFullName(output.target, output.eventName));
+    let listenTarget: 'window'|'document'|'body'|'component'|null = output.target;
+    let listenerView = view;
+    if (output.target === 'component') {
+      listenTarget = null;
+      listenerView = compView;
+    }
+    const disposable =
+        <any>listenerView.renderer.listen(listenTarget || el, output.eventName, handleEventClosure);
+    view.disposables ![def.outputIndex + i] = disposable;
+  }
+}
+
+function renderEventHandlerClosure(view: ViewData, index: number, eventName: string) {
+  return (event: any) => dispatchEvent(view, index, eventName, event);
+}
+
+
+export function checkAndUpdateElementInline(
+    view: ViewData, def: NodeDef, v0: any, v1: any, v2: any, v3: any, v4: any, v5: any, v6: any,
+    v7: any, v8: any, v9: any): boolean {
+  const bindLen = def.bindings.length;
+  let changed = false;
+  if (bindLen > 0 && checkAndUpdateElementValue(view, def, 0, v0)) changed = true;
+  if (bindLen > 1 && checkAndUpdateElementValue(view, def, 1, v1)) changed = true;
+  if (bindLen > 2 && checkAndUpdateElementValue(view, def, 2, v2)) changed = true;
+  if (bindLen > 3 && checkAndUpdateElementValue(view, def, 3, v3)) changed = true;
+  if (bindLen > 4 && checkAndUpdateElementValue(view, def, 4, v4)) changed = true;
+  if (bindLen > 5 && checkAndUpdateElementValue(view, def, 5, v5)) changed = true;
+  if (bindLen > 6 && checkAndUpdateElementValue(view, def, 6, v6)) changed = true;
+  if (bindLen > 7 && checkAndUpdateElementValue(view, def, 7, v7)) changed = true;
+  if (bindLen > 8 && checkAndUpdateElementValue(view, def, 8, v8)) changed = true;
+  if (bindLen > 9 && checkAndUpdateElementValue(view, def, 9, v9)) changed = true;
+  return changed;
+}
+
+export function checkAndUpdateElementDynamic(view: ViewData, def: NodeDef, values: any[]): boolean {
+  let changed = false;
+  for (let i = 0; i < values.length; i++) {
+    if (checkAndUpdateElementValue(view, def, i, values[i])) changed = true;
+  }
+  return changed;
+}
+
+function checkAndUpdateElementValue(view: ViewData, def: NodeDef, bindingIdx: number, value: any) {
+  if (!checkAndUpdateBinding(view, def, bindingIdx, value)) {
+    return false;
+  }
+  const binding = def.bindings[bindingIdx];
+  const elData = asElementData(view, def.index);
+  const renderNode = elData.renderElement;
+  const name = binding.name !;
+  switch (binding.flags & BindingFlags.Types) {
+    case BindingFlags.TypeElementAttribute:
+      setElementAttribute(view, binding, renderNode, binding.ns, name, value);
+      break;
+    case BindingFlags.TypeElementClass:
+      setElementClass(view, renderNode, name, value);
+      break;
+    case BindingFlags.TypeElementStyle:
+      setElementStyle(view, binding, renderNode, name, value);
+      break;
+    case BindingFlags.TypeProperty:
+      const bindView = (def.flags & NodeFlags.ComponentView &&
+                        binding.flags & BindingFlags.SyntheticHostProperty) ?
+          elData.componentView :
+          view;
+      setElementProperty(bindView, binding, renderNode, name, value);
+      break;
+  }
+  return true;
+}
+
+function setElementAttribute(
+    view: ViewData, binding: BindingDef, renderNode: any, ns: string | null, name: string,
+    value: any) {
+  const securityContext = binding.securityContext;
+  let renderValue = securityContext ? view.root.sanitizer.sanitize(securityContext, value) : value;
+  renderValue = renderValue != null ? renderValue.toString() : null;
+  const renderer = view.renderer;
+  if (value != null) {
+    renderer.setAttribute(renderNode, name, renderValue, ns);
+  } else {
+    renderer.removeAttribute(renderNode, name, ns);
+  }
+}
+
+function setElementClass(view: ViewData, renderNode: any, name: string, value: boolean) {
+  const renderer = view.renderer;
+  if (value) {
+    renderer.addClass(renderNode, name);
+  } else {
+    renderer.removeClass(renderNode, name);
+  }
+}
+
+function setElementStyle(
+    view: ViewData, binding: BindingDef, renderNode: any, name: string, value: any) {
+  let renderValue: string|null =
+      view.root.sanitizer.sanitize(SecurityContext.STYLE, value as{} | string);
+  if (renderValue != null) {
+    renderValue = renderValue.toString();
+    const unit = binding.suffix;
+    if (unit != null) {
+      renderValue = renderValue + unit;
+    }
+  } else {
+    renderValue = null;
+  }
+  const renderer = view.renderer;
+  if (renderValue != null) {
+    renderer.setStyle(renderNode, name, renderValue);
+  } else {
+    renderer.removeStyle(renderNode, name);
+  }
+}
+
+function setElementProperty(
+    view: ViewData, binding: BindingDef, renderNode: any, name: string, value: any) {
+  const securityContext = binding.securityContext;
+  let renderValue = securityContext ? view.root.sanitizer.sanitize(securityContext, value) : value;
+  view.renderer.setProperty(renderNode, name, renderValue);
+}
diff --git a/angular/core/src/view/entrypoint.ts b/angular/core/src/view/entrypoint.ts
new file mode 100644
index 0000000..f0355db
--- /dev/null
+++ b/angular/core/src/view/entrypoint.ts
@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injector} from '../di/injector';
+import {NgModuleFactory, NgModuleRef} from '../linker/ng_module_factory';
+import {Type} from '../type';
+
+import {initServicesIfNeeded} from './services';
+import {NgModuleDefinitionFactory, ProviderOverride, Services} from './types';
+import {resolveDefinition} from './util';
+
+export function overrideProvider(override: ProviderOverride) {
+  initServicesIfNeeded();
+  return Services.overrideProvider(override);
+}
+
+export function clearProviderOverrides() {
+  initServicesIfNeeded();
+  return Services.clearProviderOverrides();
+}
+
+// Attention: this function is called as top level function.
+// Putting any logic in here will destroy closure tree shaking!
+export function createNgModuleFactory(
+    ngModuleType: Type<any>, bootstrapComponents: Type<any>[],
+    defFactory: NgModuleDefinitionFactory): NgModuleFactory<any> {
+  return new NgModuleFactory_(ngModuleType, bootstrapComponents, defFactory);
+}
+
+class NgModuleFactory_ extends NgModuleFactory<any> {
+  constructor(
+      public readonly moduleType: Type<any>, private _bootstrapComponents: Type<any>[],
+      private _ngModuleDefFactory: NgModuleDefinitionFactory) {
+    // Attention: this ctor is called as top level function.
+    // Putting any logic in here will destroy closure tree shaking!
+    super();
+  }
+
+  create(parentInjector: Injector|null): NgModuleRef<any> {
+    initServicesIfNeeded();
+    const def = resolveDefinition(this._ngModuleDefFactory);
+    return Services.createNgModuleRef(
+        this.moduleType, parentInjector || Injector.NULL, this._bootstrapComponents, def);
+  }
+}
diff --git a/angular/core/src/view/errors.ts b/angular/core/src/view/errors.ts
new file mode 100644
index 0000000..96df939
--- /dev/null
+++ b/angular/core/src/view/errors.ts
@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ERROR_DEBUG_CONTEXT, ERROR_LOGGER, getDebugContext} from '../errors';
+import {DebugContext, ViewState} from './types';
+
+export function expressionChangedAfterItHasBeenCheckedError(
+    context: DebugContext, oldValue: any, currValue: any, isFirstCheck: boolean): Error {
+  let msg =
+      `ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value: '${oldValue}'. Current value: '${currValue}'.`;
+  if (isFirstCheck) {
+    msg +=
+        ` It seems like the view has been created after its parent and its children have been dirty checked.` +
+        ` Has it been created in a change detection hook ?`;
+  }
+  return viewDebugError(msg, context);
+}
+
+export function viewWrappedDebugError(err: any, context: DebugContext): Error {
+  if (!(err instanceof Error)) {
+    // errors that are not Error instances don't have a stack,
+    // so it is ok to wrap them into a new Error object...
+    err = new Error(err.toString());
+  }
+  _addDebugContext(err, context);
+  return err;
+}
+
+export function viewDebugError(msg: string, context: DebugContext): Error {
+  const err = new Error(msg);
+  _addDebugContext(err, context);
+  return err;
+}
+
+function _addDebugContext(err: Error, context: DebugContext) {
+  (err as any)[ERROR_DEBUG_CONTEXT] = context;
+  (err as any)[ERROR_LOGGER] = context.logError.bind(context);
+}
+
+export function isViewDebugError(err: Error): boolean {
+  return !!getDebugContext(err);
+}
+
+export function viewDestroyedError(action: string): Error {
+  return new Error(`ViewDestroyedError: Attempt to use a destroyed view: ${action}`);
+}
diff --git a/angular/core/src/view/index.ts b/angular/core/src/view/index.ts
new file mode 100644
index 0000000..4275d44
--- /dev/null
+++ b/angular/core/src/view/index.ts
@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export {anchorDef, elementDef} from './element';
+export {clearProviderOverrides, createNgModuleFactory, overrideProvider} from './entrypoint';
+export {ngContentDef} from './ng_content';
+export {moduleDef, moduleProvideDef} from './ng_module';
+export {directiveDef, pipeDef, providerDef} from './provider';
+export {pureArrayDef, pureObjectDef, purePipeDef} from './pure_expression';
+export {queryDef} from './query';
+export {ViewRef_, createComponentFactory, getComponentViewDefinitionFactory, nodeValue} from './refs';
+export {initServicesIfNeeded} from './services';
+export {textDef} from './text';
+export {EMPTY_ARRAY, EMPTY_MAP, createRendererType2, elementEventFullName, inlineInterpolate, interpolate, rootRenderNodes, tokenKey, unwrapValue} from './util';
+export {viewDef} from './view';
+export {attachEmbeddedView, detachEmbeddedView, moveEmbeddedView} from './view_attach';
+
+export * from './types';
diff --git a/angular/core/src/view/ng_content.ts b/angular/core/src/view/ng_content.ts
new file mode 100644
index 0000000..dfe251a
--- /dev/null
+++ b/angular/core/src/view/ng_content.ts
@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {NodeDef, NodeFlags, ViewData} from './types';
+import {RenderNodeAction, getParentRenderElement, visitProjectedRenderNodes} from './util';
+
+export function ngContentDef(ngContentIndex: number, index: number): NodeDef {
+  return {
+    // will bet set by the view definition
+    index: -1,
+    parent: null,
+    renderParent: null,
+    bindingIndex: -1,
+    outputIndex: -1,
+    // regular values
+    flags: NodeFlags.TypeNgContent,
+    childFlags: 0,
+    directChildFlags: 0,
+    childMatchedQueries: 0,
+    matchedQueries: {},
+    matchedQueryIds: 0,
+    references: {}, ngContentIndex,
+    childCount: 0,
+    bindings: [],
+    bindingFlags: 0,
+    outputs: [],
+    element: null,
+    provider: null,
+    text: null,
+    query: null,
+    ngContent: {index}
+  };
+}
+
+export function appendNgContent(view: ViewData, renderHost: any, def: NodeDef) {
+  const parentEl = getParentRenderElement(view, renderHost, def);
+  if (!parentEl) {
+    // Nothing to do if there is no parent element.
+    return;
+  }
+  const ngContentIndex = def.ngContent !.index;
+  visitProjectedRenderNodes(
+      view, ngContentIndex, RenderNodeAction.AppendChild, parentEl, null, undefined);
+}
diff --git a/angular/core/src/view/ng_module.ts b/angular/core/src/view/ng_module.ts
new file mode 100644
index 0000000..c7c464a
--- /dev/null
+++ b/angular/core/src/view/ng_module.ts
@@ -0,0 +1,174 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injector, THROW_IF_NOT_FOUND} from '../di/injector';
+import {NgModuleRef} from '../linker/ng_module_factory';
+
+import {DepDef, DepFlags, NgModuleData, NgModuleDefinition, NgModuleDefinitionFactory, NgModuleProviderDef, NodeFlags} from './types';
+import {splitDepsDsl, tokenKey} from './util';
+
+const NOT_CREATED = new Object();
+
+const InjectorRefTokenKey = tokenKey(Injector);
+const NgModuleRefTokenKey = tokenKey(NgModuleRef);
+
+export function moduleProvideDef(
+    flags: NodeFlags, token: any, value: any,
+    deps: ([DepFlags, any] | any)[]): NgModuleProviderDef {
+  const depDefs = splitDepsDsl(deps);
+  return {
+    // will bet set by the module definition
+    index: -1,
+    deps: depDefs, flags, token, value
+  };
+}
+
+export function moduleDef(providers: NgModuleProviderDef[]): NgModuleDefinition {
+  const providersByKey: {[key: string]: NgModuleProviderDef} = {};
+  for (let i = 0; i < providers.length; i++) {
+    const provider = providers[i];
+    provider.index = i;
+    providersByKey[tokenKey(provider.token)] = provider;
+  }
+  return {
+    // Will be filled later...
+    factory: null,
+    providersByKey,
+    providers
+  };
+}
+
+export function initNgModule(data: NgModuleData) {
+  const def = data._def;
+  const providers = data._providers = new Array(def.providers.length);
+  for (let i = 0; i < def.providers.length; i++) {
+    const provDef = def.providers[i];
+    providers[i] = provDef.flags & NodeFlags.LazyProvider ? NOT_CREATED :
+                                                            _createProviderInstance(data, provDef);
+  }
+}
+
+export function resolveNgModuleDep(
+    data: NgModuleData, depDef: DepDef, notFoundValue: any = Injector.THROW_IF_NOT_FOUND): any {
+  if (depDef.flags & DepFlags.Value) {
+    return depDef.token;
+  }
+  if (depDef.flags & DepFlags.Optional) {
+    notFoundValue = null;
+  }
+  if (depDef.flags & DepFlags.SkipSelf) {
+    return data._parent.get(depDef.token, notFoundValue);
+  }
+  const tokenKey = depDef.tokenKey;
+  switch (tokenKey) {
+    case InjectorRefTokenKey:
+    case NgModuleRefTokenKey:
+      return data;
+  }
+  const providerDef = data._def.providersByKey[tokenKey];
+  if (providerDef) {
+    let providerInstance = data._providers[providerDef.index];
+    if (providerInstance === NOT_CREATED) {
+      providerInstance = data._providers[providerDef.index] =
+          _createProviderInstance(data, providerDef);
+    }
+    return providerInstance;
+  }
+  return data._parent.get(depDef.token, notFoundValue);
+}
+
+
+function _createProviderInstance(ngModule: NgModuleData, providerDef: NgModuleProviderDef): any {
+  let injectable: any;
+  switch (providerDef.flags & NodeFlags.Types) {
+    case NodeFlags.TypeClassProvider:
+      injectable = _createClass(ngModule, providerDef.value, providerDef.deps);
+      break;
+    case NodeFlags.TypeFactoryProvider:
+      injectable = _callFactory(ngModule, providerDef.value, providerDef.deps);
+      break;
+    case NodeFlags.TypeUseExistingProvider:
+      injectable = resolveNgModuleDep(ngModule, providerDef.deps[0]);
+      break;
+    case NodeFlags.TypeValueProvider:
+      injectable = providerDef.value;
+      break;
+  }
+  return injectable;
+}
+
+function _createClass(ngModule: NgModuleData, ctor: any, deps: DepDef[]): any {
+  const len = deps.length;
+  let injectable: any;
+  switch (len) {
+    case 0:
+      injectable = new ctor();
+      break;
+    case 1:
+      injectable = new ctor(resolveNgModuleDep(ngModule, deps[0]));
+      break;
+    case 2:
+      injectable =
+          new ctor(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]));
+      break;
+    case 3:
+      injectable = new ctor(
+          resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]),
+          resolveNgModuleDep(ngModule, deps[2]));
+      break;
+    default:
+      const depValues = new Array(len);
+      for (let i = 0; i < len; i++) {
+        depValues[i] = resolveNgModuleDep(ngModule, deps[i]);
+      }
+      injectable = new ctor(...depValues);
+  }
+  return injectable;
+}
+
+function _callFactory(ngModule: NgModuleData, factory: any, deps: DepDef[]): any {
+  const len = deps.length;
+  let injectable: any;
+  switch (len) {
+    case 0:
+      injectable = factory();
+      break;
+    case 1:
+      injectable = factory(resolveNgModuleDep(ngModule, deps[0]));
+      break;
+    case 2:
+      injectable =
+          factory(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]));
+      break;
+    case 3:
+      injectable = factory(
+          resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]),
+          resolveNgModuleDep(ngModule, deps[2]));
+      break;
+    default:
+      const depValues = Array(len);
+      for (let i = 0; i < len; i++) {
+        depValues[i] = resolveNgModuleDep(ngModule, deps[i]);
+      }
+      injectable = factory(...depValues);
+  }
+  return injectable;
+}
+
+export function callNgModuleLifecycle(ngModule: NgModuleData, lifecycles: NodeFlags) {
+  const def = ngModule._def;
+  for (let i = 0; i < def.providers.length; i++) {
+    const provDef = def.providers[i];
+    if (provDef.flags & NodeFlags.OnDestroy) {
+      const instance = ngModule._providers[i];
+      if (instance && instance !== NOT_CREATED) {
+        instance.ngOnDestroy();
+      }
+    }
+  }
+}
diff --git a/angular/core/src/view/provider.ts b/angular/core/src/view/provider.ts
new file mode 100644
index 0000000..798d599
--- /dev/null
+++ b/angular/core/src/view/provider.ts
@@ -0,0 +1,520 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ChangeDetectorRef, SimpleChange, SimpleChanges, WrappedValue} from '../change_detection/change_detection';
+import {Injector} from '../di';
+import {ElementRef} from '../linker/element_ref';
+import {TemplateRef} from '../linker/template_ref';
+import {ViewContainerRef} from '../linker/view_container_ref';
+import {Renderer as RendererV1, Renderer2} from '../render/api';
+
+import {createChangeDetectorRef, createInjector, createRendererV1} from './refs';
+import {BindingDef, BindingFlags, DepDef, DepFlags, NodeDef, NodeFlags, OutputDef, OutputType, ProviderData, QueryValueType, Services, ViewData, ViewFlags, ViewState, asElementData, asProviderData} from './types';
+import {calcBindingFlags, checkBinding, dispatchEvent, isComponentView, splitDepsDsl, splitMatchedQueriesDsl, tokenKey, viewParentEl} from './util';
+
+const RendererV1TokenKey = tokenKey(RendererV1);
+const Renderer2TokenKey = tokenKey(Renderer2);
+const ElementRefTokenKey = tokenKey(ElementRef);
+const ViewContainerRefTokenKey = tokenKey(ViewContainerRef);
+const TemplateRefTokenKey = tokenKey(TemplateRef);
+const ChangeDetectorRefTokenKey = tokenKey(ChangeDetectorRef);
+const InjectorRefTokenKey = tokenKey(Injector);
+
+const NOT_CREATED = new Object();
+
+export function directiveDef(
+    flags: NodeFlags, matchedQueries: [string | number, QueryValueType][], childCount: number,
+    ctor: any, deps: ([DepFlags, any] | any)[], props?: {[name: string]: [number, string]},
+    outputs?: {[name: string]: string}): NodeDef {
+  const bindings: BindingDef[] = [];
+  if (props) {
+    for (let prop in props) {
+      const [bindingIndex, nonMinifiedName] = props[prop];
+      bindings[bindingIndex] = {
+        flags: BindingFlags.TypeProperty,
+        name: prop, nonMinifiedName,
+        ns: null,
+        securityContext: null,
+        suffix: null
+      };
+    }
+  }
+  const outputDefs: OutputDef[] = [];
+  if (outputs) {
+    for (let propName in outputs) {
+      outputDefs.push(
+          {type: OutputType.DirectiveOutput, propName, target: null, eventName: outputs[propName]});
+    }
+  }
+  flags |= NodeFlags.TypeDirective;
+  return _def(flags, matchedQueries, childCount, ctor, ctor, deps, bindings, outputDefs);
+}
+
+export function pipeDef(flags: NodeFlags, ctor: any, deps: ([DepFlags, any] | any)[]): NodeDef {
+  flags |= NodeFlags.TypePipe;
+  return _def(flags, null, 0, ctor, ctor, deps);
+}
+
+export function providerDef(
+    flags: NodeFlags, matchedQueries: [string | number, QueryValueType][], token: any, value: any,
+    deps: ([DepFlags, any] | any)[]): NodeDef {
+  return _def(flags, matchedQueries, 0, token, value, deps);
+}
+
+export function _def(
+    flags: NodeFlags, matchedQueriesDsl: [string | number, QueryValueType][] | null,
+    childCount: number, token: any, value: any, deps: ([DepFlags, any] | any)[],
+    bindings?: BindingDef[], outputs?: OutputDef[]): NodeDef {
+  const {matchedQueries, references, matchedQueryIds} = splitMatchedQueriesDsl(matchedQueriesDsl);
+  if (!outputs) {
+    outputs = [];
+  }
+  if (!bindings) {
+    bindings = [];
+  }
+
+  const depDefs = splitDepsDsl(deps);
+
+  return {
+    // will bet set by the view definition
+    index: -1,
+    parent: null,
+    renderParent: null,
+    bindingIndex: -1,
+    outputIndex: -1,
+    // regular values
+    flags,
+    childFlags: 0,
+    directChildFlags: 0,
+    childMatchedQueries: 0, matchedQueries, matchedQueryIds, references,
+    ngContentIndex: -1, childCount, bindings,
+    bindingFlags: calcBindingFlags(bindings), outputs,
+    element: null,
+    provider: {token, value, deps: depDefs},
+    text: null,
+    query: null,
+    ngContent: null
+  };
+}
+
+export function createProviderInstance(view: ViewData, def: NodeDef): any {
+  return def.flags & NodeFlags.LazyProvider ? NOT_CREATED : _createProviderInstance(view, def);
+}
+
+export function createPipeInstance(view: ViewData, def: NodeDef): any {
+  // deps are looked up from component.
+  let compView = view;
+  while (compView.parent && !isComponentView(compView)) {
+    compView = compView.parent;
+  }
+  // pipes can see the private services of the component
+  const allowPrivateServices = true;
+  // pipes are always eager and classes!
+  return createClass(
+      compView.parent !, viewParentEl(compView) !, allowPrivateServices, def.provider !.value,
+      def.provider !.deps);
+}
+
+export function createDirectiveInstance(view: ViewData, def: NodeDef): any {
+  // components can see other private services, other directives can't.
+  const allowPrivateServices = (def.flags & NodeFlags.Component) > 0;
+  // directives are always eager and classes!
+  const instance = createClass(
+      view, def.parent !, allowPrivateServices, def.provider !.value, def.provider !.deps);
+  if (def.outputs.length) {
+    for (let i = 0; i < def.outputs.length; i++) {
+      const output = def.outputs[i];
+      const subscription = instance[output.propName !].subscribe(
+          eventHandlerClosure(view, def.parent !.index, output.eventName));
+      view.disposables ![def.outputIndex + i] = subscription.unsubscribe.bind(subscription);
+    }
+  }
+  return instance;
+}
+
+function eventHandlerClosure(view: ViewData, index: number, eventName: string) {
+  return (event: any) => dispatchEvent(view, index, eventName, event);
+}
+
+export function checkAndUpdateDirectiveInline(
+    view: ViewData, def: NodeDef, v0: any, v1: any, v2: any, v3: any, v4: any, v5: any, v6: any,
+    v7: any, v8: any, v9: any): boolean {
+  const providerData = asProviderData(view, def.index);
+  const directive = providerData.instance;
+  let changed = false;
+  let changes: SimpleChanges = undefined !;
+  const bindLen = def.bindings.length;
+  if (bindLen > 0 && checkBinding(view, def, 0, v0)) {
+    changed = true;
+    changes = updateProp(view, providerData, def, 0, v0, changes);
+  }
+  if (bindLen > 1 && checkBinding(view, def, 1, v1)) {
+    changed = true;
+    changes = updateProp(view, providerData, def, 1, v1, changes);
+  }
+  if (bindLen > 2 && checkBinding(view, def, 2, v2)) {
+    changed = true;
+    changes = updateProp(view, providerData, def, 2, v2, changes);
+  }
+  if (bindLen > 3 && checkBinding(view, def, 3, v3)) {
+    changed = true;
+    changes = updateProp(view, providerData, def, 3, v3, changes);
+  }
+  if (bindLen > 4 && checkBinding(view, def, 4, v4)) {
+    changed = true;
+    changes = updateProp(view, providerData, def, 4, v4, changes);
+  }
+  if (bindLen > 5 && checkBinding(view, def, 5, v5)) {
+    changed = true;
+    changes = updateProp(view, providerData, def, 5, v5, changes);
+  }
+  if (bindLen > 6 && checkBinding(view, def, 6, v6)) {
+    changed = true;
+    changes = updateProp(view, providerData, def, 6, v6, changes);
+  }
+  if (bindLen > 7 && checkBinding(view, def, 7, v7)) {
+    changed = true;
+    changes = updateProp(view, providerData, def, 7, v7, changes);
+  }
+  if (bindLen > 8 && checkBinding(view, def, 8, v8)) {
+    changed = true;
+    changes = updateProp(view, providerData, def, 8, v8, changes);
+  }
+  if (bindLen > 9 && checkBinding(view, def, 9, v9)) {
+    changed = true;
+    changes = updateProp(view, providerData, def, 9, v9, changes);
+  }
+  if (changes) {
+    directive.ngOnChanges(changes);
+  }
+  if ((view.state & ViewState.FirstCheck) && (def.flags & NodeFlags.OnInit)) {
+    directive.ngOnInit();
+  }
+  if (def.flags & NodeFlags.DoCheck) {
+    directive.ngDoCheck();
+  }
+  return changed;
+}
+
+export function checkAndUpdateDirectiveDynamic(
+    view: ViewData, def: NodeDef, values: any[]): boolean {
+  const providerData = asProviderData(view, def.index);
+  const directive = providerData.instance;
+  let changed = false;
+  let changes: SimpleChanges = undefined !;
+  for (let i = 0; i < values.length; i++) {
+    if (checkBinding(view, def, i, values[i])) {
+      changed = true;
+      changes = updateProp(view, providerData, def, i, values[i], changes);
+    }
+  }
+  if (changes) {
+    directive.ngOnChanges(changes);
+  }
+  if ((view.state & ViewState.FirstCheck) && (def.flags & NodeFlags.OnInit)) {
+    directive.ngOnInit();
+  }
+  if (def.flags & NodeFlags.DoCheck) {
+    directive.ngDoCheck();
+  }
+  return changed;
+}
+
+function _createProviderInstance(view: ViewData, def: NodeDef): any {
+  // private services can see other private services
+  const allowPrivateServices = (def.flags & NodeFlags.PrivateProvider) > 0;
+  const providerDef = def.provider;
+  let injectable: any;
+  switch (def.flags & NodeFlags.Types) {
+    case NodeFlags.TypeClassProvider:
+      injectable = createClass(
+          view, def.parent !, allowPrivateServices, providerDef !.value, providerDef !.deps);
+      break;
+    case NodeFlags.TypeFactoryProvider:
+      injectable = callFactory(
+          view, def.parent !, allowPrivateServices, providerDef !.value, providerDef !.deps);
+      break;
+    case NodeFlags.TypeUseExistingProvider:
+      injectable = resolveDep(view, def.parent !, allowPrivateServices, providerDef !.deps[0]);
+      break;
+    case NodeFlags.TypeValueProvider:
+      injectable = providerDef !.value;
+      break;
+  }
+  return injectable;
+}
+
+function createClass(
+    view: ViewData, elDef: NodeDef, allowPrivateServices: boolean, ctor: any, deps: DepDef[]): any {
+  const len = deps.length;
+  let injectable: any;
+  switch (len) {
+    case 0:
+      injectable = new ctor();
+      break;
+    case 1:
+      injectable = new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]));
+      break;
+    case 2:
+      injectable = new ctor(
+          resolveDep(view, elDef, allowPrivateServices, deps[0]),
+          resolveDep(view, elDef, allowPrivateServices, deps[1]));
+      break;
+    case 3:
+      injectable = new ctor(
+          resolveDep(view, elDef, allowPrivateServices, deps[0]),
+          resolveDep(view, elDef, allowPrivateServices, deps[1]),
+          resolveDep(view, elDef, allowPrivateServices, deps[2]));
+      break;
+    default:
+      const depValues = new Array(len);
+      for (let i = 0; i < len; i++) {
+        depValues[i] = resolveDep(view, elDef, allowPrivateServices, deps[i]);
+      }
+      injectable = new ctor(...depValues);
+  }
+  return injectable;
+}
+
+function callFactory(
+    view: ViewData, elDef: NodeDef, allowPrivateServices: boolean, factory: any,
+    deps: DepDef[]): any {
+  const len = deps.length;
+  let injectable: any;
+  switch (len) {
+    case 0:
+      injectable = factory();
+      break;
+    case 1:
+      injectable = factory(resolveDep(view, elDef, allowPrivateServices, deps[0]));
+      break;
+    case 2:
+      injectable = factory(
+          resolveDep(view, elDef, allowPrivateServices, deps[0]),
+          resolveDep(view, elDef, allowPrivateServices, deps[1]));
+      break;
+    case 3:
+      injectable = factory(
+          resolveDep(view, elDef, allowPrivateServices, deps[0]),
+          resolveDep(view, elDef, allowPrivateServices, deps[1]),
+          resolveDep(view, elDef, allowPrivateServices, deps[2]));
+      break;
+    default:
+      const depValues = Array(len);
+      for (let i = 0; i < len; i++) {
+        depValues[i] = resolveDep(view, elDef, allowPrivateServices, deps[i]);
+      }
+      injectable = factory(...depValues);
+  }
+  return injectable;
+}
+
+// This default value is when checking the hierarchy for a token.
+//
+// It means both:
+// - the token is not provided by the current injector,
+// - only the element injectors should be checked (ie do not check module injectors
+//
+//          mod1
+//         /
+//       el1   mod2
+//         \  /
+//         el2
+//
+// When requesting el2.injector.get(token), we should check in the following order and return the
+// first found value:
+// - el2.injector.get(token, default)
+// - el1.injector.get(token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) -> do not check the module
+// - mod2.injector.get(token, default)
+export const NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};
+
+export function resolveDep(
+    view: ViewData, elDef: NodeDef, allowPrivateServices: boolean, depDef: DepDef,
+    notFoundValue: any = Injector.THROW_IF_NOT_FOUND): any {
+  if (depDef.flags & DepFlags.Value) {
+    return depDef.token;
+  }
+  const startView = view;
+  if (depDef.flags & DepFlags.Optional) {
+    notFoundValue = null;
+  }
+  const tokenKey = depDef.tokenKey;
+
+  if (tokenKey === ChangeDetectorRefTokenKey) {
+    // directives on the same element as a component should be able to control the change detector
+    // of that component as well.
+    allowPrivateServices = !!(elDef && elDef.element !.componentView);
+  }
+
+  if (elDef && (depDef.flags & DepFlags.SkipSelf)) {
+    allowPrivateServices = false;
+    elDef = elDef.parent !;
+  }
+
+  while (view) {
+    if (elDef) {
+      switch (tokenKey) {
+        case RendererV1TokenKey: {
+          const compView = findCompView(view, elDef, allowPrivateServices);
+          return createRendererV1(compView);
+        }
+        case Renderer2TokenKey: {
+          const compView = findCompView(view, elDef, allowPrivateServices);
+          return compView.renderer;
+        }
+        case ElementRefTokenKey:
+          return new ElementRef(asElementData(view, elDef.index).renderElement);
+        case ViewContainerRefTokenKey:
+          return asElementData(view, elDef.index).viewContainer;
+        case TemplateRefTokenKey: {
+          if (elDef.element !.template) {
+            return asElementData(view, elDef.index).template;
+          }
+          break;
+        }
+        case ChangeDetectorRefTokenKey: {
+          let cdView = findCompView(view, elDef, allowPrivateServices);
+          return createChangeDetectorRef(cdView);
+        }
+        case InjectorRefTokenKey:
+          return createInjector(view, elDef);
+        default:
+          const providerDef =
+              (allowPrivateServices ? elDef.element !.allProviders :
+                                      elDef.element !.publicProviders) ![tokenKey];
+          if (providerDef) {
+            const providerData = asProviderData(view, providerDef.index);
+            if (providerData.instance === NOT_CREATED) {
+              providerData.instance = _createProviderInstance(view, providerDef);
+            }
+            return providerData.instance;
+          }
+      }
+    }
+    allowPrivateServices = isComponentView(view);
+    elDef = viewParentEl(view) !;
+    view = view.parent !;
+  }
+
+  const value = startView.root.injector.get(depDef.token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR);
+
+  if (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR ||
+      notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) {
+    // Return the value from the root element injector when
+    // - it provides it
+    //   (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)
+    // - the module injector should not be checked
+    //   (notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)
+    return value;
+  }
+
+  return startView.root.ngModule.injector.get(depDef.token, notFoundValue);
+}
+
+function findCompView(view: ViewData, elDef: NodeDef, allowPrivateServices: boolean) {
+  let compView: ViewData;
+  if (allowPrivateServices) {
+    compView = asElementData(view, elDef.index).componentView;
+  } else {
+    compView = view;
+    while (compView.parent && !isComponentView(compView)) {
+      compView = compView.parent;
+    }
+  }
+  return compView;
+}
+
+function updateProp(
+    view: ViewData, providerData: ProviderData, def: NodeDef, bindingIdx: number, value: any,
+    changes: SimpleChanges): SimpleChanges {
+  if (def.flags & NodeFlags.Component) {
+    const compView = asElementData(view, def.parent !.index).componentView;
+    if (compView.def.flags & ViewFlags.OnPush) {
+      compView.state |= ViewState.ChecksEnabled;
+    }
+  }
+  const binding = def.bindings[bindingIdx];
+  const propName = binding.name !;
+  // Note: This is still safe with Closure Compiler as
+  // the user passed in the property name as an object has to `providerDef`,
+  // so Closure Compiler will have renamed the property correctly already.
+  providerData.instance[propName] = value;
+  if (def.flags & NodeFlags.OnChanges) {
+    changes = changes || {};
+    let oldValue = view.oldValues[def.bindingIndex + bindingIdx];
+    if (oldValue instanceof WrappedValue) {
+      oldValue = oldValue.wrapped;
+    }
+    const binding = def.bindings[bindingIdx];
+    changes[binding.nonMinifiedName !] =
+        new SimpleChange(oldValue, value, (view.state & ViewState.FirstCheck) !== 0);
+  }
+  view.oldValues[def.bindingIndex + bindingIdx] = value;
+  return changes;
+}
+
+export function callLifecycleHooksChildrenFirst(view: ViewData, lifecycles: NodeFlags) {
+  if (!(view.def.nodeFlags & lifecycles)) {
+    return;
+  }
+  const nodes = view.def.nodes;
+  for (let i = 0; i < nodes.length; i++) {
+    const nodeDef = nodes[i];
+    let parent = nodeDef.parent;
+    if (!parent && nodeDef.flags & lifecycles) {
+      // matching root node (e.g. a pipe)
+      callProviderLifecycles(view, i, nodeDef.flags & lifecycles);
+    }
+    if ((nodeDef.childFlags & lifecycles) === 0) {
+      // no child matches one of the lifecycles
+      i += nodeDef.childCount;
+    }
+    while (parent && (parent.flags & NodeFlags.TypeElement) &&
+           i === parent.index + parent.childCount) {
+      // last child of an element
+      if (parent.directChildFlags & lifecycles) {
+        callElementProvidersLifecycles(view, parent, lifecycles);
+      }
+      parent = parent.parent;
+    }
+  }
+}
+
+function callElementProvidersLifecycles(view: ViewData, elDef: NodeDef, lifecycles: NodeFlags) {
+  for (let i = elDef.index + 1; i <= elDef.index + elDef.childCount; i++) {
+    const nodeDef = view.def.nodes[i];
+    if (nodeDef.flags & lifecycles) {
+      callProviderLifecycles(view, i, nodeDef.flags & lifecycles);
+    }
+    // only visit direct children
+    i += nodeDef.childCount;
+  }
+}
+
+function callProviderLifecycles(view: ViewData, index: number, lifecycles: NodeFlags) {
+  const provider = asProviderData(view, index).instance;
+  if (provider === NOT_CREATED) {
+    return;
+  }
+  Services.setCurrentNode(view, index);
+  if (lifecycles & NodeFlags.AfterContentInit) {
+    provider.ngAfterContentInit();
+  }
+  if (lifecycles & NodeFlags.AfterContentChecked) {
+    provider.ngAfterContentChecked();
+  }
+  if (lifecycles & NodeFlags.AfterViewInit) {
+    provider.ngAfterViewInit();
+  }
+  if (lifecycles & NodeFlags.AfterViewChecked) {
+    provider.ngAfterViewChecked();
+  }
+  if (lifecycles & NodeFlags.OnDestroy) {
+    provider.ngOnDestroy();
+  }
+}
diff --git a/angular/core/src/view/pure_expression.ts b/angular/core/src/view/pure_expression.ts
new file mode 100644
index 0000000..d8ab3c8
--- /dev/null
+++ b/angular/core/src/view/pure_expression.ts
@@ -0,0 +1,199 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {BindingDef, BindingFlags, NodeDef, NodeFlags, PureExpressionData, ViewData, asPureExpressionData} from './types';
+import {calcBindingFlags, checkAndUpdateBinding} from './util';
+
+export function purePipeDef(argCount: number): NodeDef {
+  // argCount + 1 to include the pipe as first arg
+  return _pureExpressionDef(NodeFlags.TypePurePipe, new Array(argCount + 1));
+}
+
+export function pureArrayDef(argCount: number): NodeDef {
+  return _pureExpressionDef(NodeFlags.TypePureArray, new Array(argCount));
+}
+
+export function pureObjectDef(propToIndex: {[p: string]: number}): NodeDef {
+  const keys = Object.keys(propToIndex);
+  const nbKeys = keys.length;
+  const propertyNames = new Array(nbKeys);
+  for (let i = 0; i < nbKeys; i++) {
+    const key = keys[i];
+    const index = propToIndex[key];
+    propertyNames[index] = key;
+  }
+
+  return _pureExpressionDef(NodeFlags.TypePureObject, propertyNames);
+}
+
+function _pureExpressionDef(flags: NodeFlags, propertyNames: string[]): NodeDef {
+  const bindings: BindingDef[] = new Array(propertyNames.length);
+  for (let i = 0; i < propertyNames.length; i++) {
+    const prop = propertyNames[i];
+    bindings[i] = {
+      flags: BindingFlags.TypeProperty,
+      name: prop,
+      ns: null,
+      nonMinifiedName: prop,
+      securityContext: null,
+      suffix: null
+    };
+  }
+  return {
+    // will bet set by the view definition
+    index: -1,
+    parent: null,
+    renderParent: null,
+    bindingIndex: -1,
+    outputIndex: -1,
+    // regular values
+    flags,
+    childFlags: 0,
+    directChildFlags: 0,
+    childMatchedQueries: 0,
+    matchedQueries: {},
+    matchedQueryIds: 0,
+    references: {},
+    ngContentIndex: -1,
+    childCount: 0, bindings,
+    bindingFlags: calcBindingFlags(bindings),
+    outputs: [],
+    element: null,
+    provider: null,
+    text: null,
+    query: null,
+    ngContent: null
+  };
+}
+
+export function createPureExpression(view: ViewData, def: NodeDef): PureExpressionData {
+  return {value: undefined};
+}
+
+export function checkAndUpdatePureExpressionInline(
+    view: ViewData, def: NodeDef, v0: any, v1: any, v2: any, v3: any, v4: any, v5: any, v6: any,
+    v7: any, v8: any, v9: any): boolean {
+  const bindings = def.bindings;
+  let changed = false;
+  const bindLen = bindings.length;
+  if (bindLen > 0 && checkAndUpdateBinding(view, def, 0, v0)) changed = true;
+  if (bindLen > 1 && checkAndUpdateBinding(view, def, 1, v1)) changed = true;
+  if (bindLen > 2 && checkAndUpdateBinding(view, def, 2, v2)) changed = true;
+  if (bindLen > 3 && checkAndUpdateBinding(view, def, 3, v3)) changed = true;
+  if (bindLen > 4 && checkAndUpdateBinding(view, def, 4, v4)) changed = true;
+  if (bindLen > 5 && checkAndUpdateBinding(view, def, 5, v5)) changed = true;
+  if (bindLen > 6 && checkAndUpdateBinding(view, def, 6, v6)) changed = true;
+  if (bindLen > 7 && checkAndUpdateBinding(view, def, 7, v7)) changed = true;
+  if (bindLen > 8 && checkAndUpdateBinding(view, def, 8, v8)) changed = true;
+  if (bindLen > 9 && checkAndUpdateBinding(view, def, 9, v9)) changed = true;
+
+  if (changed) {
+    const data = asPureExpressionData(view, def.index);
+    let value: any;
+    switch (def.flags & NodeFlags.Types) {
+      case NodeFlags.TypePureArray:
+        value = new Array(bindings.length);
+        if (bindLen > 0) value[0] = v0;
+        if (bindLen > 1) value[1] = v1;
+        if (bindLen > 2) value[2] = v2;
+        if (bindLen > 3) value[3] = v3;
+        if (bindLen > 4) value[4] = v4;
+        if (bindLen > 5) value[5] = v5;
+        if (bindLen > 6) value[6] = v6;
+        if (bindLen > 7) value[7] = v7;
+        if (bindLen > 8) value[8] = v8;
+        if (bindLen > 9) value[9] = v9;
+        break;
+      case NodeFlags.TypePureObject:
+        value = {};
+        if (bindLen > 0) value[bindings[0].name !] = v0;
+        if (bindLen > 1) value[bindings[1].name !] = v1;
+        if (bindLen > 2) value[bindings[2].name !] = v2;
+        if (bindLen > 3) value[bindings[3].name !] = v3;
+        if (bindLen > 4) value[bindings[4].name !] = v4;
+        if (bindLen > 5) value[bindings[5].name !] = v5;
+        if (bindLen > 6) value[bindings[6].name !] = v6;
+        if (bindLen > 7) value[bindings[7].name !] = v7;
+        if (bindLen > 8) value[bindings[8].name !] = v8;
+        if (bindLen > 9) value[bindings[9].name !] = v9;
+        break;
+      case NodeFlags.TypePurePipe:
+        const pipe = v0;
+        switch (bindLen) {
+          case 1:
+            value = pipe.transform(v0);
+            break;
+          case 2:
+            value = pipe.transform(v1);
+            break;
+          case 3:
+            value = pipe.transform(v1, v2);
+            break;
+          case 4:
+            value = pipe.transform(v1, v2, v3);
+            break;
+          case 5:
+            value = pipe.transform(v1, v2, v3, v4);
+            break;
+          case 6:
+            value = pipe.transform(v1, v2, v3, v4, v5);
+            break;
+          case 7:
+            value = pipe.transform(v1, v2, v3, v4, v5, v6);
+            break;
+          case 8:
+            value = pipe.transform(v1, v2, v3, v4, v5, v6, v7);
+            break;
+          case 9:
+            value = pipe.transform(v1, v2, v3, v4, v5, v6, v7, v8);
+            break;
+          case 10:
+            value = pipe.transform(v1, v2, v3, v4, v5, v6, v7, v8, v9);
+            break;
+        }
+        break;
+    }
+    data.value = value;
+  }
+  return changed;
+}
+
+export function checkAndUpdatePureExpressionDynamic(
+    view: ViewData, def: NodeDef, values: any[]): boolean {
+  const bindings = def.bindings;
+  let changed = false;
+  for (let i = 0; i < values.length; i++) {
+    // Note: We need to loop over all values, so that
+    // the old values are updates as well!
+    if (checkAndUpdateBinding(view, def, i, values[i])) {
+      changed = true;
+    }
+  }
+  if (changed) {
+    const data = asPureExpressionData(view, def.index);
+    let value: any;
+    switch (def.flags & NodeFlags.Types) {
+      case NodeFlags.TypePureArray:
+        value = values;
+        break;
+      case NodeFlags.TypePureObject:
+        value = {};
+        for (let i = 0; i < values.length; i++) {
+          value[bindings[i].name !] = values[i];
+        }
+        break;
+      case NodeFlags.TypePurePipe:
+        const pipe = values[0];
+        const params = values.slice(1);
+        value = (<any>pipe.transform)(...params);
+        break;
+    }
+    data.value = value;
+  }
+  return changed;
+}
diff --git a/angular/core/src/view/query.ts b/angular/core/src/view/query.ts
new file mode 100644
index 0000000..8422162
--- /dev/null
+++ b/angular/core/src/view/query.ts
@@ -0,0 +1,193 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ElementRef} from '../linker/element_ref';
+import {QueryList} from '../linker/query_list';
+
+import {NodeDef, NodeFlags, QueryBindingDef, QueryBindingType, QueryDef, QueryValueType, ViewData, asElementData, asProviderData, asQueryList} from './types';
+import {declaredViewContainer, filterQueryId, isEmbeddedView} from './util';
+
+export function queryDef(
+    flags: NodeFlags, id: number, bindings: {[propName: string]: QueryBindingType}): NodeDef {
+  let bindingDefs: QueryBindingDef[] = [];
+  for (let propName in bindings) {
+    const bindingType = bindings[propName];
+    bindingDefs.push({propName, bindingType});
+  }
+
+  return {
+    // will bet set by the view definition
+    index: -1,
+    parent: null,
+    renderParent: null,
+    bindingIndex: -1,
+    outputIndex: -1,
+    // regular values
+    flags,
+    childFlags: 0,
+    directChildFlags: 0,
+    childMatchedQueries: 0,
+    ngContentIndex: -1,
+    matchedQueries: {},
+    matchedQueryIds: 0,
+    references: {},
+    childCount: 0,
+    bindings: [],
+    bindingFlags: 0,
+    outputs: [],
+    element: null,
+    provider: null,
+    text: null,
+    query: {id, filterId: filterQueryId(id), bindings: bindingDefs},
+    ngContent: null
+  };
+}
+
+export function createQuery(): QueryList<any> {
+  return new QueryList();
+}
+
+export function dirtyParentQueries(view: ViewData) {
+  const queryIds = view.def.nodeMatchedQueries;
+  while (view.parent && isEmbeddedView(view)) {
+    let tplDef = view.parentNodeDef !;
+    view = view.parent;
+    // content queries
+    const end = tplDef.index + tplDef.childCount;
+    for (let i = 0; i <= end; i++) {
+      const nodeDef = view.def.nodes[i];
+      if ((nodeDef.flags & NodeFlags.TypeContentQuery) &&
+          (nodeDef.flags & NodeFlags.DynamicQuery) &&
+          (nodeDef.query !.filterId & queryIds) === nodeDef.query !.filterId) {
+        asQueryList(view, i).setDirty();
+      }
+      if ((nodeDef.flags & NodeFlags.TypeElement && i + nodeDef.childCount < tplDef.index) ||
+          !(nodeDef.childFlags & NodeFlags.TypeContentQuery) ||
+          !(nodeDef.childFlags & NodeFlags.DynamicQuery)) {
+        // skip elements that don't contain the template element or no query.
+        i += nodeDef.childCount;
+      }
+    }
+  }
+
+  // view queries
+  if (view.def.nodeFlags & NodeFlags.TypeViewQuery) {
+    for (let i = 0; i < view.def.nodes.length; i++) {
+      const nodeDef = view.def.nodes[i];
+      if ((nodeDef.flags & NodeFlags.TypeViewQuery) && (nodeDef.flags & NodeFlags.DynamicQuery)) {
+        asQueryList(view, i).setDirty();
+      }
+      // only visit the root nodes
+      i += nodeDef.childCount;
+    }
+  }
+}
+
+export function checkAndUpdateQuery(view: ViewData, nodeDef: NodeDef) {
+  const queryList = asQueryList(view, nodeDef.index);
+  if (!queryList.dirty) {
+    return;
+  }
+  let directiveInstance: any;
+  let newValues: any[] = undefined !;
+  if (nodeDef.flags & NodeFlags.TypeContentQuery) {
+    const elementDef = nodeDef.parent !.parent !;
+    newValues = calcQueryValues(
+        view, elementDef.index, elementDef.index + elementDef.childCount, nodeDef.query !, []);
+    directiveInstance = asProviderData(view, nodeDef.parent !.index).instance;
+  } else if (nodeDef.flags & NodeFlags.TypeViewQuery) {
+    newValues = calcQueryValues(view, 0, view.def.nodes.length - 1, nodeDef.query !, []);
+    directiveInstance = view.component;
+  }
+  queryList.reset(newValues);
+  const bindings = nodeDef.query !.bindings;
+  let notify = false;
+  for (let i = 0; i < bindings.length; i++) {
+    const binding = bindings[i];
+    let boundValue: any;
+    switch (binding.bindingType) {
+      case QueryBindingType.First:
+        boundValue = queryList.first;
+        break;
+      case QueryBindingType.All:
+        boundValue = queryList;
+        notify = true;
+        break;
+    }
+    directiveInstance[binding.propName] = boundValue;
+  }
+  if (notify) {
+    queryList.notifyOnChanges();
+  }
+}
+
+function calcQueryValues(
+    view: ViewData, startIndex: number, endIndex: number, queryDef: QueryDef,
+    values: any[]): any[] {
+  for (let i = startIndex; i <= endIndex; i++) {
+    const nodeDef = view.def.nodes[i];
+    const valueType = nodeDef.matchedQueries[queryDef.id];
+    if (valueType != null) {
+      values.push(getQueryValue(view, nodeDef, valueType));
+    }
+    if (nodeDef.flags & NodeFlags.TypeElement && nodeDef.element !.template &&
+        (nodeDef.element !.template !.nodeMatchedQueries & queryDef.filterId) ===
+            queryDef.filterId) {
+      // check embedded views that were attached at the place of their template.
+      const elementData = asElementData(view, i);
+      if (nodeDef.flags & NodeFlags.EmbeddedViews) {
+        const embeddedViews = elementData.viewContainer !._embeddedViews;
+        for (let k = 0; k < embeddedViews.length; k++) {
+          const embeddedView = embeddedViews[k];
+          const dvc = declaredViewContainer(embeddedView);
+          if (dvc && dvc === elementData) {
+            calcQueryValues(embeddedView, 0, embeddedView.def.nodes.length - 1, queryDef, values);
+          }
+        }
+      }
+      const projectedViews = elementData.template._projectedViews;
+      if (projectedViews) {
+        for (let k = 0; k < projectedViews.length; k++) {
+          const projectedView = projectedViews[k];
+          calcQueryValues(projectedView, 0, projectedView.def.nodes.length - 1, queryDef, values);
+        }
+      }
+    }
+    if ((nodeDef.childMatchedQueries & queryDef.filterId) !== queryDef.filterId) {
+      // if no child matches the query, skip the children.
+      i += nodeDef.childCount;
+    }
+  }
+  return values;
+}
+
+export function getQueryValue(
+    view: ViewData, nodeDef: NodeDef, queryValueType: QueryValueType): any {
+  if (queryValueType != null) {
+    // a match
+    let value: any;
+    switch (queryValueType) {
+      case QueryValueType.RenderElement:
+        value = asElementData(view, nodeDef.index).renderElement;
+        break;
+      case QueryValueType.ElementRef:
+        value = new ElementRef(asElementData(view, nodeDef.index).renderElement);
+        break;
+      case QueryValueType.TemplateRef:
+        value = asElementData(view, nodeDef.index).template;
+        break;
+      case QueryValueType.ViewContainerRef:
+        value = asElementData(view, nodeDef.index).viewContainer;
+        break;
+      case QueryValueType.Provider:
+        value = asProviderData(view, nodeDef.index).instance;
+        break;
+    }
+    return value;
+  }
+}
diff --git a/angular/core/src/view/refs.ts b/angular/core/src/view/refs.ts
new file mode 100644
index 0000000..bb9040f
--- /dev/null
+++ b/angular/core/src/view/refs.ts
@@ -0,0 +1,506 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ApplicationRef} from '../application_ref';
+import {ChangeDetectorRef} from '../change_detection/change_detection';
+import {Injector} from '../di/injector';
+import {ComponentFactory, ComponentRef} from '../linker/component_factory';
+import {ComponentFactoryBoundToModule, ComponentFactoryResolver} from '../linker/component_factory_resolver';
+import {ElementRef} from '../linker/element_ref';
+import {InternalNgModuleRef, NgModuleRef} from '../linker/ng_module_factory';
+import {TemplateRef} from '../linker/template_ref';
+import {ViewContainerRef} from '../linker/view_container_ref';
+import {EmbeddedViewRef, InternalViewRef, ViewRef} from '../linker/view_ref';
+import {Renderer as RendererV1, Renderer2} from '../render/api';
+import {Type} from '../type';
+import {stringify} from '../util';
+import {VERSION} from '../version';
+
+import {callNgModuleLifecycle, initNgModule, resolveNgModuleDep} from './ng_module';
+import {DepFlags, ElementData, NgModuleData, NgModuleDefinition, NodeDef, NodeFlags, Services, TemplateData, ViewContainerData, ViewData, ViewDefinitionFactory, ViewState, asElementData, asProviderData, asTextData} from './types';
+import {markParentViewsForCheck, resolveDefinition, rootRenderNodes, splitNamespace, tokenKey, viewParentEl} from './util';
+import {attachEmbeddedView, detachEmbeddedView, moveEmbeddedView, renderDetachView} from './view_attach';
+
+const EMPTY_CONTEXT = new Object();
+
+// Attention: this function is called as top level function.
+// Putting any logic in here will destroy closure tree shaking!
+export function createComponentFactory(
+    selector: string, componentType: Type<any>, viewDefFactory: ViewDefinitionFactory,
+    inputs: {[propName: string]: string} | null, outputs: {[propName: string]: string},
+    ngContentSelectors: string[]): ComponentFactory<any> {
+  return new ComponentFactory_(
+      selector, componentType, viewDefFactory, inputs, outputs, ngContentSelectors);
+}
+
+export function getComponentViewDefinitionFactory(componentFactory: ComponentFactory<any>):
+    ViewDefinitionFactory {
+  return (componentFactory as ComponentFactory_).viewDefFactory;
+}
+
+class ComponentFactory_ extends ComponentFactory<any> {
+  /**
+   * @internal
+   */
+  viewDefFactory: ViewDefinitionFactory;
+
+  constructor(
+      public selector: string, public componentType: Type<any>,
+      viewDefFactory: ViewDefinitionFactory, private _inputs: {[propName: string]: string}|null,
+      private _outputs: {[propName: string]: string}, public ngContentSelectors: string[]) {
+    // Attention: this ctor is called as top level function.
+    // Putting any logic in here will destroy closure tree shaking!
+    super();
+    this.viewDefFactory = viewDefFactory;
+  }
+
+  get inputs() {
+    const inputsArr: {propName: string, templateName: string}[] = [];
+    const inputs = this._inputs !;
+    for (let propName in inputs) {
+      const templateName = inputs[propName];
+      inputsArr.push({propName, templateName});
+    }
+    return inputsArr;
+  }
+
+  get outputs() {
+    const outputsArr: {propName: string, templateName: string}[] = [];
+    for (let propName in this._outputs) {
+      const templateName = this._outputs[propName];
+      outputsArr.push({propName, templateName});
+    }
+    return outputsArr;
+  }
+
+  /**
+   * Creates a new component.
+   */
+  create(
+      injector: Injector, projectableNodes?: any[][], rootSelectorOrNode?: string|any,
+      ngModule?: NgModuleRef<any>): ComponentRef<any> {
+    if (!ngModule) {
+      throw new Error('ngModule should be provided');
+    }
+    const viewDef = resolveDefinition(this.viewDefFactory);
+    const componentNodeIndex = viewDef.nodes[0].element !.componentProvider !.index;
+    const view = Services.createRootView(
+        injector, projectableNodes || [], rootSelectorOrNode, viewDef, ngModule, EMPTY_CONTEXT);
+    const component = asProviderData(view, componentNodeIndex).instance;
+    if (rootSelectorOrNode) {
+      view.renderer.setAttribute(asElementData(view, 0).renderElement, 'ng-version', VERSION.full);
+    }
+
+    return new ComponentRef_(view, new ViewRef_(view), component);
+  }
+}
+
+class ComponentRef_ extends ComponentRef<any> {
+  private _elDef: NodeDef;
+  constructor(private _view: ViewData, private _viewRef: ViewRef, private _component: any) {
+    super();
+    this._elDef = this._view.def.nodes[0];
+  }
+  get location(): ElementRef {
+    return new ElementRef(asElementData(this._view, this._elDef.index).renderElement);
+  }
+  get injector(): Injector { return new Injector_(this._view, this._elDef); }
+  get instance(): any { return this._component; };
+  get hostView(): ViewRef { return this._viewRef; };
+  get changeDetectorRef(): ChangeDetectorRef { return this._viewRef; };
+  get componentType(): Type<any> { return <any>this._component.constructor; }
+
+  destroy(): void { this._viewRef.destroy(); }
+  onDestroy(callback: Function): void { this._viewRef.onDestroy(callback); }
+}
+
+export function createViewContainerData(
+    view: ViewData, elDef: NodeDef, elData: ElementData): ViewContainerData {
+  return new ViewContainerRef_(view, elDef, elData);
+}
+
+class ViewContainerRef_ implements ViewContainerData {
+  /**
+   * @internal
+   */
+  _embeddedViews: ViewData[] = [];
+  constructor(private _view: ViewData, private _elDef: NodeDef, private _data: ElementData) {}
+
+  get element(): ElementRef { return new ElementRef(this._data.renderElement); }
+
+  get injector(): Injector { return new Injector_(this._view, this._elDef); }
+
+  get parentInjector(): Injector {
+    let view = this._view;
+    let elDef = this._elDef.parent;
+    while (!elDef && view) {
+      elDef = viewParentEl(view);
+      view = view.parent !;
+    }
+
+    return view ? new Injector_(view, elDef) : new Injector_(this._view, null);
+  }
+
+  clear(): void {
+    const len = this._embeddedViews.length;
+    for (let i = len - 1; i >= 0; i--) {
+      const view = detachEmbeddedView(this._data, i) !;
+      Services.destroyView(view);
+    }
+  }
+
+  get(index: number): ViewRef|null {
+    const view = this._embeddedViews[index];
+    if (view) {
+      const ref = new ViewRef_(view);
+      ref.attachToViewContainerRef(this);
+      return ref;
+    }
+    return null;
+  }
+
+  get length(): number { return this._embeddedViews.length; };
+
+  createEmbeddedView<C>(templateRef: TemplateRef<C>, context?: C, index?: number):
+      EmbeddedViewRef<C> {
+    const viewRef = templateRef.createEmbeddedView(context || <any>{});
+    this.insert(viewRef, index);
+    return viewRef;
+  }
+
+  createComponent<C>(
+      componentFactory: ComponentFactory<C>, index?: number, injector?: Injector,
+      projectableNodes?: any[][], ngModuleRef?: NgModuleRef<any>): ComponentRef<C> {
+    const contextInjector = injector || this.parentInjector;
+    if (!ngModuleRef && !(componentFactory instanceof ComponentFactoryBoundToModule)) {
+      ngModuleRef = contextInjector.get(NgModuleRef);
+    }
+    const componentRef =
+        componentFactory.create(contextInjector, projectableNodes, undefined, ngModuleRef);
+    this.insert(componentRef.hostView, index);
+    return componentRef;
+  }
+
+  insert(viewRef: ViewRef, index?: number): ViewRef {
+    if (viewRef.destroyed) {
+      throw new Error('Cannot insert a destroyed View in a ViewContainer!');
+    }
+    const viewRef_ = <ViewRef_>viewRef;
+    const viewData = viewRef_._view;
+    attachEmbeddedView(this._view, this._data, index, viewData);
+    viewRef_.attachToViewContainerRef(this);
+    return viewRef;
+  }
+
+  move(viewRef: ViewRef_, currentIndex: number): ViewRef {
+    if (viewRef.destroyed) {
+      throw new Error('Cannot move a destroyed View in a ViewContainer!');
+    }
+    const previousIndex = this._embeddedViews.indexOf(viewRef._view);
+    moveEmbeddedView(this._data, previousIndex, currentIndex);
+    return viewRef;
+  }
+
+  indexOf(viewRef: ViewRef): number {
+    return this._embeddedViews.indexOf((<ViewRef_>viewRef)._view);
+  }
+
+  remove(index?: number): void {
+    const viewData = detachEmbeddedView(this._data, index);
+    if (viewData) {
+      Services.destroyView(viewData);
+    }
+  }
+
+  detach(index?: number): ViewRef|null {
+    const view = detachEmbeddedView(this._data, index);
+    return view ? new ViewRef_(view) : null;
+  }
+}
+
+export function createChangeDetectorRef(view: ViewData): ChangeDetectorRef {
+  return new ViewRef_(view);
+}
+
+export class ViewRef_ implements EmbeddedViewRef<any>, InternalViewRef {
+  /** @internal */
+  _view: ViewData;
+  private _viewContainerRef: ViewContainerRef|null;
+  private _appRef: ApplicationRef|null;
+
+  constructor(_view: ViewData) {
+    this._view = _view;
+    this._viewContainerRef = null;
+    this._appRef = null;
+  }
+
+  get rootNodes(): any[] { return rootRenderNodes(this._view); }
+
+  get context() { return this._view.context; }
+
+  get destroyed(): boolean { return (this._view.state & ViewState.Destroyed) !== 0; }
+
+  markForCheck(): void { markParentViewsForCheck(this._view); }
+  detach(): void { this._view.state &= ~ViewState.Attached; }
+  detectChanges(): void {
+    const fs = this._view.root.rendererFactory;
+    if (fs.begin) {
+      fs.begin();
+    }
+    Services.checkAndUpdateView(this._view);
+    if (fs.end) {
+      fs.end();
+    }
+  }
+  checkNoChanges(): void { Services.checkNoChangesView(this._view); }
+
+  reattach(): void { this._view.state |= ViewState.Attached; }
+  onDestroy(callback: Function) {
+    if (!this._view.disposables) {
+      this._view.disposables = [];
+    }
+    this._view.disposables.push(<any>callback);
+  }
+
+  destroy() {
+    if (this._appRef) {
+      this._appRef.detachView(this);
+    } else if (this._viewContainerRef) {
+      this._viewContainerRef.detach(this._viewContainerRef.indexOf(this));
+    }
+    Services.destroyView(this._view);
+  }
+
+  detachFromAppRef() {
+    this._appRef = null;
+    renderDetachView(this._view);
+    Services.dirtyParentQueries(this._view);
+  }
+
+  attachToAppRef(appRef: ApplicationRef) {
+    if (this._viewContainerRef) {
+      throw new Error('This view is already attached to a ViewContainer!');
+    }
+    this._appRef = appRef;
+  }
+
+  attachToViewContainerRef(vcRef: ViewContainerRef) {
+    if (this._appRef) {
+      throw new Error('This view is already attached directly to the ApplicationRef!');
+    }
+    this._viewContainerRef = vcRef;
+  }
+}
+
+export function createTemplateData(view: ViewData, def: NodeDef): TemplateData {
+  return new TemplateRef_(view, def);
+}
+
+class TemplateRef_ extends TemplateRef<any> implements TemplateData {
+  /**
+   * @internal
+   */
+  _projectedViews: ViewData[];
+
+  constructor(private _parentView: ViewData, private _def: NodeDef) { super(); }
+
+  createEmbeddedView(context: any): EmbeddedViewRef<any> {
+    return new ViewRef_(Services.createEmbeddedView(
+        this._parentView, this._def, this._def.element !.template !, context));
+  }
+
+  get elementRef(): ElementRef {
+    return new ElementRef(asElementData(this._parentView, this._def.index).renderElement);
+  }
+}
+
+export function createInjector(view: ViewData, elDef: NodeDef): Injector {
+  return new Injector_(view, elDef);
+}
+
+class Injector_ implements Injector {
+  constructor(private view: ViewData, private elDef: NodeDef|null) {}
+  get(token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND): any {
+    const allowPrivateServices =
+        this.elDef ? (this.elDef.flags & NodeFlags.ComponentView) !== 0 : false;
+    return Services.resolveDep(
+        this.view, this.elDef, allowPrivateServices,
+        {flags: DepFlags.None, token, tokenKey: tokenKey(token)}, notFoundValue);
+  }
+}
+
+export function nodeValue(view: ViewData, index: number): any {
+  const def = view.def.nodes[index];
+  if (def.flags & NodeFlags.TypeElement) {
+    const elData = asElementData(view, def.index);
+    return def.element !.template ? elData.template : elData.renderElement;
+  } else if (def.flags & NodeFlags.TypeText) {
+    return asTextData(view, def.index).renderText;
+  } else if (def.flags & (NodeFlags.CatProvider | NodeFlags.TypePipe)) {
+    return asProviderData(view, def.index).instance;
+  }
+  throw new Error(`Illegal state: read nodeValue for node index ${index}`);
+}
+
+export function createRendererV1(view: ViewData): RendererV1 {
+  return new RendererAdapter(view.renderer);
+}
+
+class RendererAdapter implements RendererV1 {
+  constructor(private delegate: Renderer2) {}
+  selectRootElement(selectorOrNode: string|Element): Element {
+    return this.delegate.selectRootElement(selectorOrNode);
+  }
+
+  createElement(parent: Element|DocumentFragment, namespaceAndName: string): Element {
+    const [ns, name] = splitNamespace(namespaceAndName);
+    const el = this.delegate.createElement(name, ns);
+    if (parent) {
+      this.delegate.appendChild(parent, el);
+    }
+    return el;
+  }
+
+  createViewRoot(hostElement: Element): Element|DocumentFragment { return hostElement; }
+
+  createTemplateAnchor(parentElement: Element|DocumentFragment): Comment {
+    const comment = this.delegate.createComment('');
+    if (parentElement) {
+      this.delegate.appendChild(parentElement, comment);
+    }
+    return comment;
+  }
+
+  createText(parentElement: Element|DocumentFragment, value: string): any {
+    const node = this.delegate.createText(value);
+    if (parentElement) {
+      this.delegate.appendChild(parentElement, node);
+    }
+    return node;
+  }
+
+  projectNodes(parentElement: Element|DocumentFragment, nodes: Node[]) {
+    for (let i = 0; i < nodes.length; i++) {
+      this.delegate.appendChild(parentElement, nodes[i]);
+    }
+  }
+
+  attachViewAfter(node: Node, viewRootNodes: Node[]) {
+    const parentElement = this.delegate.parentNode(node);
+    const nextSibling = this.delegate.nextSibling(node);
+    for (let i = 0; i < viewRootNodes.length; i++) {
+      this.delegate.insertBefore(parentElement, viewRootNodes[i], nextSibling);
+    }
+  }
+
+  detachView(viewRootNodes: (Element|Text|Comment)[]) {
+    for (let i = 0; i < viewRootNodes.length; i++) {
+      const node = viewRootNodes[i];
+      const parentElement = this.delegate.parentNode(node);
+      this.delegate.removeChild(parentElement, node);
+    }
+  }
+
+  destroyView(hostElement: Element|DocumentFragment, viewAllNodes: Node[]) {
+    for (let i = 0; i < viewAllNodes.length; i++) {
+      this.delegate.destroyNode !(viewAllNodes[i]);
+    }
+  }
+
+  listen(renderElement: any, name: string, callback: Function): Function {
+    return this.delegate.listen(renderElement, name, <any>callback);
+  }
+
+  listenGlobal(target: string, name: string, callback: Function): Function {
+    return this.delegate.listen(target, name, <any>callback);
+  }
+
+  setElementProperty(
+      renderElement: Element|DocumentFragment, propertyName: string, propertyValue: any): void {
+    this.delegate.setProperty(renderElement, propertyName, propertyValue);
+  }
+
+  setElementAttribute(renderElement: Element, namespaceAndName: string, attributeValue: string):
+      void {
+    const [ns, name] = splitNamespace(namespaceAndName);
+    if (attributeValue != null) {
+      this.delegate.setAttribute(renderElement, name, attributeValue, ns);
+    } else {
+      this.delegate.removeAttribute(renderElement, name, ns);
+    }
+  }
+
+  setBindingDebugInfo(renderElement: Element, propertyName: string, propertyValue: string): void {}
+
+  setElementClass(renderElement: Element, className: string, isAdd: boolean): void {
+    if (isAdd) {
+      this.delegate.addClass(renderElement, className);
+    } else {
+      this.delegate.removeClass(renderElement, className);
+    }
+  }
+
+  setElementStyle(renderElement: HTMLElement, styleName: string, styleValue: string): void {
+    if (styleValue != null) {
+      this.delegate.setStyle(renderElement, styleName, styleValue);
+    } else {
+      this.delegate.removeStyle(renderElement, styleName);
+    }
+  }
+
+  invokeElementMethod(renderElement: Element, methodName: string, args: any[]): void {
+    (renderElement as any)[methodName].apply(renderElement, args);
+  }
+
+  setText(renderNode: Text, text: string): void { this.delegate.setValue(renderNode, text); }
+
+  animate(): any { throw new Error('Renderer.animate is no longer supported!'); }
+}
+
+
+export function createNgModuleRef(
+    moduleType: Type<any>, parent: Injector, bootstrapComponents: Type<any>[],
+    def: NgModuleDefinition): NgModuleRef<any> {
+  return new NgModuleRef_(moduleType, parent, bootstrapComponents, def);
+}
+
+class NgModuleRef_ implements NgModuleData, InternalNgModuleRef<any> {
+  private _destroyListeners: (() => void)[] = [];
+  private _destroyed: boolean = false;
+  /** @internal */
+  _providers: any[];
+
+  constructor(
+      private _moduleType: Type<any>, public _parent: Injector,
+      public _bootstrapComponents: Type<any>[], public _def: NgModuleDefinition) {
+    initNgModule(this);
+  }
+
+  get(token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND): any {
+    return resolveNgModuleDep(
+        this, {token: token, tokenKey: tokenKey(token), flags: DepFlags.None}, notFoundValue);
+  }
+
+  get instance() { return this.get(this._moduleType); }
+
+  get componentFactoryResolver() { return this.get(ComponentFactoryResolver); }
+
+  get injector(): Injector { return this; }
+
+  destroy(): void {
+    if (this._destroyed) {
+      throw new Error(
+          `The ng module ${stringify(this.instance.constructor)} has already been destroyed.`);
+    }
+    this._destroyed = true;
+    callNgModuleLifecycle(this, NodeFlags.OnDestroy);
+    this._destroyListeners.forEach((listener) => listener());
+  }
+
+  onDestroy(callback: () => void): void { this._destroyListeners.push(callback); }
+}
diff --git a/angular/core/src/view/services.ts b/angular/core/src/view/services.ts
new file mode 100644
index 0000000..61df522
--- /dev/null
+++ b/angular/core/src/view/services.ts
@@ -0,0 +1,775 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {isDevMode} from '../application_ref';
+import {DebugElement, DebugNode, EventListener, getDebugNode, indexDebugNode, removeDebugNodeFromIndex} from '../debug/debug_node';
+import {Injector} from '../di';
+import {ErrorHandler} from '../error_handler';
+import {NgModuleRef} from '../linker/ng_module_factory';
+import {Renderer2, RendererFactory2, RendererStyleFlags2, RendererType2} from '../render/api';
+import {Sanitizer} from '../security';
+import {Type} from '../type';
+
+import {isViewDebugError, viewDestroyedError, viewWrappedDebugError} from './errors';
+import {resolveDep} from './provider';
+import {dirtyParentQueries, getQueryValue} from './query';
+import {createInjector, createNgModuleRef} from './refs';
+import {ArgumentType, BindingFlags, CheckType, DebugContext, DepDef, ElementData, NgModuleDefinition, NgModuleProviderDef, NodeDef, NodeFlags, NodeLogger, ProviderOverride, RootData, Services, ViewData, ViewDefinition, ViewState, asElementData, asPureExpressionData} from './types';
+import {NOOP, isComponentView, renderNode, splitDepsDsl, viewParentEl} from './util';
+import {checkAndUpdateNode, checkAndUpdateView, checkNoChangesNode, checkNoChangesView, createComponentView, createEmbeddedView, createRootView, destroyView} from './view';
+
+
+let initialized = false;
+
+export function initServicesIfNeeded() {
+  if (initialized) {
+    return;
+  }
+  initialized = true;
+  const services = isDevMode() ? createDebugServices() : createProdServices();
+  Services.setCurrentNode = services.setCurrentNode;
+  Services.createRootView = services.createRootView;
+  Services.createEmbeddedView = services.createEmbeddedView;
+  Services.createComponentView = services.createComponentView;
+  Services.createNgModuleRef = services.createNgModuleRef;
+  Services.overrideProvider = services.overrideProvider;
+  Services.clearProviderOverrides = services.clearProviderOverrides;
+  Services.checkAndUpdateView = services.checkAndUpdateView;
+  Services.checkNoChangesView = services.checkNoChangesView;
+  Services.destroyView = services.destroyView;
+  Services.resolveDep = resolveDep;
+  Services.createDebugContext = services.createDebugContext;
+  Services.handleEvent = services.handleEvent;
+  Services.updateDirectives = services.updateDirectives;
+  Services.updateRenderer = services.updateRenderer;
+  Services.dirtyParentQueries = dirtyParentQueries;
+}
+
+function createProdServices() {
+  return {
+    setCurrentNode: () => {},
+    createRootView: createProdRootView,
+    createEmbeddedView: createEmbeddedView,
+    createComponentView: createComponentView,
+    createNgModuleRef: createNgModuleRef,
+    overrideProvider: NOOP,
+    clearProviderOverrides: NOOP,
+    checkAndUpdateView: checkAndUpdateView,
+    checkNoChangesView: checkNoChangesView,
+    destroyView: destroyView,
+    createDebugContext: (view: ViewData, nodeIndex: number) => new DebugContext_(view, nodeIndex),
+    handleEvent: (view: ViewData, nodeIndex: number, eventName: string, event: any) =>
+                     view.def.handleEvent(view, nodeIndex, eventName, event),
+    updateDirectives: (view: ViewData, checkType: CheckType) => view.def.updateDirectives(
+                          checkType === CheckType.CheckAndUpdate ? prodCheckAndUpdateNode :
+                                                                   prodCheckNoChangesNode,
+                          view),
+    updateRenderer: (view: ViewData, checkType: CheckType) => view.def.updateRenderer(
+                        checkType === CheckType.CheckAndUpdate ? prodCheckAndUpdateNode :
+                                                                 prodCheckNoChangesNode,
+                        view),
+  };
+}
+
+function createDebugServices() {
+  return {
+    setCurrentNode: debugSetCurrentNode,
+    createRootView: debugCreateRootView,
+    createEmbeddedView: debugCreateEmbeddedView,
+    createComponentView: debugCreateComponentView,
+    createNgModuleRef: debugCreateNgModuleRef,
+    overrideProvider: debugOverrideProvider,
+    clearProviderOverrides: debugClearProviderOverrides,
+    checkAndUpdateView: debugCheckAndUpdateView,
+    checkNoChangesView: debugCheckNoChangesView,
+    destroyView: debugDestroyView,
+    createDebugContext: (view: ViewData, nodeIndex: number) => new DebugContext_(view, nodeIndex),
+    handleEvent: debugHandleEvent,
+    updateDirectives: debugUpdateDirectives,
+    updateRenderer: debugUpdateRenderer,
+  };
+}
+
+function createProdRootView(
+    elInjector: Injector, projectableNodes: any[][], rootSelectorOrNode: string | any,
+    def: ViewDefinition, ngModule: NgModuleRef<any>, context?: any): ViewData {
+  const rendererFactory: RendererFactory2 = ngModule.injector.get(RendererFactory2);
+  return createRootView(
+      createRootData(elInjector, ngModule, rendererFactory, projectableNodes, rootSelectorOrNode),
+      def, context);
+}
+
+function debugCreateRootView(
+    elInjector: Injector, projectableNodes: any[][], rootSelectorOrNode: string | any,
+    def: ViewDefinition, ngModule: NgModuleRef<any>, context?: any): ViewData {
+  const rendererFactory: RendererFactory2 = ngModule.injector.get(RendererFactory2);
+  const root = createRootData(
+      elInjector, ngModule, new DebugRendererFactory2(rendererFactory), projectableNodes,
+      rootSelectorOrNode);
+  const defWithOverride = applyProviderOverridesToView(def);
+  return callWithDebugContext(
+      DebugAction.create, createRootView, null, [root, defWithOverride, context]);
+}
+
+function createRootData(
+    elInjector: Injector, ngModule: NgModuleRef<any>, rendererFactory: RendererFactory2,
+    projectableNodes: any[][], rootSelectorOrNode: any): RootData {
+  const sanitizer = ngModule.injector.get(Sanitizer);
+  const errorHandler = ngModule.injector.get(ErrorHandler);
+  const renderer = rendererFactory.createRenderer(null, null);
+  return {
+    ngModule,
+    injector: elInjector, projectableNodes,
+    selectorOrNode: rootSelectorOrNode, sanitizer, rendererFactory, renderer, errorHandler
+  };
+}
+
+function debugCreateEmbeddedView(
+    parentView: ViewData, anchorDef: NodeDef, viewDef: ViewDefinition, context?: any): ViewData {
+  const defWithOverride = applyProviderOverridesToView(viewDef);
+  return callWithDebugContext(
+      DebugAction.create, createEmbeddedView, null,
+      [parentView, anchorDef, defWithOverride, context]);
+}
+
+function debugCreateComponentView(
+    parentView: ViewData, nodeDef: NodeDef, viewDef: ViewDefinition, hostElement: any): ViewData {
+  const defWithOverride = applyProviderOverridesToView(viewDef);
+  return callWithDebugContext(
+      DebugAction.create, createComponentView, null,
+      [parentView, nodeDef, defWithOverride, hostElement]);
+}
+
+function debugCreateNgModuleRef(
+    moduleType: Type<any>, parentInjector: Injector, bootstrapComponents: Type<any>[],
+    def: NgModuleDefinition): NgModuleRef<any> {
+  const defWithOverride = applyProviderOverridesToNgModule(def);
+  return createNgModuleRef(moduleType, parentInjector, bootstrapComponents, defWithOverride);
+}
+
+const providerOverrides = new Map<any, ProviderOverride>();
+
+function debugOverrideProvider(override: ProviderOverride) {
+  providerOverrides.set(override.token, override);
+}
+
+function debugClearProviderOverrides() {
+  providerOverrides.clear();
+}
+
+// Notes about the algorithm:
+// 1) Locate the providers of an element and check if one of them was overwritten
+// 2) Change the providers of that element
+//
+// We only create new datastructures if we need to, to keep perf impact
+// reasonable.
+function applyProviderOverridesToView(def: ViewDefinition): ViewDefinition {
+  if (providerOverrides.size === 0) {
+    return def;
+  }
+  const elementIndicesWithOverwrittenProviders = findElementIndicesWithOverwrittenProviders(def);
+  if (elementIndicesWithOverwrittenProviders.length === 0) {
+    return def;
+  }
+  // clone the whole view definition,
+  // as it maintains references between the nodes that are hard to update.
+  def = def.factory !(() => NOOP);
+  for (let i = 0; i < elementIndicesWithOverwrittenProviders.length; i++) {
+    applyProviderOverridesToElement(def, elementIndicesWithOverwrittenProviders[i]);
+  }
+  return def;
+
+  function findElementIndicesWithOverwrittenProviders(def: ViewDefinition): number[] {
+    const elIndicesWithOverwrittenProviders: number[] = [];
+    let lastElementDef: NodeDef|null = null;
+    for (let i = 0; i < def.nodes.length; i++) {
+      const nodeDef = def.nodes[i];
+      if (nodeDef.flags & NodeFlags.TypeElement) {
+        lastElementDef = nodeDef;
+      }
+      if (lastElementDef && nodeDef.flags & NodeFlags.CatProviderNoDirective &&
+          providerOverrides.has(nodeDef.provider !.token)) {
+        elIndicesWithOverwrittenProviders.push(lastElementDef !.index);
+        lastElementDef = null;
+      }
+    }
+    return elIndicesWithOverwrittenProviders;
+  }
+
+  function applyProviderOverridesToElement(viewDef: ViewDefinition, elIndex: number) {
+    for (let i = elIndex + 1; i < viewDef.nodes.length; i++) {
+      const nodeDef = viewDef.nodes[i];
+      if (nodeDef.flags & NodeFlags.TypeElement) {
+        // stop at the next element
+        return;
+      }
+      if (nodeDef.flags & NodeFlags.CatProviderNoDirective) {
+        // Make all providers lazy, so that we don't get into trouble
+        // with ordering problems of providers on the same element
+        nodeDef.flags |= NodeFlags.LazyProvider;
+        const provider = nodeDef.provider !;
+        const override = providerOverrides.get(provider.token);
+        if (override) {
+          nodeDef.flags = (nodeDef.flags & ~NodeFlags.CatProviderNoDirective) | override.flags;
+          provider.deps = splitDepsDsl(override.deps);
+          provider.value = override.value;
+        }
+      }
+    }
+  }
+}
+
+// Notes about the algorithm:
+// We only create new datastructures if we need to, to keep perf impact
+// reasonable.
+function applyProviderOverridesToNgModule(def: NgModuleDefinition): NgModuleDefinition {
+  if (providerOverrides.size === 0 || !hasOverrrides(def)) {
+    return def;
+  }
+  // clone the whole view definition,
+  // as it maintains references between the nodes that are hard to update.
+  def = def.factory !(() => NOOP);
+  applyProviderOverrides(def);
+  return def;
+
+  function hasOverrrides(def: NgModuleDefinition): boolean {
+    return def.providers.some(
+        node =>
+            !!(node.flags & NodeFlags.CatProviderNoDirective) && providerOverrides.has(node.token));
+  }
+
+  function applyProviderOverrides(def: NgModuleDefinition) {
+    for (let i = 0; i < def.providers.length; i++) {
+      const provider = def.providers[i];
+      // Make all providers lazy, so that we don't get into trouble
+      // with ordering problems of providers on the same element
+      provider.flags |= NodeFlags.LazyProvider;
+      const override = providerOverrides.get(provider.token);
+      if (override) {
+        provider.flags = (provider.flags & ~NodeFlags.CatProviderNoDirective) | override.flags;
+        provider.deps = splitDepsDsl(override.deps);
+        provider.value = override.value;
+      }
+    }
+  }
+}
+
+function prodCheckAndUpdateNode(
+    view: ViewData, nodeIndex: number, argStyle: ArgumentType, v0?: any, v1?: any, v2?: any,
+    v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): any {
+  const nodeDef = view.def.nodes[nodeIndex];
+  checkAndUpdateNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+  return (nodeDef.flags & NodeFlags.CatPureExpression) ?
+      asPureExpressionData(view, nodeIndex).value :
+      undefined;
+}
+
+function prodCheckNoChangesNode(
+    view: ViewData, nodeIndex: number, argStyle: ArgumentType, v0?: any, v1?: any, v2?: any,
+    v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): any {
+  const nodeDef = view.def.nodes[nodeIndex];
+  checkNoChangesNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+  return (nodeDef.flags & NodeFlags.CatPureExpression) ?
+      asPureExpressionData(view, nodeIndex).value :
+      undefined;
+}
+
+function debugCheckAndUpdateView(view: ViewData) {
+  return callWithDebugContext(DebugAction.detectChanges, checkAndUpdateView, null, [view]);
+}
+
+function debugCheckNoChangesView(view: ViewData) {
+  return callWithDebugContext(DebugAction.checkNoChanges, checkNoChangesView, null, [view]);
+}
+
+function debugDestroyView(view: ViewData) {
+  return callWithDebugContext(DebugAction.destroy, destroyView, null, [view]);
+}
+
+enum DebugAction {
+  create,
+  detectChanges,
+  checkNoChanges,
+  destroy,
+  handleEvent
+}
+
+let _currentAction: DebugAction;
+let _currentView: ViewData;
+let _currentNodeIndex: number|null;
+
+function debugSetCurrentNode(view: ViewData, nodeIndex: number | null) {
+  _currentView = view;
+  _currentNodeIndex = nodeIndex;
+}
+
+function debugHandleEvent(view: ViewData, nodeIndex: number, eventName: string, event: any) {
+  debugSetCurrentNode(view, nodeIndex);
+  return callWithDebugContext(
+      DebugAction.handleEvent, view.def.handleEvent, null, [view, nodeIndex, eventName, event]);
+}
+
+function debugUpdateDirectives(view: ViewData, checkType: CheckType) {
+  if (view.state & ViewState.Destroyed) {
+    throw viewDestroyedError(DebugAction[_currentAction]);
+  }
+  debugSetCurrentNode(view, nextDirectiveWithBinding(view, 0));
+  return view.def.updateDirectives(debugCheckDirectivesFn, view);
+
+  function debugCheckDirectivesFn(
+      view: ViewData, nodeIndex: number, argStyle: ArgumentType, ...values: any[]) {
+    const nodeDef = view.def.nodes[nodeIndex];
+    if (checkType === CheckType.CheckAndUpdate) {
+      debugCheckAndUpdateNode(view, nodeDef, argStyle, values);
+    } else {
+      debugCheckNoChangesNode(view, nodeDef, argStyle, values);
+    }
+    if (nodeDef.flags & NodeFlags.TypeDirective) {
+      debugSetCurrentNode(view, nextDirectiveWithBinding(view, nodeIndex));
+    }
+    return (nodeDef.flags & NodeFlags.CatPureExpression) ?
+        asPureExpressionData(view, nodeDef.index).value :
+        undefined;
+  }
+}
+
+function debugUpdateRenderer(view: ViewData, checkType: CheckType) {
+  if (view.state & ViewState.Destroyed) {
+    throw viewDestroyedError(DebugAction[_currentAction]);
+  }
+  debugSetCurrentNode(view, nextRenderNodeWithBinding(view, 0));
+  return view.def.updateRenderer(debugCheckRenderNodeFn, view);
+
+  function debugCheckRenderNodeFn(
+      view: ViewData, nodeIndex: number, argStyle: ArgumentType, ...values: any[]) {
+    const nodeDef = view.def.nodes[nodeIndex];
+    if (checkType === CheckType.CheckAndUpdate) {
+      debugCheckAndUpdateNode(view, nodeDef, argStyle, values);
+    } else {
+      debugCheckNoChangesNode(view, nodeDef, argStyle, values);
+    }
+    if (nodeDef.flags & NodeFlags.CatRenderNode) {
+      debugSetCurrentNode(view, nextRenderNodeWithBinding(view, nodeIndex));
+    }
+    return (nodeDef.flags & NodeFlags.CatPureExpression) ?
+        asPureExpressionData(view, nodeDef.index).value :
+        undefined;
+  }
+}
+
+function debugCheckAndUpdateNode(
+    view: ViewData, nodeDef: NodeDef, argStyle: ArgumentType, givenValues: any[]): void {
+  const changed = (<any>checkAndUpdateNode)(view, nodeDef, argStyle, ...givenValues);
+  if (changed) {
+    const values = argStyle === ArgumentType.Dynamic ? givenValues[0] : givenValues;
+    if (nodeDef.flags & NodeFlags.TypeDirective) {
+      const bindingValues: {[key: string]: string} = {};
+      for (let i = 0; i < nodeDef.bindings.length; i++) {
+        const binding = nodeDef.bindings[i];
+        const value = values[i];
+        if (binding.flags & BindingFlags.TypeProperty) {
+          bindingValues[normalizeDebugBindingName(binding.nonMinifiedName !)] =
+              normalizeDebugBindingValue(value);
+        }
+      }
+      const elDef = nodeDef.parent !;
+      const el = asElementData(view, elDef.index).renderElement;
+      if (!elDef.element !.name) {
+        // a comment.
+        view.renderer.setValue(el, `bindings=${JSON.stringify(bindingValues, null, 2)}`);
+      } else {
+        // a regular element.
+        for (let attr in bindingValues) {
+          const value = bindingValues[attr];
+          if (value != null) {
+            view.renderer.setAttribute(el, attr, value);
+          } else {
+            view.renderer.removeAttribute(el, attr);
+          }
+        }
+      }
+    }
+  }
+}
+
+function debugCheckNoChangesNode(
+    view: ViewData, nodeDef: NodeDef, argStyle: ArgumentType, values: any[]): void {
+  (<any>checkNoChangesNode)(view, nodeDef, argStyle, ...values);
+}
+
+function normalizeDebugBindingName(name: string) {
+  // Attribute names with `$` (eg `x-y$`) are valid per spec, but unsupported by some browsers
+  name = camelCaseToDashCase(name.replace(/[$@]/g, '_'));
+  return `ng-reflect-${name}`;
+}
+
+const CAMEL_CASE_REGEXP = /([A-Z])/g;
+
+function camelCaseToDashCase(input: string): string {
+  return input.replace(CAMEL_CASE_REGEXP, (...m: any[]) => '-' + m[1].toLowerCase());
+}
+
+function normalizeDebugBindingValue(value: any): string {
+  try {
+    // Limit the size of the value as otherwise the DOM just gets polluted.
+    return value != null ? value.toString().slice(0, 30) : value;
+  } catch (e) {
+    return '[ERROR] Exception while trying to serialize the value';
+  }
+}
+
+function nextDirectiveWithBinding(view: ViewData, nodeIndex: number): number|null {
+  for (let i = nodeIndex; i < view.def.nodes.length; i++) {
+    const nodeDef = view.def.nodes[i];
+    if (nodeDef.flags & NodeFlags.TypeDirective && nodeDef.bindings && nodeDef.bindings.length) {
+      return i;
+    }
+  }
+  return null;
+}
+
+function nextRenderNodeWithBinding(view: ViewData, nodeIndex: number): number|null {
+  for (let i = nodeIndex; i < view.def.nodes.length; i++) {
+    const nodeDef = view.def.nodes[i];
+    if ((nodeDef.flags & NodeFlags.CatRenderNode) && nodeDef.bindings && nodeDef.bindings.length) {
+      return i;
+    }
+  }
+  return null;
+}
+
+class DebugContext_ implements DebugContext {
+  private nodeDef: NodeDef;
+  private elView: ViewData;
+  private elDef: NodeDef;
+  constructor(public view: ViewData, public nodeIndex: number|null) {
+    if (nodeIndex == null) {
+      this.nodeIndex = nodeIndex = 0;
+    }
+    this.nodeDef = view.def.nodes[nodeIndex];
+    let elDef = this.nodeDef;
+    let elView = view;
+    while (elDef && (elDef.flags & NodeFlags.TypeElement) === 0) {
+      elDef = elDef.parent !;
+    }
+    if (!elDef) {
+      while (!elDef && elView) {
+        elDef = viewParentEl(elView) !;
+        elView = elView.parent !;
+      }
+    }
+    this.elDef = elDef;
+    this.elView = elView;
+  }
+  private get elOrCompView() {
+    // Has to be done lazily as we use the DebugContext also during creation of elements...
+    return asElementData(this.elView, this.elDef.index).componentView || this.view;
+  }
+  get injector(): Injector { return createInjector(this.elView, this.elDef); }
+  get component(): any { return this.elOrCompView.component; }
+  get context(): any { return this.elOrCompView.context; }
+  get providerTokens(): any[] {
+    const tokens: any[] = [];
+    if (this.elDef) {
+      for (let i = this.elDef.index + 1; i <= this.elDef.index + this.elDef.childCount; i++) {
+        const childDef = this.elView.def.nodes[i];
+        if (childDef.flags & NodeFlags.CatProvider) {
+          tokens.push(childDef.provider !.token);
+        }
+        i += childDef.childCount;
+      }
+    }
+    return tokens;
+  }
+  get references(): {[key: string]: any} {
+    const references: {[key: string]: any} = {};
+    if (this.elDef) {
+      collectReferences(this.elView, this.elDef, references);
+
+      for (let i = this.elDef.index + 1; i <= this.elDef.index + this.elDef.childCount; i++) {
+        const childDef = this.elView.def.nodes[i];
+        if (childDef.flags & NodeFlags.CatProvider) {
+          collectReferences(this.elView, childDef, references);
+        }
+        i += childDef.childCount;
+      }
+    }
+    return references;
+  }
+  get componentRenderElement() {
+    const elData = findHostElement(this.elOrCompView);
+    return elData ? elData.renderElement : undefined;
+  }
+  get renderNode(): any {
+    return this.nodeDef.flags & NodeFlags.TypeText ? renderNode(this.view, this.nodeDef) :
+                                                     renderNode(this.elView, this.elDef);
+  }
+  logError(console: Console, ...values: any[]) {
+    let logViewDef: ViewDefinition;
+    let logNodeIndex: number;
+    if (this.nodeDef.flags & NodeFlags.TypeText) {
+      logViewDef = this.view.def;
+      logNodeIndex = this.nodeDef.index;
+    } else {
+      logViewDef = this.elView.def;
+      logNodeIndex = this.elDef.index;
+    }
+    // Note: we only generate a log function for text and element nodes
+    // to make the generated code as small as possible.
+    const renderNodeIndex = getRenderNodeIndex(logViewDef, logNodeIndex);
+    let currRenderNodeIndex = -1;
+    let nodeLogger: NodeLogger = () => {
+      currRenderNodeIndex++;
+      if (currRenderNodeIndex === renderNodeIndex) {
+        return console.error.bind(console, ...values);
+      } else {
+        return NOOP;
+      }
+    };
+    logViewDef.factory !(nodeLogger);
+    if (currRenderNodeIndex < renderNodeIndex) {
+      console.error('Illegal state: the ViewDefinitionFactory did not call the logger!');
+      (<any>console.error)(...values);
+    }
+  }
+}
+
+function getRenderNodeIndex(viewDef: ViewDefinition, nodeIndex: number): number {
+  let renderNodeIndex = -1;
+  for (let i = 0; i <= nodeIndex; i++) {
+    const nodeDef = viewDef.nodes[i];
+    if (nodeDef.flags & NodeFlags.CatRenderNode) {
+      renderNodeIndex++;
+    }
+  }
+  return renderNodeIndex;
+}
+
+function findHostElement(view: ViewData): ElementData|null {
+  while (view && !isComponentView(view)) {
+    view = view.parent !;
+  }
+  if (view.parent) {
+    return asElementData(view.parent, viewParentEl(view) !.index);
+  }
+  return null;
+}
+
+function collectReferences(view: ViewData, nodeDef: NodeDef, references: {[key: string]: any}) {
+  for (let refName in nodeDef.references) {
+    references[refName] = getQueryValue(view, nodeDef, nodeDef.references[refName]);
+  }
+}
+
+function callWithDebugContext(action: DebugAction, fn: any, self: any, args: any[]) {
+  const oldAction = _currentAction;
+  const oldView = _currentView;
+  const oldNodeIndex = _currentNodeIndex;
+  try {
+    _currentAction = action;
+    const result = fn.apply(self, args);
+    _currentView = oldView;
+    _currentNodeIndex = oldNodeIndex;
+    _currentAction = oldAction;
+    return result;
+  } catch (e) {
+    if (isViewDebugError(e) || !_currentView) {
+      throw e;
+    }
+    throw viewWrappedDebugError(e, getCurrentDebugContext() !);
+  }
+}
+
+export function getCurrentDebugContext(): DebugContext|null {
+  return _currentView ? new DebugContext_(_currentView, _currentNodeIndex) : null;
+}
+
+
+class DebugRendererFactory2 implements RendererFactory2 {
+  constructor(private delegate: RendererFactory2) {}
+
+  createRenderer(element: any, renderData: RendererType2|null): Renderer2 {
+    return new DebugRenderer2(this.delegate.createRenderer(element, renderData));
+  }
+
+  begin() {
+    if (this.delegate.begin) {
+      this.delegate.begin();
+    }
+  }
+  end() {
+    if (this.delegate.end) {
+      this.delegate.end();
+    }
+  }
+
+  whenRenderingDone(): Promise<any> {
+    if (this.delegate.whenRenderingDone) {
+      return this.delegate.whenRenderingDone();
+    }
+    return Promise.resolve(null);
+  }
+}
+
+
+class DebugRenderer2 implements Renderer2 {
+  constructor(private delegate: Renderer2) {}
+
+  get data() { return this.delegate.data; }
+
+  destroyNode(node: any) {
+    removeDebugNodeFromIndex(getDebugNode(node) !);
+    if (this.delegate.destroyNode) {
+      this.delegate.destroyNode(node);
+    }
+  }
+
+  destroy() { this.delegate.destroy(); }
+
+  createElement(name: string, namespace?: string): any {
+    const el = this.delegate.createElement(name, namespace);
+    const debugCtx = getCurrentDebugContext();
+    if (debugCtx) {
+      const debugEl = new DebugElement(el, null, debugCtx);
+      debugEl.name = name;
+      indexDebugNode(debugEl);
+    }
+    return el;
+  }
+
+  createComment(value: string): any {
+    const comment = this.delegate.createComment(value);
+    const debugCtx = getCurrentDebugContext();
+    if (debugCtx) {
+      indexDebugNode(new DebugNode(comment, null, debugCtx));
+    }
+    return comment;
+  }
+
+  createText(value: string): any {
+    const text = this.delegate.createText(value);
+    const debugCtx = getCurrentDebugContext();
+    if (debugCtx) {
+      indexDebugNode(new DebugNode(text, null, debugCtx));
+    }
+    return text;
+  }
+
+  appendChild(parent: any, newChild: any): void {
+    const debugEl = getDebugNode(parent);
+    const debugChildEl = getDebugNode(newChild);
+    if (debugEl && debugChildEl && debugEl instanceof DebugElement) {
+      debugEl.addChild(debugChildEl);
+    }
+    this.delegate.appendChild(parent, newChild);
+  }
+
+  insertBefore(parent: any, newChild: any, refChild: any): void {
+    const debugEl = getDebugNode(parent);
+    const debugChildEl = getDebugNode(newChild);
+    const debugRefEl = getDebugNode(refChild) !;
+    if (debugEl && debugChildEl && debugEl instanceof DebugElement) {
+      debugEl.insertBefore(debugRefEl, debugChildEl);
+    }
+
+    this.delegate.insertBefore(parent, newChild, refChild);
+  }
+
+  removeChild(parent: any, oldChild: any): void {
+    const debugEl = getDebugNode(parent);
+    const debugChildEl = getDebugNode(oldChild);
+    if (debugEl && debugChildEl && debugEl instanceof DebugElement) {
+      debugEl.removeChild(debugChildEl);
+    }
+    this.delegate.removeChild(parent, oldChild);
+  }
+
+  selectRootElement(selectorOrNode: string|any): any {
+    const el = this.delegate.selectRootElement(selectorOrNode);
+    const debugCtx = getCurrentDebugContext();
+    if (debugCtx) {
+      indexDebugNode(new DebugElement(el, null, debugCtx));
+    }
+    return el;
+  }
+
+  setAttribute(el: any, name: string, value: string, namespace?: string): void {
+    const debugEl = getDebugNode(el);
+    if (debugEl && debugEl instanceof DebugElement) {
+      const fullName = namespace ? namespace + ':' + name : name;
+      debugEl.attributes[fullName] = value;
+    }
+    this.delegate.setAttribute(el, name, value, namespace);
+  }
+
+  removeAttribute(el: any, name: string, namespace?: string): void {
+    const debugEl = getDebugNode(el);
+    if (debugEl && debugEl instanceof DebugElement) {
+      const fullName = namespace ? namespace + ':' + name : name;
+      debugEl.attributes[fullName] = null;
+    }
+    this.delegate.removeAttribute(el, name, namespace);
+  }
+
+  addClass(el: any, name: string): void {
+    const debugEl = getDebugNode(el);
+    if (debugEl && debugEl instanceof DebugElement) {
+      debugEl.classes[name] = true;
+    }
+    this.delegate.addClass(el, name);
+  }
+
+  removeClass(el: any, name: string): void {
+    const debugEl = getDebugNode(el);
+    if (debugEl && debugEl instanceof DebugElement) {
+      debugEl.classes[name] = false;
+    }
+    this.delegate.removeClass(el, name);
+  }
+
+  setStyle(el: any, style: string, value: any, flags: RendererStyleFlags2): void {
+    const debugEl = getDebugNode(el);
+    if (debugEl && debugEl instanceof DebugElement) {
+      debugEl.styles[style] = value;
+    }
+    this.delegate.setStyle(el, style, value, flags);
+  }
+
+  removeStyle(el: any, style: string, flags: RendererStyleFlags2): void {
+    const debugEl = getDebugNode(el);
+    if (debugEl && debugEl instanceof DebugElement) {
+      debugEl.styles[style] = null;
+    }
+    this.delegate.removeStyle(el, style, flags);
+  }
+
+  setProperty(el: any, name: string, value: any): void {
+    const debugEl = getDebugNode(el);
+    if (debugEl && debugEl instanceof DebugElement) {
+      debugEl.properties[name] = value;
+    }
+    this.delegate.setProperty(el, name, value);
+  }
+
+  listen(
+      target: 'document'|'windows'|'body'|any, eventName: string,
+      callback: (event: any) => boolean): () => void {
+    if (typeof target !== 'string') {
+      const debugEl = getDebugNode(target);
+      if (debugEl) {
+        debugEl.listeners.push(new EventListener(eventName, callback));
+      }
+    }
+
+    return this.delegate.listen(target, eventName, callback);
+  }
+
+  parentNode(node: any): any { return this.delegate.parentNode(node); }
+  nextSibling(node: any): any { return this.delegate.nextSibling(node); }
+  setValue(node: any, value: string): void { return this.delegate.setValue(node, value); }
+}
diff --git a/angular/core/src/view/text.ts b/angular/core/src/view/text.ts
new file mode 100644
index 0000000..95af7ed
--- /dev/null
+++ b/angular/core/src/view/text.ts
@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {BindingDef, BindingFlags, NodeDef, NodeFlags, TextData, ViewData, asTextData} from './types';
+import {calcBindingFlags, checkAndUpdateBinding, getParentRenderElement} from './util';
+
+export function textDef(ngContentIndex: number, constants: string[]): NodeDef {
+  const bindings: BindingDef[] = new Array(constants.length - 1);
+  for (let i = 1; i < constants.length; i++) {
+    bindings[i - 1] = {
+      flags: BindingFlags.TypeProperty,
+      name: null,
+      ns: null,
+      nonMinifiedName: null,
+      securityContext: null,
+      suffix: constants[i]
+    };
+  }
+  const flags = NodeFlags.TypeText;
+  return {
+    // will bet set by the view definition
+    index: -1,
+    parent: null,
+    renderParent: null,
+    bindingIndex: -1,
+    outputIndex: -1,
+    // regular values
+    flags,
+    childFlags: 0,
+    directChildFlags: 0,
+    childMatchedQueries: 0,
+    matchedQueries: {},
+    matchedQueryIds: 0,
+    references: {}, ngContentIndex,
+    childCount: 0, bindings,
+    bindingFlags: calcBindingFlags(bindings),
+    outputs: [],
+    element: null,
+    provider: null,
+    text: {prefix: constants[0]},
+    query: null,
+    ngContent: null
+  };
+}
+
+export function createText(view: ViewData, renderHost: any, def: NodeDef): TextData {
+  let renderNode: any;
+  const renderer = view.renderer;
+  renderNode = renderer.createText(def.text !.prefix);
+  const parentEl = getParentRenderElement(view, renderHost, def);
+  if (parentEl) {
+    renderer.appendChild(parentEl, renderNode);
+  }
+  return {renderText: renderNode};
+}
+
+export function checkAndUpdateTextInline(
+    view: ViewData, def: NodeDef, v0: any, v1: any, v2: any, v3: any, v4: any, v5: any, v6: any,
+    v7: any, v8: any, v9: any): boolean {
+  let changed = false;
+  const bindings = def.bindings;
+  const bindLen = bindings.length;
+  if (bindLen > 0 && checkAndUpdateBinding(view, def, 0, v0)) changed = true;
+  if (bindLen > 1 && checkAndUpdateBinding(view, def, 1, v1)) changed = true;
+  if (bindLen > 2 && checkAndUpdateBinding(view, def, 2, v2)) changed = true;
+  if (bindLen > 3 && checkAndUpdateBinding(view, def, 3, v3)) changed = true;
+  if (bindLen > 4 && checkAndUpdateBinding(view, def, 4, v4)) changed = true;
+  if (bindLen > 5 && checkAndUpdateBinding(view, def, 5, v5)) changed = true;
+  if (bindLen > 6 && checkAndUpdateBinding(view, def, 6, v6)) changed = true;
+  if (bindLen > 7 && checkAndUpdateBinding(view, def, 7, v7)) changed = true;
+  if (bindLen > 8 && checkAndUpdateBinding(view, def, 8, v8)) changed = true;
+  if (bindLen > 9 && checkAndUpdateBinding(view, def, 9, v9)) changed = true;
+
+  if (changed) {
+    let value = def.text !.prefix;
+    if (bindLen > 0) value += _addInterpolationPart(v0, bindings[0]);
+    if (bindLen > 1) value += _addInterpolationPart(v1, bindings[1]);
+    if (bindLen > 2) value += _addInterpolationPart(v2, bindings[2]);
+    if (bindLen > 3) value += _addInterpolationPart(v3, bindings[3]);
+    if (bindLen > 4) value += _addInterpolationPart(v4, bindings[4]);
+    if (bindLen > 5) value += _addInterpolationPart(v5, bindings[5]);
+    if (bindLen > 6) value += _addInterpolationPart(v6, bindings[6]);
+    if (bindLen > 7) value += _addInterpolationPart(v7, bindings[7]);
+    if (bindLen > 8) value += _addInterpolationPart(v8, bindings[8]);
+    if (bindLen > 9) value += _addInterpolationPart(v9, bindings[9]);
+    const renderNode = asTextData(view, def.index).renderText;
+    view.renderer.setValue(renderNode, value);
+  }
+  return changed;
+}
+
+export function checkAndUpdateTextDynamic(view: ViewData, def: NodeDef, values: any[]): boolean {
+  const bindings = def.bindings;
+  let changed = false;
+  for (let i = 0; i < values.length; i++) {
+    // Note: We need to loop over all values, so that
+    // the old values are updates as well!
+    if (checkAndUpdateBinding(view, def, i, values[i])) {
+      changed = true;
+    }
+  }
+  if (changed) {
+    let value = '';
+    for (let i = 0; i < values.length; i++) {
+      value = value + _addInterpolationPart(values[i], bindings[i]);
+    }
+    value = def.text !.prefix + value;
+    const renderNode = asTextData(view, def.index).renderText;
+    view.renderer.setValue(renderNode, value);
+  }
+  return changed;
+}
+
+function _addInterpolationPart(value: any, binding: BindingDef): string {
+  const valueStr = value != null ? value.toString() : '';
+  return valueStr + binding.suffix;
+}
diff --git a/angular/core/src/view/types.ts b/angular/core/src/view/types.ts
new file mode 100644
index 0000000..7b5093b
--- /dev/null
+++ b/angular/core/src/view/types.ts
@@ -0,0 +1,555 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injector} from '../di';
+import {ErrorHandler} from '../error_handler';
+import {NgModuleRef} from '../linker/ng_module_factory';
+import {QueryList} from '../linker/query_list';
+import {TemplateRef} from '../linker/template_ref';
+import {ViewContainerRef} from '../linker/view_container_ref';
+import {Renderer2, RendererFactory2, RendererType2} from '../render/api';
+import {Sanitizer, SecurityContext} from '../security';
+import {Type} from '../type';
+
+// -------------------------------------
+// Defs
+// -------------------------------------
+
+/**
+ * Factory for ViewDefinitions/NgModuleDefinitions.
+ * We use a function so we can reexeute it in case an error happens and use the given logger
+ * function to log the error from the definition of the node, which is shown in all browser
+ * logs.
+ */
+export interface DefinitionFactory<D extends Definition<any>> { (logger: NodeLogger): D; }
+
+/**
+ * Function to call console.error at the right source location. This is an indirection
+ * via another function as browser will log the location that actually called
+ * `console.error`.
+ */
+export interface NodeLogger { (): () => void; }
+
+export interface Definition<DF extends DefinitionFactory<any>> { factory: DF|null; }
+
+export interface NgModuleDefinition extends Definition<NgModuleDefinitionFactory> {
+  providers: NgModuleProviderDef[];
+  providersByKey: {[tokenKey: string]: NgModuleProviderDef};
+}
+
+export interface NgModuleDefinitionFactory extends DefinitionFactory<NgModuleDefinition> {}
+;
+
+export interface ViewDefinition extends Definition<ViewDefinitionFactory> {
+  flags: ViewFlags;
+  updateDirectives: ViewUpdateFn;
+  updateRenderer: ViewUpdateFn;
+  handleEvent: ViewHandleEventFn;
+  /**
+   * Order: Depth first.
+   * Especially providers are before elements / anchors.
+   */
+  nodes: NodeDef[];
+  /** aggregated NodeFlags for all nodes **/
+  nodeFlags: NodeFlags;
+  rootNodeFlags: NodeFlags;
+  lastRenderRootNode: NodeDef|null;
+  bindingCount: number;
+  outputCount: number;
+  /**
+   * Binary or of all query ids that are matched by one of the nodes.
+   * This includes query ids from templates as well.
+   * Used as a bloom filter.
+   */
+  nodeMatchedQueries: number;
+}
+
+export interface ViewDefinitionFactory extends DefinitionFactory<ViewDefinition> {}
+
+
+export interface ViewUpdateFn { (check: NodeCheckFn, view: ViewData): void; }
+
+// helper functions to create an overloaded function type.
+export interface NodeCheckFn {
+  (view: ViewData, nodeIndex: number, argStyle: ArgumentType.Dynamic, values: any[]): any;
+
+  (view: ViewData, nodeIndex: number, argStyle: ArgumentType.Inline, v0?: any, v1?: any, v2?: any,
+   v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): any;
+}
+
+export const enum ArgumentType {Inline = 0, Dynamic = 1}
+
+export interface ViewHandleEventFn {
+  (view: ViewData, nodeIndex: number, eventName: string, event: any): boolean;
+}
+
+/**
+ * Bitmask for ViewDefinition.flags.
+ */
+export const enum ViewFlags {
+  None = 0,
+  OnPush = 1 << 1,
+}
+
+/**
+ * A node definition in the view.
+ *
+ * Note: We use one type for all nodes so that loops that loop over all nodes
+ * of a ViewDefinition stay monomorphic!
+ */
+export interface NodeDef {
+  flags: NodeFlags;
+  index: number;
+  parent: NodeDef|null;
+  renderParent: NodeDef|null;
+  /** this is checked against NgContentDef.index to find matched nodes */
+  ngContentIndex: number;
+  /** number of transitive children */
+  childCount: number;
+  /** aggregated NodeFlags for all transitive children (does not include self) **/
+  childFlags: NodeFlags;
+  /** aggregated NodeFlags for all direct children (does not include self) **/
+  directChildFlags: NodeFlags;
+
+  bindingIndex: number;
+  bindings: BindingDef[];
+  bindingFlags: BindingFlags;
+  outputIndex: number;
+  outputs: OutputDef[];
+  /**
+   * references that the user placed on the element
+   */
+  references: {[refId: string]: QueryValueType};
+  /**
+   * ids and value types of all queries that are matched by this node.
+   */
+  matchedQueries: {[queryId: number]: QueryValueType};
+  /** Binary or of all matched query ids of this node. */
+  matchedQueryIds: number;
+  /**
+   * Binary or of all query ids that are matched by one of the children.
+   * This includes query ids from templates as well.
+   * Used as a bloom filter.
+   */
+  childMatchedQueries: number;
+  element: ElementDef|null;
+  provider: ProviderDef|null;
+  text: TextDef|null;
+  query: QueryDef|null;
+  ngContent: NgContentDef|null;
+}
+
+/**
+ * Bitmask for NodeDef.flags.
+ * Naming convention:
+ * - `Type...`: flags that are mutually exclusive
+ * - `Cat...`: union of multiple `Type...` (short for category).
+ */
+export const enum NodeFlags {
+  None = 0,
+  TypeElement = 1 << 0,
+  TypeText = 1 << 1,
+  ProjectedTemplate = 1 << 2,
+  CatRenderNode = TypeElement | TypeText,
+  TypeNgContent = 1 << 3,
+  TypePipe = 1 << 4,
+  TypePureArray = 1 << 5,
+  TypePureObject = 1 << 6,
+  TypePurePipe = 1 << 7,
+  CatPureExpression = TypePureArray | TypePureObject | TypePurePipe,
+  TypeValueProvider = 1 << 8,
+  TypeClassProvider = 1 << 9,
+  TypeFactoryProvider = 1 << 10,
+  TypeUseExistingProvider = 1 << 11,
+  LazyProvider = 1 << 12,
+  PrivateProvider = 1 << 13,
+  TypeDirective = 1 << 14,
+  Component = 1 << 15,
+  CatProviderNoDirective =
+      TypeValueProvider | TypeClassProvider | TypeFactoryProvider | TypeUseExistingProvider,
+  CatProvider = CatProviderNoDirective | TypeDirective,
+  OnInit = 1 << 16,
+  OnDestroy = 1 << 17,
+  DoCheck = 1 << 18,
+  OnChanges = 1 << 19,
+  AfterContentInit = 1 << 20,
+  AfterContentChecked = 1 << 21,
+  AfterViewInit = 1 << 22,
+  AfterViewChecked = 1 << 23,
+  EmbeddedViews = 1 << 24,
+  ComponentView = 1 << 25,
+  TypeContentQuery = 1 << 26,
+  TypeViewQuery = 1 << 27,
+  StaticQuery = 1 << 28,
+  DynamicQuery = 1 << 29,
+  CatQuery = TypeContentQuery | TypeViewQuery,
+
+  // mutually exclusive values...
+  Types = CatRenderNode | TypeNgContent | TypePipe | CatPureExpression | CatProvider | CatQuery
+}
+
+export interface BindingDef {
+  flags: BindingFlags;
+  ns: string|null;
+  name: string|null;
+  nonMinifiedName: string|null;
+  securityContext: SecurityContext|null;
+  suffix: string|null;
+}
+
+export const enum BindingFlags {
+  TypeElementAttribute = 1 << 0,
+  TypeElementClass = 1 << 1,
+  TypeElementStyle = 1 << 2,
+  TypeProperty = 1 << 3,
+  SyntheticProperty = 1 << 4,
+  SyntheticHostProperty = 1 << 5,
+  CatSyntheticProperty = SyntheticProperty | SyntheticHostProperty,
+
+  // mutually exclusive values...
+  Types = TypeElementAttribute | TypeElementClass | TypeElementStyle | TypeProperty
+}
+
+export interface OutputDef {
+  type: OutputType;
+  target: 'window'|'document'|'body'|'component'|null;
+  eventName: string;
+  propName: string|null;
+}
+
+export const enum OutputType {ElementOutput, DirectiveOutput}
+
+export const enum QueryValueType {
+  ElementRef = 0,
+  RenderElement = 1,
+  TemplateRef = 2,
+  ViewContainerRef = 3,
+  Provider = 4
+}
+
+export interface ElementDef {
+  name: string|null;
+  ns: string|null;
+  /** ns, name, value */
+  attrs: [string, string, string][]|null;
+  template: ViewDefinition|null;
+  componentProvider: NodeDef|null;
+  componentRendererType: RendererType2|null;
+  // closure to allow recursive components
+  componentView: ViewDefinitionFactory|null;
+  /**
+   * visible public providers for DI in the view,
+   * as see from this element. This does not include private providers.
+   */
+  publicProviders: {[tokenKey: string]: NodeDef}|null;
+  /**
+   * same as visiblePublicProviders, but also includes private providers
+   * that are located on this element.
+   */
+  allProviders: {[tokenKey: string]: NodeDef}|null;
+  handleEvent: ElementHandleEventFn|null;
+}
+
+export interface ElementHandleEventFn { (view: ViewData, eventName: string, event: any): boolean; }
+
+export interface ProviderDef {
+  token: any;
+  value: any;
+  deps: DepDef[];
+}
+
+export interface NgModuleProviderDef {
+  flags: NodeFlags;
+  index: number;
+  token: any;
+  value: any;
+  deps: DepDef[];
+}
+
+export interface DepDef {
+  flags: DepFlags;
+  token: any;
+  tokenKey: string;
+}
+
+/**
+ * Bitmask for DI flags
+ */
+export const enum DepFlags {
+  None = 0,
+  SkipSelf = 1 << 0,
+  Optional = 1 << 1,
+  Value = 2 << 2,
+}
+
+export interface TextDef { prefix: string; }
+
+export interface QueryDef {
+  id: number;
+  // variant of the id that can be used to check against NodeDef.matchedQueryIds, ...
+  filterId: number;
+  bindings: QueryBindingDef[];
+}
+
+export interface QueryBindingDef {
+  propName: string;
+  bindingType: QueryBindingType;
+}
+
+export const enum QueryBindingType {First = 0, All = 1}
+
+export interface NgContentDef {
+  /**
+   * this index is checked against NodeDef.ngContentIndex to find the nodes
+   * that are matched by this ng-content.
+   * Note that a NodeDef with an ng-content can be reprojected, i.e.
+   * have a ngContentIndex on its own.
+   */
+  index: number;
+}
+
+// -------------------------------------
+// Data
+// -------------------------------------
+
+export interface NgModuleData extends Injector, NgModuleRef<any> {
+  // Note: we are using the prefix _ as NgModuleData is an NgModuleRef and therefore directly
+  // exposed to the user.
+  _def: NgModuleDefinition;
+  _parent: Injector;
+  _providers: any[];
+}
+
+/**
+ * View instance data.
+ * Attention: Adding fields to this is performance sensitive!
+ */
+export interface ViewData {
+  def: ViewDefinition;
+  root: RootData;
+  renderer: Renderer2;
+  // index of component provider / anchor.
+  parentNodeDef: NodeDef|null;
+  parent: ViewData|null;
+  viewContainerParent: ViewData|null;
+  component: any;
+  context: any;
+  // Attention: Never loop over this, as this will
+  // create a polymorphic usage site.
+  // Instead: Always loop over ViewDefinition.nodes,
+  // and call the right accessor (e.g. `elementData`) based on
+  // the NodeType.
+  nodes: {[key: number]: NodeData};
+  state: ViewState;
+  oldValues: any[];
+  disposables: DisposableFn[]|null;
+}
+
+/**
+ * Bitmask of states
+ */
+export const enum ViewState {
+  BeforeFirstCheck = 1 << 0,
+  FirstCheck = 1 << 1,
+  Attached = 1 << 2,
+  ChecksEnabled = 1 << 3,
+  IsProjectedView = 1 << 4,
+  CheckProjectedView = 1 << 5,
+  CheckProjectedViews = 1 << 6,
+  Destroyed = 1 << 7,
+
+  CatDetectChanges = Attached | ChecksEnabled,
+  CatInit = BeforeFirstCheck | CatDetectChanges
+}
+
+export interface DisposableFn { (): void; }
+
+/**
+ * Node instance data.
+ *
+ * We have a separate type per NodeType to save memory
+ * (TextData | ElementData | ProviderData | PureExpressionData | QueryList<any>)
+ *
+ * To keep our code monomorphic,
+ * we prohibit using `NodeData` directly but enforce the use of accessors (`asElementData`, ...).
+ * This way, no usage site can get a `NodeData` from view.nodes and then use it for different
+ * purposes.
+ */
+export class NodeData { private __brand: any; }
+
+/**
+ * Data for an instantiated NodeType.Text.
+ *
+ * Attention: Adding fields to this is performance sensitive!
+ */
+export interface TextData { renderText: any; }
+
+/**
+ * Accessor for view.nodes, enforcing that every usage site stays monomorphic.
+ */
+export function asTextData(view: ViewData, index: number): TextData {
+  return <any>view.nodes[index];
+}
+
+/**
+ * Data for an instantiated NodeType.Element.
+ *
+ * Attention: Adding fields to this is performance sensitive!
+ */
+export interface ElementData {
+  renderElement: any;
+  componentView: ViewData;
+  viewContainer: ViewContainerData|null;
+  template: TemplateData;
+}
+
+export interface ViewContainerData extends ViewContainerRef {
+  // Note: we are using the prefix _ as ViewContainerData is a ViewContainerRef and therefore
+  // directly
+  // exposed to the user.
+  _embeddedViews: ViewData[];
+}
+
+export interface TemplateData extends TemplateRef<any> {
+  // views that have been created from the template
+  // of this element,
+  // but inserted into the embeddedViews of another element.
+  // By default, this is undefined.
+  // Note: we are using the prefix _ as TemplateData is a TemplateRef and therefore directly
+  // exposed to the user.
+  _projectedViews: ViewData[];
+}
+
+/**
+ * Accessor for view.nodes, enforcing that every usage site stays monomorphic.
+ */
+export function asElementData(view: ViewData, index: number): ElementData {
+  return <any>view.nodes[index];
+}
+
+/**
+ * Data for an instantiated NodeType.Provider.
+ *
+ * Attention: Adding fields to this is performance sensitive!
+ */
+export interface ProviderData { instance: any; }
+
+/**
+ * Accessor for view.nodes, enforcing that every usage site stays monomorphic.
+ */
+export function asProviderData(view: ViewData, index: number): ProviderData {
+  return <any>view.nodes[index];
+}
+
+/**
+ * Data for an instantiated NodeType.PureExpression.
+ *
+ * Attention: Adding fields to this is performance sensitive!
+ */
+export interface PureExpressionData { value: any; }
+
+/**
+ * Accessor for view.nodes, enforcing that every usage site stays monomorphic.
+ */
+export function asPureExpressionData(view: ViewData, index: number): PureExpressionData {
+  return <any>view.nodes[index];
+}
+
+/**
+ * Accessor for view.nodes, enforcing that every usage site stays monomorphic.
+ */
+export function asQueryList(view: ViewData, index: number): QueryList<any> {
+  return <any>view.nodes[index];
+}
+
+export interface RootData {
+  injector: Injector;
+  ngModule: NgModuleRef<any>;
+  projectableNodes: any[][];
+  selectorOrNode: any;
+  renderer: Renderer2;
+  rendererFactory: RendererFactory2;
+  errorHandler: ErrorHandler;
+  sanitizer: Sanitizer;
+}
+
+export abstract class DebugContext {
+  abstract get view(): ViewData;
+  abstract get nodeIndex(): number|null;
+  abstract get injector(): Injector;
+  abstract get component(): any;
+  abstract get providerTokens(): any[];
+  abstract get references(): {[key: string]: any};
+  abstract get context(): any;
+  abstract get componentRenderElement(): any;
+  abstract get renderNode(): any;
+  abstract logError(console: Console, ...values: any[]): void;
+}
+
+// -------------------------------------
+// Other
+// -------------------------------------
+
+export const enum CheckType {CheckAndUpdate, CheckNoChanges}
+
+export interface ProviderOverride {
+  token: any;
+  flags: NodeFlags;
+  value: any;
+  deps: ([DepFlags, any]|any)[];
+}
+
+export interface Services {
+  setCurrentNode(view: ViewData, nodeIndex: number): void;
+  createRootView(
+      injector: Injector, projectableNodes: any[][], rootSelectorOrNode: string|any,
+      def: ViewDefinition, ngModule: NgModuleRef<any>, context?: any): ViewData;
+  createEmbeddedView(parent: ViewData, anchorDef: NodeDef, viewDef: ViewDefinition, context?: any):
+      ViewData;
+  createComponentView(
+      parentView: ViewData, nodeDef: NodeDef, viewDef: ViewDefinition, hostElement: any): ViewData;
+  createNgModuleRef(
+      moduleType: Type<any>, parent: Injector, bootstrapComponents: Type<any>[],
+      def: NgModuleDefinition): NgModuleRef<any>;
+  overrideProvider(override: ProviderOverride): void;
+  clearProviderOverrides(): void;
+  checkAndUpdateView(view: ViewData): void;
+  checkNoChangesView(view: ViewData): void;
+  destroyView(view: ViewData): void;
+  resolveDep(
+      view: ViewData, elDef: NodeDef|null, allowPrivateServices: boolean, depDef: DepDef,
+      notFoundValue?: any): any;
+  createDebugContext(view: ViewData, nodeIndex: number): DebugContext;
+  handleEvent: ViewHandleEventFn;
+  updateDirectives: (view: ViewData, checkType: CheckType) => void;
+  updateRenderer: (view: ViewData, checkType: CheckType) => void;
+  dirtyParentQueries: (view: ViewData) => void;
+}
+
+/**
+ * This object is used to prevent cycles in the source files and to have a place where
+ * debug mode can hook it. It is lazily filled when `isDevMode` is known.
+ */
+export const Services: Services = {
+  setCurrentNode: undefined !,
+  createRootView: undefined !,
+  createEmbeddedView: undefined !,
+  createComponentView: undefined !,
+  createNgModuleRef: undefined !,
+  overrideProvider: undefined !,
+  clearProviderOverrides: undefined !,
+  checkAndUpdateView: undefined !,
+  checkNoChangesView: undefined !,
+  destroyView: undefined !,
+  resolveDep: undefined !,
+  createDebugContext: undefined !,
+  handleEvent: undefined !,
+  updateDirectives: undefined !,
+  updateRenderer: undefined !,
+  dirtyParentQueries: undefined !,
+};
diff --git a/angular/core/src/view/util.ts b/angular/core/src/view/util.ts
new file mode 100644
index 0000000..48016f2
--- /dev/null
+++ b/angular/core/src/view/util.ts
@@ -0,0 +1,440 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {WrappedValue, devModeEqual} from '../change_detection/change_detection';
+import {ViewEncapsulation} from '../metadata/view';
+import {RendererType2} from '../render/api';
+import {looseIdentical, stringify} from '../util';
+
+import {expressionChangedAfterItHasBeenCheckedError} from './errors';
+import {BindingDef, BindingFlags, Definition, DefinitionFactory, DepDef, DepFlags, ElementData, NodeDef, NodeFlags, QueryValueType, Services, ViewData, ViewDefinition, ViewDefinitionFactory, ViewFlags, ViewState, asElementData, asTextData} from './types';
+
+export const NOOP: any = () => {};
+
+const _tokenKeyCache = new Map<any, string>();
+
+export function tokenKey(token: any): string {
+  let key = _tokenKeyCache.get(token);
+  if (!key) {
+    key = stringify(token) + '_' + _tokenKeyCache.size;
+    _tokenKeyCache.set(token, key);
+  }
+  return key;
+}
+
+export function unwrapValue(view: ViewData, nodeIdx: number, bindingIdx: number, value: any): any {
+  if (value instanceof WrappedValue) {
+    value = value.wrapped;
+    let globalBindingIdx = view.def.nodes[nodeIdx].bindingIndex + bindingIdx;
+    let oldValue = view.oldValues[globalBindingIdx];
+    if (oldValue instanceof WrappedValue) {
+      oldValue = oldValue.wrapped;
+    }
+    view.oldValues[globalBindingIdx] = new WrappedValue(oldValue);
+  }
+  return value;
+}
+
+const UNDEFINED_RENDERER_TYPE_ID = '$$undefined';
+const EMPTY_RENDERER_TYPE_ID = '$$empty';
+
+// Attention: this function is called as top level function.
+// Putting any logic in here will destroy closure tree shaking!
+export function createRendererType2(values: {
+  styles: (string | any[])[],
+  encapsulation: ViewEncapsulation,
+  data: {[kind: string]: any[]}
+}): RendererType2 {
+  return {
+    id: UNDEFINED_RENDERER_TYPE_ID,
+    styles: values.styles,
+    encapsulation: values.encapsulation,
+    data: values.data
+  };
+}
+
+let _renderCompCount = 0;
+
+export function resolveRendererType2(type?: RendererType2 | null): RendererType2|null {
+  if (type && type.id === UNDEFINED_RENDERER_TYPE_ID) {
+    // first time we see this RendererType2. Initialize it...
+    const isFilled =
+        ((type.encapsulation != null && type.encapsulation !== ViewEncapsulation.None) ||
+         type.styles.length || Object.keys(type.data).length);
+    if (isFilled) {
+      type.id = `c${_renderCompCount++}`;
+    } else {
+      type.id = EMPTY_RENDERER_TYPE_ID;
+    }
+  }
+  if (type && type.id === EMPTY_RENDERER_TYPE_ID) {
+    type = null;
+  }
+  return type || null;
+}
+
+export function checkBinding(
+    view: ViewData, def: NodeDef, bindingIdx: number, value: any): boolean {
+  const oldValues = view.oldValues;
+  if ((view.state & ViewState.FirstCheck) ||
+      !looseIdentical(oldValues[def.bindingIndex + bindingIdx], value)) {
+    return true;
+  }
+  return false;
+}
+
+export function checkAndUpdateBinding(
+    view: ViewData, def: NodeDef, bindingIdx: number, value: any): boolean {
+  if (checkBinding(view, def, bindingIdx, value)) {
+    view.oldValues[def.bindingIndex + bindingIdx] = value;
+    return true;
+  }
+  return false;
+}
+
+export function checkBindingNoChanges(
+    view: ViewData, def: NodeDef, bindingIdx: number, value: any) {
+  const oldValue = view.oldValues[def.bindingIndex + bindingIdx];
+  if ((view.state & ViewState.BeforeFirstCheck) || !devModeEqual(oldValue, value)) {
+    throw expressionChangedAfterItHasBeenCheckedError(
+        Services.createDebugContext(view, def.index), oldValue, value,
+        (view.state & ViewState.BeforeFirstCheck) !== 0);
+  }
+}
+
+export function markParentViewsForCheck(view: ViewData) {
+  let currView: ViewData|null = view;
+  while (currView) {
+    if (currView.def.flags & ViewFlags.OnPush) {
+      currView.state |= ViewState.ChecksEnabled;
+    }
+    currView = currView.viewContainerParent || currView.parent;
+  }
+}
+
+export function markParentViewsForCheckProjectedViews(view: ViewData, endView: ViewData) {
+  let currView: ViewData|null = view;
+  while (currView && currView !== endView) {
+    currView.state |= ViewState.CheckProjectedViews;
+    currView = currView.viewContainerParent || currView.parent;
+  }
+}
+
+export function dispatchEvent(
+    view: ViewData, nodeIndex: number, eventName: string, event: any): boolean|undefined {
+  try {
+    const nodeDef = view.def.nodes[nodeIndex];
+    const startView = nodeDef.flags & NodeFlags.ComponentView ?
+        asElementData(view, nodeIndex).componentView :
+        view;
+    markParentViewsForCheck(startView);
+    return Services.handleEvent(view, nodeIndex, eventName, event);
+  } catch (e) {
+    // Attention: Don't rethrow, as it would cancel Observable subscriptions!
+    view.root.errorHandler.handleError(e);
+  }
+}
+
+export function declaredViewContainer(view: ViewData): ElementData|null {
+  if (view.parent) {
+    const parentView = view.parent;
+    return asElementData(parentView, view.parentNodeDef !.index);
+  }
+  return null;
+}
+
+/**
+ * for component views, this is the host element.
+ * for embedded views, this is the index of the parent node
+ * that contains the view container.
+ */
+export function viewParentEl(view: ViewData): NodeDef|null {
+  const parentView = view.parent;
+  if (parentView) {
+    return view.parentNodeDef !.parent;
+  } else {
+    return null;
+  }
+}
+
+export function renderNode(view: ViewData, def: NodeDef): any {
+  switch (def.flags & NodeFlags.Types) {
+    case NodeFlags.TypeElement:
+      return asElementData(view, def.index).renderElement;
+    case NodeFlags.TypeText:
+      return asTextData(view, def.index).renderText;
+  }
+}
+
+export function elementEventFullName(target: string | null, name: string): string {
+  return target ? `${target}:${name}` : name;
+}
+
+export function isComponentView(view: ViewData): boolean {
+  return !!view.parent && !!(view.parentNodeDef !.flags & NodeFlags.Component);
+}
+
+export function isEmbeddedView(view: ViewData): boolean {
+  return !!view.parent && !(view.parentNodeDef !.flags & NodeFlags.Component);
+}
+
+export function filterQueryId(queryId: number): number {
+  return 1 << (queryId % 32);
+}
+
+export function splitMatchedQueriesDsl(
+    matchedQueriesDsl: [string | number, QueryValueType][] | null): {
+  matchedQueries: {[queryId: string]: QueryValueType},
+  references: {[refId: string]: QueryValueType},
+  matchedQueryIds: number
+} {
+  const matchedQueries: {[queryId: string]: QueryValueType} = {};
+  let matchedQueryIds = 0;
+  const references: {[refId: string]: QueryValueType} = {};
+  if (matchedQueriesDsl) {
+    matchedQueriesDsl.forEach(([queryId, valueType]) => {
+      if (typeof queryId === 'number') {
+        matchedQueries[queryId] = valueType;
+        matchedQueryIds |= filterQueryId(queryId);
+      } else {
+        references[queryId] = valueType;
+      }
+    });
+  }
+  return {matchedQueries, references, matchedQueryIds};
+}
+
+export function splitDepsDsl(deps: ([DepFlags, any] | any)[]): DepDef[] {
+  return deps.map(value => {
+    let token: any;
+    let flags: DepFlags;
+    if (Array.isArray(value)) {
+      [flags, token] = value;
+    } else {
+      flags = DepFlags.None;
+      token = value;
+    }
+    return {flags, token, tokenKey: tokenKey(token)};
+  });
+}
+
+export function getParentRenderElement(view: ViewData, renderHost: any, def: NodeDef): any {
+  let renderParent = def.renderParent;
+  if (renderParent) {
+    if ((renderParent.flags & NodeFlags.TypeElement) === 0 ||
+        (renderParent.flags & NodeFlags.ComponentView) === 0 ||
+        (renderParent.element !.componentRendererType &&
+         renderParent.element !.componentRendererType !.encapsulation ===
+             ViewEncapsulation.Native)) {
+      // only children of non components, or children of components with native encapsulation should
+      // be attached.
+      return asElementData(view, def.renderParent !.index).renderElement;
+    }
+  } else {
+    return renderHost;
+  }
+}
+
+const DEFINITION_CACHE = new WeakMap<any, Definition<any>>();
+
+export function resolveDefinition<D extends Definition<any>>(factory: DefinitionFactory<D>): D {
+  let value = DEFINITION_CACHE.get(factory) !as D;
+  if (!value) {
+    value = factory(() => NOOP);
+    value.factory = factory;
+    DEFINITION_CACHE.set(factory, value);
+  }
+  return value;
+}
+
+export function rootRenderNodes(view: ViewData): any[] {
+  const renderNodes: any[] = [];
+  visitRootRenderNodes(view, RenderNodeAction.Collect, undefined, undefined, renderNodes);
+  return renderNodes;
+}
+
+export const enum RenderNodeAction {Collect, AppendChild, InsertBefore, RemoveChild}
+
+export function visitRootRenderNodes(
+    view: ViewData, action: RenderNodeAction, parentNode: any, nextSibling: any, target?: any[]) {
+  // We need to re-compute the parent node in case the nodes have been moved around manually
+  if (action === RenderNodeAction.RemoveChild) {
+    parentNode = view.renderer.parentNode(renderNode(view, view.def.lastRenderRootNode !));
+  }
+  visitSiblingRenderNodes(
+      view, action, 0, view.def.nodes.length - 1, parentNode, nextSibling, target);
+}
+
+export function visitSiblingRenderNodes(
+    view: ViewData, action: RenderNodeAction, startIndex: number, endIndex: number, parentNode: any,
+    nextSibling: any, target?: any[]) {
+  for (let i = startIndex; i <= endIndex; i++) {
+    const nodeDef = view.def.nodes[i];
+    if (nodeDef.flags & (NodeFlags.TypeElement | NodeFlags.TypeText | NodeFlags.TypeNgContent)) {
+      visitRenderNode(view, nodeDef, action, parentNode, nextSibling, target);
+    }
+    // jump to next sibling
+    i += nodeDef.childCount;
+  }
+}
+
+export function visitProjectedRenderNodes(
+    view: ViewData, ngContentIndex: number, action: RenderNodeAction, parentNode: any,
+    nextSibling: any, target?: any[]) {
+  let compView: ViewData|null = view;
+  while (compView && !isComponentView(compView)) {
+    compView = compView.parent;
+  }
+  const hostView = compView !.parent;
+  const hostElDef = viewParentEl(compView !);
+  const startIndex = hostElDef !.index + 1;
+  const endIndex = hostElDef !.index + hostElDef !.childCount;
+  for (let i = startIndex; i <= endIndex; i++) {
+    const nodeDef = hostView !.def.nodes[i];
+    if (nodeDef.ngContentIndex === ngContentIndex) {
+      visitRenderNode(hostView !, nodeDef, action, parentNode, nextSibling, target);
+    }
+    // jump to next sibling
+    i += nodeDef.childCount;
+  }
+  if (!hostView !.parent) {
+    // a root view
+    const projectedNodes = view.root.projectableNodes[ngContentIndex];
+    if (projectedNodes) {
+      for (let i = 0; i < projectedNodes.length; i++) {
+        execRenderNodeAction(view, projectedNodes[i], action, parentNode, nextSibling, target);
+      }
+    }
+  }
+}
+
+function visitRenderNode(
+    view: ViewData, nodeDef: NodeDef, action: RenderNodeAction, parentNode: any, nextSibling: any,
+    target?: any[]) {
+  if (nodeDef.flags & NodeFlags.TypeNgContent) {
+    visitProjectedRenderNodes(
+        view, nodeDef.ngContent !.index, action, parentNode, nextSibling, target);
+  } else {
+    const rn = renderNode(view, nodeDef);
+    if (action === RenderNodeAction.RemoveChild && (nodeDef.flags & NodeFlags.ComponentView) &&
+        (nodeDef.bindingFlags & BindingFlags.CatSyntheticProperty)) {
+      // Note: we might need to do both actions.
+      if (nodeDef.bindingFlags & (BindingFlags.SyntheticProperty)) {
+        execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);
+      }
+      if (nodeDef.bindingFlags & (BindingFlags.SyntheticHostProperty)) {
+        const compView = asElementData(view, nodeDef.index).componentView;
+        execRenderNodeAction(compView, rn, action, parentNode, nextSibling, target);
+      }
+    } else {
+      execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);
+    }
+    if (nodeDef.flags & NodeFlags.EmbeddedViews) {
+      const embeddedViews = asElementData(view, nodeDef.index).viewContainer !._embeddedViews;
+      for (let k = 0; k < embeddedViews.length; k++) {
+        visitRootRenderNodes(embeddedViews[k], action, parentNode, nextSibling, target);
+      }
+    }
+    if (nodeDef.flags & NodeFlags.TypeElement && !nodeDef.element !.name) {
+      visitSiblingRenderNodes(
+          view, action, nodeDef.index + 1, nodeDef.index + nodeDef.childCount, parentNode,
+          nextSibling, target);
+    }
+  }
+}
+
+function execRenderNodeAction(
+    view: ViewData, renderNode: any, action: RenderNodeAction, parentNode: any, nextSibling: any,
+    target?: any[]) {
+  const renderer = view.renderer;
+  switch (action) {
+    case RenderNodeAction.AppendChild:
+      renderer.appendChild(parentNode, renderNode);
+      break;
+    case RenderNodeAction.InsertBefore:
+      renderer.insertBefore(parentNode, renderNode, nextSibling);
+      break;
+    case RenderNodeAction.RemoveChild:
+      renderer.removeChild(parentNode, renderNode);
+      break;
+    case RenderNodeAction.Collect:
+      target !.push(renderNode);
+      break;
+  }
+}
+
+const NS_PREFIX_RE = /^:([^:]+):(.+)$/;
+
+export function splitNamespace(name: string): string[] {
+  if (name[0] === ':') {
+    const match = name.match(NS_PREFIX_RE) !;
+    return [match[1], match[2]];
+  }
+  return ['', name];
+}
+
+export function calcBindingFlags(bindings: BindingDef[]): BindingFlags {
+  let flags = 0;
+  for (let i = 0; i < bindings.length; i++) {
+    flags |= bindings[i].flags;
+  }
+  return flags;
+}
+
+export function interpolate(valueCount: number, constAndInterp: string[]): string {
+  let result = '';
+  for (let i = 0; i < valueCount * 2; i = i + 2) {
+    result = result + constAndInterp[i] + _toStringWithNull(constAndInterp[i + 1]);
+  }
+  return result + constAndInterp[valueCount * 2];
+}
+
+export function inlineInterpolate(
+    valueCount: number, c0: string, a1: any, c1: string, a2?: any, c2?: string, a3?: any,
+    c3?: string, a4?: any, c4?: string, a5?: any, c5?: string, a6?: any, c6?: string, a7?: any,
+    c7?: string, a8?: any, c8?: string, a9?: any, c9?: string): string {
+  switch (valueCount) {
+    case 1:
+      return c0 + _toStringWithNull(a1) + c1;
+    case 2:
+      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2;
+    case 3:
+      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+          c3;
+    case 4:
+      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+          c3 + _toStringWithNull(a4) + c4;
+    case 5:
+      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+          c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5;
+    case 6:
+      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+          c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) + c6;
+    case 7:
+      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+          c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +
+          c6 + _toStringWithNull(a7) + c7;
+    case 8:
+      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+          c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +
+          c6 + _toStringWithNull(a7) + c7 + _toStringWithNull(a8) + c8;
+    case 9:
+      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+          c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +
+          c6 + _toStringWithNull(a7) + c7 + _toStringWithNull(a8) + c8 + _toStringWithNull(a9) + c9;
+    default:
+      throw new Error(`Does not support more than 9 expressions`);
+  }
+}
+
+function _toStringWithNull(v: any): string {
+  return v != null ? v.toString() : '';
+}
+
+export const EMPTY_ARRAY: any[] = [];
+export const EMPTY_MAP: {[key: string]: any} = {};
diff --git a/angular/core/src/view/view.ts b/angular/core/src/view/view.ts
new file mode 100644
index 0000000..7572791
--- /dev/null
+++ b/angular/core/src/view/view.ts
@@ -0,0 +1,668 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Renderer2} from '../render/api';
+
+import {checkAndUpdateElementDynamic, checkAndUpdateElementInline, createElement, listenToElementOutputs} from './element';
+import {expressionChangedAfterItHasBeenCheckedError} from './errors';
+import {appendNgContent} from './ng_content';
+import {callLifecycleHooksChildrenFirst, checkAndUpdateDirectiveDynamic, checkAndUpdateDirectiveInline, createDirectiveInstance, createPipeInstance, createProviderInstance} from './provider';
+import {checkAndUpdatePureExpressionDynamic, checkAndUpdatePureExpressionInline, createPureExpression} from './pure_expression';
+import {checkAndUpdateQuery, createQuery} from './query';
+import {createTemplateData, createViewContainerData} from './refs';
+import {checkAndUpdateTextDynamic, checkAndUpdateTextInline, createText} from './text';
+import {ArgumentType, CheckType, ElementData, NodeData, NodeDef, NodeFlags, ProviderData, RootData, Services, ViewData, ViewDefinition, ViewFlags, ViewHandleEventFn, ViewState, ViewUpdateFn, asElementData, asQueryList, asTextData} from './types';
+import {NOOP, checkBindingNoChanges, isComponentView, markParentViewsForCheckProjectedViews, resolveDefinition, tokenKey} from './util';
+import {detachProjectedView} from './view_attach';
+
+export function viewDef(
+    flags: ViewFlags, nodes: NodeDef[], updateDirectives?: ViewUpdateFn,
+    updateRenderer?: ViewUpdateFn): ViewDefinition {
+  // clone nodes and set auto calculated values
+  let viewBindingCount = 0;
+  let viewDisposableCount = 0;
+  let viewNodeFlags = 0;
+  let viewRootNodeFlags = 0;
+  let viewMatchedQueries = 0;
+  let currentParent: NodeDef|null = null;
+  let currentElementHasPublicProviders = false;
+  let currentElementHasPrivateProviders = false;
+  let lastRenderRootNode: NodeDef|null = null;
+  for (let i = 0; i < nodes.length; i++) {
+    while (currentParent && i > currentParent.index + currentParent.childCount) {
+      const newParent: NodeDef|null = currentParent.parent;
+      if (newParent) {
+        newParent.childFlags |= currentParent.childFlags !;
+        newParent.childMatchedQueries |= currentParent.childMatchedQueries;
+      }
+      currentParent = newParent;
+    }
+    const node = nodes[i];
+    node.index = i;
+    node.parent = currentParent;
+    node.bindingIndex = viewBindingCount;
+    node.outputIndex = viewDisposableCount;
+
+    // renderParent needs to account for ng-container!
+    let currentRenderParent: NodeDef|null;
+    if (currentParent && currentParent.flags & NodeFlags.TypeElement &&
+        !currentParent.element !.name) {
+      currentRenderParent = currentParent.renderParent;
+    } else {
+      currentRenderParent = currentParent;
+    }
+    node.renderParent = currentRenderParent;
+
+    if (node.element) {
+      const elDef = node.element;
+      elDef.publicProviders =
+          currentParent ? currentParent.element !.publicProviders : Object.create(null);
+      elDef.allProviders = elDef.publicProviders;
+      // Note: We assume that all providers of an element are before any child element!
+      currentElementHasPublicProviders = false;
+      currentElementHasPrivateProviders = false;
+    }
+    validateNode(currentParent, node, nodes.length);
+
+    viewNodeFlags |= node.flags;
+    viewMatchedQueries |= node.matchedQueryIds;
+    if (node.element && node.element.template) {
+      viewMatchedQueries |= node.element.template.nodeMatchedQueries;
+    }
+    if (currentParent) {
+      currentParent.childFlags |= node.flags;
+      currentParent.directChildFlags |= node.flags;
+      currentParent.childMatchedQueries |= node.matchedQueryIds;
+      if (node.element && node.element.template) {
+        currentParent.childMatchedQueries |= node.element.template.nodeMatchedQueries;
+      }
+    } else {
+      viewRootNodeFlags |= node.flags;
+    }
+
+    viewBindingCount += node.bindings.length;
+    viewDisposableCount += node.outputs.length;
+
+    if (!currentRenderParent && (node.flags & NodeFlags.CatRenderNode)) {
+      lastRenderRootNode = node;
+    }
+    if (node.flags & NodeFlags.CatProvider) {
+      if (!currentElementHasPublicProviders) {
+        currentElementHasPublicProviders = true;
+        // Use prototypical inheritance to not get O(n^2) complexity...
+        currentParent !.element !.publicProviders =
+            Object.create(currentParent !.element !.publicProviders);
+        currentParent !.element !.allProviders = currentParent !.element !.publicProviders;
+      }
+      const isPrivateService = (node.flags & NodeFlags.PrivateProvider) !== 0;
+      const isComponent = (node.flags & NodeFlags.Component) !== 0;
+      if (!isPrivateService || isComponent) {
+        currentParent !.element !.publicProviders ![tokenKey(node.provider !.token)] = node;
+      } else {
+        if (!currentElementHasPrivateProviders) {
+          currentElementHasPrivateProviders = true;
+          // Use protoyypical inheritance to not get O(n^2) complexity...
+          currentParent !.element !.allProviders =
+              Object.create(currentParent !.element !.publicProviders);
+        }
+        currentParent !.element !.allProviders ![tokenKey(node.provider !.token)] = node;
+      }
+      if (isComponent) {
+        currentParent !.element !.componentProvider = node;
+      }
+    }
+    if (node.childCount) {
+      currentParent = node;
+    }
+  }
+  while (currentParent) {
+    const newParent = currentParent.parent;
+    if (newParent) {
+      newParent.childFlags |= currentParent.childFlags;
+      newParent.childMatchedQueries |= currentParent.childMatchedQueries;
+    }
+    currentParent = newParent;
+  }
+  const handleEvent: ViewHandleEventFn = (view, nodeIndex, eventName, event) =>
+      nodes[nodeIndex].element !.handleEvent !(view, eventName, event);
+  return {
+    // Will be filled later...
+    factory: null,
+    nodeFlags: viewNodeFlags,
+    rootNodeFlags: viewRootNodeFlags,
+    nodeMatchedQueries: viewMatchedQueries, flags,
+    nodes: nodes,
+    updateDirectives: updateDirectives || NOOP,
+    updateRenderer: updateRenderer || NOOP,
+    handleEvent: handleEvent || NOOP,
+    bindingCount: viewBindingCount,
+    outputCount: viewDisposableCount, lastRenderRootNode
+  };
+}
+
+function validateNode(parent: NodeDef | null, node: NodeDef, nodeCount: number) {
+  const template = node.element && node.element.template;
+  if (template) {
+    if (!template.lastRenderRootNode) {
+      throw new Error(`Illegal State: Embedded templates without nodes are not allowed!`);
+    }
+    if (template.lastRenderRootNode &&
+        template.lastRenderRootNode.flags & NodeFlags.EmbeddedViews) {
+      throw new Error(
+          `Illegal State: Last root node of a template can't have embedded views, at index ${node.index}!`);
+    }
+  }
+  if (node.flags & NodeFlags.CatProvider) {
+    const parentFlags = parent ? parent.flags : 0;
+    if ((parentFlags & NodeFlags.TypeElement) === 0) {
+      throw new Error(
+          `Illegal State: StaticProvider/Directive nodes need to be children of elements or anchors, at index ${node.index}!`);
+    }
+  }
+  if (node.query) {
+    if (node.flags & NodeFlags.TypeContentQuery &&
+        (!parent || (parent.flags & NodeFlags.TypeDirective) === 0)) {
+      throw new Error(
+          `Illegal State: Content Query nodes need to be children of directives, at index ${node.index}!`);
+    }
+    if (node.flags & NodeFlags.TypeViewQuery && parent) {
+      throw new Error(
+          `Illegal State: View Query nodes have to be top level nodes, at index ${node.index}!`);
+    }
+  }
+  if (node.childCount) {
+    const parentEnd = parent ? parent.index + parent.childCount : nodeCount - 1;
+    if (node.index <= parentEnd && node.index + node.childCount > parentEnd) {
+      throw new Error(
+          `Illegal State: childCount of node leads outside of parent, at index ${node.index}!`);
+    }
+  }
+}
+
+export function createEmbeddedView(
+    parent: ViewData, anchorDef: NodeDef, viewDef: ViewDefinition, context?: any): ViewData {
+  // embedded views are seen as siblings to the anchor, so we need
+  // to get the parent of the anchor and use it as parentIndex.
+  const view = createView(parent.root, parent.renderer, parent, anchorDef, viewDef);
+  initView(view, parent.component, context);
+  createViewNodes(view);
+  return view;
+}
+
+export function createRootView(root: RootData, def: ViewDefinition, context?: any): ViewData {
+  const view = createView(root, root.renderer, null, null, def);
+  initView(view, context, context);
+  createViewNodes(view);
+  return view;
+}
+
+export function createComponentView(
+    parentView: ViewData, nodeDef: NodeDef, viewDef: ViewDefinition, hostElement: any): ViewData {
+  const rendererType = nodeDef.element !.componentRendererType;
+  let compRenderer: Renderer2;
+  if (!rendererType) {
+    compRenderer = parentView.root.renderer;
+  } else {
+    compRenderer = parentView.root.rendererFactory.createRenderer(hostElement, rendererType);
+  }
+  return createView(
+      parentView.root, compRenderer, parentView, nodeDef.element !.componentProvider, viewDef);
+}
+
+function createView(
+    root: RootData, renderer: Renderer2, parent: ViewData | null, parentNodeDef: NodeDef | null,
+    def: ViewDefinition): ViewData {
+  const nodes: NodeData[] = new Array(def.nodes.length);
+  const disposables = def.outputCount ? new Array(def.outputCount) : null;
+  const view: ViewData = {
+    def,
+    parent,
+    viewContainerParent: null, parentNodeDef,
+    context: null,
+    component: null, nodes,
+    state: ViewState.CatInit, root, renderer,
+    oldValues: new Array(def.bindingCount), disposables
+  };
+  return view;
+}
+
+function initView(view: ViewData, component: any, context: any) {
+  view.component = component;
+  view.context = context;
+}
+
+function createViewNodes(view: ViewData) {
+  let renderHost: any;
+  if (isComponentView(view)) {
+    const hostDef = view.parentNodeDef;
+    renderHost = asElementData(view.parent !, hostDef !.parent !.index).renderElement;
+  }
+  const def = view.def;
+  const nodes = view.nodes;
+  for (let i = 0; i < def.nodes.length; i++) {
+    const nodeDef = def.nodes[i];
+    Services.setCurrentNode(view, i);
+    let nodeData: any;
+    switch (nodeDef.flags & NodeFlags.Types) {
+      case NodeFlags.TypeElement:
+        const el = createElement(view, renderHost, nodeDef) as any;
+        let componentView: ViewData = undefined !;
+        if (nodeDef.flags & NodeFlags.ComponentView) {
+          const compViewDef = resolveDefinition(nodeDef.element !.componentView !);
+          componentView = Services.createComponentView(view, nodeDef, compViewDef, el);
+        }
+        listenToElementOutputs(view, componentView, nodeDef, el);
+        nodeData = <ElementData>{
+          renderElement: el,
+          componentView,
+          viewContainer: null,
+          template: nodeDef.element !.template ? createTemplateData(view, nodeDef) : undefined
+        };
+        if (nodeDef.flags & NodeFlags.EmbeddedViews) {
+          nodeData.viewContainer = createViewContainerData(view, nodeDef, nodeData);
+        }
+        break;
+      case NodeFlags.TypeText:
+        nodeData = createText(view, renderHost, nodeDef) as any;
+        break;
+      case NodeFlags.TypeClassProvider:
+      case NodeFlags.TypeFactoryProvider:
+      case NodeFlags.TypeUseExistingProvider:
+      case NodeFlags.TypeValueProvider: {
+        const instance = createProviderInstance(view, nodeDef);
+        nodeData = <ProviderData>{instance};
+        break;
+      }
+      case NodeFlags.TypePipe: {
+        const instance = createPipeInstance(view, nodeDef);
+        nodeData = <ProviderData>{instance};
+        break;
+      }
+      case NodeFlags.TypeDirective: {
+        const instance = createDirectiveInstance(view, nodeDef);
+        nodeData = <ProviderData>{instance};
+        if (nodeDef.flags & NodeFlags.Component) {
+          const compView = asElementData(view, nodeDef.parent !.index).componentView;
+          initView(compView, instance, instance);
+        }
+        break;
+      }
+      case NodeFlags.TypePureArray:
+      case NodeFlags.TypePureObject:
+      case NodeFlags.TypePurePipe:
+        nodeData = createPureExpression(view, nodeDef) as any;
+        break;
+      case NodeFlags.TypeContentQuery:
+      case NodeFlags.TypeViewQuery:
+        nodeData = createQuery() as any;
+        break;
+      case NodeFlags.TypeNgContent:
+        appendNgContent(view, renderHost, nodeDef);
+        // no runtime data needed for NgContent...
+        nodeData = undefined;
+        break;
+    }
+    nodes[i] = nodeData;
+  }
+  // Create the ViewData.nodes of component views after we created everything else,
+  // so that e.g. ng-content works
+  execComponentViewsAction(view, ViewAction.CreateViewNodes);
+
+  // fill static content and view queries
+  execQueriesAction(
+      view, NodeFlags.TypeContentQuery | NodeFlags.TypeViewQuery, NodeFlags.StaticQuery,
+      CheckType.CheckAndUpdate);
+}
+
+export function checkNoChangesView(view: ViewData) {
+  markProjectedViewsForCheck(view);
+  Services.updateDirectives(view, CheckType.CheckNoChanges);
+  execEmbeddedViewsAction(view, ViewAction.CheckNoChanges);
+  Services.updateRenderer(view, CheckType.CheckNoChanges);
+  execComponentViewsAction(view, ViewAction.CheckNoChanges);
+  // Note: We don't check queries for changes as we didn't do this in v2.x.
+  // TODO(tbosch): investigate if we can enable the check again in v5.x with a nicer error message.
+  view.state &= ~(ViewState.CheckProjectedViews | ViewState.CheckProjectedView);
+}
+
+export function checkAndUpdateView(view: ViewData) {
+  if (view.state & ViewState.BeforeFirstCheck) {
+    view.state &= ~ViewState.BeforeFirstCheck;
+    view.state |= ViewState.FirstCheck;
+  } else {
+    view.state &= ~ViewState.FirstCheck;
+  }
+  markProjectedViewsForCheck(view);
+  Services.updateDirectives(view, CheckType.CheckAndUpdate);
+  execEmbeddedViewsAction(view, ViewAction.CheckAndUpdate);
+  execQueriesAction(
+      view, NodeFlags.TypeContentQuery, NodeFlags.DynamicQuery, CheckType.CheckAndUpdate);
+
+  callLifecycleHooksChildrenFirst(
+      view, NodeFlags.AfterContentChecked |
+          (view.state & ViewState.FirstCheck ? NodeFlags.AfterContentInit : 0));
+
+  Services.updateRenderer(view, CheckType.CheckAndUpdate);
+
+  execComponentViewsAction(view, ViewAction.CheckAndUpdate);
+  execQueriesAction(
+      view, NodeFlags.TypeViewQuery, NodeFlags.DynamicQuery, CheckType.CheckAndUpdate);
+  callLifecycleHooksChildrenFirst(
+      view, NodeFlags.AfterViewChecked |
+          (view.state & ViewState.FirstCheck ? NodeFlags.AfterViewInit : 0));
+
+  if (view.def.flags & ViewFlags.OnPush) {
+    view.state &= ~ViewState.ChecksEnabled;
+  }
+  view.state &= ~(ViewState.CheckProjectedViews | ViewState.CheckProjectedView);
+}
+
+export function checkAndUpdateNode(
+    view: ViewData, nodeDef: NodeDef, argStyle: ArgumentType, v0?: any, v1?: any, v2?: any,
+    v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): boolean {
+  if (argStyle === ArgumentType.Inline) {
+    return checkAndUpdateNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+  } else {
+    return checkAndUpdateNodeDynamic(view, nodeDef, v0);
+  }
+}
+
+function markProjectedViewsForCheck(view: ViewData) {
+  const def = view.def;
+  if (!(def.nodeFlags & NodeFlags.ProjectedTemplate)) {
+    return;
+  }
+  for (let i = 0; i < def.nodes.length; i++) {
+    const nodeDef = def.nodes[i];
+    if (nodeDef.flags & NodeFlags.ProjectedTemplate) {
+      const projectedViews = asElementData(view, i).template._projectedViews;
+      if (projectedViews) {
+        for (let i = 0; i < projectedViews.length; i++) {
+          const projectedView = projectedViews[i];
+          projectedView.state |= ViewState.CheckProjectedView;
+          markParentViewsForCheckProjectedViews(projectedView, view);
+        }
+      }
+    } else if ((nodeDef.childFlags & NodeFlags.ProjectedTemplate) === 0) {
+      // a parent with leafs
+      // no child is a component,
+      // then skip the children
+      i += nodeDef.childCount;
+    }
+  }
+}
+
+function checkAndUpdateNodeInline(
+    view: ViewData, nodeDef: NodeDef, v0?: any, v1?: any, v2?: any, v3?: any, v4?: any, v5?: any,
+    v6?: any, v7?: any, v8?: any, v9?: any): boolean {
+  let changed = false;
+  switch (nodeDef.flags & NodeFlags.Types) {
+    case NodeFlags.TypeElement:
+      changed = checkAndUpdateElementInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+      break;
+    case NodeFlags.TypeText:
+      changed = checkAndUpdateTextInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+      break;
+    case NodeFlags.TypeDirective:
+      changed =
+          checkAndUpdateDirectiveInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+      break;
+    case NodeFlags.TypePureArray:
+    case NodeFlags.TypePureObject:
+    case NodeFlags.TypePurePipe:
+      changed =
+          checkAndUpdatePureExpressionInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+      break;
+  }
+  return changed;
+}
+
+function checkAndUpdateNodeDynamic(view: ViewData, nodeDef: NodeDef, values: any[]): boolean {
+  let changed = false;
+  switch (nodeDef.flags & NodeFlags.Types) {
+    case NodeFlags.TypeElement:
+      changed = checkAndUpdateElementDynamic(view, nodeDef, values);
+      break;
+    case NodeFlags.TypeText:
+      changed = checkAndUpdateTextDynamic(view, nodeDef, values);
+      break;
+    case NodeFlags.TypeDirective:
+      changed = checkAndUpdateDirectiveDynamic(view, nodeDef, values);
+      break;
+    case NodeFlags.TypePureArray:
+    case NodeFlags.TypePureObject:
+    case NodeFlags.TypePurePipe:
+      changed = checkAndUpdatePureExpressionDynamic(view, nodeDef, values);
+      break;
+  }
+  if (changed) {
+    // Update oldValues after all bindings have been updated,
+    // as a setter for a property might update other properties.
+    const bindLen = nodeDef.bindings.length;
+    const bindingStart = nodeDef.bindingIndex;
+    const oldValues = view.oldValues;
+    for (let i = 0; i < bindLen; i++) {
+      oldValues[bindingStart + i] = values[i];
+    }
+  }
+  return changed;
+}
+
+export function checkNoChangesNode(
+    view: ViewData, nodeDef: NodeDef, argStyle: ArgumentType, v0?: any, v1?: any, v2?: any,
+    v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): any {
+  if (argStyle === ArgumentType.Inline) {
+    checkNoChangesNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+  } else {
+    checkNoChangesNodeDynamic(view, nodeDef, v0);
+  }
+  // Returning false is ok here as we would have thrown in case of a change.
+  return false;
+}
+
+function checkNoChangesNodeInline(
+    view: ViewData, nodeDef: NodeDef, v0: any, v1: any, v2: any, v3: any, v4: any, v5: any, v6: any,
+    v7: any, v8: any, v9: any): void {
+  const bindLen = nodeDef.bindings.length;
+  if (bindLen > 0) checkBindingNoChanges(view, nodeDef, 0, v0);
+  if (bindLen > 1) checkBindingNoChanges(view, nodeDef, 1, v1);
+  if (bindLen > 2) checkBindingNoChanges(view, nodeDef, 2, v2);
+  if (bindLen > 3) checkBindingNoChanges(view, nodeDef, 3, v3);
+  if (bindLen > 4) checkBindingNoChanges(view, nodeDef, 4, v4);
+  if (bindLen > 5) checkBindingNoChanges(view, nodeDef, 5, v5);
+  if (bindLen > 6) checkBindingNoChanges(view, nodeDef, 6, v6);
+  if (bindLen > 7) checkBindingNoChanges(view, nodeDef, 7, v7);
+  if (bindLen > 8) checkBindingNoChanges(view, nodeDef, 8, v8);
+  if (bindLen > 9) checkBindingNoChanges(view, nodeDef, 9, v9);
+}
+
+function checkNoChangesNodeDynamic(view: ViewData, nodeDef: NodeDef, values: any[]): void {
+  for (let i = 0; i < values.length; i++) {
+    checkBindingNoChanges(view, nodeDef, i, values[i]);
+  }
+}
+
+/**
+ * Workaround https://github.com/angular/tsickle/issues/497
+ * @suppress {misplacedTypeAnnotation}
+ */
+function checkNoChangesQuery(view: ViewData, nodeDef: NodeDef) {
+  const queryList = asQueryList(view, nodeDef.index);
+  if (queryList.dirty) {
+    throw expressionChangedAfterItHasBeenCheckedError(
+        Services.createDebugContext(view, nodeDef.index), `Query ${nodeDef.query!.id} not dirty`,
+        `Query ${nodeDef.query!.id} dirty`, (view.state & ViewState.BeforeFirstCheck) !== 0);
+  }
+}
+
+export function destroyView(view: ViewData) {
+  if (view.state & ViewState.Destroyed) {
+    return;
+  }
+  execEmbeddedViewsAction(view, ViewAction.Destroy);
+  execComponentViewsAction(view, ViewAction.Destroy);
+  callLifecycleHooksChildrenFirst(view, NodeFlags.OnDestroy);
+  if (view.disposables) {
+    for (let i = 0; i < view.disposables.length; i++) {
+      view.disposables[i]();
+    }
+  }
+  detachProjectedView(view);
+  if (view.renderer.destroyNode) {
+    destroyViewNodes(view);
+  }
+  if (isComponentView(view)) {
+    view.renderer.destroy();
+  }
+  view.state |= ViewState.Destroyed;
+}
+
+function destroyViewNodes(view: ViewData) {
+  const len = view.def.nodes.length;
+  for (let i = 0; i < len; i++) {
+    const def = view.def.nodes[i];
+    if (def.flags & NodeFlags.TypeElement) {
+      view.renderer.destroyNode !(asElementData(view, i).renderElement);
+    } else if (def.flags & NodeFlags.TypeText) {
+      view.renderer.destroyNode !(asTextData(view, i).renderText);
+    }
+  }
+}
+
+enum ViewAction {
+  CreateViewNodes,
+  CheckNoChanges,
+  CheckNoChangesProjectedViews,
+  CheckAndUpdate,
+  CheckAndUpdateProjectedViews,
+  Destroy
+}
+
+function execComponentViewsAction(view: ViewData, action: ViewAction) {
+  const def = view.def;
+  if (!(def.nodeFlags & NodeFlags.ComponentView)) {
+    return;
+  }
+  for (let i = 0; i < def.nodes.length; i++) {
+    const nodeDef = def.nodes[i];
+    if (nodeDef.flags & NodeFlags.ComponentView) {
+      // a leaf
+      callViewAction(asElementData(view, i).componentView, action);
+    } else if ((nodeDef.childFlags & NodeFlags.ComponentView) === 0) {
+      // a parent with leafs
+      // no child is a component,
+      // then skip the children
+      i += nodeDef.childCount;
+    }
+  }
+}
+
+function execEmbeddedViewsAction(view: ViewData, action: ViewAction) {
+  const def = view.def;
+  if (!(def.nodeFlags & NodeFlags.EmbeddedViews)) {
+    return;
+  }
+  for (let i = 0; i < def.nodes.length; i++) {
+    const nodeDef = def.nodes[i];
+    if (nodeDef.flags & NodeFlags.EmbeddedViews) {
+      // a leaf
+      const embeddedViews = asElementData(view, i).viewContainer !._embeddedViews;
+      for (let k = 0; k < embeddedViews.length; k++) {
+        callViewAction(embeddedViews[k], action);
+      }
+    } else if ((nodeDef.childFlags & NodeFlags.EmbeddedViews) === 0) {
+      // a parent with leafs
+      // no child is a component,
+      // then skip the children
+      i += nodeDef.childCount;
+    }
+  }
+}
+
+function callViewAction(view: ViewData, action: ViewAction) {
+  const viewState = view.state;
+  switch (action) {
+    case ViewAction.CheckNoChanges:
+      if ((viewState & ViewState.Destroyed) === 0) {
+        if ((viewState & ViewState.CatDetectChanges) === ViewState.CatDetectChanges) {
+          checkNoChangesView(view);
+        } else if (viewState & ViewState.CheckProjectedViews) {
+          execProjectedViewsAction(view, ViewAction.CheckNoChangesProjectedViews);
+        }
+      }
+      break;
+    case ViewAction.CheckNoChangesProjectedViews:
+      if ((viewState & ViewState.Destroyed) === 0) {
+        if (viewState & ViewState.CheckProjectedView) {
+          checkNoChangesView(view);
+        } else if (viewState & ViewState.CheckProjectedViews) {
+          execProjectedViewsAction(view, action);
+        }
+      }
+      break;
+    case ViewAction.CheckAndUpdate:
+      if ((viewState & ViewState.Destroyed) === 0) {
+        if ((viewState & ViewState.CatDetectChanges) === ViewState.CatDetectChanges) {
+          checkAndUpdateView(view);
+        } else if (viewState & ViewState.CheckProjectedViews) {
+          execProjectedViewsAction(view, ViewAction.CheckAndUpdateProjectedViews);
+        }
+      }
+      break;
+    case ViewAction.CheckAndUpdateProjectedViews:
+      if ((viewState & ViewState.Destroyed) === 0) {
+        if (viewState & ViewState.CheckProjectedView) {
+          checkAndUpdateView(view);
+        } else if (viewState & ViewState.CheckProjectedViews) {
+          execProjectedViewsAction(view, action);
+        }
+      }
+      break;
+    case ViewAction.Destroy:
+      // Note: destroyView recurses over all views,
+      // so we don't need to special case projected views here.
+      destroyView(view);
+      break;
+    case ViewAction.CreateViewNodes:
+      createViewNodes(view);
+      break;
+  }
+}
+
+function execProjectedViewsAction(view: ViewData, action: ViewAction) {
+  execEmbeddedViewsAction(view, action);
+  execComponentViewsAction(view, action);
+}
+
+function execQueriesAction(
+    view: ViewData, queryFlags: NodeFlags, staticDynamicQueryFlag: NodeFlags,
+    checkType: CheckType) {
+  if (!(view.def.nodeFlags & queryFlags) || !(view.def.nodeFlags & staticDynamicQueryFlag)) {
+    return;
+  }
+  const nodeCount = view.def.nodes.length;
+  for (let i = 0; i < nodeCount; i++) {
+    const nodeDef = view.def.nodes[i];
+    if ((nodeDef.flags & queryFlags) && (nodeDef.flags & staticDynamicQueryFlag)) {
+      Services.setCurrentNode(view, nodeDef.index);
+      switch (checkType) {
+        case CheckType.CheckAndUpdate:
+          checkAndUpdateQuery(view, nodeDef);
+          break;
+        case CheckType.CheckNoChanges:
+          checkNoChangesQuery(view, nodeDef);
+          break;
+      }
+    }
+    if (!(nodeDef.childFlags & queryFlags) || !(nodeDef.childFlags & staticDynamicQueryFlag)) {
+      // no child has a matching query
+      // then skip the children
+      i += nodeDef.childCount;
+    }
+  }
+}
diff --git a/angular/core/src/view/view_attach.ts b/angular/core/src/view/view_attach.ts
new file mode 100644
index 0000000..31726e3
--- /dev/null
+++ b/angular/core/src/view/view_attach.ts
@@ -0,0 +1,153 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ElementData, NodeDef, NodeFlags, Services, ViewData, ViewDefinition, ViewState} from './types';
+import {RenderNodeAction, declaredViewContainer, isComponentView, renderNode, visitRootRenderNodes} from './util';
+
+export function attachEmbeddedView(
+    parentView: ViewData, elementData: ElementData, viewIndex: number | undefined | null,
+    view: ViewData) {
+  let embeddedViews = elementData.viewContainer !._embeddedViews;
+  if (viewIndex === null || viewIndex === undefined) {
+    viewIndex = embeddedViews.length;
+  }
+  view.viewContainerParent = parentView;
+  addToArray(embeddedViews, viewIndex !, view);
+  attachProjectedView(elementData, view);
+
+  Services.dirtyParentQueries(view);
+
+  const prevView = viewIndex ! > 0 ? embeddedViews[viewIndex ! - 1] : null;
+  renderAttachEmbeddedView(elementData, prevView, view);
+}
+
+function attachProjectedView(vcElementData: ElementData, view: ViewData) {
+  const dvcElementData = declaredViewContainer(view);
+  if (!dvcElementData || dvcElementData === vcElementData ||
+      view.state & ViewState.IsProjectedView) {
+    return;
+  }
+  // Note: For performance reasons, we
+  // - add a view to template._projectedViews only 1x throughout its lifetime,
+  //   and remove it not until the view is destroyed.
+  //   (hard, as when a parent view is attached/detached we would need to attach/detach all
+  //    nested projected views as well, even accross component boundaries).
+  // - don't track the insertion order of views in the projected views array
+  //   (hard, as when the views of the same template are inserted different view containers)
+  view.state |= ViewState.IsProjectedView;
+  let projectedViews = dvcElementData.template._projectedViews;
+  if (!projectedViews) {
+    projectedViews = dvcElementData.template._projectedViews = [];
+  }
+  projectedViews.push(view);
+  // Note: we are changing the NodeDef here as we cannot calculate
+  // the fact whether a template is used for projection during compilation.
+  markNodeAsProjectedTemplate(view.parent !.def, view.parentNodeDef !);
+}
+
+function markNodeAsProjectedTemplate(viewDef: ViewDefinition, nodeDef: NodeDef) {
+  if (nodeDef.flags & NodeFlags.ProjectedTemplate) {
+    return;
+  }
+  viewDef.nodeFlags |= NodeFlags.ProjectedTemplate;
+  nodeDef.flags |= NodeFlags.ProjectedTemplate;
+  let parentNodeDef = nodeDef.parent;
+  while (parentNodeDef) {
+    parentNodeDef.childFlags |= NodeFlags.ProjectedTemplate;
+    parentNodeDef = parentNodeDef.parent;
+  }
+}
+
+export function detachEmbeddedView(elementData: ElementData, viewIndex?: number): ViewData|null {
+  const embeddedViews = elementData.viewContainer !._embeddedViews;
+  if (viewIndex == null || viewIndex >= embeddedViews.length) {
+    viewIndex = embeddedViews.length - 1;
+  }
+  if (viewIndex < 0) {
+    return null;
+  }
+  const view = embeddedViews[viewIndex];
+  view.viewContainerParent = null;
+  removeFromArray(embeddedViews, viewIndex);
+
+  // See attachProjectedView for why we don't update projectedViews here.
+  Services.dirtyParentQueries(view);
+
+  renderDetachView(view);
+
+  return view;
+}
+
+export function detachProjectedView(view: ViewData) {
+  if (!(view.state & ViewState.IsProjectedView)) {
+    return;
+  }
+  const dvcElementData = declaredViewContainer(view);
+  if (dvcElementData) {
+    const projectedViews = dvcElementData.template._projectedViews;
+    if (projectedViews) {
+      removeFromArray(projectedViews, projectedViews.indexOf(view));
+      Services.dirtyParentQueries(view);
+    }
+  }
+}
+
+export function moveEmbeddedView(
+    elementData: ElementData, oldViewIndex: number, newViewIndex: number): ViewData {
+  const embeddedViews = elementData.viewContainer !._embeddedViews;
+  const view = embeddedViews[oldViewIndex];
+  removeFromArray(embeddedViews, oldViewIndex);
+  if (newViewIndex == null) {
+    newViewIndex = embeddedViews.length;
+  }
+  addToArray(embeddedViews, newViewIndex, view);
+
+  // Note: Don't need to change projectedViews as the order in there
+  // as always invalid...
+
+  Services.dirtyParentQueries(view);
+
+  renderDetachView(view);
+  const prevView = newViewIndex > 0 ? embeddedViews[newViewIndex - 1] : null;
+  renderAttachEmbeddedView(elementData, prevView, view);
+
+  return view;
+}
+
+function renderAttachEmbeddedView(
+    elementData: ElementData, prevView: ViewData | null, view: ViewData) {
+  const prevRenderNode = prevView ? renderNode(prevView, prevView.def.lastRenderRootNode !) :
+                                    elementData.renderElement;
+  const parentNode = view.renderer.parentNode(prevRenderNode);
+  const nextSibling = view.renderer.nextSibling(prevRenderNode);
+  // Note: We can't check if `nextSibling` is present, as on WebWorkers it will always be!
+  // However, browsers automatically do `appendChild` when there is no `nextSibling`.
+  visitRootRenderNodes(view, RenderNodeAction.InsertBefore, parentNode, nextSibling, undefined);
+}
+
+export function renderDetachView(view: ViewData) {
+  visitRootRenderNodes(view, RenderNodeAction.RemoveChild, null, null, undefined);
+}
+
+function addToArray(arr: any[], index: number, value: any) {
+  // perf: array.push is faster than array.splice!
+  if (index >= arr.length) {
+    arr.push(value);
+  } else {
+    arr.splice(index, 0, value);
+  }
+}
+
+function removeFromArray(arr: any[], index: number) {
+  // perf: array.pop is faster than array.splice!
+  if (index >= arr.length - 1) {
+    arr.pop();
+  } else {
+    arr.splice(index, 1);
+  }
+}
diff --git a/angular/core/src/zone.ts b/angular/core/src/zone.ts
new file mode 100644
index 0000000..e4f9a99
--- /dev/null
+++ b/angular/core/src/zone.ts
@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+// Public API for Zone
+export {NgZone} from './zone/ng_zone';
diff --git a/angular/core/src/zone/ng_zone.ts b/angular/core/src/zone/ng_zone.ts
new file mode 100644
index 0000000..1f16d2e
--- /dev/null
+++ b/angular/core/src/zone/ng_zone.ts
@@ -0,0 +1,310 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+// Import zero symbols from zone.js. This causes the zone ambient type to be
+// added to the type-checker, without emitting any runtime module load statement
+import {} from 'zone.js';
+import {EventEmitter} from '../event_emitter';
+
+/**
+ * An injectable service for executing work inside or outside of the Angular zone.
+ *
+ * The most common use of this service is to optimize performance when starting a work consisting of
+ * one or more asynchronous tasks that don't require UI updates or error handling to be handled by
+ * Angular. Such tasks can be kicked off via {@link #runOutsideAngular} and if needed, these tasks
+ * can reenter the Angular zone via {@link #run}.
+ *
+ * <!-- TODO: add/fix links to:
+ *   - docs explaining zones and the use of zones in Angular and change-detection
+ *   - link to runOutsideAngular/run (throughout this file!)
+ *   -->
+ *
+ * ### Example
+ *
+ * ```
+ * import {Component, NgZone} from '@angular/core';
+ * import {NgIf} from '@angular/common';
+ *
+ * @Component({
+ *   selector: 'ng-zone-demo'.
+ *   template: `
+ *     <h2>Demo: NgZone</h2>
+ *
+ *     <p>Progress: {{progress}}%</p>
+ *     <p *ngIf="progress >= 100">Done processing {{label}} of Angular zone!</p>
+ *
+ *     <button (click)="processWithinAngularZone()">Process within Angular zone</button>
+ *     <button (click)="processOutsideOfAngularZone()">Process outside of Angular zone</button>
+ *   `,
+ * })
+ * export class NgZoneDemo {
+ *   progress: number = 0;
+ *   label: string;
+ *
+ *   constructor(private _ngZone: NgZone) {}
+ *
+ *   // Loop inside the Angular zone
+ *   // so the UI DOES refresh after each setTimeout cycle
+ *   processWithinAngularZone() {
+ *     this.label = 'inside';
+ *     this.progress = 0;
+ *     this._increaseProgress(() => console.log('Inside Done!'));
+ *   }
+ *
+ *   // Loop outside of the Angular zone
+ *   // so the UI DOES NOT refresh after each setTimeout cycle
+ *   processOutsideOfAngularZone() {
+ *     this.label = 'outside';
+ *     this.progress = 0;
+ *     this._ngZone.runOutsideAngular(() => {
+ *       this._increaseProgress(() => {
+ *       // reenter the Angular zone and display done
+ *       this._ngZone.run(() => {console.log('Outside Done!') });
+ *     }}));
+ *   }
+ *
+ *   _increaseProgress(doneCallback: () => void) {
+ *     this.progress += 1;
+ *     console.log(`Current progress: ${this.progress}%`);
+ *
+ *     if (this.progress < 100) {
+ *       window.setTimeout(() => this._increaseProgress(doneCallback)), 10)
+ *     } else {
+ *       doneCallback();
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @experimental
+ */
+export class NgZone {
+  readonly hasPendingMicrotasks: boolean = false;
+  readonly hasPendingMacrotasks: boolean = false;
+
+  /**
+   * Whether there are no outstanding microtasks or macrotasks.
+   */
+  readonly isStable: boolean = true;
+
+  /**
+   * Notifies when code enters Angular Zone. This gets fired first on VM Turn.
+   */
+  readonly onUnstable: EventEmitter<any> = new EventEmitter(false);
+
+  /**
+   * Notifies when there is no more microtasks enqueue in the current VM Turn.
+   * This is a hint for Angular to do change detection, which may enqueue more microtasks.
+   * For this reason this event can fire multiple times per VM Turn.
+   */
+  readonly onMicrotaskEmpty: EventEmitter<any> = new EventEmitter(false);
+
+  /**
+   * Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which
+   * implies we are about to relinquish VM turn.
+   * This event gets called just once.
+   */
+  readonly onStable: EventEmitter<any> = new EventEmitter(false);
+
+  /**
+   * Notifies that an error has been delivered.
+   */
+  readonly onError: EventEmitter<any> = new EventEmitter(false);
+
+  constructor({enableLongStackTrace = false}) {
+    if (typeof Zone == 'undefined') {
+      throw new Error('Angular requires Zone.js prolyfill.');
+    }
+
+    Zone.assertZonePatched();
+    const self = this as any as NgZonePrivate;
+    self._nesting = 0;
+
+    self._outer = self._inner = Zone.current;
+
+    if ((Zone as any)['wtfZoneSpec']) {
+      self._inner = self._inner.fork((Zone as any)['wtfZoneSpec']);
+    }
+
+    if (enableLongStackTrace && (Zone as any)['longStackTraceZoneSpec']) {
+      self._inner = self._inner.fork((Zone as any)['longStackTraceZoneSpec']);
+    }
+
+    forkInnerZoneWithAngularBehavior(self);
+  }
+
+  static isInAngularZone(): boolean { return Zone.current.get('isAngularZone') === true; }
+
+  static assertInAngularZone(): void {
+    if (!NgZone.isInAngularZone()) {
+      throw new Error('Expected to be in Angular Zone, but it is not!');
+    }
+  }
+
+  static assertNotInAngularZone(): void {
+    if (NgZone.isInAngularZone()) {
+      throw new Error('Expected to not be in Angular Zone, but it is!');
+    }
+  }
+
+  /**
+   * Executes the `fn` function synchronously within the Angular zone and returns value returned by
+   * the function.
+   *
+   * Running functions via `run` allows you to reenter Angular zone from a task that was executed
+   * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
+   *
+   * Any future tasks or microtasks scheduled from within this function will continue executing from
+   * within the Angular zone.
+   *
+   * If a synchronous error happens it will be rethrown and not reported via `onError`.
+   */
+  run<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[]): T {
+    return (this as any as NgZonePrivate)._inner.run(fn, applyThis, applyArgs) as T;
+  }
+
+  /**
+   * Executes the `fn` function synchronously within the Angular zone as a task and returns value
+   * returned by the function.
+   *
+   * Running functions via `run` allows you to reenter Angular zone from a task that was executed
+   * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
+   *
+   * Any future tasks or microtasks scheduled from within this function will continue executing from
+   * within the Angular zone.
+   *
+   * If a synchronous error happens it will be rethrown and not reported via `onError`.
+   */
+  runTask<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[], name?: string): T {
+    const zone = (this as any as NgZonePrivate)._inner;
+    const task = zone.scheduleEventTask('NgZoneEvent: ' + name, fn, EMPTY_PAYLOAD, noop, noop);
+    try {
+      return zone.runTask(task, applyThis, applyArgs) as T;
+    } finally {
+      zone.cancelTask(task);
+    }
+  }
+
+  /**
+   * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not
+   * rethrown.
+   */
+  runGuarded<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[]): T {
+    return (this as any as NgZonePrivate)._inner.runGuarded(fn, applyThis, applyArgs) as T;
+  }
+
+  /**
+   * Executes the `fn` function synchronously in Angular's parent zone and returns value returned by
+   * the function.
+   *
+   * Running functions via {@link #runOutsideAngular} allows you to escape Angular's zone and do
+   * work that
+   * doesn't trigger Angular change-detection or is subject to Angular's error handling.
+   *
+   * Any future tasks or microtasks scheduled from within this function will continue executing from
+   * outside of the Angular zone.
+   *
+   * Use {@link #run} to reenter the Angular zone and do work that updates the application model.
+   */
+  runOutsideAngular<T>(fn: (...args: any[]) => T): T {
+    return (this as any as NgZonePrivate)._outer.run(fn) as T;
+  }
+}
+
+function noop(){};
+const EMPTY_PAYLOAD = {};
+
+
+interface NgZonePrivate extends NgZone {
+  _outer: Zone;
+  _inner: Zone;
+  _nesting: number;
+
+  hasPendingMicrotasks: boolean;
+  hasPendingMacrotasks: boolean;
+  isStable: boolean;
+}
+
+function checkStable(zone: NgZonePrivate) {
+  if (zone._nesting == 0 && !zone.hasPendingMicrotasks && !zone.isStable) {
+    try {
+      zone._nesting++;
+      zone.onMicrotaskEmpty.emit(null);
+    } finally {
+      zone._nesting--;
+      if (!zone.hasPendingMicrotasks) {
+        try {
+          zone.runOutsideAngular(() => zone.onStable.emit(null));
+        } finally {
+          zone.isStable = true;
+        }
+      }
+    }
+  }
+}
+
+function forkInnerZoneWithAngularBehavior(zone: NgZonePrivate) {
+  zone._inner = zone._inner.fork({
+    name: 'angular',
+    properties: <any>{'isAngularZone': true},
+    onInvokeTask: (delegate: ZoneDelegate, current: Zone, target: Zone, task: Task, applyThis: any,
+                   applyArgs: any): any => {
+      try {
+        onEnter(zone);
+        return delegate.invokeTask(target, task, applyThis, applyArgs);
+      } finally {
+        onLeave(zone);
+      }
+    },
+
+
+    onInvoke: (delegate: ZoneDelegate, current: Zone, target: Zone, callback: Function,
+               applyThis: any, applyArgs: any[], source: string): any => {
+      try {
+        onEnter(zone);
+        return delegate.invoke(target, callback, applyThis, applyArgs, source);
+      } finally {
+        onLeave(zone);
+      }
+    },
+
+    onHasTask:
+        (delegate: ZoneDelegate, current: Zone, target: Zone, hasTaskState: HasTaskState) => {
+          delegate.hasTask(target, hasTaskState);
+          if (current === target) {
+            // We are only interested in hasTask events which originate from our zone
+            // (A child hasTask event is not interesting to us)
+            if (hasTaskState.change == 'microTask') {
+              zone.hasPendingMicrotasks = hasTaskState.microTask;
+              checkStable(zone);
+            } else if (hasTaskState.change == 'macroTask') {
+              zone.hasPendingMacrotasks = hasTaskState.macroTask;
+            }
+          }
+        },
+
+    onHandleError: (delegate: ZoneDelegate, current: Zone, target: Zone, error: any): boolean => {
+      delegate.handleError(target, error);
+      zone.runOutsideAngular(() => zone.onError.emit(error));
+      return false;
+    }
+  });
+}
+
+function onEnter(zone: NgZonePrivate) {
+  zone._nesting++;
+  if (zone.isStable) {
+    zone.isStable = false;
+    zone.onUnstable.emit(null);
+  }
+}
+
+function onLeave(zone: NgZonePrivate) {
+  zone._nesting--;
+  checkStable(zone);
+}
diff --git a/angular/platform-browser-dynamic/index.ts b/angular/platform-browser-dynamic/index.ts
new file mode 100644
index 0000000..ced57d2
--- /dev/null
+++ b/angular/platform-browser-dynamic/index.ts
@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the platform-browser-dynamic package.
+ */
+export * from './src/platform-browser-dynamic';
+
+// This file only reexports content of the `src` folder. Keep it that way.
diff --git a/angular/platform-browser-dynamic/src/compiler_factory.ts b/angular/platform-browser-dynamic/src/compiler_factory.ts
new file mode 100644
index 0000000..1ffb7a8
--- /dev/null
+++ b/angular/platform-browser-dynamic/src/compiler_factory.ts
@@ -0,0 +1,221 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Compiler, CompilerFactory, ComponentFactory, CompilerOptions, ModuleWithComponentFactories, Inject, InjectionToken, Optional, PACKAGE_ROOT_URL, PlatformRef, StaticProvider, TRANSLATIONS, Type, isDevMode, platformCore, ɵConsole as Console, ViewEncapsulation, Injector, NgModuleFactory, TRANSLATIONS_FORMAT, MissingTranslationStrategy,} from '@angular/core';
+
+import {StaticSymbolCache, JitCompiler, ProviderMeta, ExternalReference, I18NHtmlParser, Identifiers, ViewCompiler, CompileMetadataResolver, UrlResolver, TemplateParser, NgModuleCompiler, JitSummaryResolver, SummaryResolver, StyleCompiler, PipeResolver, ElementSchemaRegistry, DomElementSchemaRegistry, ResourceLoader, NgModuleResolver, HtmlParser, CompileReflector, CompilerConfig, DirectiveNormalizer, DirectiveResolver, Lexer, Parser} from '@angular/compiler';
+
+import {JitReflector} from './compiler_reflector';
+
+export const ERROR_COLLECTOR_TOKEN = new InjectionToken('ErrorCollector');
+
+/**
+ * A default provider for {@link PACKAGE_ROOT_URL} that maps to '/'.
+ */
+export const DEFAULT_PACKAGE_URL_PROVIDER = {
+  provide: PACKAGE_ROOT_URL,
+  useValue: '/'
+};
+
+const _NO_RESOURCE_LOADER: ResourceLoader = {
+  get(url: string): Promise<string>{
+      throw new Error(
+          `No ResourceLoader implementation has been provided. Can't read the url "${url}"`);}
+};
+
+const baseHtmlParser = new InjectionToken('HtmlParser');
+
+export class CompilerImpl implements Compiler {
+  private _delegate: JitCompiler;
+  constructor(
+      private _injector: Injector, private _metadataResolver: CompileMetadataResolver,
+      templateParser: TemplateParser, styleCompiler: StyleCompiler, viewCompiler: ViewCompiler,
+      ngModuleCompiler: NgModuleCompiler, summaryResolver: SummaryResolver<Type<any>>,
+      compileReflector: CompileReflector, compilerConfig: CompilerConfig, console: Console) {
+    this._delegate = new JitCompiler(
+        _metadataResolver, templateParser, styleCompiler, viewCompiler, ngModuleCompiler,
+        summaryResolver, compileReflector, compilerConfig, console,
+        this.getExtraNgModuleProviders.bind(this));
+  }
+
+  get injector(): Injector { return this._injector; }
+
+  private getExtraNgModuleProviders() {
+    return [this._metadataResolver.getProviderMetadata(
+        new ProviderMeta(Compiler, {useValue: this}))];
+  }
+
+  compileModuleSync<T>(moduleType: Type<T>): NgModuleFactory<T> {
+    return this._delegate.compileModuleSync(moduleType) as NgModuleFactory<T>;
+  }
+  compileModuleAsync<T>(moduleType: Type<T>): Promise<NgModuleFactory<T>> {
+    return this._delegate.compileModuleAsync(moduleType) as Promise<NgModuleFactory<T>>;
+  }
+  compileModuleAndAllComponentsSync<T>(moduleType: Type<T>): ModuleWithComponentFactories<T> {
+    const result = this._delegate.compileModuleAndAllComponentsSync(moduleType);
+    return {
+      ngModuleFactory: result.ngModuleFactory as NgModuleFactory<T>,
+      componentFactories: result.componentFactories as ComponentFactory<any>[],
+    };
+  }
+  compileModuleAndAllComponentsAsync<T>(moduleType: Type<T>):
+      Promise<ModuleWithComponentFactories<T>> {
+    return this._delegate.compileModuleAndAllComponentsAsync(moduleType)
+        .then((result) => ({
+                ngModuleFactory: result.ngModuleFactory as NgModuleFactory<T>,
+                componentFactories: result.componentFactories as ComponentFactory<any>[],
+              }));
+  }
+  getNgContentSelectors(component: Type<any>): string[] {
+    return this._delegate.getNgContentSelectors(component);
+  }
+  loadAotSummaries(summaries: () => any[]) { this._delegate.loadAotSummaries(summaries); }
+  hasAotSummary(ref: Type<any>): boolean { return this._delegate.hasAotSummary(ref); }
+  getComponentFactory<T>(component: Type<T>): ComponentFactory<T> {
+    return this._delegate.getComponentFactory(component) as ComponentFactory<T>;
+  }
+  clearCache(): void { this._delegate.clearCache(); }
+  clearCacheFor(type: Type<any>) { this._delegate.clearCacheFor(type); }
+}
+
+/**
+ * A set of providers that provide `JitCompiler` and its dependencies to use for
+ * template compilation.
+ */
+export const COMPILER_PROVIDERS = <StaticProvider[]>[
+  {provide: CompileReflector, useValue: new JitReflector()},
+  {provide: ResourceLoader, useValue: _NO_RESOURCE_LOADER},
+  {provide: JitSummaryResolver, deps: []},
+  {provide: SummaryResolver, useExisting: JitSummaryResolver},
+  {provide: Console, deps: []},
+  {provide: Lexer, deps: []},
+  {provide: Parser, deps: [Lexer]},
+  {
+    provide: baseHtmlParser,
+    useClass: HtmlParser,
+    deps: [],
+  },
+  {
+    provide: I18NHtmlParser,
+    useFactory: (parser: HtmlParser, translations: string | null, format: string,
+                 config: CompilerConfig, console: Console) => {
+      translations = translations || '';
+      const missingTranslation =
+          translations ? config.missingTranslation ! : MissingTranslationStrategy.Ignore;
+      return new I18NHtmlParser(parser, translations, format, missingTranslation, console);
+    },
+    deps: [
+      baseHtmlParser,
+      [new Optional(), new Inject(TRANSLATIONS)],
+      [new Optional(), new Inject(TRANSLATIONS_FORMAT)],
+      [CompilerConfig],
+      [Console],
+    ]
+  },
+  {
+    provide: HtmlParser,
+    useExisting: I18NHtmlParser,
+  },
+  {
+    provide: TemplateParser, deps: [CompilerConfig, CompileReflector,
+    Parser, ElementSchemaRegistry,
+    I18NHtmlParser, Console]
+  },
+  { provide: DirectiveNormalizer, deps: [ResourceLoader, UrlResolver, HtmlParser, CompilerConfig]},
+  { provide: CompileMetadataResolver, deps: [CompilerConfig, NgModuleResolver,
+                      DirectiveResolver, PipeResolver,
+                      SummaryResolver,
+                      ElementSchemaRegistry,
+                      DirectiveNormalizer, Console,
+                      [Optional, StaticSymbolCache],
+                      CompileReflector,
+                      [Optional, ERROR_COLLECTOR_TOKEN]]},
+  DEFAULT_PACKAGE_URL_PROVIDER,
+  { provide: StyleCompiler, deps: [UrlResolver]},
+  { provide: ViewCompiler, deps: [CompilerConfig, CompileReflector, ElementSchemaRegistry]},
+  { provide: NgModuleCompiler, deps: [CompileReflector] },
+  { provide: CompilerConfig, useValue: new CompilerConfig()},
+  { provide: Compiler, useClass: CompilerImpl, deps: [Injector, CompileMetadataResolver,
+                                TemplateParser, StyleCompiler,
+                                ViewCompiler, NgModuleCompiler,
+                                SummaryResolver, CompileReflector, CompilerConfig,
+                                Console]},
+  { provide: DomElementSchemaRegistry, deps: []},
+  { provide: ElementSchemaRegistry, useExisting: DomElementSchemaRegistry},
+  { provide: UrlResolver, deps: [PACKAGE_ROOT_URL]},
+  { provide: DirectiveResolver, deps: [CompileReflector]},
+  { provide: PipeResolver, deps: [CompileReflector]},
+  { provide: NgModuleResolver, deps: [CompileReflector]},
+];
+
+export class JitCompilerFactory implements CompilerFactory {
+  private _defaultOptions: CompilerOptions[];
+  constructor(defaultOptions: CompilerOptions[]) {
+    const compilerOptions: CompilerOptions = {
+      useDebug: isDevMode(),
+      useJit: true,
+      defaultEncapsulation: ViewEncapsulation.Emulated,
+      missingTranslation: MissingTranslationStrategy.Warning,
+      enableLegacyTemplate: true,
+      preserveWhitespaces: true,
+    };
+
+    this._defaultOptions = [compilerOptions, ...defaultOptions];
+  }
+  createCompiler(options: CompilerOptions[] = []): Compiler {
+    const opts = _mergeOptions(this._defaultOptions.concat(options));
+    const injector = Injector.create([
+      COMPILER_PROVIDERS, {
+        provide: CompilerConfig,
+        useFactory: () => {
+          return new CompilerConfig({
+            // let explicit values from the compiler options overwrite options
+            // from the app providers
+            useJit: opts.useJit,
+            jitDevMode: isDevMode(),
+            // let explicit values from the compiler options overwrite options
+            // from the app providers
+            defaultEncapsulation: opts.defaultEncapsulation,
+            missingTranslation: opts.missingTranslation,
+            enableLegacyTemplate: opts.enableLegacyTemplate,
+            preserveWhitespaces: opts.preserveWhitespaces,
+          });
+        },
+        deps: []
+      },
+      opts.providers !
+    ]);
+    return injector.get(Compiler);
+  }
+}
+
+function _mergeOptions(optionsArr: CompilerOptions[]): CompilerOptions {
+  return {
+    useJit: _lastDefined(optionsArr.map(options => options.useJit)),
+    defaultEncapsulation: _lastDefined(optionsArr.map(options => options.defaultEncapsulation)),
+    providers: _mergeArrays(optionsArr.map(options => options.providers !)),
+    missingTranslation: _lastDefined(optionsArr.map(options => options.missingTranslation)),
+    enableLegacyTemplate: _lastDefined(optionsArr.map(options => options.enableLegacyTemplate)),
+    preserveWhitespaces: _lastDefined(optionsArr.map(options => options.preserveWhitespaces)),
+  };
+}
+
+function _lastDefined<T>(args: T[]): T|undefined {
+  for (let i = args.length - 1; i >= 0; i--) {
+    if (args[i] !== undefined) {
+      return args[i];
+    }
+  }
+  return undefined;
+}
+
+function _mergeArrays(parts: any[][]): any[] {
+  const result: any[] = [];
+  parts.forEach((part) => part && result.push(...part));
+  return result;
+}
diff --git a/angular/platform-browser-dynamic/src/compiler_reflector.ts b/angular/platform-browser-dynamic/src/compiler_reflector.ts
new file mode 100644
index 0000000..4334980
--- /dev/null
+++ b/angular/platform-browser-dynamic/src/compiler_reflector.ts
@@ -0,0 +1,149 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileReflector, ExternalReference, Identifiers, getUrlScheme, syntaxError} from '@angular/compiler';
+import {ANALYZE_FOR_ENTRY_COMPONENTS, ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentFactory, ComponentFactoryResolver, ComponentRef, ElementRef, Inject, InjectionToken, Injector, LOCALE_ID, NgModuleFactory, NgModuleRef, Optional, PACKAGE_ROOT_URL, PlatformRef, QueryList, Renderer, SecurityContext, StaticProvider, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Type, ViewContainerRef, ViewEncapsulation, createPlatformFactory, isDevMode, platformCore, ɵCodegenComponentFactoryResolver, ɵConsole as Console, ɵEMPTY_ARRAY, ɵEMPTY_MAP, ɵReflectionCapabilities as ReflectionCapabilities, ɵand, ɵccf, ɵcmf, ɵcrt, ɵdid, ɵeld, ɵinlineInterpolate, ɵinterpolate, ɵmod, ɵmpd, ɵncd, ɵnov, ɵpad, ɵpid, ɵpod, ɵppd, ɵprd, ɵqud, ɵregisterModuleFactory, ɵstringify as stringify, ɵted, ɵunv, ɵvid} from '@angular/core';
+
+export const MODULE_SUFFIX = '';
+const builtinExternalReferences = createBuiltinExternalReferencesMap();
+
+export class JitReflector implements CompileReflector {
+  private reflectionCapabilities: ReflectionCapabilities;
+  private builtinExternalReferences = new Map<ExternalReference, any>();
+  constructor() { this.reflectionCapabilities = new ReflectionCapabilities(); }
+  componentModuleUrl(type: any, cmpMetadata: Component): string {
+    const moduleId = cmpMetadata.moduleId;
+
+    if (typeof moduleId === 'string') {
+      const scheme = getUrlScheme(moduleId);
+      return scheme ? moduleId : `package:${moduleId}${MODULE_SUFFIX}`;
+    } else if (moduleId !== null && moduleId !== void 0) {
+      throw syntaxError(
+          `moduleId should be a string in "${stringify(type)}". See https://goo.gl/wIDDiL for more information.\n` +
+          `If you're using Webpack you should inline the template and the styles, see https://goo.gl/X2J8zc.`);
+    }
+
+    return `./${stringify(type)}`;
+  }
+  parameters(typeOrFunc: /*Type*/ any): any[][] {
+    return this.reflectionCapabilities.parameters(typeOrFunc);
+  }
+  annotations(typeOrFunc: /*Type*/ any): any[] {
+    return this.reflectionCapabilities.annotations(typeOrFunc);
+  }
+  propMetadata(typeOrFunc: /*Type*/ any): {[key: string]: any[]} {
+    return this.reflectionCapabilities.propMetadata(typeOrFunc);
+  }
+  hasLifecycleHook(type: any, lcProperty: string): boolean {
+    return this.reflectionCapabilities.hasLifecycleHook(type, lcProperty);
+  }
+  resolveExternalReference(ref: ExternalReference): any {
+    return builtinExternalReferences.get(ref) || ref.runtime;
+  }
+}
+
+
+function createBuiltinExternalReferencesMap() {
+  const map = new Map<ExternalReference, any>();
+  map.set(
+      Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS,
+
+
+      ANALYZE_FOR_ENTRY_COMPONENTS);
+  map.set(Identifiers.ElementRef, ElementRef);
+  map.set(Identifiers.NgModuleRef, NgModuleRef);
+  map.set(Identifiers.ViewContainerRef, ViewContainerRef);
+  map.set(
+      Identifiers.ChangeDetectorRef,
+
+
+      ChangeDetectorRef);
+  map.set(Identifiers.QueryList, QueryList);
+  map.set(Identifiers.TemplateRef, TemplateRef);
+  map.set(
+      Identifiers.CodegenComponentFactoryResolver,
+
+
+      ɵCodegenComponentFactoryResolver);
+  map.set(
+      Identifiers.ComponentFactoryResolver,
+
+
+      ComponentFactoryResolver);
+  map.set(Identifiers.ComponentFactory, ComponentFactory);
+  map.set(Identifiers.ComponentRef, ComponentRef);
+  map.set(Identifiers.NgModuleFactory, NgModuleFactory);
+  map.set(
+      Identifiers.createModuleFactory,
+
+
+      ɵcmf, );
+  map.set(
+      Identifiers.moduleDef,
+
+
+      ɵmod, );
+  map.set(
+      Identifiers.moduleProviderDef,
+
+
+      ɵmpd, );
+  map.set(
+      Identifiers.RegisterModuleFactoryFn,
+
+
+      ɵregisterModuleFactory, );
+  map.set(Identifiers.Injector, Injector);
+  map.set(
+      Identifiers.ViewEncapsulation,
+
+
+      ViewEncapsulation);
+  map.set(
+      Identifiers.ChangeDetectionStrategy,
+
+
+      ChangeDetectionStrategy);
+  map.set(
+      Identifiers.SecurityContext,
+
+
+      SecurityContext, );
+  map.set(Identifiers.LOCALE_ID, LOCALE_ID);
+  map.set(
+      Identifiers.TRANSLATIONS_FORMAT,
+
+
+      TRANSLATIONS_FORMAT);
+  map.set(
+      Identifiers.inlineInterpolate,
+
+
+      ɵinlineInterpolate);
+  map.set(Identifiers.interpolate, ɵinterpolate);
+  map.set(Identifiers.EMPTY_ARRAY, ɵEMPTY_ARRAY);
+  map.set(Identifiers.EMPTY_MAP, ɵEMPTY_MAP);
+  map.set(Identifiers.Renderer, Renderer);
+  map.set(Identifiers.viewDef, ɵvid);
+  map.set(Identifiers.elementDef, ɵeld);
+  map.set(Identifiers.anchorDef, ɵand);
+  map.set(Identifiers.textDef, ɵted);
+  map.set(Identifiers.directiveDef, ɵdid);
+  map.set(Identifiers.providerDef, ɵprd);
+  map.set(Identifiers.queryDef, ɵqud);
+  map.set(Identifiers.pureArrayDef, ɵpad);
+  map.set(Identifiers.pureObjectDef, ɵpod);
+  map.set(Identifiers.purePipeDef, ɵppd);
+  map.set(Identifiers.pipeDef, ɵpid);
+  map.set(Identifiers.nodeValue, ɵnov);
+  map.set(Identifiers.ngContentDef, ɵncd);
+  map.set(Identifiers.unwrapValue, ɵunv);
+  map.set(Identifiers.createRendererType2, ɵcrt);
+  map.set(Identifiers.createComponentFactory, ɵccf);
+  return map;
+}
\ No newline at end of file
diff --git a/angular/platform-browser-dynamic/src/platform-browser-dynamic.ts b/angular/platform-browser-dynamic/src/platform-browser-dynamic.ts
new file mode 100644
index 0000000..a97968c
--- /dev/null
+++ b/angular/platform-browser-dynamic/src/platform-browser-dynamic.ts
@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ResourceLoader} from '@angular/compiler';
+import {CompilerFactory, PlatformRef, Provider, StaticProvider, createPlatformFactory, platformCore} from '@angular/core';
+
+import {platformCoreDynamic} from './platform_core_dynamic';
+import {INTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS} from './platform_providers';
+import {CachedResourceLoader} from './resource_loader/resource_loader_cache';
+
+export * from './private_export';
+export {VERSION} from './version';
+
+/**
+ * @experimental
+ */
+export const RESOURCE_CACHE_PROVIDER: Provider[] =
+    [{provide: ResourceLoader, useClass: CachedResourceLoader, deps: []}];
+
+/**
+ * @stable
+ */
+export const platformBrowserDynamic = createPlatformFactory(
+    platformCoreDynamic, 'browserDynamic', INTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS);
diff --git a/angular/platform-browser-dynamic/src/platform_core_dynamic.ts b/angular/platform-browser-dynamic/src/platform_core_dynamic.ts
new file mode 100644
index 0000000..987bc1e
--- /dev/null
+++ b/angular/platform-browser-dynamic/src/platform_core_dynamic.ts
@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {COMPILER_OPTIONS, CompilerFactory, PlatformRef, StaticProvider, createPlatformFactory, platformCore} from '@angular/core';
+import {JitCompilerFactory} from './compiler_factory';
+
+/**
+ * A platform that included corePlatform and the compiler.
+ *
+ * @experimental
+ */
+export const platformCoreDynamic = createPlatformFactory(platformCore, 'coreDynamic', [
+  {provide: COMPILER_OPTIONS, useValue: {}, multi: true},
+  {provide: CompilerFactory, useClass: JitCompilerFactory, deps: [COMPILER_OPTIONS]},
+]);
diff --git a/angular/platform-browser-dynamic/src/platform_providers.ts b/angular/platform-browser-dynamic/src/platform_providers.ts
new file mode 100644
index 0000000..f477ee7
--- /dev/null
+++ b/angular/platform-browser-dynamic/src/platform_providers.ts
@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ɵPLATFORM_BROWSER_ID as PLATFORM_BROWSER_ID} from '@angular/common';
+import {ResourceLoader} from '@angular/compiler';
+import {COMPILER_OPTIONS, PLATFORM_ID, StaticProvider} from '@angular/core';
+
+import {ɵINTERNAL_BROWSER_PLATFORM_PROVIDERS as INTERNAL_BROWSER_PLATFORM_PROVIDERS} from '@angular/platform-browser';
+
+import {ResourceLoaderImpl} from './resource_loader/resource_loader_impl';
+
+export const INTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS: StaticProvider[] = [
+  INTERNAL_BROWSER_PLATFORM_PROVIDERS,
+  {
+    provide: COMPILER_OPTIONS,
+    useValue: {providers: [{provide: ResourceLoader, useClass: ResourceLoaderImpl, deps: []}]},
+    multi: true
+  },
+  {provide: PLATFORM_ID, useValue: PLATFORM_BROWSER_ID},
+];
diff --git a/angular/platform-browser-dynamic/src/private_export.ts b/angular/platform-browser-dynamic/src/private_export.ts
new file mode 100644
index 0000000..42da202
--- /dev/null
+++ b/angular/platform-browser-dynamic/src/private_export.ts
@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export {CompilerImpl as ɵCompilerImpl} from './compiler_factory';
+export {platformCoreDynamic as ɵplatformCoreDynamic} from './platform_core_dynamic';
+export {INTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS as ɵINTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS} from './platform_providers';
+export {ResourceLoaderImpl as ɵResourceLoaderImpl} from './resource_loader/resource_loader_impl';
diff --git a/angular/platform-browser-dynamic/src/resource_loader/resource_loader_cache.ts b/angular/platform-browser-dynamic/src/resource_loader/resource_loader_cache.ts
new file mode 100644
index 0000000..4fb4d71
--- /dev/null
+++ b/angular/platform-browser-dynamic/src/resource_loader/resource_loader_cache.ts
@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ResourceLoader} from '@angular/compiler';
+import {ɵglobal as global} from '@angular/core';
+
+/**
+ * An implementation of ResourceLoader that uses a template cache to avoid doing an actual
+ * ResourceLoader.
+ *
+ * The template cache needs to be built and loaded into window.$templateCache
+ * via a separate mechanism.
+ */
+export class CachedResourceLoader extends ResourceLoader {
+  private _cache: {[url: string]: string};
+
+  constructor() {
+    super();
+    this._cache = (<any>global).$templateCache;
+    if (this._cache == null) {
+      throw new Error('CachedResourceLoader: Template cache was not found in $templateCache.');
+    }
+  }
+
+  get(url: string): Promise<string> {
+    if (this._cache.hasOwnProperty(url)) {
+      return Promise.resolve(this._cache[url]);
+    } else {
+      return <Promise<any>>Promise.reject(
+          'CachedResourceLoader: Did not find cached template for ' + url);
+    }
+  }
+}
diff --git a/angular/platform-browser-dynamic/src/resource_loader/resource_loader_impl.ts b/angular/platform-browser-dynamic/src/resource_loader/resource_loader_impl.ts
new file mode 100644
index 0000000..4e5dfd6
--- /dev/null
+++ b/angular/platform-browser-dynamic/src/resource_loader/resource_loader_impl.ts
@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import {ResourceLoader} from '@angular/compiler';
+import {Injectable} from '@angular/core';
+
+
+@Injectable()
+export class ResourceLoaderImpl extends ResourceLoader {
+  get(url: string): Promise<string> {
+    let resolve: (result: any) => void;
+    let reject: (error: any) => void;
+    const promise = new Promise<string>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const xhr = new XMLHttpRequest();
+    xhr.open('GET', url, true);
+    xhr.responseType = 'text';
+
+    xhr.onload = function() {
+      // responseText is the old-school way of retrieving response (supported by IE8 & 9)
+      // response/responseType properties were introduced in ResourceLoader Level2 spec (supported
+      // by IE10)
+      const response = xhr.response || xhr.responseText;
+
+      // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
+      let status = xhr.status === 1223 ? 204 : xhr.status;
+
+      // fix status code when it is 0 (0 status is undocumented).
+      // Occurs when accessing file resources or on Android 4.1 stock browser
+      // while retrieving files from application cache.
+      if (status === 0) {
+        status = response ? 200 : 0;
+      }
+
+      if (200 <= status && status <= 300) {
+        resolve(response);
+      } else {
+        reject(`Failed to load ${url}`);
+      }
+    };
+
+    xhr.onerror = function() { reject(`Failed to load ${url}`); };
+
+    xhr.send();
+    return promise;
+  }
+}
diff --git a/angular/platform-browser-dynamic/src/version.ts b/angular/platform-browser-dynamic/src/version.ts
new file mode 100644
index 0000000..19db5be
--- /dev/null
+++ b/angular/platform-browser-dynamic/src/version.ts
@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the common package.
+ */
+
+import {Version} from '@angular/core';
+/**
+ * @stable
+ */
+export const VERSION = new Version('0.0.0-PLACEHOLDER');
diff --git a/angular/platform-browser/index.ts b/angular/platform-browser/index.ts
new file mode 100644
index 0000000..e727e2e
--- /dev/null
+++ b/angular/platform-browser/index.ts
@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+// This file is not used to build this module. It is only used during editing
+// by the TypeScript language service and during build for verification. `ngc`
+// replaces this file with production index.ts when it rewrites private symbol
+// names.
+
+export * from './public_api';
diff --git a/angular/platform-browser/public_api.ts b/angular/platform-browser/public_api.ts
new file mode 100644
index 0000000..a83ba23
--- /dev/null
+++ b/angular/platform-browser/public_api.ts
@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the platform-browser package.
+ */
+export * from './src/platform-browser';
+// This file only reexports content of the `src` folder. Keep it that way.
diff --git a/angular/platform-browser/src/browser.ts b/angular/platform-browser/src/browser.ts
new file mode 100644
index 0000000..7043cdb
--- /dev/null
+++ b/angular/platform-browser/src/browser.ts
@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CommonModule, PlatformLocation, ɵPLATFORM_BROWSER_ID as PLATFORM_BROWSER_ID} from '@angular/common';
+import {APP_ID, ApplicationModule, ErrorHandler, ModuleWithProviders, NgModule, Optional, PLATFORM_ID, PLATFORM_INITIALIZER, PlatformRef, RendererFactory2, RootRenderer, Sanitizer, SkipSelf, StaticProvider, Testability, createPlatformFactory, platformCore} from '@angular/core';
+
+import {BrowserDomAdapter} from './browser/browser_adapter';
+import {BrowserPlatformLocation} from './browser/location/browser_platform_location';
+import {Meta} from './browser/meta';
+import {SERVER_TRANSITION_PROVIDERS, TRANSITION_ID} from './browser/server-transition';
+import {BrowserGetTestability} from './browser/testability';
+import {Title} from './browser/title';
+import {ELEMENT_PROBE_PROVIDERS} from './dom/debug/ng_probe';
+import {getDOM} from './dom/dom_adapter';
+import {DomRendererFactory2} from './dom/dom_renderer';
+import {DOCUMENT} from './dom/dom_tokens';
+import {DomEventsPlugin} from './dom/events/dom_events';
+import {EVENT_MANAGER_PLUGINS, EventManager} from './dom/events/event_manager';
+import {HAMMER_GESTURE_CONFIG, HammerGestureConfig, HammerGesturesPlugin} from './dom/events/hammer_gestures';
+import {KeyEventsPlugin} from './dom/events/key_events';
+import {DomSharedStylesHost, SharedStylesHost} from './dom/shared_styles_host';
+import {DomSanitizer, DomSanitizerImpl} from './security/dom_sanitization_service';
+
+export const INTERNAL_BROWSER_PLATFORM_PROVIDERS: StaticProvider[] = [
+  {provide: PLATFORM_ID, useValue: PLATFORM_BROWSER_ID},
+  {provide: PLATFORM_INITIALIZER, useValue: initDomAdapter, multi: true},
+  {provide: PlatformLocation, useClass: BrowserPlatformLocation, deps: [DOCUMENT]},
+  {provide: DOCUMENT, useFactory: _document, deps: []},
+];
+
+/**
+ * @security Replacing built-in sanitization providers exposes the application to XSS risks.
+ * Attacker-controlled data introduced by an unsanitized provider could expose your
+ * application to XSS risks. For more detail, see the [Security Guide](http://g.co/ng/security).
+ * @experimental
+ */
+export const BROWSER_SANITIZATION_PROVIDERS: StaticProvider[] = [
+  {provide: Sanitizer, useExisting: DomSanitizer},
+  {provide: DomSanitizer, useClass: DomSanitizerImpl, deps: [DOCUMENT]},
+];
+
+/**
+ * @stable
+ */
+export const platformBrowser: (extraProviders?: StaticProvider[]) => PlatformRef =
+    createPlatformFactory(platformCore, 'browser', INTERNAL_BROWSER_PLATFORM_PROVIDERS);
+
+export function initDomAdapter() {
+  BrowserDomAdapter.makeCurrent();
+  BrowserGetTestability.init();
+}
+
+export function errorHandler(): ErrorHandler {
+  return new ErrorHandler();
+}
+
+export function _document(): any {
+  return document;
+}
+
+/**
+ * The ng module for the browser.
+ *
+ * @stable
+ */
+@NgModule({
+  providers: [
+    BROWSER_SANITIZATION_PROVIDERS,
+    {provide: ErrorHandler, useFactory: errorHandler, deps: []},
+    {provide: EVENT_MANAGER_PLUGINS, useClass: DomEventsPlugin, multi: true},
+    {provide: EVENT_MANAGER_PLUGINS, useClass: KeyEventsPlugin, multi: true},
+    {provide: EVENT_MANAGER_PLUGINS, useClass: HammerGesturesPlugin, multi: true},
+    {provide: HAMMER_GESTURE_CONFIG, useClass: HammerGestureConfig},
+    DomRendererFactory2,
+    {provide: RendererFactory2, useExisting: DomRendererFactory2},
+    {provide: SharedStylesHost, useExisting: DomSharedStylesHost},
+    DomSharedStylesHost,
+    Testability,
+    EventManager,
+    ELEMENT_PROBE_PROVIDERS,
+    Meta,
+    Title,
+  ],
+  exports: [CommonModule, ApplicationModule]
+})
+export class BrowserModule {
+  constructor(@Optional() @SkipSelf() parentModule: BrowserModule) {
+    if (parentModule) {
+      throw new Error(
+          `BrowserModule has already been loaded. If you need access to common directives such as NgIf and NgFor from a lazy loaded module, import CommonModule instead.`);
+    }
+  }
+
+  /**
+   * Configures a browser-based application to transition from a server-rendered app, if
+   * one is present on the page. The specified parameters must include an application id,
+   * which must match between the client and server applications.
+   *
+   * @experimental
+   */
+  static withServerTransition(params: {appId: string}): ModuleWithProviders {
+    return {
+      ngModule: BrowserModule,
+      providers: [
+        {provide: APP_ID, useValue: params.appId},
+        {provide: TRANSITION_ID, useExisting: APP_ID},
+        SERVER_TRANSITION_PROVIDERS,
+      ],
+    };
+  }
+}
diff --git a/angular/platform-browser/src/browser/browser_adapter.ts b/angular/platform-browser/src/browser/browser_adapter.ts
new file mode 100644
index 0000000..89dafbd
--- /dev/null
+++ b/angular/platform-browser/src/browser/browser_adapter.ts
@@ -0,0 +1,409 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ɵparseCookieValue as parseCookieValue} from '@angular/common';
+import {ɵglobal as global} from '@angular/core';
+
+import {setRootDomAdapter} from '../dom/dom_adapter';
+
+import {GenericBrowserDomAdapter} from './generic_browser_adapter';
+
+const _attrToPropMap = {
+  'class': 'className',
+  'innerHtml': 'innerHTML',
+  'readonly': 'readOnly',
+  'tabindex': 'tabIndex',
+};
+
+const DOM_KEY_LOCATION_NUMPAD = 3;
+
+// Map to convert some key or keyIdentifier values to what will be returned by getEventKey
+const _keyMap: {[k: string]: string} = {
+  // The following values are here for cross-browser compatibility and to match the W3C standard
+  // cf http://www.w3.org/TR/DOM-Level-3-Events-key/
+  '\b': 'Backspace',
+  '\t': 'Tab',
+  '\x7F': 'Delete',
+  '\x1B': 'Escape',
+  'Del': 'Delete',
+  'Esc': 'Escape',
+  'Left': 'ArrowLeft',
+  'Right': 'ArrowRight',
+  'Up': 'ArrowUp',
+  'Down': 'ArrowDown',
+  'Menu': 'ContextMenu',
+  'Scroll': 'ScrollLock',
+  'Win': 'OS'
+};
+
+// There is a bug in Chrome for numeric keypad keys:
+// https://code.google.com/p/chromium/issues/detail?id=155654
+// 1, 2, 3 ... are reported as A, B, C ...
+const _chromeNumKeyPadMap = {
+  'A': '1',
+  'B': '2',
+  'C': '3',
+  'D': '4',
+  'E': '5',
+  'F': '6',
+  'G': '7',
+  'H': '8',
+  'I': '9',
+  'J': '*',
+  'K': '+',
+  'M': '-',
+  'N': '.',
+  'O': '/',
+  '\x60': '0',
+  '\x90': 'NumLock'
+};
+
+let nodeContains: (a: any, b: any) => boolean;
+
+if (global['Node']) {
+  nodeContains = global['Node'].prototype.contains || function(node) {
+    return !!(this.compareDocumentPosition(node) & 16);
+  };
+}
+
+/**
+ * A `DomAdapter` powered by full browser DOM APIs.
+ *
+ * @security Tread carefully! Interacting with the DOM directly is dangerous and
+ * can introduce XSS risks.
+ */
+/* tslint:disable:requireParameterType no-console */
+export class BrowserDomAdapter extends GenericBrowserDomAdapter {
+  parse(templateHtml: string) { throw new Error('parse not implemented'); }
+  static makeCurrent() { setRootDomAdapter(new BrowserDomAdapter()); }
+  hasProperty(element: Node, name: string): boolean { return name in element; }
+  setProperty(el: Node, name: string, value: any) { (<any>el)[name] = value; }
+  getProperty(el: Node, name: string): any { return (<any>el)[name]; }
+  invoke(el: Node, methodName: string, args: any[]): any { (<any>el)[methodName](...args); }
+
+  // TODO(tbosch): move this into a separate environment class once we have it
+  logError(error: string): void {
+    if (window.console) {
+      if (console.error) {
+        console.error(error);
+      } else {
+        console.log(error);
+      }
+    }
+  }
+
+  log(error: string): void {
+    if (window.console) {
+      window.console.log && window.console.log(error);
+    }
+  }
+
+  logGroup(error: string): void {
+    if (window.console) {
+      window.console.group && window.console.group(error);
+    }
+  }
+
+  logGroupEnd(): void {
+    if (window.console) {
+      window.console.groupEnd && window.console.groupEnd();
+    }
+  }
+
+  get attrToPropMap(): any { return _attrToPropMap; }
+
+  contains(nodeA: any, nodeB: any): boolean { return nodeContains.call(nodeA, nodeB); }
+  querySelector(el: Element, selector: string): any { return el.querySelector(selector); }
+  querySelectorAll(el: any, selector: string): any[] { return el.querySelectorAll(selector); }
+  on(el: Node, evt: any, listener: any) { el.addEventListener(evt, listener, false); }
+  onAndCancel(el: Node, evt: any, listener: any): Function {
+    el.addEventListener(evt, listener, false);
+    // Needed to follow Dart's subscription semantic, until fix of
+    // https://code.google.com/p/dart/issues/detail?id=17406
+    return () => { el.removeEventListener(evt, listener, false); };
+  }
+  dispatchEvent(el: Node, evt: any) { el.dispatchEvent(evt); }
+  createMouseEvent(eventType: string): MouseEvent {
+    const evt: MouseEvent = document.createEvent('MouseEvent');
+    evt.initEvent(eventType, true, true);
+    return evt;
+  }
+  createEvent(eventType: any): Event {
+    const evt: Event = document.createEvent('Event');
+    evt.initEvent(eventType, true, true);
+    return evt;
+  }
+  preventDefault(evt: Event) {
+    evt.preventDefault();
+    evt.returnValue = false;
+  }
+  isPrevented(evt: Event): boolean {
+    return evt.defaultPrevented || evt.returnValue != null && !evt.returnValue;
+  }
+  getInnerHTML(el: HTMLElement): string { return el.innerHTML; }
+  getTemplateContent(el: Node): Node|null {
+    return 'content' in el && el instanceof HTMLTemplateElement ? el.content : null;
+  }
+  getOuterHTML(el: HTMLElement): string { return el.outerHTML; }
+  nodeName(node: Node): string { return node.nodeName; }
+  nodeValue(node: Node): string|null { return node.nodeValue; }
+  type(node: HTMLInputElement): string { return node.type; }
+  content(node: Node): Node {
+    if (this.hasProperty(node, 'content')) {
+      return (<any>node).content;
+    } else {
+      return node;
+    }
+  }
+  firstChild(el: Node): Node|null { return el.firstChild; }
+  nextSibling(el: Node): Node|null { return el.nextSibling; }
+  parentElement(el: Node): Node|null { return el.parentNode; }
+  childNodes(el: any): Node[] { return el.childNodes; }
+  childNodesAsList(el: Node): any[] {
+    const childNodes = el.childNodes;
+    const res = new Array(childNodes.length);
+    for (let i = 0; i < childNodes.length; i++) {
+      res[i] = childNodes[i];
+    }
+    return res;
+  }
+  clearNodes(el: Node) {
+    while (el.firstChild) {
+      el.removeChild(el.firstChild);
+    }
+  }
+  appendChild(el: Node, node: Node) { el.appendChild(node); }
+  removeChild(el: Node, node: Node) { el.removeChild(node); }
+  replaceChild(el: Node, newChild: Node, oldChild: Node) { el.replaceChild(newChild, oldChild); }
+  remove(node: Node): Node {
+    if (node.parentNode) {
+      node.parentNode.removeChild(node);
+    }
+    return node;
+  }
+  insertBefore(parent: Node, ref: Node, node: Node) { parent.insertBefore(node, ref); }
+  insertAllBefore(parent: Node, ref: Node, nodes: Node[]) {
+    nodes.forEach((n: any) => parent.insertBefore(n, ref));
+  }
+  insertAfter(parent: Node, ref: Node, node: any) { parent.insertBefore(node, ref.nextSibling); }
+  setInnerHTML(el: Element, value: string) { el.innerHTML = value; }
+  getText(el: Node): string|null { return el.textContent; }
+  setText(el: Node, value: string) { el.textContent = value; }
+  getValue(el: any): string { return el.value; }
+  setValue(el: any, value: string) { el.value = value; }
+  getChecked(el: any): boolean { return el.checked; }
+  setChecked(el: any, value: boolean) { el.checked = value; }
+  createComment(text: string): Comment { return document.createComment(text); }
+  createTemplate(html: any): HTMLElement {
+    const t = document.createElement('template');
+    t.innerHTML = html;
+    return t;
+  }
+  createElement(tagName: string, doc = document): HTMLElement { return doc.createElement(tagName); }
+  createElementNS(ns: string, tagName: string, doc = document): Element {
+    return doc.createElementNS(ns, tagName);
+  }
+  createTextNode(text: string, doc = document): Text { return doc.createTextNode(text); }
+  createScriptTag(attrName: string, attrValue: string, doc = document): HTMLScriptElement {
+    const el = <HTMLScriptElement>doc.createElement('SCRIPT');
+    el.setAttribute(attrName, attrValue);
+    return el;
+  }
+  createStyleElement(css: string, doc = document): HTMLStyleElement {
+    const style = <HTMLStyleElement>doc.createElement('style');
+    this.appendChild(style, this.createTextNode(css));
+    return style;
+  }
+  createShadowRoot(el: HTMLElement): DocumentFragment { return (<any>el).createShadowRoot(); }
+  getShadowRoot(el: HTMLElement): DocumentFragment { return (<any>el).shadowRoot; }
+  getHost(el: HTMLElement): HTMLElement { return (<any>el).host; }
+  clone(node: Node): Node { return node.cloneNode(true); }
+  getElementsByClassName(element: any, name: string): HTMLElement[] {
+    return element.getElementsByClassName(name);
+  }
+  getElementsByTagName(element: any, name: string): HTMLElement[] {
+    return element.getElementsByTagName(name);
+  }
+  classList(element: any): any[] { return Array.prototype.slice.call(element.classList, 0); }
+  addClass(element: any, className: string) { element.classList.add(className); }
+  removeClass(element: any, className: string) { element.classList.remove(className); }
+  hasClass(element: any, className: string): boolean {
+    return element.classList.contains(className);
+  }
+  setStyle(element: any, styleName: string, styleValue: string) {
+    element.style[styleName] = styleValue;
+  }
+  removeStyle(element: any, stylename: string) {
+    // IE requires '' instead of null
+    // see https://github.com/angular/angular/issues/7916
+    element.style[stylename] = '';
+  }
+  getStyle(element: any, stylename: string): string { return element.style[stylename]; }
+  hasStyle(element: any, styleName: string, styleValue?: string|null): boolean {
+    const value = this.getStyle(element, styleName) || '';
+    return styleValue ? value == styleValue : value.length > 0;
+  }
+  tagName(element: any): string { return element.tagName; }
+  attributeMap(element: any): Map<string, string> {
+    const res = new Map<string, string>();
+    const elAttrs = element.attributes;
+    for (let i = 0; i < elAttrs.length; i++) {
+      const attrib = elAttrs[i];
+      res.set(attrib.name, attrib.value);
+    }
+    return res;
+  }
+  hasAttribute(element: Element, attribute: string): boolean {
+    return element.hasAttribute(attribute);
+  }
+  hasAttributeNS(element: Element, ns: string, attribute: string): boolean {
+    return element.hasAttributeNS(ns, attribute);
+  }
+  getAttribute(element: Element, attribute: string): string|null {
+    return element.getAttribute(attribute);
+  }
+  getAttributeNS(element: Element, ns: string, name: string): string {
+    return element.getAttributeNS(ns, name);
+  }
+  setAttribute(element: Element, name: string, value: string) { element.setAttribute(name, value); }
+  setAttributeNS(element: Element, ns: string, name: string, value: string) {
+    element.setAttributeNS(ns, name, value);
+  }
+  removeAttribute(element: Element, attribute: string) { element.removeAttribute(attribute); }
+  removeAttributeNS(element: Element, ns: string, name: string) {
+    element.removeAttributeNS(ns, name);
+  }
+  templateAwareRoot(el: Node): any { return this.isTemplateElement(el) ? this.content(el) : el; }
+  createHtmlDocument(): HTMLDocument {
+    return document.implementation.createHTMLDocument('fakeTitle');
+  }
+  getBoundingClientRect(el: Element): any {
+    try {
+      return el.getBoundingClientRect();
+    } catch (e) {
+      return {top: 0, bottom: 0, left: 0, right: 0, width: 0, height: 0};
+    }
+  }
+  getTitle(doc: Document): string { return document.title; }
+  setTitle(doc: Document, newTitle: string) { document.title = newTitle || ''; }
+  elementMatches(n: any, selector: string): boolean {
+    if (n instanceof HTMLElement) {
+      return n.matches && n.matches(selector) ||
+          n.msMatchesSelector && n.msMatchesSelector(selector) ||
+          n.webkitMatchesSelector && n.webkitMatchesSelector(selector);
+    }
+
+    return false;
+  }
+  isTemplateElement(el: Node): boolean {
+    return el instanceof HTMLElement && el.nodeName == 'TEMPLATE';
+  }
+  isTextNode(node: Node): boolean { return node.nodeType === Node.TEXT_NODE; }
+  isCommentNode(node: Node): boolean { return node.nodeType === Node.COMMENT_NODE; }
+  isElementNode(node: Node): boolean { return node.nodeType === Node.ELEMENT_NODE; }
+  hasShadowRoot(node: any): boolean {
+    return node.shadowRoot != null && node instanceof HTMLElement;
+  }
+  isShadowRoot(node: any): boolean { return node instanceof DocumentFragment; }
+  importIntoDoc(node: Node): any { return document.importNode(this.templateAwareRoot(node), true); }
+  adoptNode(node: Node): any { return document.adoptNode(node); }
+  getHref(el: Element): string { return (<any>el).href; }
+
+  getEventKey(event: any): string {
+    let key = event.key;
+    if (key == null) {
+      key = event.keyIdentifier;
+      // keyIdentifier is defined in the old draft of DOM Level 3 Events implemented by Chrome and
+      // Safari cf
+      // http://www.w3.org/TR/2007/WD-DOM-Level-3-Events-20071221/events.html#Events-KeyboardEvents-Interfaces
+      if (key == null) {
+        return 'Unidentified';
+      }
+      if (key.startsWith('U+')) {
+        key = String.fromCharCode(parseInt(key.substring(2), 16));
+        if (event.location === DOM_KEY_LOCATION_NUMPAD && _chromeNumKeyPadMap.hasOwnProperty(key)) {
+          // There is a bug in Chrome for numeric keypad keys:
+          // https://code.google.com/p/chromium/issues/detail?id=155654
+          // 1, 2, 3 ... are reported as A, B, C ...
+          key = (_chromeNumKeyPadMap as any)[key];
+        }
+      }
+    }
+
+    return _keyMap[key] || key;
+  }
+  getGlobalEventTarget(doc: Document, target: string): EventTarget|null {
+    if (target === 'window') {
+      return window;
+    }
+    if (target === 'document') {
+      return document;
+    }
+    if (target === 'body') {
+      return document.body;
+    }
+    return null;
+  }
+  getHistory(): History { return window.history; }
+  getLocation(): Location { return window.location; }
+  getBaseHref(doc: Document): string|null {
+    const href = getBaseElementHref();
+    return href == null ? null : relativePath(href);
+  }
+  resetBaseElement(): void { baseElement = null; }
+  getUserAgent(): string { return window.navigator.userAgent; }
+  setData(element: Element, name: string, value: string) {
+    this.setAttribute(element, 'data-' + name, value);
+  }
+  getData(element: Element, name: string): string|null {
+    return this.getAttribute(element, 'data-' + name);
+  }
+  getComputedStyle(element: any): any { return getComputedStyle(element); }
+  // TODO(tbosch): move this into a separate environment class once we have it
+  supportsWebAnimation(): boolean {
+    return typeof(<any>Element).prototype['animate'] === 'function';
+  }
+  performanceNow(): number {
+    // performance.now() is not available in all browsers, see
+    // http://caniuse.com/#search=performance.now
+    return window.performance && window.performance.now ? window.performance.now() :
+                                                          new Date().getTime();
+  }
+
+  supportsCookies(): boolean { return true; }
+
+  getCookie(name: string): string|null { return parseCookieValue(document.cookie, name); }
+
+  setCookie(name: string, value: string) {
+    // document.cookie is magical, assigning into it assigns/overrides one cookie value, but does
+    // not clear other cookies.
+    document.cookie = encodeURIComponent(name) + '=' + encodeURIComponent(value);
+  }
+}
+
+let baseElement: HTMLElement|null = null;
+function getBaseElementHref(): string|null {
+  if (!baseElement) {
+    baseElement = document.querySelector('base') !;
+    if (!baseElement) {
+      return null;
+    }
+  }
+  return baseElement.getAttribute('href');
+}
+
+// based on urlUtils.js in AngularJS 1
+let urlParsingNode: any;
+function relativePath(url: any): string {
+  if (!urlParsingNode) {
+    urlParsingNode = document.createElement('a');
+  }
+  urlParsingNode.setAttribute('href', url);
+  return (urlParsingNode.pathname.charAt(0) === '/') ? urlParsingNode.pathname :
+                                                       '/' + urlParsingNode.pathname;
+}
diff --git a/angular/platform-browser/src/browser/generic_browser_adapter.ts b/angular/platform-browser/src/browser/generic_browser_adapter.ts
new file mode 100644
index 0000000..9e63191
--- /dev/null
+++ b/angular/platform-browser/src/browser/generic_browser_adapter.ts
@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {DomAdapter} from '../dom/dom_adapter';
+
+
+
+/**
+ * Provides DOM operations in any browser environment.
+ *
+ * @security Tread carefully! Interacting with the DOM directly is dangerous and
+ * can introduce XSS risks.
+ */
+export abstract class GenericBrowserDomAdapter extends DomAdapter {
+  private _animationPrefix: string|null = null;
+  private _transitionEnd: string|null = null;
+  constructor() {
+    super();
+    try {
+      const element = this.createElement('div', document);
+      if (this.getStyle(element, 'animationName') != null) {
+        this._animationPrefix = '';
+      } else {
+        const domPrefixes = ['Webkit', 'Moz', 'O', 'ms'];
+
+        for (let i = 0; i < domPrefixes.length; i++) {
+          if (this.getStyle(element, domPrefixes[i] + 'AnimationName') != null) {
+            this._animationPrefix = '-' + domPrefixes[i].toLowerCase() + '-';
+            break;
+          }
+        }
+      }
+
+      const transEndEventNames: {[key: string]: string} = {
+        WebkitTransition: 'webkitTransitionEnd',
+        MozTransition: 'transitionend',
+        OTransition: 'oTransitionEnd otransitionend',
+        transition: 'transitionend'
+      };
+
+      Object.keys(transEndEventNames).forEach((key: string) => {
+        if (this.getStyle(element, key) != null) {
+          this._transitionEnd = transEndEventNames[key];
+        }
+      });
+    } catch (e) {
+      this._animationPrefix = null;
+      this._transitionEnd = null;
+    }
+  }
+
+  getDistributedNodes(el: HTMLElement): Node[] { return (<any>el).getDistributedNodes(); }
+  resolveAndSetHref(el: HTMLAnchorElement, baseUrl: string, href: string) {
+    el.href = href == null ? baseUrl : baseUrl + '/../' + href;
+  }
+  supportsDOMEvents(): boolean { return true; }
+  supportsNativeShadowDOM(): boolean {
+    return typeof(<any>document.body).createShadowRoot === 'function';
+  }
+  getAnimationPrefix(): string { return this._animationPrefix ? this._animationPrefix : ''; }
+  getTransitionEnd(): string { return this._transitionEnd ? this._transitionEnd : ''; }
+  supportsAnimation(): boolean {
+    return this._animationPrefix != null && this._transitionEnd != null;
+  }
+}
diff --git a/angular/platform-browser/src/browser/location/browser_platform_location.ts b/angular/platform-browser/src/browser/location/browser_platform_location.ts
new file mode 100644
index 0000000..45f6ef4
--- /dev/null
+++ b/angular/platform-browser/src/browser/location/browser_platform_location.ts
@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {LocationChangeListener, PlatformLocation} from '@angular/common';
+import {Inject, Injectable} from '@angular/core';
+
+import {getDOM} from '../../dom/dom_adapter';
+import {DOCUMENT} from '../../dom/dom_tokens';
+
+import {supportsState} from './history';
+
+
+
+/**
+ * `PlatformLocation` encapsulates all of the direct calls to platform APIs.
+ * This class should not be used directly by an application developer. Instead, use
+ * {@link Location}.
+ */
+@Injectable()
+export class BrowserPlatformLocation extends PlatformLocation {
+  private _location: Location;
+  private _history: History;
+
+  constructor(@Inject(DOCUMENT) private _doc: any) {
+    super();
+    this._init();
+  }
+
+  // This is moved to its own method so that `MockPlatformLocationStrategy` can overwrite it
+  /** @internal */
+  _init() {
+    this._location = getDOM().getLocation();
+    this._history = getDOM().getHistory();
+  }
+
+  get location(): Location { return this._location; }
+
+  getBaseHrefFromDOM(): string { return getDOM().getBaseHref(this._doc) !; }
+
+  onPopState(fn: LocationChangeListener): void {
+    getDOM().getGlobalEventTarget(this._doc, 'window').addEventListener('popstate', fn, false);
+  }
+
+  onHashChange(fn: LocationChangeListener): void {
+    getDOM().getGlobalEventTarget(this._doc, 'window').addEventListener('hashchange', fn, false);
+  }
+
+  get pathname(): string { return this._location.pathname; }
+  get search(): string { return this._location.search; }
+  get hash(): string { return this._location.hash; }
+  set pathname(newPath: string) { this._location.pathname = newPath; }
+
+  pushState(state: any, title: string, url: string): void {
+    if (supportsState()) {
+      this._history.pushState(state, title, url);
+    } else {
+      this._location.hash = url;
+    }
+  }
+
+  replaceState(state: any, title: string, url: string): void {
+    if (supportsState()) {
+      this._history.replaceState(state, title, url);
+    } else {
+      this._location.hash = url;
+    }
+  }
+
+  forward(): void { this._history.forward(); }
+
+  back(): void { this._history.back(); }
+}
diff --git a/angular/platform-browser/src/browser/location/history.ts b/angular/platform-browser/src/browser/location/history.ts
new file mode 100644
index 0000000..b7b3f3f
--- /dev/null
+++ b/angular/platform-browser/src/browser/location/history.ts
@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export function supportsState(): boolean {
+  return !!window.history.pushState;
+}
\ No newline at end of file
diff --git a/angular/platform-browser/src/browser/meta.ts b/angular/platform-browser/src/browser/meta.ts
new file mode 100644
index 0000000..acc4308
--- /dev/null
+++ b/angular/platform-browser/src/browser/meta.ts
@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, Injectable} from '@angular/core';
+
+import {DomAdapter, getDOM} from '../dom/dom_adapter';
+import {DOCUMENT} from '../dom/dom_tokens';
+
+
+/**
+ * Represents a meta element.
+ *
+ * @experimental
+ */
+export type MetaDefinition = {
+  charset?: string; content?: string; httpEquiv?: string; id?: string; itemprop?: string;
+  name?: string;
+  property?: string;
+  scheme?: string;
+  url?: string;
+} &
+{
+  // TODO(IgorMinar): this type looks wrong
+  [prop: string]: string;
+};
+
+/**
+ * A service that can be used to get and add meta tags.
+ *
+ * @experimental
+ */
+@Injectable()
+export class Meta {
+  private _dom: DomAdapter;
+  constructor(@Inject(DOCUMENT) private _doc: any) { this._dom = getDOM(); }
+
+  addTag(tag: MetaDefinition, forceCreation: boolean = false): HTMLMetaElement|null {
+    if (!tag) return null;
+    return this._getOrCreateElement(tag, forceCreation);
+  }
+
+  addTags(tags: MetaDefinition[], forceCreation: boolean = false): HTMLMetaElement[] {
+    if (!tags) return [];
+    return tags.reduce((result: HTMLMetaElement[], tag: MetaDefinition) => {
+      if (tag) {
+        result.push(this._getOrCreateElement(tag, forceCreation));
+      }
+      return result;
+    }, []);
+  }
+
+  getTag(attrSelector: string): HTMLMetaElement|null {
+    if (!attrSelector) return null;
+    return this._dom.querySelector(this._doc, `meta[${attrSelector}]`);
+  }
+
+  getTags(attrSelector: string): HTMLMetaElement[] {
+    if (!attrSelector) return [];
+    const list /*NodeList*/ = this._dom.querySelectorAll(this._doc, `meta[${attrSelector}]`);
+    return list ? [].slice.call(list) : [];
+  }
+
+  updateTag(tag: MetaDefinition, selector?: string): HTMLMetaElement|null {
+    if (!tag) return null;
+    selector = selector || this._parseSelector(tag);
+    const meta: HTMLMetaElement = this.getTag(selector) !;
+    if (meta) {
+      return this._setMetaElementAttributes(tag, meta);
+    }
+    return this._getOrCreateElement(tag, true);
+  }
+
+  removeTag(attrSelector: string): void { this.removeTagElement(this.getTag(attrSelector) !); }
+
+  removeTagElement(meta: HTMLMetaElement): void {
+    if (meta) {
+      this._dom.remove(meta);
+    }
+  }
+
+  private _getOrCreateElement(meta: MetaDefinition, forceCreation: boolean = false):
+      HTMLMetaElement {
+    if (!forceCreation) {
+      const selector: string = this._parseSelector(meta);
+      const elem: HTMLMetaElement = this.getTag(selector) !;
+      // It's allowed to have multiple elements with the same name so it's not enough to
+      // just check that element with the same name already present on the page. We also need to
+      // check if element has tag attributes
+      if (elem && this._containsAttributes(meta, elem)) return elem;
+    }
+    const element: HTMLMetaElement = this._dom.createElement('meta') as HTMLMetaElement;
+    this._setMetaElementAttributes(meta, element);
+    const head = this._dom.getElementsByTagName(this._doc, 'head')[0];
+    this._dom.appendChild(head, element);
+    return element;
+  }
+
+  private _setMetaElementAttributes(tag: MetaDefinition, el: HTMLMetaElement): HTMLMetaElement {
+    Object.keys(tag).forEach((prop: string) => this._dom.setAttribute(el, prop, tag[prop]));
+    return el;
+  }
+
+  private _parseSelector(tag: MetaDefinition): string {
+    const attr: string = tag.name ? 'name' : 'property';
+    return `${attr}="${tag[attr]}"`;
+  }
+
+  private _containsAttributes(tag: MetaDefinition, elem: HTMLMetaElement): boolean {
+    return Object.keys(tag).every((key: string) => this._dom.getAttribute(elem, key) === tag[key]);
+  }
+}
diff --git a/angular/platform-browser/src/browser/server-transition.ts b/angular/platform-browser/src/browser/server-transition.ts
new file mode 100644
index 0000000..fde6a70
--- /dev/null
+++ b/angular/platform-browser/src/browser/server-transition.ts
@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {APP_INITIALIZER, ApplicationInitStatus, Inject, InjectionToken, Injector, StaticProvider} from '@angular/core';
+
+import {getDOM} from '../dom/dom_adapter';
+import {DOCUMENT} from '../dom/dom_tokens';
+
+/**
+ * An id that identifies a particular application being bootstrapped, that should
+ * match across the client/server boundary.
+ */
+export const TRANSITION_ID = new InjectionToken('TRANSITION_ID');
+
+export function appInitializerFactory(transitionId: string, document: any, injector: Injector) {
+  return () => {
+    // Wait for all application initializers to be completed before removing the styles set by
+    // the server.
+    injector.get(ApplicationInitStatus).donePromise.then(() => {
+      const dom = getDOM();
+      const styles: any[] =
+          Array.prototype.slice.apply(dom.querySelectorAll(document, `style[ng-transition]`));
+      styles.filter(el => dom.getAttribute(el, 'ng-transition') === transitionId)
+          .forEach(el => dom.remove(el));
+    });
+  };
+}
+
+export const SERVER_TRANSITION_PROVIDERS: StaticProvider[] = [
+  {
+    provide: APP_INITIALIZER,
+    useFactory: appInitializerFactory,
+    deps: [TRANSITION_ID, DOCUMENT, Injector],
+    multi: true
+  },
+];
diff --git a/angular/platform-browser/src/browser/testability.ts b/angular/platform-browser/src/browser/testability.ts
new file mode 100644
index 0000000..c057ed0
--- /dev/null
+++ b/angular/platform-browser/src/browser/testability.ts
@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {GetTestability, Testability, TestabilityRegistry, setTestabilityGetter, ɵglobal as global} from '@angular/core';
+
+import {getDOM} from '../dom/dom_adapter';
+
+export class BrowserGetTestability implements GetTestability {
+  static init() { setTestabilityGetter(new BrowserGetTestability()); }
+
+  addToWindow(registry: TestabilityRegistry): void {
+    global['getAngularTestability'] = (elem: any, findInAncestors: boolean = true) => {
+      const testability = registry.findTestabilityInTree(elem, findInAncestors);
+      if (testability == null) {
+        throw new Error('Could not find testability for element.');
+      }
+      return testability;
+    };
+
+    global['getAllAngularTestabilities'] = () => registry.getAllTestabilities();
+
+    global['getAllAngularRootElements'] = () => registry.getAllRootElements();
+
+    const whenAllStable = (callback: any /** TODO #9100 */) => {
+      const testabilities = global['getAllAngularTestabilities']();
+      let count = testabilities.length;
+      let didWork = false;
+      const decrement = function(didWork_: any /** TODO #9100 */) {
+        didWork = didWork || didWork_;
+        count--;
+        if (count == 0) {
+          callback(didWork);
+        }
+      };
+      testabilities.forEach(function(testability: any /** TODO #9100 */) {
+        testability.whenStable(decrement);
+      });
+    };
+
+    if (!global['frameworkStabilizers']) {
+      global['frameworkStabilizers'] = [];
+    }
+    global['frameworkStabilizers'].push(whenAllStable);
+  }
+
+  findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean):
+      Testability|null {
+    if (elem == null) {
+      return null;
+    }
+    const t = registry.getTestability(elem);
+    if (t != null) {
+      return t;
+    } else if (!findInAncestors) {
+      return null;
+    }
+    if (getDOM().isShadowRoot(elem)) {
+      return this.findTestabilityInTree(registry, getDOM().getHost(elem), true);
+    }
+    return this.findTestabilityInTree(registry, getDOM().parentElement(elem), true);
+  }
+}
diff --git a/angular/platform-browser/src/browser/title.ts b/angular/platform-browser/src/browser/title.ts
new file mode 100644
index 0000000..2ca7ba5
--- /dev/null
+++ b/angular/platform-browser/src/browser/title.ts
@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, Injectable} from '@angular/core';
+
+import {getDOM} from '../dom/dom_adapter';
+import {DOCUMENT} from '../dom/dom_tokens';
+
+
+/**
+ * A service that can be used to get and set the title of a current HTML document.
+ *
+ * Since an Angular application can't be bootstrapped on the entire HTML document (`<html>` tag)
+ * it is not possible to bind to the `text` property of the `HTMLTitleElement` elements
+ * (representing the `<title>` tag). Instead, this service can be used to set and get the current
+ * title value.
+ *
+ * @experimental
+ */
+@Injectable()
+export class Title {
+  constructor(@Inject(DOCUMENT) private _doc: any) {}
+  /**
+   * Get the title of the current HTML document.
+   */
+  getTitle(): string { return getDOM().getTitle(this._doc); }
+
+  /**
+   * Set the title of the current HTML document.
+   * @param newTitle
+   */
+  setTitle(newTitle: string) { getDOM().setTitle(this._doc, newTitle); }
+}
diff --git a/angular/platform-browser/src/browser/tools/browser.ts b/angular/platform-browser/src/browser/tools/browser.ts
new file mode 100644
index 0000000..2f233c4
--- /dev/null
+++ b/angular/platform-browser/src/browser/tools/browser.ts
@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+const win = typeof window !== 'undefined' && window || <any>{};
+export {win as window};
diff --git a/angular/platform-browser/src/browser/tools/common_tools.ts b/angular/platform-browser/src/browser/tools/common_tools.ts
new file mode 100644
index 0000000..f4f7d05
--- /dev/null
+++ b/angular/platform-browser/src/browser/tools/common_tools.ts
@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ApplicationRef, ComponentRef} from '@angular/core';
+import {getDOM} from '../../dom/dom_adapter';
+import {window} from './browser';
+
+export class ChangeDetectionPerfRecord {
+  constructor(public msPerTick: number, public numTicks: number) {}
+}
+
+/**
+ * Entry point for all Angular profiling-related debug tools. This object
+ * corresponds to the `ng.profiler` in the dev console.
+ */
+export class AngularProfiler {
+  appRef: ApplicationRef;
+
+  constructor(ref: ComponentRef<any>) { this.appRef = ref.injector.get(ApplicationRef); }
+
+  // tslint:disable:no-console
+  /**
+   * Exercises change detection in a loop and then prints the average amount of
+   * time in milliseconds how long a single round of change detection takes for
+   * the current state of the UI. It runs a minimum of 5 rounds for a minimum
+   * of 500 milliseconds.
+   *
+   * Optionally, a user may pass a `config` parameter containing a map of
+   * options. Supported options are:
+   *
+   * `record` (boolean) - causes the profiler to record a CPU profile while
+   * it exercises the change detector. Example:
+   *
+   * ```
+   * ng.profiler.timeChangeDetection({record: true})
+   * ```
+   */
+  timeChangeDetection(config: any): ChangeDetectionPerfRecord {
+    const record = config && config['record'];
+    const profileName = 'Change Detection';
+    // Profiler is not available in Android browsers, nor in IE 9 without dev tools opened
+    const isProfilerAvailable = window.console.profile != null;
+    if (record && isProfilerAvailable) {
+      window.console.profile(profileName);
+    }
+    const start = getDOM().performanceNow();
+    let numTicks = 0;
+    while (numTicks < 5 || (getDOM().performanceNow() - start) < 500) {
+      this.appRef.tick();
+      numTicks++;
+    }
+    const end = getDOM().performanceNow();
+    if (record && isProfilerAvailable) {
+      // need to cast to <any> because type checker thinks there's no argument
+      // while in fact there is:
+      //
+      // https://developer.mozilla.org/en-US/docs/Web/API/Console/profileEnd
+      (<any>window.console.profileEnd)(profileName);
+    }
+    const msPerTick = (end - start) / numTicks;
+    window.console.log(`ran ${numTicks} change detection cycles`);
+    window.console.log(`${msPerTick.toFixed(2)} ms per check`);
+
+    return new ChangeDetectionPerfRecord(msPerTick, numTicks);
+  }
+}
diff --git a/angular/platform-browser/src/browser/tools/tools.ts b/angular/platform-browser/src/browser/tools/tools.ts
new file mode 100644
index 0000000..1ebbbb1
--- /dev/null
+++ b/angular/platform-browser/src/browser/tools/tools.ts
@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ComponentRef} from '@angular/core';
+import {exportNgVar} from '../../dom/util';
+import {AngularProfiler} from './common_tools';
+
+const PROFILER_GLOBAL_NAME = 'profiler';
+
+/**
+ * Enabled Angular debug tools that are accessible via your browser's
+ * developer console.
+ *
+ * Usage:
+ *
+ * 1. Open developer console (e.g. in Chrome Ctrl + Shift + j)
+ * 1. Type `ng.` (usually the console will show auto-complete suggestion)
+ * 1. Try the change detection profiler `ng.profiler.timeChangeDetection()`
+ *    then hit Enter.
+ *
+ * @experimental All debugging apis are currently experimental.
+ */
+export function enableDebugTools<T>(ref: ComponentRef<T>): ComponentRef<T> {
+  exportNgVar(PROFILER_GLOBAL_NAME, new AngularProfiler(ref));
+  return ref;
+}
+
+/**
+ * Disables Angular tools.
+ *
+ * @experimental All debugging apis are currently experimental.
+ */
+export function disableDebugTools(): void {
+  exportNgVar(PROFILER_GLOBAL_NAME, null);
+}
diff --git a/angular/platform-browser/src/dom/debug/by.ts b/angular/platform-browser/src/dom/debug/by.ts
new file mode 100644
index 0000000..866885c
--- /dev/null
+++ b/angular/platform-browser/src/dom/debug/by.ts
@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {DebugElement, Predicate, Type} from '@angular/core';
+import {getDOM} from '../../dom/dom_adapter';
+
+
+
+/**
+ * Predicates for use with {@link DebugElement}'s query functions.
+ *
+ * @experimental All debugging apis are currently experimental.
+ */
+export class By {
+  /**
+   * Match all elements.
+   *
+   * ## Example
+   *
+   * {@example platform-browser/dom/debug/ts/by/by.ts region='by_all'}
+   */
+  static all(): Predicate<DebugElement> { return (debugElement) => true; }
+
+  /**
+   * Match elements by the given CSS selector.
+   *
+   * ## Example
+   *
+   * {@example platform-browser/dom/debug/ts/by/by.ts region='by_css'}
+   */
+  static css(selector: string): Predicate<DebugElement> {
+    return (debugElement) => {
+      return debugElement.nativeElement != null ?
+          getDOM().elementMatches(debugElement.nativeElement, selector) :
+          false;
+    };
+  }
+
+  /**
+   * Match elements that have the given directive present.
+   *
+   * ## Example
+   *
+   * {@example platform-browser/dom/debug/ts/by/by.ts region='by_directive'}
+   */
+  static directive(type: Type<any>): Predicate<DebugElement> {
+    return (debugElement) => debugElement.providerTokens !.indexOf(type) !== -1;
+  }
+}
diff --git a/angular/platform-browser/src/dom/debug/ng_probe.ts b/angular/platform-browser/src/dom/debug/ng_probe.ts
new file mode 100644
index 0000000..e74b9cb
--- /dev/null
+++ b/angular/platform-browser/src/dom/debug/ng_probe.ts
@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as core from '@angular/core';
+import {exportNgVar} from '../util';
+
+const CORE_TOKENS = {
+  'ApplicationRef': core.ApplicationRef,
+  'NgZone': core.NgZone,
+};
+
+const INSPECT_GLOBAL_NAME = 'probe';
+const CORE_TOKENS_GLOBAL_NAME = 'coreTokens';
+
+/**
+ * Returns a {@link DebugElement} for the given native DOM element, or
+ * null if the given native element does not have an Angular view associated
+ * with it.
+ */
+export function inspectNativeElement(element: any): core.DebugNode|null {
+  return core.getDebugNode(element);
+}
+
+/**
+ * Deprecated. Use the one from '@angular/core'.
+ * @deprecated
+ */
+export class NgProbeToken {
+  constructor(public name: string, public token: any) {}
+}
+
+export function _createNgProbe(extraTokens: NgProbeToken[], coreTokens: core.NgProbeToken[]): any {
+  const tokens = (extraTokens || []).concat(coreTokens || []);
+  exportNgVar(INSPECT_GLOBAL_NAME, inspectNativeElement);
+  exportNgVar(CORE_TOKENS_GLOBAL_NAME, {...CORE_TOKENS, ..._ngProbeTokensToMap(tokens || [])});
+  return () => inspectNativeElement;
+}
+
+function _ngProbeTokensToMap(tokens: NgProbeToken[]): {[name: string]: any} {
+  return tokens.reduce((prev: any, t: any) => (prev[t.name] = t.token, prev), {});
+}
+
+/**
+ * Providers which support debugging Angular applications (e.g. via `ng.probe`).
+ */
+export const ELEMENT_PROBE_PROVIDERS: core.Provider[] = [
+  {
+    provide: core.APP_INITIALIZER,
+    useFactory: _createNgProbe,
+    deps: [
+      [NgProbeToken, new core.Optional()],
+      [core.NgProbeToken, new core.Optional()],
+    ],
+    multi: true,
+  },
+];
diff --git a/angular/platform-browser/src/dom/dom_adapter.ts b/angular/platform-browser/src/dom/dom_adapter.ts
new file mode 100644
index 0000000..922aca5
--- /dev/null
+++ b/angular/platform-browser/src/dom/dom_adapter.ts
@@ -0,0 +1,163 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Type} from '@angular/core';
+
+let _DOM: DomAdapter = null !;
+
+export function getDOM() {
+  return _DOM;
+}
+
+export function setDOM(adapter: DomAdapter) {
+  _DOM = adapter;
+}
+
+export function setRootDomAdapter(adapter: DomAdapter) {
+  if (!_DOM) {
+    _DOM = adapter;
+  }
+}
+
+/* tslint:disable:requireParameterType */
+/**
+ * Provides DOM operations in an environment-agnostic way.
+ *
+ * @security Tread carefully! Interacting with the DOM directly is dangerous and
+ * can introduce XSS risks.
+ */
+export abstract class DomAdapter {
+  public resourceLoaderType: Type<any> = null !;
+  abstract hasProperty(element: any, name: string): boolean;
+  abstract setProperty(el: Element, name: string, value: any): any;
+  abstract getProperty(el: Element, name: string): any;
+  abstract invoke(el: Element, methodName: string, args: any[]): any;
+
+  abstract logError(error: any): any;
+  abstract log(error: any): any;
+  abstract logGroup(error: any): any;
+  abstract logGroupEnd(): any;
+
+  /**
+   * Maps attribute names to their corresponding property names for cases
+   * where attribute name doesn't match property name.
+   */
+  get attrToPropMap(): {[key: string]: string} { return this._attrToPropMap; };
+  set attrToPropMap(value: {[key: string]: string}) { this._attrToPropMap = value; };
+  /** @internal */
+  _attrToPropMap: {[key: string]: string};
+
+  abstract contains(nodeA: any, nodeB: any): boolean;
+  abstract parse(templateHtml: string): any;
+  abstract querySelector(el: any, selector: string): any;
+  abstract querySelectorAll(el: any, selector: string): any[];
+  abstract on(el: any, evt: any, listener: any): any;
+  abstract onAndCancel(el: any, evt: any, listener: any): Function;
+  abstract dispatchEvent(el: any, evt: any): any;
+  abstract createMouseEvent(eventType: any): any;
+  abstract createEvent(eventType: string): any;
+  abstract preventDefault(evt: any): any;
+  abstract isPrevented(evt: any): boolean;
+  abstract getInnerHTML(el: any): string;
+  /** Returns content if el is a <template> element, null otherwise. */
+  abstract getTemplateContent(el: any): any;
+  abstract getOuterHTML(el: any): string;
+  abstract nodeName(node: any): string;
+  abstract nodeValue(node: any): string|null;
+  abstract type(node: any): string;
+  abstract content(node: any): any;
+  abstract firstChild(el: any): Node|null;
+  abstract nextSibling(el: any): Node|null;
+  abstract parentElement(el: any): Node|null;
+  abstract childNodes(el: any): Node[];
+  abstract childNodesAsList(el: any): Node[];
+  abstract clearNodes(el: any): any;
+  abstract appendChild(el: any, node: any): any;
+  abstract removeChild(el: any, node: any): any;
+  abstract replaceChild(el: any, newNode: any, oldNode: any): any;
+  abstract remove(el: any): Node;
+  abstract insertBefore(parent: any, ref: any, node: any): any;
+  abstract insertAllBefore(parent: any, ref: any, nodes: any): any;
+  abstract insertAfter(parent: any, el: any, node: any): any;
+  abstract setInnerHTML(el: any, value: any): any;
+  abstract getText(el: any): string|null;
+  abstract setText(el: any, value: string): any;
+  abstract getValue(el: any): string;
+  abstract setValue(el: any, value: string): any;
+  abstract getChecked(el: any): boolean;
+  abstract setChecked(el: any, value: boolean): any;
+  abstract createComment(text: string): any;
+  abstract createTemplate(html: any): HTMLElement;
+  abstract createElement(tagName: any, doc?: any): HTMLElement;
+  abstract createElementNS(ns: string, tagName: string, doc?: any): Element;
+  abstract createTextNode(text: string, doc?: any): Text;
+  abstract createScriptTag(attrName: string, attrValue: string, doc?: any): HTMLElement;
+  abstract createStyleElement(css: string, doc?: any): HTMLStyleElement;
+  abstract createShadowRoot(el: any): any;
+  abstract getShadowRoot(el: any): any;
+  abstract getHost(el: any): any;
+  abstract getDistributedNodes(el: any): Node[];
+  abstract clone /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/;
+  abstract getElementsByClassName(element: any, name: string): HTMLElement[];
+  abstract getElementsByTagName(element: any, name: string): HTMLElement[];
+  abstract classList(element: any): any[];
+  abstract addClass(element: any, className: string): any;
+  abstract removeClass(element: any, className: string): any;
+  abstract hasClass(element: any, className: string): boolean;
+  abstract setStyle(element: any, styleName: string, styleValue: string): any;
+  abstract removeStyle(element: any, styleName: string): any;
+  abstract getStyle(element: any, styleName: string): string;
+  abstract hasStyle(element: any, styleName: string, styleValue?: string): boolean;
+  abstract tagName(element: any): string;
+  abstract attributeMap(element: any): Map<string, string>;
+  abstract hasAttribute(element: any, attribute: string): boolean;
+  abstract hasAttributeNS(element: any, ns: string, attribute: string): boolean;
+  abstract getAttribute(element: any, attribute: string): string|null;
+  abstract getAttributeNS(element: any, ns: string, attribute: string): string;
+  abstract setAttribute(element: any, name: string, value: string): any;
+  abstract setAttributeNS(element: any, ns: string, name: string, value: string): any;
+  abstract removeAttribute(element: any, attribute: string): any;
+  abstract removeAttributeNS(element: any, ns: string, attribute: string): any;
+  abstract templateAwareRoot(el: any): any;
+  abstract createHtmlDocument(): HTMLDocument;
+  abstract getBoundingClientRect(el: any): any;
+  abstract getTitle(doc: Document): string;
+  abstract setTitle(doc: Document, newTitle: string): any;
+  abstract elementMatches(n: any, selector: string): boolean;
+  abstract isTemplateElement(el: any): boolean;
+  abstract isTextNode(node: any): boolean;
+  abstract isCommentNode(node: any): boolean;
+  abstract isElementNode(node: any): boolean;
+  abstract hasShadowRoot(node: any): boolean;
+  abstract isShadowRoot(node: any): boolean;
+  abstract importIntoDoc /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/;
+  abstract adoptNode /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/;
+  abstract getHref(element: any): string;
+  abstract getEventKey(event: any): string;
+  abstract resolveAndSetHref(element: any, baseUrl: string, href: string): any;
+  abstract supportsDOMEvents(): boolean;
+  abstract supportsNativeShadowDOM(): boolean;
+  abstract getGlobalEventTarget(doc: Document, target: string): any;
+  abstract getHistory(): History;
+  abstract getLocation(): Location;
+  abstract getBaseHref(doc: Document): string|null;
+  abstract resetBaseElement(): void;
+  abstract getUserAgent(): string;
+  abstract setData(element: any, name: string, value: string): any;
+  abstract getComputedStyle(element: any): any;
+  abstract getData(element: any, name: string): string|null;
+  abstract supportsWebAnimation(): boolean;
+  abstract performanceNow(): number;
+  abstract getAnimationPrefix(): string;
+  abstract getTransitionEnd(): string;
+  abstract supportsAnimation(): boolean;
+
+  abstract supportsCookies(): boolean;
+  abstract getCookie(name: string): string|null;
+  abstract setCookie(name: string, value: string): any;
+}
diff --git a/angular/platform-browser/src/dom/dom_renderer.ts b/angular/platform-browser/src/dom/dom_renderer.ts
new file mode 100644
index 0000000..221b994
--- /dev/null
+++ b/angular/platform-browser/src/dom/dom_renderer.ts
@@ -0,0 +1,285 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injectable, Renderer2, RendererFactory2, RendererStyleFlags2, RendererType2, ViewEncapsulation} from '@angular/core';
+
+import {EventManager} from './events/event_manager';
+import {DomSharedStylesHost} from './shared_styles_host';
+
+export const NAMESPACE_URIS: {[ns: string]: string} = {
+  'svg': 'http://www.w3.org/2000/svg',
+  'xhtml': 'http://www.w3.org/1999/xhtml',
+  'xlink': 'http://www.w3.org/1999/xlink',
+  'xml': 'http://www.w3.org/XML/1998/namespace',
+  'xmlns': 'http://www.w3.org/2000/xmlns/',
+};
+
+const COMPONENT_REGEX = /%COMP%/g;
+export const COMPONENT_VARIABLE = '%COMP%';
+export const HOST_ATTR = `_nghost-${COMPONENT_VARIABLE}`;
+export const CONTENT_ATTR = `_ngcontent-${COMPONENT_VARIABLE}`;
+
+export function shimContentAttribute(componentShortId: string): string {
+  return CONTENT_ATTR.replace(COMPONENT_REGEX, componentShortId);
+}
+
+export function shimHostAttribute(componentShortId: string): string {
+  return HOST_ATTR.replace(COMPONENT_REGEX, componentShortId);
+}
+
+export function flattenStyles(
+    compId: string, styles: Array<any|any[]>, target: string[]): string[] {
+  for (let i = 0; i < styles.length; i++) {
+    let style = styles[i];
+
+    if (Array.isArray(style)) {
+      flattenStyles(compId, style, target);
+    } else {
+      style = style.replace(COMPONENT_REGEX, compId);
+      target.push(style);
+    }
+  }
+  return target;
+}
+
+function decoratePreventDefault(eventHandler: Function): Function {
+  return (event: any) => {
+    const allowDefaultBehavior = eventHandler(event);
+    if (allowDefaultBehavior === false) {
+      // TODO(tbosch): move preventDefault into event plugins...
+      event.preventDefault();
+      event.returnValue = false;
+    }
+  };
+}
+
+@Injectable()
+export class DomRendererFactory2 implements RendererFactory2 {
+  private rendererByCompId = new Map<string, Renderer2>();
+  private defaultRenderer: Renderer2;
+
+  constructor(private eventManager: EventManager, private sharedStylesHost: DomSharedStylesHost) {
+    this.defaultRenderer = new DefaultDomRenderer2(eventManager);
+  };
+
+  createRenderer(element: any, type: RendererType2|null): Renderer2 {
+    if (!element || !type) {
+      return this.defaultRenderer;
+    }
+    switch (type.encapsulation) {
+      case ViewEncapsulation.Emulated: {
+        let renderer = this.rendererByCompId.get(type.id);
+        if (!renderer) {
+          renderer =
+              new EmulatedEncapsulationDomRenderer2(this.eventManager, this.sharedStylesHost, type);
+          this.rendererByCompId.set(type.id, renderer);
+        }
+        (<EmulatedEncapsulationDomRenderer2>renderer).applyToHost(element);
+        return renderer;
+      }
+      case ViewEncapsulation.Native:
+        return new ShadowDomRenderer(this.eventManager, this.sharedStylesHost, element, type);
+      default: {
+        if (!this.rendererByCompId.has(type.id)) {
+          const styles = flattenStyles(type.id, type.styles, []);
+          this.sharedStylesHost.addStyles(styles);
+          this.rendererByCompId.set(type.id, this.defaultRenderer);
+        }
+        return this.defaultRenderer;
+      }
+    }
+  }
+
+  begin() {}
+  end() {}
+}
+
+class DefaultDomRenderer2 implements Renderer2 {
+  data: {[key: string]: any} = Object.create(null);
+
+  constructor(private eventManager: EventManager) {}
+
+  destroy(): void {}
+
+  destroyNode: null;
+
+  createElement(name: string, namespace?: string): any {
+    if (namespace) {
+      return document.createElementNS(NAMESPACE_URIS[namespace], name);
+    }
+
+    return document.createElement(name);
+  }
+
+  createComment(value: string): any { return document.createComment(value); }
+
+  createText(value: string): any { return document.createTextNode(value); }
+
+  appendChild(parent: any, newChild: any): void { parent.appendChild(newChild); }
+
+  insertBefore(parent: any, newChild: any, refChild: any): void {
+    if (parent) {
+      parent.insertBefore(newChild, refChild);
+    }
+  }
+
+  removeChild(parent: any, oldChild: any): void {
+    if (parent) {
+      parent.removeChild(oldChild);
+    }
+  }
+
+  selectRootElement(selectorOrNode: string|any): any {
+    let el: any = typeof selectorOrNode === 'string' ? document.querySelector(selectorOrNode) :
+                                                       selectorOrNode;
+    if (!el) {
+      throw new Error(`The selector "${selectorOrNode}" did not match any elements`);
+    }
+    el.textContent = '';
+    return el;
+  }
+
+  parentNode(node: any): any { return node.parentNode; }
+
+  nextSibling(node: any): any { return node.nextSibling; }
+
+  setAttribute(el: any, name: string, value: string, namespace?: string): void {
+    if (namespace) {
+      name = `${namespace}:${name}`;
+      const namespaceUri = NAMESPACE_URIS[namespace];
+      if (namespaceUri) {
+        el.setAttributeNS(namespaceUri, name, value);
+      } else {
+        el.setAttribute(name, value);
+      }
+    } else {
+      el.setAttribute(name, value);
+    }
+  }
+
+  removeAttribute(el: any, name: string, namespace?: string): void {
+    if (namespace) {
+      const namespaceUri = NAMESPACE_URIS[namespace];
+      if (namespaceUri) {
+        el.removeAttributeNS(namespaceUri, name);
+      } else {
+        el.removeAttribute(`${namespace}:${name}`);
+      }
+    } else {
+      el.removeAttribute(name);
+    }
+  }
+
+  addClass(el: any, name: string): void { el.classList.add(name); }
+
+  removeClass(el: any, name: string): void { el.classList.remove(name); }
+
+  setStyle(el: any, style: string, value: any, flags: RendererStyleFlags2): void {
+    if (flags & RendererStyleFlags2.DashCase) {
+      el.style.setProperty(
+          style, value, !!(flags & RendererStyleFlags2.Important) ? 'important' : '');
+    } else {
+      el.style[style] = value;
+    }
+  }
+
+  removeStyle(el: any, style: string, flags: RendererStyleFlags2): void {
+    if (flags & RendererStyleFlags2.DashCase) {
+      el.style.removeProperty(style);
+    } else {
+      // IE requires '' instead of null
+      // see https://github.com/angular/angular/issues/7916
+      el.style[style] = '';
+    }
+  }
+
+  setProperty(el: any, name: string, value: any): void {
+    checkNoSyntheticProp(name, 'property');
+    el[name] = value;
+  }
+
+  setValue(node: any, value: string): void { node.nodeValue = value; }
+
+  listen(target: 'window'|'document'|'body'|any, event: string, callback: (event: any) => boolean):
+      () => void {
+    checkNoSyntheticProp(event, 'listener');
+    if (typeof target === 'string') {
+      return <() => void>this.eventManager.addGlobalEventListener(
+          target, event, decoratePreventDefault(callback));
+    }
+    return <() => void>this.eventManager.addEventListener(
+               target, event, decoratePreventDefault(callback)) as() => void;
+  }
+}
+
+const AT_CHARCODE = '@'.charCodeAt(0);
+function checkNoSyntheticProp(name: string, nameKind: string) {
+  if (name.charCodeAt(0) === AT_CHARCODE) {
+    throw new Error(
+        `Found the synthetic ${nameKind} ${name}. Please include either "BrowserAnimationsModule" or "NoopAnimationsModule" in your application.`);
+  }
+}
+
+class EmulatedEncapsulationDomRenderer2 extends DefaultDomRenderer2 {
+  private contentAttr: string;
+  private hostAttr: string;
+
+  constructor(
+      eventManager: EventManager, sharedStylesHost: DomSharedStylesHost,
+      private component: RendererType2) {
+    super(eventManager);
+    const styles = flattenStyles(component.id, component.styles, []);
+    sharedStylesHost.addStyles(styles);
+
+    this.contentAttr = shimContentAttribute(component.id);
+    this.hostAttr = shimHostAttribute(component.id);
+  }
+
+  applyToHost(element: any) { super.setAttribute(element, this.hostAttr, ''); }
+
+  createElement(parent: any, name: string): Element {
+    const el = super.createElement(parent, name);
+    super.setAttribute(el, this.contentAttr, '');
+    return el;
+  }
+}
+
+class ShadowDomRenderer extends DefaultDomRenderer2 {
+  private shadowRoot: any;
+
+  constructor(
+      eventManager: EventManager, private sharedStylesHost: DomSharedStylesHost,
+      private hostEl: any, private component: RendererType2) {
+    super(eventManager);
+    this.shadowRoot = (hostEl as any).createShadowRoot();
+    this.sharedStylesHost.addHost(this.shadowRoot);
+    const styles = flattenStyles(component.id, component.styles, []);
+    for (let i = 0; i < styles.length; i++) {
+      const styleEl = document.createElement('style');
+      styleEl.textContent = styles[i];
+      this.shadowRoot.appendChild(styleEl);
+    }
+  }
+
+  private nodeOrShadowRoot(node: any): any { return node === this.hostEl ? this.shadowRoot : node; }
+
+  destroy() { this.sharedStylesHost.removeHost(this.shadowRoot); }
+
+  appendChild(parent: any, newChild: any): void {
+    return super.appendChild(this.nodeOrShadowRoot(parent), newChild);
+  }
+  insertBefore(parent: any, newChild: any, refChild: any): void {
+    return super.insertBefore(this.nodeOrShadowRoot(parent), newChild, refChild);
+  }
+  removeChild(parent: any, oldChild: any): void {
+    return super.removeChild(this.nodeOrShadowRoot(parent), oldChild);
+  }
+  parentNode(node: any): any {
+    return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(node)));
+  }
+}
diff --git a/angular/platform-browser/src/dom/dom_tokens.ts b/angular/platform-browser/src/dom/dom_tokens.ts
new file mode 100644
index 0000000..aa05acc
--- /dev/null
+++ b/angular/platform-browser/src/dom/dom_tokens.ts
@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {DOCUMENT as commonDOCUMENT} from '@angular/common';
+import {InjectionToken} from '@angular/core';
+
+
+/**
+ * A DI Token representing the main rendering context. In a browser this is the DOM Document.
+ *
+ * Note: Document might not be available in the Application Context when Application and Rendering
+ * Contexts are not the same (e.g. when running the application into a Web Worker).
+ *
+ * @deprecated import from `@angular/common` instead.
+ */
+export const DOCUMENT = commonDOCUMENT;
diff --git a/angular/platform-browser/src/dom/events/dom_events.ts b/angular/platform-browser/src/dom/events/dom_events.ts
new file mode 100644
index 0000000..3174a91
--- /dev/null
+++ b/angular/platform-browser/src/dom/events/dom_events.ts
@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, Injectable, NgZone, ɵglobal as global} from '@angular/core';
+
+import {DOCUMENT} from '../dom_tokens';
+
+import {EventManagerPlugin} from './event_manager';
+
+/**
+ * Detect if Zone is present. If it is then bypass 'addEventListener' since Angular can do much more
+ * efficient bookkeeping than Zone can, because we have additional information. This speeds up
+ * addEventListener by 3x.
+ */
+const Zone = global['Zone'];
+const __symbol__ = Zone && Zone['__symbol__'] || function<T>(v: T): T {
+  return v;
+};
+const ADD_EVENT_LISTENER: 'addEventListener' = __symbol__('addEventListener');
+const REMOVE_EVENT_LISTENER: 'removeEventListener' = __symbol__('removeEventListener');
+
+@Injectable()
+export class DomEventsPlugin extends EventManagerPlugin {
+  constructor(@Inject(DOCUMENT) doc: any, private ngZone: NgZone) { super(doc); }
+
+  // This plugin should come last in the list of plugins, because it accepts all
+  // events.
+  supports(eventName: string): boolean { return true; }
+
+  addEventListener(element: HTMLElement, eventName: string, handler: Function): Function {
+    /**
+     * This code is about to add a listener to the DOM. If Zone.js is present, than
+     * `addEventListener` has been patched. The patched code adds overhead in both
+     * memory and speed (3x slower) than native. For this reason if we detect that
+     * Zone.js is present we bypass zone and use native addEventListener instead.
+     * The result is faster registration but the zone will not be restored. We do
+     * manual zone restoration in element.ts renderEventHandlerClosure method.
+     *
+     * NOTE: it is possible that the element is from different iframe, and so we
+     * have to check before we execute the method.
+     */
+    const self = this;
+    let byPassZoneJS = element[ADD_EVENT_LISTENER];
+    let callback: EventListener = handler as EventListener;
+    if (byPassZoneJS) {
+      callback = function() {
+        return self.ngZone.runTask(handler as any, null, arguments as any, eventName);
+      };
+    }
+    element[byPassZoneJS ? ADD_EVENT_LISTENER : 'addEventListener'](eventName, callback, false);
+    return () => element[byPassZoneJS ? REMOVE_EVENT_LISTENER : 'removeEventListener'](
+               eventName, callback as any, false);
+  }
+}
diff --git a/angular/platform-browser/src/dom/events/event_manager.ts b/angular/platform-browser/src/dom/events/event_manager.ts
new file mode 100644
index 0000000..6254e1d
--- /dev/null
+++ b/angular/platform-browser/src/dom/events/event_manager.ts
@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, Injectable, InjectionToken, NgZone} from '@angular/core';
+
+import {getDOM} from '../dom_adapter';
+
+/**
+ * @stable
+ */
+export const EVENT_MANAGER_PLUGINS =
+    new InjectionToken<EventManagerPlugin[]>('EventManagerPlugins');
+
+/**
+ * @stable
+ */
+@Injectable()
+export class EventManager {
+  private _plugins: EventManagerPlugin[];
+  private _eventNameToPlugin = new Map<string, EventManagerPlugin>();
+
+  constructor(@Inject(EVENT_MANAGER_PLUGINS) plugins: EventManagerPlugin[], private _zone: NgZone) {
+    plugins.forEach(p => p.manager = this);
+    this._plugins = plugins.slice().reverse();
+  }
+
+  addEventListener(element: HTMLElement, eventName: string, handler: Function): Function {
+    const plugin = this._findPluginFor(eventName);
+    return plugin.addEventListener(element, eventName, handler);
+  }
+
+  addGlobalEventListener(target: string, eventName: string, handler: Function): Function {
+    const plugin = this._findPluginFor(eventName);
+    return plugin.addGlobalEventListener(target, eventName, handler);
+  }
+
+  getZone(): NgZone { return this._zone; }
+
+  /** @internal */
+  _findPluginFor(eventName: string): EventManagerPlugin {
+    const plugin = this._eventNameToPlugin.get(eventName);
+    if (plugin) {
+      return plugin;
+    }
+
+    const plugins = this._plugins;
+    for (let i = 0; i < plugins.length; i++) {
+      const plugin = plugins[i];
+      if (plugin.supports(eventName)) {
+        this._eventNameToPlugin.set(eventName, plugin);
+        return plugin;
+      }
+    }
+    throw new Error(`No event manager plugin found for event ${eventName}`);
+  }
+}
+
+export abstract class EventManagerPlugin {
+  constructor(private _doc: any) {}
+
+  manager: EventManager;
+
+  abstract supports(eventName: string): boolean;
+
+  abstract addEventListener(element: HTMLElement, eventName: string, handler: Function): Function;
+
+  addGlobalEventListener(element: string, eventName: string, handler: Function): Function {
+    const target: HTMLElement = getDOM().getGlobalEventTarget(this._doc, element);
+    if (!target) {
+      throw new Error(`Unsupported event target ${target} for event ${eventName}`);
+    }
+    return this.addEventListener(target, eventName, handler);
+  };
+}
diff --git a/angular/platform-browser/src/dom/events/hammer_gestures.ts b/angular/platform-browser/src/dom/events/hammer_gestures.ts
new file mode 100644
index 0000000..9969757
--- /dev/null
+++ b/angular/platform-browser/src/dom/events/hammer_gestures.ts
@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, Injectable, InjectionToken} from '@angular/core';
+
+import {DOCUMENT} from '../dom_tokens';
+
+import {EventManagerPlugin} from './event_manager';
+
+const EVENT_NAMES = {
+  // pan
+  'pan': true,
+  'panstart': true,
+  'panmove': true,
+  'panend': true,
+  'pancancel': true,
+  'panleft': true,
+  'panright': true,
+  'panup': true,
+  'pandown': true,
+  // pinch
+  'pinch': true,
+  'pinchstart': true,
+  'pinchmove': true,
+  'pinchend': true,
+  'pinchcancel': true,
+  'pinchin': true,
+  'pinchout': true,
+  // press
+  'press': true,
+  'pressup': true,
+  // rotate
+  'rotate': true,
+  'rotatestart': true,
+  'rotatemove': true,
+  'rotateend': true,
+  'rotatecancel': true,
+  // swipe
+  'swipe': true,
+  'swipeleft': true,
+  'swiperight': true,
+  'swipeup': true,
+  'swipedown': true,
+  // tap
+  'tap': true,
+};
+
+/**
+ * A DI token that you can use to provide{@link HammerGestureConfig} to Angular. Use it to configure
+ * Hammer gestures.
+ *
+ * @experimental
+ */
+export const HAMMER_GESTURE_CONFIG = new InjectionToken<HammerGestureConfig>('HammerGestureConfig');
+
+export interface HammerInstance {
+  on(eventName: string, callback?: Function): void;
+  off(eventName: string, callback?: Function): void;
+}
+
+/**
+ * @experimental
+ */
+@Injectable()
+export class HammerGestureConfig {
+  events: string[] = [];
+
+  overrides: {[key: string]: Object} = {};
+
+  buildHammer(element: HTMLElement): HammerInstance {
+    const mc = new Hammer(element);
+
+    mc.get('pinch').set({enable: true});
+    mc.get('rotate').set({enable: true});
+
+    for (const eventName in this.overrides) {
+      mc.get(eventName).set(this.overrides[eventName]);
+    }
+
+    return mc;
+  }
+}
+
+@Injectable()
+export class HammerGesturesPlugin extends EventManagerPlugin {
+  constructor(
+      @Inject(DOCUMENT) doc: any,
+      @Inject(HAMMER_GESTURE_CONFIG) private _config: HammerGestureConfig) {
+    super(doc);
+  }
+
+  supports(eventName: string): boolean {
+    if (!EVENT_NAMES.hasOwnProperty(eventName.toLowerCase()) && !this.isCustomEvent(eventName)) {
+      return false;
+    }
+
+    if (!(window as any).Hammer) {
+      throw new Error(`Hammer.js is not loaded, can not bind ${eventName} event`);
+    }
+
+    return true;
+  }
+
+  addEventListener(element: HTMLElement, eventName: string, handler: Function): Function {
+    const zone = this.manager.getZone();
+    eventName = eventName.toLowerCase();
+
+    return zone.runOutsideAngular(() => {
+      // Creating the manager bind events, must be done outside of angular
+      const mc = this._config.buildHammer(element);
+      const callback = function(eventObj: HammerInput) {
+        zone.runGuarded(function() { handler(eventObj); });
+      };
+      mc.on(eventName, callback);
+      return () => mc.off(eventName, callback);
+    });
+  }
+
+  isCustomEvent(eventName: string): boolean { return this._config.events.indexOf(eventName) > -1; }
+}
diff --git a/angular/platform-browser/src/dom/events/key_events.ts b/angular/platform-browser/src/dom/events/key_events.ts
new file mode 100644
index 0000000..5d0d7f2
--- /dev/null
+++ b/angular/platform-browser/src/dom/events/key_events.ts
@@ -0,0 +1,114 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, Injectable, NgZone} from '@angular/core';
+
+import {getDOM} from '../dom_adapter';
+import {DOCUMENT} from '../dom_tokens';
+
+import {EventManagerPlugin} from './event_manager';
+
+const MODIFIER_KEYS = ['alt', 'control', 'meta', 'shift'];
+const MODIFIER_KEY_GETTERS: {[key: string]: (event: KeyboardEvent) => boolean} = {
+  'alt': (event: KeyboardEvent) => event.altKey,
+  'control': (event: KeyboardEvent) => event.ctrlKey,
+  'meta': (event: KeyboardEvent) => event.metaKey,
+  'shift': (event: KeyboardEvent) => event.shiftKey
+};
+
+/**
+ * @experimental
+ */
+@Injectable()
+export class KeyEventsPlugin extends EventManagerPlugin {
+  constructor(@Inject(DOCUMENT) doc: any) { super(doc); }
+
+  supports(eventName: string): boolean { return KeyEventsPlugin.parseEventName(eventName) != null; }
+
+  addEventListener(element: HTMLElement, eventName: string, handler: Function): Function {
+    const parsedEvent = KeyEventsPlugin.parseEventName(eventName) !;
+
+    const outsideHandler =
+        KeyEventsPlugin.eventCallback(parsedEvent['fullKey'], handler, this.manager.getZone());
+
+    return this.manager.getZone().runOutsideAngular(() => {
+      return getDOM().onAndCancel(element, parsedEvent['domEventName'], outsideHandler);
+    });
+  }
+
+  static parseEventName(eventName: string): {[key: string]: string}|null {
+    const parts: string[] = eventName.toLowerCase().split('.');
+
+    const domEventName = parts.shift();
+    if ((parts.length === 0) || !(domEventName === 'keydown' || domEventName === 'keyup')) {
+      return null;
+    }
+
+    const key = KeyEventsPlugin._normalizeKey(parts.pop() !);
+
+    let fullKey = '';
+    MODIFIER_KEYS.forEach(modifierName => {
+      const index: number = parts.indexOf(modifierName);
+      if (index > -1) {
+        parts.splice(index, 1);
+        fullKey += modifierName + '.';
+      }
+    });
+    fullKey += key;
+
+    if (parts.length != 0 || key.length === 0) {
+      // returning null instead of throwing to let another plugin process the event
+      return null;
+    }
+
+    const result: {[k: string]: string} = {};
+    result['domEventName'] = domEventName;
+    result['fullKey'] = fullKey;
+    return result;
+  }
+
+  static getEventFullKey(event: KeyboardEvent): string {
+    let fullKey = '';
+    let key = getDOM().getEventKey(event);
+    key = key.toLowerCase();
+    if (key === ' ') {
+      key = 'space';  // for readability
+    } else if (key === '.') {
+      key = 'dot';  // because '.' is used as a separator in event names
+    }
+    MODIFIER_KEYS.forEach(modifierName => {
+      if (modifierName != key) {
+        const modifierGetter = MODIFIER_KEY_GETTERS[modifierName];
+        if (modifierGetter(event)) {
+          fullKey += modifierName + '.';
+        }
+      }
+    });
+    fullKey += key;
+    return fullKey;
+  }
+
+  static eventCallback(fullKey: any, handler: Function, zone: NgZone): Function {
+    return (event: any /** TODO #9100 */) => {
+      if (KeyEventsPlugin.getEventFullKey(event) === fullKey) {
+        zone.runGuarded(() => handler(event));
+      }
+    };
+  }
+
+  /** @internal */
+  static _normalizeKey(keyName: string): string {
+    // TODO: switch to a Map if the mapping grows too much
+    switch (keyName) {
+      case 'esc':
+        return 'escape';
+      default:
+        return keyName;
+    }
+  }
+}
diff --git a/angular/platform-browser/src/dom/shared_styles_host.ts b/angular/platform-browser/src/dom/shared_styles_host.ts
new file mode 100644
index 0000000..097e036
--- /dev/null
+++ b/angular/platform-browser/src/dom/shared_styles_host.ts
@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, Injectable, OnDestroy} from '@angular/core';
+import {getDOM} from './dom_adapter';
+import {DOCUMENT} from './dom_tokens';
+
+@Injectable()
+export class SharedStylesHost {
+  /** @internal */
+  protected _stylesSet = new Set<string>();
+
+  addStyles(styles: string[]): void {
+    const additions = new Set<string>();
+    styles.forEach(style => {
+      if (!this._stylesSet.has(style)) {
+        this._stylesSet.add(style);
+        additions.add(style);
+      }
+    });
+    this.onStylesAdded(additions);
+  }
+
+  onStylesAdded(additions: Set<string>): void {}
+
+  getAllStyles(): string[] { return Array.from(this._stylesSet); }
+}
+
+@Injectable()
+export class DomSharedStylesHost extends SharedStylesHost implements OnDestroy {
+  private _hostNodes = new Set<Node>();
+  private _styleNodes = new Set<Node>();
+  constructor(@Inject(DOCUMENT) private _doc: any) {
+    super();
+    this._hostNodes.add(_doc.head);
+  }
+
+  private _addStylesToHost(styles: Set<string>, host: Node): void {
+    styles.forEach((style: string) => {
+      const styleEl = this._doc.createElement('style');
+      styleEl.textContent = style;
+      this._styleNodes.add(host.appendChild(styleEl));
+    });
+  }
+
+  addHost(hostNode: Node): void {
+    this._addStylesToHost(this._stylesSet, hostNode);
+    this._hostNodes.add(hostNode);
+  }
+
+  removeHost(hostNode: Node): void { this._hostNodes.delete(hostNode); }
+
+  onStylesAdded(additions: Set<string>): void {
+    this._hostNodes.forEach(hostNode => this._addStylesToHost(additions, hostNode));
+  }
+
+  ngOnDestroy(): void { this._styleNodes.forEach(styleNode => getDOM().remove(styleNode)); }
+}
diff --git a/angular/platform-browser/src/dom/util.ts b/angular/platform-browser/src/dom/util.ts
new file mode 100644
index 0000000..efbbbdb
--- /dev/null
+++ b/angular/platform-browser/src/dom/util.ts
@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ɵglobal as global} from '@angular/core';
+
+const CAMEL_CASE_REGEXP = /([A-Z])/g;
+const DASH_CASE_REGEXP = /-([a-z])/g;
+
+
+export function camelCaseToDashCase(input: string): string {
+  return input.replace(CAMEL_CASE_REGEXP, (...m: string[]) => '-' + m[1].toLowerCase());
+}
+
+export function dashCaseToCamelCase(input: string): string {
+  return input.replace(DASH_CASE_REGEXP, (...m: string[]) => m[1].toUpperCase());
+}
+
+/**
+ * Exports the value under a given `name` in the global property `ng`. For example `ng.probe` if
+ * `name` is `'probe'`.
+ * @param name Name under which it will be exported. Keep in mind this will be a property of the
+ * global `ng` object.
+ * @param value The value to export.
+ */
+export function exportNgVar(name: string, value: any): void {
+  if (!ng) {
+    global['ng'] = ng = (global['ng'] as{[key: string]: any} | undefined) || {};
+  }
+  ng[name] = value;
+}
+
+let ng: {[key: string]: any}|undefined;
diff --git a/angular/platform-browser/src/platform-browser.ts b/angular/platform-browser/src/platform-browser.ts
new file mode 100644
index 0000000..deb1df2
--- /dev/null
+++ b/angular/platform-browser/src/platform-browser.ts
@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export {BrowserModule, platformBrowser} from './browser';
+export {Meta, MetaDefinition} from './browser/meta';
+export {Title} from './browser/title';
+export {disableDebugTools, enableDebugTools} from './browser/tools/tools';
+export {By} from './dom/debug/by';
+export {NgProbeToken} from './dom/debug/ng_probe';
+export {DOCUMENT} from './dom/dom_tokens';
+export {EVENT_MANAGER_PLUGINS, EventManager} from './dom/events/event_manager';
+export {HAMMER_GESTURE_CONFIG, HammerGestureConfig} from './dom/events/hammer_gestures';
+export {DomSanitizer, SafeHtml, SafeResourceUrl, SafeScript, SafeStyle, SafeUrl, SafeValue} from './security/dom_sanitization_service';
+export * from './private_export';
+export {VERSION} from './version';
diff --git a/angular/platform-browser/src/private_export.ts b/angular/platform-browser/src/private_export.ts
new file mode 100644
index 0000000..0ae42de
--- /dev/null
+++ b/angular/platform-browser/src/private_export.ts
@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export {BROWSER_SANITIZATION_PROVIDERS as ɵBROWSER_SANITIZATION_PROVIDERS, INTERNAL_BROWSER_PLATFORM_PROVIDERS as ɵINTERNAL_BROWSER_PLATFORM_PROVIDERS, initDomAdapter as ɵinitDomAdapter} from './browser';
+export {BrowserDomAdapter as ɵBrowserDomAdapter} from './browser/browser_adapter';
+export {BrowserPlatformLocation as ɵBrowserPlatformLocation} from './browser/location/browser_platform_location';
+export {TRANSITION_ID as ɵTRANSITION_ID} from './browser/server-transition';
+export {BrowserGetTestability as ɵBrowserGetTestability} from './browser/testability';
+export {ELEMENT_PROBE_PROVIDERS as ɵELEMENT_PROBE_PROVIDERS} from './dom/debug/ng_probe';
+export {DomAdapter as ɵDomAdapter, getDOM as ɵgetDOM, setRootDomAdapter as ɵsetRootDomAdapter} from './dom/dom_adapter';
+export {DomRendererFactory2 as ɵDomRendererFactory2, NAMESPACE_URIS as ɵNAMESPACE_URIS, flattenStyles as ɵflattenStyles, shimContentAttribute as ɵshimContentAttribute, shimHostAttribute as ɵshimHostAttribute} from './dom/dom_renderer';
+export {DomEventsPlugin as ɵDomEventsPlugin} from './dom/events/dom_events';
+export {HammerGesturesPlugin as ɵHammerGesturesPlugin} from './dom/events/hammer_gestures';
+export {KeyEventsPlugin as ɵKeyEventsPlugin} from './dom/events/key_events';
+export {DomSharedStylesHost as ɵDomSharedStylesHost, SharedStylesHost as ɵSharedStylesHost} from './dom/shared_styles_host';
diff --git a/angular/platform-browser/src/security/dom_sanitization_service.ts b/angular/platform-browser/src/security/dom_sanitization_service.ts
new file mode 100644
index 0000000..2810968
--- /dev/null
+++ b/angular/platform-browser/src/security/dom_sanitization_service.ts
@@ -0,0 +1,235 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Inject, Injectable, Sanitizer, SecurityContext} from '@angular/core';
+
+import {DOCUMENT} from '../dom/dom_tokens';
+
+import {sanitizeHtml} from './html_sanitizer';
+import {sanitizeStyle} from './style_sanitizer';
+import {sanitizeUrl} from './url_sanitizer';
+
+export {SecurityContext};
+
+
+
+/**
+ * Marker interface for a value that's safe to use in a particular context.
+ *
+ * @stable
+ */
+export interface SafeValue {}
+
+/**
+ * Marker interface for a value that's safe to use as HTML.
+ *
+ * @stable
+ */
+export interface SafeHtml extends SafeValue {}
+
+/**
+ * Marker interface for a value that's safe to use as style (CSS).
+ *
+ * @stable
+ */
+export interface SafeStyle extends SafeValue {}
+
+/**
+ * Marker interface for a value that's safe to use as JavaScript.
+ *
+ * @stable
+ */
+export interface SafeScript extends SafeValue {}
+
+/**
+ * Marker interface for a value that's safe to use as a URL linking to a document.
+ *
+ * @stable
+ */
+export interface SafeUrl extends SafeValue {}
+
+/**
+ * Marker interface for a value that's safe to use as a URL to load executable code from.
+ *
+ * @stable
+ */
+export interface SafeResourceUrl extends SafeValue {}
+
+/**
+ * DomSanitizer helps preventing Cross Site Scripting Security bugs (XSS) by sanitizing
+ * values to be safe to use in the different DOM contexts.
+ *
+ * For example, when binding a URL in an `<a [href]="someValue">` hyperlink, `someValue` will be
+ * sanitized so that an attacker cannot inject e.g. a `javascript:` URL that would execute code on
+ * the website.
+ *
+ * In specific situations, it might be necessary to disable sanitization, for example if the
+ * application genuinely needs to produce a `javascript:` style link with a dynamic value in it.
+ * Users can bypass security by constructing a value with one of the `bypassSecurityTrust...`
+ * methods, and then binding to that value from the template.
+ *
+ * These situations should be very rare, and extraordinary care must be taken to avoid creating a
+ * Cross Site Scripting (XSS) security bug!
+ *
+ * When using `bypassSecurityTrust...`, make sure to call the method as early as possible and as
+ * close as possible to the source of the value, to make it easy to verify no security bug is
+ * created by its use.
+ *
+ * It is not required (and not recommended) to bypass security if the value is safe, e.g. a URL that
+ * does not start with a suspicious protocol, or an HTML snippet that does not contain dangerous
+ * code. The sanitizer leaves safe values intact.
+ *
+ * @security Calling any of the `bypassSecurityTrust...` APIs disables Angular's built-in
+ * sanitization for the value passed in. Carefully check and audit all values and code paths going
+ * into this call. Make sure any user data is appropriately escaped for this security context.
+ * For more detail, see the [Security Guide](http://g.co/ng/security).
+ *
+ * @stable
+ */
+export abstract class DomSanitizer implements Sanitizer {
+  /**
+   * Sanitizes a value for use in the given SecurityContext.
+   *
+   * If value is trusted for the context, this method will unwrap the contained safe value and use
+   * it directly. Otherwise, value will be sanitized to be safe in the given context, for example
+   * by replacing URLs that have an unsafe protocol part (such as `javascript:`). The implementation
+   * is responsible to make sure that the value can definitely be safely used in the given context.
+   */
+  abstract sanitize(context: SecurityContext, value: SafeValue|string|null): string|null;
+
+  /**
+   * Bypass security and trust the given value to be safe HTML. Only use this when the bound HTML
+   * is unsafe (e.g. contains `<script>` tags) and the code should be executed. The sanitizer will
+   * leave safe HTML intact, so in most situations this method should not be used.
+   *
+   * **WARNING:** calling this method with untrusted user data exposes your application to XSS
+   * security risks!
+   */
+  abstract bypassSecurityTrustHtml(value: string): SafeHtml;
+
+  /**
+   * Bypass security and trust the given value to be safe style value (CSS).
+   *
+   * **WARNING:** calling this method with untrusted user data exposes your application to XSS
+   * security risks!
+   */
+  abstract bypassSecurityTrustStyle(value: string): SafeStyle;
+
+  /**
+   * Bypass security and trust the given value to be safe JavaScript.
+   *
+   * **WARNING:** calling this method with untrusted user data exposes your application to XSS
+   * security risks!
+   */
+  abstract bypassSecurityTrustScript(value: string): SafeScript;
+
+  /**
+   * Bypass security and trust the given value to be a safe style URL, i.e. a value that can be used
+   * in hyperlinks or `<img src>`.
+   *
+   * **WARNING:** calling this method with untrusted user data exposes your application to XSS
+   * security risks!
+   */
+  abstract bypassSecurityTrustUrl(value: string): SafeUrl;
+
+  /**
+   * Bypass security and trust the given value to be a safe resource URL, i.e. a location that may
+   * be used to load executable code from, like `<script src>`, or `<iframe src>`.
+   *
+   * **WARNING:** calling this method with untrusted user data exposes your application to XSS
+   * security risks!
+   */
+  abstract bypassSecurityTrustResourceUrl(value: string): SafeResourceUrl;
+}
+
+
+@Injectable()
+export class DomSanitizerImpl extends DomSanitizer {
+  constructor(@Inject(DOCUMENT) private _doc: any) { super(); }
+
+  sanitize(ctx: SecurityContext, value: SafeValue|string|null): string|null {
+    if (value == null) return null;
+    switch (ctx) {
+      case SecurityContext.NONE:
+        return value as string;
+      case SecurityContext.HTML:
+        if (value instanceof SafeHtmlImpl) return value.changingThisBreaksApplicationSecurity;
+        this.checkNotSafeValue(value, 'HTML');
+        return sanitizeHtml(this._doc, String(value));
+      case SecurityContext.STYLE:
+        if (value instanceof SafeStyleImpl) return value.changingThisBreaksApplicationSecurity;
+        this.checkNotSafeValue(value, 'Style');
+        return sanitizeStyle(value as string);
+      case SecurityContext.SCRIPT:
+        if (value instanceof SafeScriptImpl) return value.changingThisBreaksApplicationSecurity;
+        this.checkNotSafeValue(value, 'Script');
+        throw new Error('unsafe value used in a script context');
+      case SecurityContext.URL:
+        if (value instanceof SafeResourceUrlImpl || value instanceof SafeUrlImpl) {
+          // Allow resource URLs in URL contexts, they are strictly more trusted.
+          return value.changingThisBreaksApplicationSecurity;
+        }
+        this.checkNotSafeValue(value, 'URL');
+        return sanitizeUrl(String(value));
+      case SecurityContext.RESOURCE_URL:
+        if (value instanceof SafeResourceUrlImpl) {
+          return value.changingThisBreaksApplicationSecurity;
+        }
+        this.checkNotSafeValue(value, 'ResourceURL');
+        throw new Error(
+            'unsafe value used in a resource URL context (see http://g.co/ng/security#xss)');
+      default:
+        throw new Error(`Unexpected SecurityContext ${ctx} (see http://g.co/ng/security#xss)`);
+    }
+  }
+
+  private checkNotSafeValue(value: any, expectedType: string) {
+    if (value instanceof SafeValueImpl) {
+      throw new Error(
+          `Required a safe ${expectedType}, got a ${value.getTypeName()} ` +
+          `(see http://g.co/ng/security#xss)`);
+    }
+  }
+
+  bypassSecurityTrustHtml(value: string): SafeHtml { return new SafeHtmlImpl(value); }
+  bypassSecurityTrustStyle(value: string): SafeStyle { return new SafeStyleImpl(value); }
+  bypassSecurityTrustScript(value: string): SafeScript { return new SafeScriptImpl(value); }
+  bypassSecurityTrustUrl(value: string): SafeUrl { return new SafeUrlImpl(value); }
+  bypassSecurityTrustResourceUrl(value: string): SafeResourceUrl {
+    return new SafeResourceUrlImpl(value);
+  }
+}
+
+abstract class SafeValueImpl implements SafeValue {
+  constructor(public changingThisBreaksApplicationSecurity: string) {
+    // empty
+  }
+
+  abstract getTypeName(): string;
+
+  toString() {
+    return `SafeValue must use [property]=binding: ${this.changingThisBreaksApplicationSecurity}` +
+        ` (see http://g.co/ng/security#xss)`;
+  }
+}
+
+class SafeHtmlImpl extends SafeValueImpl implements SafeHtml {
+  getTypeName() { return 'HTML'; }
+}
+class SafeStyleImpl extends SafeValueImpl implements SafeStyle {
+  getTypeName() { return 'Style'; }
+}
+class SafeScriptImpl extends SafeValueImpl implements SafeScript {
+  getTypeName() { return 'Script'; }
+}
+class SafeUrlImpl extends SafeValueImpl implements SafeUrl {
+  getTypeName() { return 'URL'; }
+}
+class SafeResourceUrlImpl extends SafeValueImpl implements SafeResourceUrl {
+  getTypeName() { return 'ResourceURL'; }
+}
diff --git a/angular/platform-browser/src/security/html_sanitizer.ts b/angular/platform-browser/src/security/html_sanitizer.ts
new file mode 100644
index 0000000..07fb7c8
--- /dev/null
+++ b/angular/platform-browser/src/security/html_sanitizer.ts
@@ -0,0 +1,302 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {isDevMode} from '@angular/core';
+
+import {DomAdapter, getDOM} from '../dom/dom_adapter';
+
+import {sanitizeSrcset, sanitizeUrl} from './url_sanitizer';
+
+/** A <body> element that can be safely used to parse untrusted HTML. Lazily initialized below. */
+let inertElement: HTMLElement|null = null;
+/** Lazily initialized to make sure the DOM adapter gets set before use. */
+let DOM: DomAdapter = null !;
+
+/** Returns an HTML element that is guaranteed to not execute code when creating elements in it. */
+function getInertElement() {
+  if (inertElement) return inertElement;
+  DOM = getDOM();
+
+  // Prefer using <template> element if supported.
+  const templateEl = DOM.createElement('template');
+  if ('content' in templateEl) return templateEl;
+
+  const doc = DOM.createHtmlDocument();
+  inertElement = DOM.querySelector(doc, 'body');
+  if (inertElement == null) {
+    // usually there should be only one body element in the document, but IE doesn't have any, so we
+    // need to create one.
+    const html = DOM.createElement('html', doc);
+    inertElement = DOM.createElement('body', doc);
+    DOM.appendChild(html, inertElement);
+    DOM.appendChild(doc, html);
+  }
+  return inertElement;
+}
+
+function tagSet(tags: string): {[k: string]: boolean} {
+  const res: {[k: string]: boolean} = {};
+  for (const t of tags.split(',')) res[t] = true;
+  return res;
+}
+
+function merge(...sets: {[k: string]: boolean}[]): {[k: string]: boolean} {
+  const res: {[k: string]: boolean} = {};
+  for (const s of sets) {
+    for (const v in s) {
+      if (s.hasOwnProperty(v)) res[v] = true;
+    }
+  }
+  return res;
+}
+
+// Good source of info about elements and attributes
+// http://dev.w3.org/html5/spec/Overview.html#semantics
+// http://simon.html5.org/html-elements
+
+// Safe Void Elements - HTML5
+// http://dev.w3.org/html5/spec/Overview.html#void-elements
+const VOID_ELEMENTS = tagSet('area,br,col,hr,img,wbr');
+
+// Elements that you can, intentionally, leave open (and which close themselves)
+// http://dev.w3.org/html5/spec/Overview.html#optional-tags
+const OPTIONAL_END_TAG_BLOCK_ELEMENTS = tagSet('colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr');
+const OPTIONAL_END_TAG_INLINE_ELEMENTS = tagSet('rp,rt');
+const OPTIONAL_END_TAG_ELEMENTS =
+    merge(OPTIONAL_END_TAG_INLINE_ELEMENTS, OPTIONAL_END_TAG_BLOCK_ELEMENTS);
+
+// Safe Block Elements - HTML5
+const BLOCK_ELEMENTS = merge(
+    OPTIONAL_END_TAG_BLOCK_ELEMENTS,
+    tagSet(
+        'address,article,' +
+        'aside,blockquote,caption,center,del,details,dialog,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,' +
+        'h6,header,hgroup,hr,ins,main,map,menu,nav,ol,pre,section,summary,table,ul'));
+
+// Inline Elements - HTML5
+const INLINE_ELEMENTS = merge(
+    OPTIONAL_END_TAG_INLINE_ELEMENTS,
+    tagSet(
+        'a,abbr,acronym,audio,b,' +
+        'bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,picture,q,ruby,rp,rt,s,' +
+        'samp,small,source,span,strike,strong,sub,sup,time,track,tt,u,var,video'));
+
+const VALID_ELEMENTS =
+    merge(VOID_ELEMENTS, BLOCK_ELEMENTS, INLINE_ELEMENTS, OPTIONAL_END_TAG_ELEMENTS);
+
+// Attributes that have href and hence need to be sanitized
+const URI_ATTRS = tagSet('background,cite,href,itemtype,longdesc,poster,src,xlink:href');
+
+// Attributes that have special href set hence need to be sanitized
+const SRCSET_ATTRS = tagSet('srcset');
+
+const HTML_ATTRS = tagSet(
+    'abbr,accesskey,align,alt,autoplay,axis,bgcolor,border,cellpadding,cellspacing,class,clear,color,cols,colspan,' +
+    'compact,controls,coords,datetime,default,dir,download,face,headers,height,hidden,hreflang,hspace,' +
+    'ismap,itemscope,itemprop,kind,label,lang,language,loop,media,muted,nohref,nowrap,open,preload,rel,rev,role,rows,rowspan,rules,' +
+    'scope,scrolling,shape,size,sizes,span,srclang,start,summary,tabindex,target,title,translate,type,usemap,' +
+    'valign,value,vspace,width');
+
+// NB: This currently consciously doesn't support SVG. SVG sanitization has had several security
+// issues in the past, so it seems safer to leave it out if possible. If support for binding SVG via
+// innerHTML is required, SVG attributes should be added here.
+
+// NB: Sanitization does not allow <form> elements or other active elements (<button> etc). Those
+// can be sanitized, but they increase security surface area without a legitimate use case, so they
+// are left out here.
+
+const VALID_ATTRS = merge(URI_ATTRS, SRCSET_ATTRS, HTML_ATTRS);
+
+/**
+ * SanitizingHtmlSerializer serializes a DOM fragment, stripping out any unsafe elements and unsafe
+ * attributes.
+ */
+class SanitizingHtmlSerializer {
+  // Explicitly track if something was stripped, to avoid accidentally warning of sanitization just
+  // because characters were re-encoded.
+  public sanitizedSomething = false;
+  private buf: string[] = [];
+
+  sanitizeChildren(el: Element): string {
+    // This cannot use a TreeWalker, as it has to run on Angular's various DOM adapters.
+    // However this code never accesses properties off of `document` before deleting its contents
+    // again, so it shouldn't be vulnerable to DOM clobbering.
+    let current: Node = el.firstChild !;
+    while (current) {
+      if (DOM.isElementNode(current)) {
+        this.startElement(current as Element);
+      } else if (DOM.isTextNode(current)) {
+        this.chars(DOM.nodeValue(current) !);
+      } else {
+        // Strip non-element, non-text nodes.
+        this.sanitizedSomething = true;
+      }
+      if (DOM.firstChild(current)) {
+        current = DOM.firstChild(current) !;
+        continue;
+      }
+      while (current) {
+        // Leaving the element. Walk up and to the right, closing tags as we go.
+        if (DOM.isElementNode(current)) {
+          this.endElement(current as Element);
+        }
+
+        let next = checkClobberedElement(current, DOM.nextSibling(current) !);
+
+        if (next) {
+          current = next;
+          break;
+        }
+
+        current = checkClobberedElement(current, DOM.parentElement(current) !);
+      }
+    }
+    return this.buf.join('');
+  }
+
+  private startElement(element: Element) {
+    const tagName = DOM.nodeName(element).toLowerCase();
+    if (!VALID_ELEMENTS.hasOwnProperty(tagName)) {
+      this.sanitizedSomething = true;
+      return;
+    }
+    this.buf.push('<');
+    this.buf.push(tagName);
+    DOM.attributeMap(element).forEach((value: string, attrName: string) => {
+      const lower = attrName.toLowerCase();
+      if (!VALID_ATTRS.hasOwnProperty(lower)) {
+        this.sanitizedSomething = true;
+        return;
+      }
+      // TODO(martinprobst): Special case image URIs for data:image/...
+      if (URI_ATTRS[lower]) value = sanitizeUrl(value);
+      if (SRCSET_ATTRS[lower]) value = sanitizeSrcset(value);
+      this.buf.push(' ');
+      this.buf.push(attrName);
+      this.buf.push('="');
+      this.buf.push(encodeEntities(value));
+      this.buf.push('"');
+    });
+    this.buf.push('>');
+  }
+
+  private endElement(current: Element) {
+    const tagName = DOM.nodeName(current).toLowerCase();
+    if (VALID_ELEMENTS.hasOwnProperty(tagName) && !VOID_ELEMENTS.hasOwnProperty(tagName)) {
+      this.buf.push('</');
+      this.buf.push(tagName);
+      this.buf.push('>');
+    }
+  }
+
+  private chars(chars: string) { this.buf.push(encodeEntities(chars)); }
+}
+
+function checkClobberedElement(node: Node, nextNode: Node): Node {
+  if (nextNode && DOM.contains(node, nextNode)) {
+    throw new Error(
+        `Failed to sanitize html because the element is clobbered: ${DOM.getOuterHTML(node)}`);
+  }
+  return nextNode;
+}
+
+// Regular Expressions for parsing tags and attributes
+const SURROGATE_PAIR_REGEXP = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+// ! to ~ is the ASCII range.
+const NON_ALPHANUMERIC_REGEXP = /([^\#-~ |!])/g;
+
+/**
+ * Escapes all potentially dangerous characters, so that the
+ * resulting string can be safely inserted into attribute or
+ * element text.
+ * @param value
+ */
+function encodeEntities(value: string) {
+  return value.replace(/&/g, '&amp;')
+      .replace(
+          SURROGATE_PAIR_REGEXP,
+          function(match: string) {
+            const hi = match.charCodeAt(0);
+            const low = match.charCodeAt(1);
+            return '&#' + (((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000) + ';';
+          })
+      .replace(
+          NON_ALPHANUMERIC_REGEXP,
+          function(match: string) { return '&#' + match.charCodeAt(0) + ';'; })
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;');
+}
+
+/**
+ * When IE9-11 comes across an unknown namespaced attribute e.g. 'xlink:foo' it adds 'xmlns:ns1'
+ * attribute to declare ns1 namespace and prefixes the attribute with 'ns1' (e.g. 'ns1:xlink:foo').
+ *
+ * This is undesirable since we don't want to allow any of these custom attributes. This method
+ * strips them all.
+ */
+function stripCustomNsAttrs(el: Element) {
+  DOM.attributeMap(el).forEach((_, attrName) => {
+    if (attrName === 'xmlns:ns1' || attrName.indexOf('ns1:') === 0) {
+      DOM.removeAttribute(el, attrName);
+    }
+  });
+  for (const n of DOM.childNodesAsList(el)) {
+    if (DOM.isElementNode(n)) stripCustomNsAttrs(n as Element);
+  }
+}
+
+/**
+ * Sanitizes the given unsafe, untrusted HTML fragment, and returns HTML text that is safe to add to
+ * the DOM in a browser environment.
+ */
+export function sanitizeHtml(defaultDoc: any, unsafeHtmlInput: string): string {
+  try {
+    const containerEl = getInertElement();
+    // Make sure unsafeHtml is actually a string (TypeScript types are not enforced at runtime).
+    let unsafeHtml = unsafeHtmlInput ? String(unsafeHtmlInput) : '';
+
+    // mXSS protection. Repeatedly parse the document to make sure it stabilizes, so that a browser
+    // trying to auto-correct incorrect HTML cannot cause formerly inert HTML to become dangerous.
+    let mXSSAttempts = 5;
+    let parsedHtml = unsafeHtml;
+
+    do {
+      if (mXSSAttempts === 0) {
+        throw new Error('Failed to sanitize html because the input is unstable');
+      }
+      mXSSAttempts--;
+
+      unsafeHtml = parsedHtml;
+      DOM.setInnerHTML(containerEl, unsafeHtml);
+      if (defaultDoc.documentMode) {
+        // strip custom-namespaced attributes on IE<=11
+        stripCustomNsAttrs(containerEl);
+      }
+      parsedHtml = DOM.getInnerHTML(containerEl);
+    } while (unsafeHtml !== parsedHtml);
+
+    const sanitizer = new SanitizingHtmlSerializer();
+    const safeHtml = sanitizer.sanitizeChildren(DOM.getTemplateContent(containerEl) || containerEl);
+
+    // Clear out the body element.
+    const parent = DOM.getTemplateContent(containerEl) || containerEl;
+    for (const child of DOM.childNodesAsList(parent)) {
+      DOM.removeChild(parent, child);
+    }
+
+    if (isDevMode() && sanitizer.sanitizedSomething) {
+      DOM.log('WARNING: sanitizing HTML stripped some content (see http://g.co/ng/security#xss).');
+    }
+
+    return safeHtml;
+  } catch (e) {
+    // In case anything goes wrong, clear out inertElement to reset the entire DOM structure.
+    inertElement = null;
+    throw e;
+  }
+}
diff --git a/angular/platform-browser/src/security/style_sanitizer.ts b/angular/platform-browser/src/security/style_sanitizer.ts
new file mode 100644
index 0000000..6490c2d
--- /dev/null
+++ b/angular/platform-browser/src/security/style_sanitizer.ts
@@ -0,0 +1,106 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {isDevMode} from '@angular/core';
+
+import {getDOM} from '../dom/dom_adapter';
+
+import {sanitizeUrl} from './url_sanitizer';
+
+
+/**
+ * Regular expression for safe style values.
+ *
+ * Quotes (" and ') are allowed, but a check must be done elsewhere to ensure they're balanced.
+ *
+ * ',' allows multiple values to be assigned to the same property (e.g. background-attachment or
+ * font-family) and hence could allow multiple values to get injected, but that should pose no risk
+ * of XSS.
+ *
+ * The function expression checks only for XSS safety, not for CSS validity.
+ *
+ * This regular expression was taken from the Closure sanitization library, and augmented for
+ * transformation values.
+ */
+const VALUES = '[-,."\'%_!# a-zA-Z0-9]+';
+const TRANSFORMATION_FNS = '(?:matrix|translate|scale|rotate|skew|perspective)(?:X|Y|3d)?';
+const COLOR_FNS = '(?:rgb|hsl)a?';
+const GRADIENTS = '(?:repeating-)?(?:linear|radial)-gradient';
+const CSS3_FNS = '(?:calc|attr)';
+const FN_ARGS = '\\([-0-9.%, #a-zA-Z]+\\)';
+const SAFE_STYLE_VALUE = new RegExp(
+    `^(${VALUES}|` +
+        `(?:${TRANSFORMATION_FNS}|${COLOR_FNS}|${GRADIENTS}|${CSS3_FNS})` +
+        `${FN_ARGS})$`,
+    'g');
+
+/**
+ * Matches a `url(...)` value with an arbitrary argument as long as it does
+ * not contain parentheses.
+ *
+ * The URL value still needs to be sanitized separately.
+ *
+ * `url(...)` values are a very common use case, e.g. for `background-image`. With carefully crafted
+ * CSS style rules, it is possible to construct an information leak with `url` values in CSS, e.g.
+ * by observing whether scroll bars are displayed, or character ranges used by a font face
+ * definition.
+ *
+ * Angular only allows binding CSS values (as opposed to entire CSS rules), so it is unlikely that
+ * binding a URL value without further cooperation from the page will cause an information leak, and
+ * if so, it is just a leak, not a full blown XSS vulnerability.
+ *
+ * Given the common use case, low likelihood of attack vector, and low impact of an attack, this
+ * code is permissive and allows URLs that sanitize otherwise.
+ */
+const URL_RE = /^url\(([^)]+)\)$/;
+
+/**
+ * Checks that quotes (" and ') are properly balanced inside a string. Assumes
+ * that neither escape (\) nor any other character that could result in
+ * breaking out of a string parsing context are allowed;
+ * see http://www.w3.org/TR/css3-syntax/#string-token-diagram.
+ *
+ * This code was taken from the Closure sanitization library.
+ */
+function hasBalancedQuotes(value: string) {
+  let outsideSingle = true;
+  let outsideDouble = true;
+  for (let i = 0; i < value.length; i++) {
+    const c = value.charAt(i);
+    if (c === '\'' && outsideDouble) {
+      outsideSingle = !outsideSingle;
+    } else if (c === '"' && outsideSingle) {
+      outsideDouble = !outsideDouble;
+    }
+  }
+  return outsideSingle && outsideDouble;
+}
+
+/**
+ * Sanitizes the given untrusted CSS style property value (i.e. not an entire object, just a single
+ * value) and returns a value that is safe to use in a browser environment.
+ */
+export function sanitizeStyle(value: string): string {
+  value = String(value).trim();  // Make sure it's actually a string.
+  if (!value) return '';
+
+  // Single url(...) values are supported, but only for URLs that sanitize cleanly. See above for
+  // reasoning behind this.
+  const urlMatch = value.match(URL_RE);
+  if ((urlMatch && sanitizeUrl(urlMatch[1]) === urlMatch[1]) ||
+      value.match(SAFE_STYLE_VALUE) && hasBalancedQuotes(value)) {
+    return value;  // Safe style values.
+  }
+
+  if (isDevMode()) {
+    getDOM().log(
+        `WARNING: sanitizing unsafe style value ${value} (see http://g.co/ng/security#xss).`);
+  }
+
+  return 'unsafe';
+}
diff --git a/angular/platform-browser/src/security/url_sanitizer.ts b/angular/platform-browser/src/security/url_sanitizer.ts
new file mode 100644
index 0000000..1ff6fe3
--- /dev/null
+++ b/angular/platform-browser/src/security/url_sanitizer.ts
@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {isDevMode} from '@angular/core';
+
+import {getDOM} from '../dom/dom_adapter';
+
+
+/**
+ * A pattern that recognizes a commonly useful subset of URLs that are safe.
+ *
+ * This regular expression matches a subset of URLs that will not cause script
+ * execution if used in URL context within a HTML document. Specifically, this
+ * regular expression matches if (comment from here on and regex copied from
+ * Soy's EscapingConventions):
+ * (1) Either a protocol in a whitelist (http, https, mailto or ftp).
+ * (2) or no protocol.  A protocol must be followed by a colon. The below
+ *     allows that by allowing colons only after one of the characters [/?#].
+ *     A colon after a hash (#) must be in the fragment.
+ *     Otherwise, a colon after a (?) must be in a query.
+ *     Otherwise, a colon after a single solidus (/) must be in a path.
+ *     Otherwise, a colon after a double solidus (//) must be in the authority
+ *     (before port).
+ *
+ * The pattern disallows &, used in HTML entity declarations before
+ * one of the characters in [/?#]. This disallows HTML entities used in the
+ * protocol name, which should never happen, e.g. "h&#116;tp" for "http".
+ * It also disallows HTML entities in the first path part of a relative path,
+ * e.g. "foo&lt;bar/baz".  Our existing escaping functions should not produce
+ * that. More importantly, it disallows masking of a colon,
+ * e.g. "javascript&#58;...".
+ *
+ * This regular expression was taken from the Closure sanitization library.
+ */
+const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi;
+
+/* A pattern that matches safe srcset values */
+const SAFE_SRCSET_PATTERN = /^(?:(?:https?|file):|[^&:/?#]*(?:[/?#]|$))/gi;
+
+/** A pattern that matches safe data URLs. Only matches image, video and audio types. */
+const DATA_URL_PATTERN =
+    /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+\/]+=*$/i;
+
+export function sanitizeUrl(url: string): string {
+  url = String(url);
+  if (url.match(SAFE_URL_PATTERN) || url.match(DATA_URL_PATTERN)) return url;
+
+  if (isDevMode()) {
+    getDOM().log(`WARNING: sanitizing unsafe URL value ${url} (see http://g.co/ng/security#xss)`);
+  }
+
+  return 'unsafe:' + url;
+}
+
+export function sanitizeSrcset(srcset: string): string {
+  srcset = String(srcset);
+  return srcset.split(',').map((srcset) => sanitizeUrl(srcset.trim())).join(', ');
+}
diff --git a/angular/platform-browser/src/version.ts b/angular/platform-browser/src/version.ts
new file mode 100644
index 0000000..19db5be
--- /dev/null
+++ b/angular/platform-browser/src/version.ts
@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the common package.
+ */
+
+import {Version} from '@angular/core';
+/**
+ * @stable
+ */
+export const VERSION = new Version('0.0.0-PLACEHOLDER');
diff --git a/angular/typings.d.ts b/angular/typings.d.ts
new file mode 100644
index 0000000..13ee481
--- /dev/null
+++ b/angular/typings.d.ts
@@ -0,0 +1,4 @@
+declare var System: any;
+
+declare var Hammer: any;
+declare type HammerInput = {};
diff --git a/app/app.component.html b/app/app.component.html
index 9a0fc87..d4e5a7b 100644
--- a/app/app.component.html
+++ b/app/app.component.html
@@ -1 +1 @@
-<h1>Angular2 quickstart</h1>
\ No newline at end of file
+<h1>Angular2 quickstart</h1>
diff --git a/app/app.component.ts b/app/app.component.ts
index 57c94a5..4c7596e 100644
--- a/app/app.component.ts
+++ b/app/app.component.ts
@@ -1,7 +1,9 @@
-import { Component } from '@angular/core';
-
-@Component({
-  selector: 'my-app',
-  templateUrl: `./app.component.html`
-})
-export class AppComponent { }
\ No newline at end of file
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'my-app',
+  templateUrl: `./app.component.html`
+})
+export class AppComponent {
+
+}
diff --git a/app/main.ts b/app/main.ts
index 3d4db6d..4cdf1d2 100644
--- a/app/main.ts
+++ b/app/main.ts
@@ -1,5 +1,8 @@
-import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
-
-import { AppModule } from './app.module';
-
-platformBrowserDynamic().bootstrapModule(AppModule);
\ No newline at end of file
+import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+
+import { AppModule } from './app.module';
+import { enableProdMode } from '@angular/core';
+
+platformBrowserDynamic().bootstrapModule(AppModule);
+
+
diff --git a/bs-config.json b/bs-config.json
new file mode 100644
index 0000000..d8f183e
--- /dev/null
+++ b/bs-config.json
@@ -0,0 +1,3 @@
+{
+  "port": 8000
+}
\ No newline at end of file
diff --git a/package.json b/package.json
index 6295890..63eb963 100644
--- a/package.json
+++ b/package.json
@@ -9,14 +9,6 @@
   },
   "license": "ISC",
   "dependencies": {
-    "@angular/common": "4.1.0",
-    "@angular/compiler": "4.1.0",
-    "@angular/core": "4.1.0",
-    "@angular/forms": "4.1.0",
-    "@angular/http": "4.1.0",
-    "@angular/platform-browser": "4.1.0",
-    "@angular/platform-browser-dynamic": "4.1.0",
-    "@angular/router": "4.1.0",
     "core-js": "^2.4.1",
     "rxjs": "^5.1.0",
     "systemjs": "0.19.41",
diff --git a/systemjs-angular-loader.js b/systemjs-angular-loader.js
index bdbb737..45f9ed7 100644
--- a/systemjs-angular-loader.js
+++ b/systemjs-angular-loader.js
@@ -1,46 +1,46 @@
-var templateUrlRegex = /templateUrl\s*:(\s*['"`](.*?)['"`]\s*)/gm;
-var stylesRegex = /styleUrls *:(\s*\[[^\]]*?\])/g;
-var stringRegex = /(['`"])((?:[^\\]\\\1|.)*?)\1/g;
-
-module.exports.translate = function(load){
-  var url = document.createElement('a');
-  url.href = load.address;
-
-  var basePathParts = url.pathname.split('/');
-
-  basePathParts.pop();
-  var basePath = basePathParts.join('/');
-
-  var baseHref = document.createElement('a');
-  baseHref.href = this.baseURL;
-  baseHref = baseHref.pathname;
-
-  basePath = basePath.replace(baseHref, '');
-  basePath = basePath.replace('dist', 'app')
-
-  load.source = load.source
-    .replace(templateUrlRegex, function(match, quote, url){
-      let resolvedUrl = url;
-
-      if (url.startsWith('.')) {
-        resolvedUrl = basePath + url.substr(1);
-      }
-
-      return 'templateUrl: "' + resolvedUrl + '"';
-    })
-    .replace(stylesRegex, function(match, relativeUrls) {
-      var urls = [];
-
-      while ((match = stringRegex.exec(relativeUrls)) !== null) {
-        if (match[2].startsWith('.')) {
-          urls.push('"' + basePath + match[2].substr(1) + '"');
-        } else {
-          urls.push('"' + match[2] + '"');
-        }
-      }
-
-      return "styleUrls: [" + urls.join(', ') + "]";
-    });
-
-  return load;
-};
\ No newline at end of file
+var templateUrlRegex = /templateUrl\s*:(\s*['"`](.*?)['"`]\s*)/gm;
+var stylesRegex = /styleUrls *:(\s*\[[^\]]*?\])/g;
+var stringRegex = /(['`"])((?:[^\\]\\\1|.)*?)\1/g;
+
+module.exports.translate = function(load){
+  var url = document.createElement('a');
+  url.href = load.address;
+
+  var basePathParts = url.pathname.split('/');
+
+  basePathParts.pop();
+  var basePath = basePathParts.join('/');
+
+  var baseHref = document.createElement('a');
+  baseHref.href = this.baseURL;
+  baseHref = baseHref.pathname;
+
+  basePath = basePath.replace(baseHref, '');
+  basePath = basePath.replace('dist/app', 'app');
+
+  load.source = load.source
+    .replace(templateUrlRegex, function(match, quote, url){
+      var resolvedUrl = url;
+
+      if (url.startsWith('.')) {
+        resolvedUrl = basePath + url.substr(1);
+      }
+
+      return 'templateUrl: "' + resolvedUrl + '"';
+    })
+    .replace(stylesRegex, function(match, relativeUrls) {
+      var urls = [];
+
+      while ((match = stringRegex.exec(relativeUrls)) !== null) {
+        if (match[2].startsWith('.')) {
+          urls.push('"' + basePath + match[2].substr(1) + '"');
+        } else {
+          urls.push('"' + match[2] + '"');
+        }
+      }
+
+      return "styleUrls: [" + urls.join(', ') + "]";
+    });
+
+  return load;
+};
diff --git a/systemjs.config.js b/systemjs.config.js
index ef8b5e9..43cae4b 100644
--- a/systemjs.config.js
+++ b/systemjs.config.js
@@ -1,44 +1,43 @@
-/**
- * System configuration for Angular 2 samples
- * Adjust as necessary for your application needs.
- */
-(function (global) {
-  System.config({
-    paths: {
-      // paths serve as alias
-      'npm:': 'node_modules/'
-    },
-    // map tells the System loader where to look for things
-    map: {
-      // our app is within the app folder
-      app: 'dist',
-      // angular bundles
-      '@angular/core': 'npm:@angular/core/bundles/core.umd.js',
-      '@angular/common': 'npm:@angular/common/bundles/common.umd.js',
-      '@angular/compiler': 'npm:@angular/compiler/bundles/compiler.umd.js',
-      '@angular/platform-browser': 'npm:@angular/platform-browser/bundles/platform-browser.umd.js',
-      '@angular/platform-browser-dynamic': 'npm:@angular/platform-browser-dynamic/bundles/platform-browser-dynamic.umd.js',
-      '@angular/http': 'npm:@angular/http/bundles/http.umd.js',
-      '@angular/router': 'npm:@angular/router/bundles/router.umd.js',
-      '@angular/forms': 'npm:@angular/forms/bundles/forms.umd.js',
-
-      // other libraries
-      'rxjs': 'npm:rxjs'
-    },
-    // packages tells the System loader how to load when no filename and/or no extension
-    packages: {
-      app: {
-        main: './main.js',
-        defaultExtension: 'js',
-        meta: {
-          './*.js': {
-            loader: 'systemjs-angular-loader.js'
-          }
-        }
-      },
-      rxjs: {
-        defaultExtension: 'js'
-      }
-    }
-  });
-})(this);
\ No newline at end of file
+/**
+ * System configuration for Angular 2 samples
+ * Adjust as necessary for your application needs.
+ */
+(function (global) {
+  System.config({
+    "defaultJSExtensions": true,
+    paths: {
+      // paths serve as alias
+      'npm:': 'node_modules/'
+    },
+    // map tells the System loader where to look for things
+    map: {
+      // our app is within the app folder
+      app: 'dist/app',
+      // angular bundles
+      '@angular/core': 'dist/angular/core/index',
+      '@angular/common': 'dist/angular/common/index',
+      '@angular/compiler': 'dist/angular/compiler/index',
+      '@angular/platform-browser': 'dist/angular/platform-browser/index',
+      '@angular/platform-browser-dynamic': 'dist/angular/platform-browser-dynamic/index',
+
+
+      // other libraries
+      'rxjs': 'npm:rxjs'
+    },
+    // packages tells the System loader how to load when no filename and/or no extension
+    packages: {
+      app: {
+        main: './main.js',
+        defaultExtension: 'js',
+        meta: {
+          './*.js': {
+            loader: 'systemjs-angular-loader.js'
+          }
+        }
+      },
+      rxjs: {
+        defaultExtension: 'js'
+      }
+    }
+  });
+})(this);
diff --git a/tsconfig.json b/tsconfig.json
index d8d61b2..2fc30a1 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,14 +1,23 @@
-{
-  "compilerOptions": {
-    "target": "es5",
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "sourceMap": true,
-    "lib": [ "es2015", "dom" ],
-    "outDir": "dist",
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "removeComments": false,
-    "noImplicitAny": false
-  }
-}
\ No newline at end of file
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "lib": [ "es2015", "dom" ],
+    "outDir": "dist",
+    "strictNullChecks": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "removeComments": false,
+    "noImplicitAny": false,
+    "baseUrl": ".",
+    "paths": {
+      "@angular/common": ["angular/common"],
+      "@angular/compiler": ["angular/compiler/index"],
+      "@angular/core": ["angular/core/index"],
+      "@angular/platform-browser": ["angular/platform-browser"],
+      "@angular/platform-browser-dynamic": ["angular/platform-browser-dynamic"]
+    }
+  }
+}