Template Upload

node_modules/angular2/ts/README.js.md

@@ -0,0 +1,15 @@
+Angular2
+=========
+
+The sources for this package are in the main [Angular2](https://github.com/angular/angular) repo. Please file issues and pull requests against that repo. This is the repository for the upcoming 2.0 version. If you're looking for the current official version of Angular you should go to [angular/angular.js](https://github.com/angular/angular.js)
+
+This package contains different sources for different users:
+
+1. The files located in the root folder can be consumed using CommonJS.
+2. The files under `/es6` are es6 compatible files that can be transpiled to
+   es5 using any transpiler. This contains:
+    * `dev/`: a development version that includes runtime type assertions
+    * `prod/`: a production version that does not include runtime type assertions
+3. The files under `/ts` are the TypeScript source files.
+
+License: Apache MIT 2.0

node_modules/angular2/ts/animate.ts

@@ -0,0 +1,5 @@
+export {Animation} from './src/animate/animation';
+export {AnimationBuilder} from './src/animate/animation_builder';
+export {BrowserDetails} from './src/animate/browser_details';
+export {CssAnimationBuilder} from './src/animate/css_animation_builder';
+export {CssAnimationOptions} from './src/animate/css_animation_options';

node_modules/angular2/ts/animate/testing.ts

@@ -0,0 +1 @@
+export * from 'angular2/src/mock/animation_builder_mock';

node_modules/angular2/ts/bootstrap.ts

@@ -0,0 +1,6 @@
+/**
+ * See {@link bootstrap} for more information.
+ * @deprecated
+ */
+export {bootstrap} from 'angular2/platform/browser';
+export {AngularEntrypoint} from 'angular2/src/core/angular_entrypoint';

node_modules/angular2/ts/bootstrap_static.ts

@@ -0,0 +1,6 @@
+/**
+ * See {@link bootstrap} for more information.
+ * @deprecated
+ */
+export {bootstrapStatic} from 'angular2/platform/browser_static';
+export {AngularEntrypoint} from 'angular2/src/core/angular_entrypoint';

node_modules/angular2/ts/common.ts

@@ -0,0 +1,4 @@
+export * from './src/common/pipes';
+export * from './src/common/directives';
+export * from './src/common/forms';
+export * from './src/common/common_directives';

node_modules/angular2/ts/compiler.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * @description
+ * Starting point to import all compiler APIs.
+ */
+export * from './src/compiler/url_resolver';
+export * from './src/compiler/xhr';
+export * from './src/compiler/compiler';

node_modules/angular2/ts/core.ts

@@ -0,0 +1,29 @@
+/**
+ * @module
+ * @description
+ * Starting point to import all public core APIs.
+ */
+export * from './src/core/metadata';
+export * from './src/core/util';
+export * from './src/core/prod_mode';
+export * from './src/core/di';
+export * from './src/facade/facade';
+export {enableProdMode} from 'angular2/src/facade/lang';
+export {platform, createNgZone, PlatformRef, ApplicationRef} from './src/core/application_ref';
+export {
+  APP_ID,
+  APP_COMPONENT,
+  APP_INITIALIZER,
+  PACKAGE_ROOT_URL,
+  PLATFORM_INITIALIZER
+} from './src/core/application_tokens';
+export * from './src/core/zone';
+export * from './src/core/render';
+export * from './src/core/linker';
+export {DebugElement, DebugNode, asNativeElements} from './src/core/debug/debug_node';
+export * from './src/core/testability/testability';
+export * from './src/core/change_detection';
+export * from './src/core/platform_directives_and_pipes';
+export * from './src/core/platform_common_providers';
+export * from './src/core/application_common_providers';
+export * from './src/core/reflection/reflection';

node_modules/angular2/ts/examples/README.md

@@ -0,0 +1,6 @@
+# API Examples
+
+This folder contains small example apps that get in-lined into our API docs.
+These examples are written with idiomatic TypeScript, and are not transpiled to Dart.
+Each example contains tests for application behavior (as opposed to testing Angular's
+behavior) just like an Angular application developer would write.

node_modules/angular2/ts/examples/common/forms/ts/validators/validators.ts

@@ -0,0 +1,30 @@
+import {Component} from 'angular2/core';
+import {MinLengthValidator, MaxLengthValidator} from 'angular2/common';
+
+// #docregion min
+@Component({
+  selector: 'min-cmp',
+  directives: [MinLengthValidator],
+  template: `
+<form>
+  <p>Year: <input ngControl="year" minlength="2"></p>
+</form>
+`
+})
+class MinLengthTestComponent {
+}
+// #enddocregion
+
+// #docregion max
+@Component({
+  selector: 'max-cmp',
+  directives: [MaxLengthValidator],
+  template: `
+<form>
+  <p>Year: <input ngControl="year" maxlength="4"></p>
+</form>
+`
+})
+class MaxLengthTestComponent {
+}
+// #enddocregion

node_modules/angular2/ts/examples/compiler/ts/url_resolver/url_resolver.ts

@@ -0,0 +1,19 @@
+import {provide} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+import {UrlResolver} from 'angular2/compiler';
+
+var MyApp: any;
+
+// #docregion url_resolver
+class MyUrlResolver extends UrlResolver {
+  resolve(baseUrl: string, url: string): string {
+    // Serve CSS files from a special CDN.
+    if (url.substr(-4) === '.css') {
+      return super.resolve('http://cdn.myapp.com/css/', url);
+    }
+    return super.resolve(baseUrl, url);
+  }
+}
+
+bootstrap(MyApp, [provide(UrlResolver, {useClass: MyUrlResolver})]);
+// #enddocregion

node_modules/angular2/ts/examples/core/debug/ts/debug_element/debug_element.ts

@@ -0,0 +1,8 @@
+import {DebugElement} from 'angular2/core';
+
+var debugElement: DebugElement;
+var predicate: any;
+
+// #docregion scope_all
+debugElement.query(predicate);
+// #enddocregion

node_modules/angular2/ts/examples/core/di/ts/forward_ref/forward_ref.ts

@@ -0,0 +1,26 @@
+import {Inject, Injector, forwardRef, resolveForwardRef, ForwardRefFn} from 'angular2/core';
+
+// #docregion forward_ref_fn
+var ref = forwardRef(() => Lock);
+// #enddocregion
+
+// #docregion forward_ref
+class Door {
+  lock: Lock;
+  constructor(@Inject(forwardRef(() => Lock)) lock: Lock) { this.lock = lock; }
+}
+
+// Only at this point Lock is defined.
+class Lock {}
+
+var injector = Injector.resolveAndCreate([Door, Lock]);
+var door = injector.get(Door);
+expect(door instanceof Door).toBe(true);
+expect(door.lock instanceof Lock).toBe(true);
+// #enddocregion
+
+// #docregion resolve_forward_ref
+var ref = forwardRef(() => "refValue");
+expect(resolveForwardRef(ref)).toEqual("refValue");
+expect(resolveForwardRef("regularValue")).toEqual("regularValue");
+// #enddocregion

node_modules/angular2/ts/examples/core/forms/ts/ng_validators/ng_validators.ts

@@ -0,0 +1,10 @@
+import {bootstrap} from 'angular2/platform/browser';
+import {NG_VALIDATORS} from 'angular2/common';
+import {Provider} from 'angular2/core';
+
+let MyApp: Function = null;
+let myValidator: any = null;
+
+// #docregion ng_validators
+bootstrap(MyApp, [new Provider(NG_VALIDATORS, {useValue: myValidator, multi: true})]);
+// #enddocregion

node_modules/angular2/ts/examples/core/pipes/ts/async_pipe/async_pipe_example.dart

@@ -0,0 +1,2 @@
+library angular2.examples.core.pipes.ts.async_pipe;
+// TODO(alxhub): Implement an example for Dart.

node_modules/angular2/ts/examples/core/pipes/ts/async_pipe/async_pipe_example.ts

@@ -0,0 +1,59 @@
+import {Component, provide} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+import {Observable, Subscriber} from 'rxjs/Rx';
+
+// #docregion AsyncPipe
+@Component({
+  selector: 'async-example',
+  template: `<div>
+    <p>Wait for it... {{ greeting | async }}</p>
+    <button (click)="clicked()">{{ arrived ? 'Reset' : 'Resolve' }}</button>
+  </div>`
+})
+export class AsyncPipeExample {
+  greeting: Promise<string> = null;
+  arrived: boolean = false;
+
+  private resolve: Function = null;
+
+  constructor() { this.reset(); }
+
+  reset() {
+    this.arrived = false;
+    this.greeting = new Promise<string>((resolve, reject) => { this.resolve = resolve; });
+  }
+
+  clicked() {
+    if (this.arrived) {
+      this.reset();
+    } else {
+      this.resolve("hi there!");
+      this.arrived = true;
+    }
+  }
+}
+// #enddocregion
+
+// #docregion AsyncPipeObservable
+@Component({selector: "task-cmp", template: "Time: {{ time | async }}"})
+class Task {
+  time = new Observable<number>((observer: Subscriber<number>) => {
+    setInterval(() => observer.next(new Date().getTime()), 500);
+  });
+}
+// #enddocregion
+
+@Component({
+  selector: 'example-app',
+  directives: [AsyncPipeExample],
+  template: `
+    <h1>AsyncPipe Example</h1>
+    <async-example></async-example>
+  `
+})
+export class AppCmp {
+}
+
+export function main() {
+  bootstrap(AppCmp);
+}

node_modules/angular2/ts/examples/core/pipes/ts/async_pipe/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+<head>
+  <title>AsyncPipe Example</title>
+  <base href="/">
+
+  <script src="http://cdn.rawgit.com/google/traceur-compiler/90da568c7aa8e53ea362db1fc211fbb4f65b5e94/bin/traceur-runtime.js"></script>
+  <script src="http://cdnjs.cloudflare.com/ajax/libs/systemjs/0.18.4/system.js"></script>
+  <script>System.config({ baseURL: '/', defaultJSExtensions: true});</script>
+  <script src="/bundle/angular2.dev.js"></script>
+  <script src="/bundle/router.dev.js"></script>
+</head>
+<body>
+<example-app>
+  Loading...
+</example-app>
+<script>
+  var filename = 'angular2/examples/core/pipes/ts/async_pipe/async_pipe_example';
+  System.import(filename).then(function(m) {
+    m.main();
+  }, console.error.bind(console));
+</script>
+</body>
+</html>

node_modules/angular2/ts/examples/core/pipes/ts/date_pipe/date_pipe_example.dart

@@ -0,0 +1,2 @@
+library angular2.examples.core.pipes.ts.date_pipe;
+// TODO(alxhub): Implement an example for Dart.

node_modules/angular2/ts/examples/core/pipes/ts/date_pipe/date_pipe_example.ts

@@ -0,0 +1,31 @@
+import {Component, provide} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+
+// #docregion DatePipe
+@Component({
+  selector: 'date-example',
+  template: `<div>
+    <p>Today is {{today | date}}</p>
+    <p>Or if you prefer, {{today | date:'fullDate'}}</p>
+    <p>The time is {{today | date:'jmZ'}}</p>
+  </div>`
+})
+export class DatePipeExample {
+  today: number = Date.now();
+}
+// #enddocregion
+
+@Component({
+  selector: 'example-app',
+  directives: [DatePipeExample],
+  template: `
+    <h1>DatePipe Example</h1>
+    <date-example></date-example>
+  `
+})
+export class AppCmp {
+}
+
+export function main() {
+  bootstrap(AppCmp);
+}

node_modules/angular2/ts/examples/core/pipes/ts/date_pipe/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+<head>
+  <title>DatePipe Example</title>
+  <base href="/">
+
+  <script src="http://cdn.rawgit.com/google/traceur-compiler/90da568c7aa8e53ea362db1fc211fbb4f65b5e94/bin/traceur-runtime.js"></script>
+  <script src="http://cdnjs.cloudflare.com/ajax/libs/systemjs/0.18.4/system.js"></script>
+  <script>System.config({ baseURL: '/', defaultJSExtensions: true});</script>
+  <script src="/bundle/angular2.dev.js"></script>
+  <script src="/bundle/router.dev.js"></script>
+</head>
+<body>
+<example-app>
+  Loading...
+</example-app>
+<script>
+  var filename = 'angular2/examples/core/pipes/ts/date_pipe/date_pipe_example';
+  System.import(filename).then(function(m) {
+    m.main();
+  }, console.error.bind(console));
+</script>
+</body>
+</html>

node_modules/angular2/ts/examples/core/pipes/ts/json_pipe/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+<head>
+  <title>JsonPipe Example</title>
+  <base href="/">
+
+  <script src="http://cdn.rawgit.com/google/traceur-compiler/90da568c7aa8e53ea362db1fc211fbb4f65b5e94/bin/traceur-runtime.js"></script>
+  <script src="http://cdnjs.cloudflare.com/ajax/libs/systemjs/0.18.4/system.js"></script>
+  <script>System.config({ baseURL: '/', defaultJSExtensions: true});</script>
+  <script src="/bundle/angular2.dev.js"></script>
+  <script src="/bundle/router.dev.js"></script>
+</head>
+<body>
+<example-app>
+  Loading...
+</example-app>
+<script>
+  var filename = 'angular2/examples/core/pipes/ts/json_pipe/json_pipe_example';
+  System.import(filename).then(function(m) {
+    m.main();
+  }, console.error.bind(console));
+</script>
+</body>
+</html>

node_modules/angular2/ts/examples/core/pipes/ts/json_pipe/json_pipe_example.ts

@@ -0,0 +1,32 @@
+import {Component, provide} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+
+// #docregion JsonPipe
+@Component({
+  selector: 'json-example',
+  template: `<div>
+    <p>Without JSON pipe:</p>
+    <pre>{{object}}</pre>
+    <p>With JSON pipe:</p>
+    <pre>{{object | json}}</pre>
+  </div>`
+})
+export class JsonPipeExample {
+  object: Object = {foo: 'bar', baz: 'qux', nested: {xyz: 3, numbers: [1, 2, 3, 4, 5]}}
+}
+// #enddocregion
+
+@Component({
+  selector: 'example-app',
+  directives: [JsonPipeExample],
+  template: `
+    <h1>JsonPipe Example</h1>
+    <json-example></json-example>
+  `
+})
+export class AppCmp {
+}
+
+export function main() {
+  bootstrap(AppCmp);
+}

node_modules/angular2/ts/examples/core/pipes/ts/lowerupper_pipe/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+<head>
+  <title>LowercasePipe &amp; UppercasePipe Example</title>
+  <base href="/">
+
+  <script src="http://cdn.rawgit.com/google/traceur-compiler/90da568c7aa8e53ea362db1fc211fbb4f65b5e94/bin/traceur-runtime.js"></script>
+  <script src="http://cdnjs.cloudflare.com/ajax/libs/systemjs/0.18.4/system.js"></script>
+  <script>System.config({ baseURL: '/', defaultJSExtensions: true});</script>
+  <script src="/bundle/angular2.dev.js"></script>
+  <script src="/bundle/router.dev.js"></script>
+</head>
+<body>
+<example-app>
+  Loading...
+</example-app>
+<script>
+  var filename = 'angular2/examples/core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example';
+  System.import(filename).then(function(m) {
+    m.main();
+  }, console.error.bind(console));
+</script>
+</body>
+</html>

node_modules/angular2/ts/examples/core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts

@@ -0,0 +1,32 @@
+import {Component, provide} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+
+// #docregion LowerUpperPipe
+@Component({
+  selector: 'lowerupper-example',
+  template: `<div>
+    <label>Name: </label><input #name (keyup)="change(name.value)" type="text">
+    <p>In lowercase: <pre>'{{value | lowercase}}'</pre></p>
+    <p>In uppercase: <pre>'{{value | uppercase}}'</pre></p>
+  </div>`
+})
+export class LowerUpperPipeExample {
+  value: string;
+  change(value: string) { this.value = value; }
+}
+// #enddocregion
+
+@Component({
+  selector: 'example-app',
+  directives: [LowerUpperPipeExample],
+  template: `
+    <h1>LowercasePipe &amp; UppercasePipe Example</h1>
+    <lowerupper-example></lowerupper-example>
+  `
+})
+export class AppCmp {
+}
+
+export function main() {
+  bootstrap(AppCmp);
+}

node_modules/angular2/ts/examples/core/pipes/ts/number_pipe/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+<head>
+  <title>Numeric Pipe Examples</title>
+  <base href="/">
+
+  <script src="http://cdn.rawgit.com/google/traceur-compiler/90da568c7aa8e53ea362db1fc211fbb4f65b5e94/bin/traceur-runtime.js"></script>
+  <script src="http://cdnjs.cloudflare.com/ajax/libs/systemjs/0.18.4/system.js"></script>
+  <script>System.config({ baseURL: '/', defaultJSExtensions: true});</script>
+  <script src="/bundle/angular2.dev.js"></script>
+  <script src="/bundle/router.dev.js"></script>
+</head>
+<body>
+<example-app>
+  Loading...
+</example-app>
+<script>
+  var filename = 'angular2/examples/core/pipes/ts/number_pipe/number_pipe_example';
+  System.import(filename).then(function(m) {
+    m.main();
+  }, console.error.bind(console));
+</script>
+</body>
+</html>

node_modules/angular2/ts/examples/core/pipes/ts/number_pipe/number_pipe_example.ts

@@ -0,0 +1,66 @@
+import {Component, provide} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+
+// #docregion NumberPipe
+@Component({
+  selector: 'number-example',
+  template: `<div>
+    <p>e (no formatting): {{e}}</p>
+    <p>e (3.1-5): {{e | number:'3.1-5'}}</p>
+    <p>pi (no formatting): {{pi}}</p>
+    <p>pi (3.5-5): {{pi | number:'3.5-5'}}</p>
+  </div>`
+})
+export class NumberPipeExample {
+  pi: number = 3.141;
+  e: number = 2.718281828459045;
+}
+// #enddocregion
+
+// #docregion PercentPipe
+@Component({
+  selector: 'percent-example',
+  template: `<div>
+    <p>A: {{a | percent}}</p>
+    <p>B: {{b | percent:'4.3-5'}}</p>
+  </div>`
+})
+export class PercentPipeExample {
+  a: number = 0.259;
+  b: number = 1.3495;
+}
+// #enddocregion
+
+// #docregion CurrencyPipe
+@Component({
+  selector: 'currency-example',
+  template: `<div>
+    <p>A: {{a | currency:'USD':false}}</p>
+    <p>B: {{b | currency:'USD':true:'4.2-2'}}</p>
+  </div>`
+})
+export class CurrencyPipeExample {
+  a: number = 0.259;
+  b: number = 1.3495;
+}
+// #enddocregion
+
+@Component({
+  selector: 'example-app',
+  directives: [NumberPipeExample, PercentPipeExample, CurrencyPipeExample],
+  template: `
+    <h1>Numeric Pipe Examples</h1>
+    <h2>NumberPipe Example</h2>
+    <number-example></number-example>
+    <h2>PercentPipe Example</h2>
+    <percent-example></percent-example>
+    <h2>CurrencyPipeExample</h2>
+    <currency-example></currency-example>
+  `
+})
+export class AppCmp {
+}
+
+export function main() {
+  bootstrap(AppCmp);
+}

node_modules/angular2/ts/examples/core/pipes/ts/slice_pipe/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+<head>
+  <title>SlicePipe Example</title>
+  <base href="/">
+
+  <script src="http://cdn.rawgit.com/google/traceur-compiler/90da568c7aa8e53ea362db1fc211fbb4f65b5e94/bin/traceur-runtime.js"></script>
+  <script src="http://cdnjs.cloudflare.com/ajax/libs/systemjs/0.18.4/system.js"></script>
+  <script>System.config({ baseURL: '/', defaultJSExtensions: true});</script>
+  <script src="/bundle/angular2.dev.js"></script>
+  <script src="/bundle/router.dev.js"></script>
+</head>
+<body>
+<example-app>
+  Loading...
+</example-app>
+<script>
+  var filename = 'angular2/examples/core/pipes/ts/slice_pipe/slice_pipe_example';
+  System.import(filename).then(function(m) {
+    m.main();
+  }, console.error.bind(console));
+</script>
+</body>
+</html>

node_modules/angular2/ts/examples/core/pipes/ts/slice_pipe/slice_pipe_example.ts

@@ -0,0 +1,47 @@
+import {Component, provide} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+
+// #docregion SlicePipe_string
+@Component({
+  selector: 'slice-string-example',
+  template: `<div>
+    <p>{{str}}[0:4]: '{{str | slice:0:4}}' - output is expected to be 'abcd'</p>
+    <p>{{str}}[4:0]: '{{str | slice:4:0}}' - output is expected to be ''</p>
+    <p>{{str}}[-4]: '{{str | slice:-4}}' - output is expected to be 'ghij'</p>
+    <p>{{str}}[-4:-2]: '{{str | slice:-4:-2}}' - output is expected to be 'gh'</p>
+    <p>{{str}}[-100]: '{{str | slice:-100}}' - output is expected to be 'abcdefghij'</p>
+    <p>{{str}}[100]: '{{str | slice:100}}' - output is expected to be ''</p>
+  </div>`
+})
+export class SlicePipeStringExample {
+  str: string = 'abcdefghij';
+}
+// #enddocregion
+
+// #docregion SlicePipe_list
+@Component({
+  selector: 'slice-list-example',
+  template: `<div>
+    <li *ngFor="var i of collection | slice:1:3">{{i}}</li>
+  </div>`
+})
+export class SlicePipeListExample {
+  collection: string[] = ['a', 'b', 'c', 'd'];
+}
+// #enddocregion
+
+@Component({
+  selector: 'example-app',
+  directives: [SlicePipeListExample, SlicePipeStringExample],
+  template: `
+    <h1>SlicePipe Examples</h1>
+    <slice-list-example></slice-list-example>
+    <slice-string-example></slice-string-example>
+  `
+})
+export class AppCmp {
+}
+
+export function main() {
+  bootstrap(AppCmp);
+}

node_modules/angular2/ts/examples/core/ts/bootstrap/bootstrap.ts

@@ -0,0 +1,13 @@
+import {Component} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+
+// #docregion bootstrap
+@Component({selector: 'my-app', template: 'Hello {{ name }}!'})
+class MyApp {
+  name: string = 'World';
+}
+
+function main() {
+  return bootstrap(MyApp);
+}
+// #enddocregion

node_modules/angular2/ts/examples/core/ts/metadata/metadata.ts

@@ -0,0 +1,43 @@
+import {Component, Attribute, Directive, Pipe} from 'angular2/core';
+
+var CustomDirective: Function;
+
+// #docregion component
+@Component({selector: 'greet', template: 'Hello {{name}}!', directives: [CustomDirective]})
+class Greet {
+  name: string = 'World';
+}
+// #enddocregion
+
+// #docregion attributeFactory
+@Component({selector: 'page', template: 'Title: {{title}}'})
+class Page {
+  title: string;
+  constructor(@Attribute('title') title: string) { this.title = title; }
+}
+// #enddocregion
+
+// #docregion attributeMetadata
+@Directive({selector: 'input'})
+class InputAttrDirective {
+  constructor(@Attribute('type') type: string) {
+    // type would be 'text' in this example
+  }
+}
+// #enddocregion
+
+// #docregion directive
+@Directive({selector: 'input'})
+class InputDirective {
+  constructor() {
+    // Add some logic.
+  }
+}
+// #enddocregion
+
+// #docregion pipe
+@Pipe({name: 'lowercase'})
+class Lowercase {
+  transform(v: string, args: any[]) { return v.toLowerCase(); }
+}
+// #enddocregion

node_modules/angular2/ts/examples/core/ts/platform/platform.ts

@@ -0,0 +1,13 @@
+import {Component, platform} from 'angular2/core';
+import {BROWSER_PROVIDERS, BROWSER_APP_PROVIDERS} from 'angular2/platform/browser';
+
+var appProviders: any[] = [];
+
+// #docregion longform
+@Component({selector: 'my-app', template: 'Hello World'})
+class MyApp {
+}
+
+var app = platform(BROWSER_PROVIDERS).application([BROWSER_APP_PROVIDERS, appProviders]);
+app.bootstrap(MyApp);
+// #enddocregion

node_modules/angular2/ts/examples/core/ts/prod_mode/my_component.ts

@@ -0,0 +1,5 @@
+import {Component} from 'angular2/core';
+
+@Component({selector: 'my-component', template: '<h1>My Component</h1>'})
+export class MyComponent {
+}

node_modules/angular2/ts/examples/core/ts/prod_mode/prod_mode_example.ts

@@ -0,0 +1,8 @@
+// #docregion enableProdMode
+import {enableProdMode} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+import {MyComponent} from './my_component';
+
+enableProdMode();
+bootstrap(MyComponent);
+// #enddocregion

node_modules/angular2/ts/examples/facade/ts/async/observable.ts

@@ -0,0 +1,8 @@
+// #docregion Observable
+import {Observable, Subscriber} from 'rxjs/Rx';
+var obs = new Observable<number>((obs: Subscriber<number>) => {
+  var i = 0;
+  setInterval(() => { obs.next(++i); }, 1000);
+});
+obs.subscribe(i => console.log(`${i} seconds elapsed`));
+// #enddocregion

node_modules/angular2/ts/examples/facade/ts/async/observable_all.ts

@@ -0,0 +1,3 @@
+// #docregion Observable
+import 'rxjs';
+// #enddocregion

node_modules/angular2/ts/examples/facade/ts/async/observable_patched.ts

@@ -0,0 +1,10 @@
+// #docregion Observable
+import {Observable, Subscriber} from 'rxjs/Rx';
+import 'rxjs/add/operator/map';
+
+var obs = new Observable<number>((obs: Subscriber<any>) => {
+  var i = 0;
+  setInterval(() => obs.next(++i), 1000);
+});
+obs.map((i: number) => `${i} seconds elapsed`).subscribe(msg => console.log(msg));
+// #enddocregion

node_modules/angular2/ts/examples/facade/ts/async/observable_pure.ts

@@ -0,0 +1,10 @@
+// #docregion Observable
+import {Observable, Subscriber} from 'rxjs/Rx';
+import {map} from 'rxjs/operator/map';
+
+var obs = new Observable<number>((sub: Subscriber<number>) => {
+  var i = 0;
+  setInterval(() => sub.next(++i), 1000);
+});
+map.call(obs, (i: number) => `${i} seconds elapsed`).subscribe((msg: string) => console.log(msg));
+// #enddocregion

node_modules/angular2/ts/examples/platform/dom/debug/ts/by/by.ts

@@ -0,0 +1,17 @@
+import {By} from 'angular2/platform/browser';
+import {DebugElement} from 'angular2/core';
+
+var debugElement: DebugElement;
+class MyDirective {}
+
+// #docregion by_all
+debugElement.query(By.all());
+// #enddocregion
+
+// #docregion by_css
+debugElement.query(By.css('[attribute]'));
+// #enddocregion
+
+// #docregion by_directive
+debugElement.query(By.directive(MyDirective));
+// #enddocregion

node_modules/angular2/ts/examples/platform/dom/debug/ts/debug_element_view_listener/providers.ts

@@ -0,0 +1,10 @@
+import {Component} from 'angular2/core';
+import {bootstrap, ELEMENT_PROBE_PROVIDERS} from 'angular2/platform/browser';
+
+@Component({selector: 'my-component'})
+class MyAppComponent {
+}
+
+// #docregion providers
+bootstrap(MyAppComponent, [ELEMENT_PROBE_PROVIDERS]);
+// #enddocregion

node_modules/angular2/ts/examples/router/ts/can_activate/can_activate_example.ts

@@ -0,0 +1,57 @@
+import {provide, Component} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+import {
+  CanActivate,
+  RouteConfig,
+  ComponentInstruction,
+  APP_BASE_HREF,
+  ROUTER_DIRECTIVES
+} from 'angular2/router';
+
+function checkIfWeHavePermission(instruction: ComponentInstruction) {
+  return instruction.params['id'] == '1';
+}
+
+// #docregion canActivate
+@Component({selector: 'control-panel-cmp', template: `<div>Settings: ...</div>`})
+@CanActivate(checkIfWeHavePermission)
+class ControlPanelCmp {
+}
+// #enddocregion
+
+
+@Component({
+  selector: 'home-cmp',
+  template: `
+    <h1>Welcome Home!</h1>
+    <div>
+      Edit <a [routerLink]="['/ControlPanelCmp', {id: 1}]" id="user-1-link">User 1</a> |
+      Edit <a [routerLink]="['/ControlPanelCmp', {id: 2}]" id="user-2-link">User 2</a>
+    </div>
+  `,
+  directives: [ROUTER_DIRECTIVES]
+})
+class HomeCmp {
+}
+
+
+@Component({
+  selector: 'example-app',
+  template: `
+    <h1>My App</h1>
+    <router-outlet></router-outlet>
+  `,
+  directives: [ROUTER_DIRECTIVES]
+})
+@RouteConfig([
+  {path: '/user-settings/:id', component: ControlPanelCmp, name: 'ControlPanelCmp'},
+  {path: '/', component: HomeCmp, name: 'HomeCmp'}
+])
+class AppCmp {
+}
+
+
+export function main() {
+  return bootstrap(
+      AppCmp, [provide(APP_BASE_HREF, {useValue: '/angular2/examples/router/ts/can_activate'})]);
+}

node_modules/angular2/ts/examples/router/ts/can_activate/can_activate_spec.ts

@@ -0,0 +1,36 @@
+import {verifyNoBrowserErrors, browser} from 'angular2/src/testing/e2e_util';
+import {expect} from 'angular2/testing';
+
+function waitForElement(selector: string) {
+  var EC = (<any>protractor).ExpectedConditions;
+  // Waits for the element with id 'abc' to be present on the dom.
+  browser.wait(EC.presenceOf($(selector)), 20000);
+}
+
+describe('reuse example app', function() {
+
+  afterEach(verifyNoBrowserErrors);
+
+  var URL = 'angular2/examples/router/ts/can_activate/';
+
+  it('should navigate to user 1', function() {
+    browser.get(URL);
+    waitForElement('home-cmp');
+
+    element(by.css('#user-1-link')).click();
+    waitForElement('control-panel-cmp');
+    expect(browser.getCurrentUrl()).toMatch(/\/user-settings\/1$/);
+
+    expect(element(by.css('control-panel-cmp')).getText()).toContain('Settings');
+  });
+
+  it('should not navigate to user 2', function() {
+    browser.get(URL);
+    waitForElement('home-cmp');
+
+    element(by.css('#user-2-link')).click();
+    waitForElement('home-cmp');
+
+    expect(element(by.css('home-cmp')).getText()).toContain('Welcome Home!');
+  });
+});

node_modules/angular2/ts/examples/router/ts/can_activate/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+<head>
+  <title>Routing canActivate Lifecycle Example</title>
+  <base href="/">
+
+  <script src="http://cdn.rawgit.com/google/traceur-compiler/90da568c7aa8e53ea362db1fc211fbb4f65b5e94/bin/traceur-runtime.js"></script>
+  <script src="http://cdnjs.cloudflare.com/ajax/libs/systemjs/0.18.4/system.js"></script>
+  <script>System.config({ baseURL: '/', defaultJSExtensions: true});</script>
+  <script src="/bundle/angular2.dev.js"></script>
+  <script src="/bundle/router.dev.js"></script>
+</head>
+<body>
+<example-app>
+  Loading...
+</example-app>
+<script>
+  var filename = 'angular2/examples/router/ts/can_activate/can_activate_example';
+  System.import(filename).then(function(m) {
+    m.main();
+  }, console.error.bind(console));
+</script>
+</body>
+</html>

node_modules/angular2/ts/examples/router/ts/can_deactivate/can_deactivate_example.ts

@@ -0,0 +1,67 @@
+import {provide, Component} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+import {
+  CanDeactivate,
+  RouteConfig,
+  RouteParams,
+  ComponentInstruction,
+  ROUTER_DIRECTIVES,
+  APP_BASE_HREF
+} from 'angular2/router';
+
+// #docregion routerCanDeactivate
+@Component({
+  selector: 'note-cmp',
+  template: `
+    <div>
+      <h2>id: {{id}}</h2>
+      <textarea cols="40" rows="10"></textarea>
+    </div>`
+})
+class NoteCmp implements CanDeactivate {
+  id: string;
+
+  constructor(params: RouteParams) { this.id = params.get('id'); }
+
+  routerCanDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    return confirm('Are you sure you want to leave?');
+  }
+}
+// #enddocregion
+
+
+@Component({
+  selector: 'note-index-cmp',
+  template: `
+    <h1>Your Notes</h1>
+    <div>
+      Edit <a [routerLink]="['/NoteCmp', {id: 1}]" id="note-1-link">Note 1</a> |
+      Edit <a [routerLink]="['/NoteCmp', {id: 2}]" id="note-2-link">Note 2</a>
+    </div>
+  `,
+  directives: [ROUTER_DIRECTIVES]
+})
+class NoteIndexCmp {
+}
+
+
+@Component({
+  selector: 'example-app',
+  template: `
+    <h1>My App</h1>
+    <router-outlet></router-outlet>
+  `,
+  directives: [ROUTER_DIRECTIVES]
+})
+@RouteConfig([
+  {path: '/note/:id', component: NoteCmp, name: 'NoteCmp'},
+  {path: '/', component: NoteIndexCmp, name: 'NoteIndexCmp'}
+])
+class AppCmp {
+}
+
+
+export function main() {
+  return bootstrap(
+      AppCmp, [provide(APP_BASE_HREF, {useValue: '/angular2/examples/router/ts/can_deactivate'})]);
+}

node_modules/angular2/ts/examples/router/ts/can_deactivate/can_deactivate_spec.ts

@@ -0,0 +1,52 @@
+import {verifyNoBrowserErrors, browser} from 'angular2/src/testing/e2e_util';
+import {expect} from 'angular2/testing';
+
+function waitForElement(selector: string) {
+  var EC = (<any>protractor).ExpectedConditions;
+  // Waits for the element with id 'abc' to be present on the dom.
+  browser.wait(EC.presenceOf($(selector)), 20000);
+}
+
+function waitForAlert() {
+  var EC = (<any>protractor).ExpectedConditions;
+  browser.wait(EC.alertIsPresent(), 1000);
+}
+
+describe('can deactivate example app', function() {
+
+  afterEach(verifyNoBrowserErrors);
+
+  var URL = 'angular2/examples/router/ts/can_deactivate/';
+
+  it('should not navigate away when prompt is cancelled', function() {
+    browser.get(URL);
+    waitForElement('note-index-cmp');
+
+    element(by.css('#note-1-link')).click();
+    waitForElement('note-cmp');
+
+    browser.navigate().back();
+    waitForAlert();
+
+    browser.switchTo().alert().dismiss();  // Use to simulate cancel button
+
+    expect(element(by.css('note-cmp')).getText()).toContain('id: 1');
+  });
+
+  it('should navigate away when prompt is confirmed', function() {
+    browser.get(URL);
+    waitForElement('note-index-cmp');
+
+    element(by.css('#note-1-link')).click();
+    waitForElement('note-cmp');
+
+    browser.navigate().back();
+    waitForAlert();
+
+    browser.switchTo().alert().accept();
+
+    waitForElement('note-index-cmp');
+
+    expect(element(by.css('note-index-cmp')).getText()).toContain('Your Notes');
+  });
+});

node_modules/angular2/ts/examples/router/ts/can_deactivate/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+<head>
+  <title>Routing routerCanDeactivate Lifecycle Example</title>
+  <base href="/">
+
+  <script src="http://cdn.rawgit.com/google/traceur-compiler/90da568c7aa8e53ea362db1fc211fbb4f65b5e94/bin/traceur-runtime.js"></script>
+  <script src="http://cdnjs.cloudflare.com/ajax/libs/systemjs/0.18.4/system.js"></script>
+  <script>System.config({ baseURL: '/', defaultJSExtensions: true});</script>
+  <script src="/bundle/angular2.dev.js"></script>
+  <script src="/bundle/router.dev.js"></script>
+</head>
+<body>
+<example-app>
+  Loading...
+</example-app>
+<script>
+  var filename = 'angular2/examples/router/ts/can_deactivate/can_deactivate_example';
+  System.import(filename).then(function(m) {
+    m.main();
+  }, console.error.bind(console));
+</script>
+</body>
+</html>

node_modules/angular2/ts/examples/router/ts/on_activate/on_activate_example.ts

@@ -0,0 +1,57 @@
+import {Component, provide} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+import {
+  OnActivate,
+  ComponentInstruction,
+  RouteConfig,
+  ROUTER_DIRECTIVES,
+  APP_BASE_HREF
+} from 'angular2/router';
+
+// #docregion routerOnActivate
+@Component({template: `Child`})
+class ChildCmp {
+}
+
+@Component({
+  template: `
+    <h2>Parent</h2> (<router-outlet></router-outlet>) 
+    <p>{{log}}</p>`,
+  directives: [ROUTER_DIRECTIVES]
+})
+@RouteConfig([{path: '/child', name: 'Child', component: ChildCmp}])
+class ParentCmp implements OnActivate {
+  log: string = '';
+
+  routerOnActivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    this.log = `Finished navigating from "${prev ? prev.urlPath : 'null'}" to "${next.urlPath}"`;
+
+    return new Promise(resolve => {
+      // The ChildCmp gets instantiated only when the Promise is resolved
+      setTimeout(() => resolve(null), 1000);
+    });
+  }
+}
+// #enddocregion
+
+
+@Component({
+  selector: 'example-app',
+  template: `
+    <h1>My app</h1>
+    
+    <nav>
+      <a [routerLink]="['Parent', 'Child']">Child</a>
+    </nav>
+    <router-outlet></router-outlet>
+  `,
+  directives: [ROUTER_DIRECTIVES]
+})
+@RouteConfig([{path: '/parent/...', name: 'Parent', component: ParentCmp}])
+export class AppCmp {
+}
+
+export function main() {
+  return bootstrap(
+      AppCmp, [provide(APP_BASE_HREF, {useValue: '/angular2/examples/router/ts/on_activate'})]);
+}

node_modules/angular2/ts/examples/router/ts/on_deactivate/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+<head>
+  <title>Routing Reuse Lifecycle Example</title>
+  <base href="/">
+
+  <script src="http://cdn.rawgit.com/google/traceur-compiler/90da568c7aa8e53ea362db1fc211fbb4f65b5e94/bin/traceur-runtime.js"></script>
+  <script src="http://cdnjs.cloudflare.com/ajax/libs/systemjs/0.18.4/system.js"></script>
+  <script>System.config({ baseURL: '/', defaultJSExtensions: true});</script>
+  <script src="/bundle/angular2.dev.js"></script>
+  <script src="/bundle/router.dev.js"></script>
+</head>
+<body>
+<example-app>
+  Loading...
+</example-app>
+<script>
+  var filename = 'angular2/examples/router/ts/on_deactivate/on_deactivate_example';
+  System.import(filename).then(function(m) {
+    m.main();
+  }, console.error.bind(console));
+</script>
+</body>
+</html>

node_modules/angular2/ts/examples/router/ts/on_deactivate/on_deactivate_example.ts

@@ -0,0 +1,63 @@
+import {Component, Injectable, provide} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+import {
+  OnDeactivate,
+  ComponentInstruction,
+  RouteConfig,
+  ROUTER_DIRECTIVES,
+  APP_BASE_HREF
+} from 'angular2/router';
+
+
+@Injectable()
+class LogService {
+  logs: string[] = [];
+
+  addLog(message: string): void { this.logs.push(message); }
+}
+
+
+// #docregion routerOnDeactivate
+@Component({selector: 'my-cmp', template: `<div>hello</div>`})
+class MyCmp implements OnDeactivate {
+  constructor(private logService: LogService) {}
+
+  routerOnDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    this.logService.addLog(
+        `Navigating from "${prev ? prev.urlPath : 'null'}" to "${next.urlPath}"`);
+  }
+}
+// #enddocregion
+
+
+@Component({
+  selector: 'example-app',
+  template: `
+    <h1>My App</h1>
+    <nav>
+      <a [routerLink]="['/HomeCmp']" id="home-link">Navigate Home</a> |
+      <a [routerLink]="['/ParamCmp', {param: 1}]" id="param-link">Navigate with a Param</a>
+    </nav>
+    <router-outlet></router-outlet>
+    <div id="log">
+      <h2>Log:</h2>
+      <p *ngFor="#logItem of logService.logs">{{ logItem }}</p>
+    </div>
+  `,
+  directives: [ROUTER_DIRECTIVES]
+})
+@RouteConfig([
+  {path: '/', component: MyCmp, name: 'HomeCmp'},
+  {path: '/:param', component: MyCmp, name: 'ParamCmp'}
+])
+class AppCmp {
+  constructor(public logService: LogService) {}
+}
+
+
+export function main() {
+  return bootstrap(AppCmp, [
+    provide(APP_BASE_HREF, {useValue: '/angular2/examples/router/ts/on_deactivate'}),
+    LogService
+  ]);
+}

node_modules/angular2/ts/examples/router/ts/on_deactivate/on_deactivate_spec.ts

@@ -0,0 +1,32 @@
+import {verifyNoBrowserErrors, browser} from 'angular2/src/testing/e2e_util';
+import {expect} from 'angular2/testing';
+
+function waitForElement(selector: string) {
+  var EC = (<any>protractor).ExpectedConditions;
+  // Waits for the element with id 'abc' to be present on the dom.
+  browser.wait(EC.presenceOf($(selector)), 20000);
+}
+
+describe('on activate example app', function() {
+  afterEach(verifyNoBrowserErrors);
+
+  var URL = 'angular2/examples/router/ts/on_deactivate/';
+
+  it('should update the text when navigating between routes', function() {
+    browser.get(URL);
+    waitForElement('my-cmp');
+
+    expect(element(by.css('#log')).getText()).toEqual('Log:');
+
+    element(by.css('#param-link')).click();
+    waitForElement('my-cmp');
+
+    expect(element(by.css('#log')).getText()).toEqual('Log:\nNavigating from "" to "1"');
+
+    browser.navigate().back();
+    waitForElement('my-cmp');
+
+    expect(element(by.css('#log')).getText())
+        .toEqual('Log:\nNavigating from "" to "1"\nNavigating from "1" to ""');
+  });
+});

node_modules/angular2/ts/examples/router/ts/reuse/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+<head>
+  <title>Routing Reuse Lifecycle Example</title>
+  <base href="/">
+
+  <script src="http://cdn.rawgit.com/google/traceur-compiler/90da568c7aa8e53ea362db1fc211fbb4f65b5e94/bin/traceur-runtime.js"></script>
+  <script src="http://cdnjs.cloudflare.com/ajax/libs/systemjs/0.18.4/system.js"></script>
+  <script>System.config({ baseURL: '/', defaultJSExtensions: true});</script>
+  <script src="/bundle/angular2.dev.js"></script>
+  <script src="/bundle/router.dev.js"></script>
+</head>
+<body>
+<example-app>
+  Loading...
+</example-app>
+<script>
+var filename = 'angular2/examples/router/ts/reuse/reuse_example';
+System.import(filename).then(function(m) {
+  m.main();
+}, console.error.bind(console));
+</script>
+</body>
+</html>

node_modules/angular2/ts/examples/router/ts/reuse/reuse_example.ts

@@ -0,0 +1,58 @@
+import {Component, provide} from 'angular2/core';
+import {bootstrap} from 'angular2/platform/browser';
+import {
+  CanActivate,
+  RouteConfig,
+  ComponentInstruction,
+  ROUTER_DIRECTIVES,
+  APP_BASE_HREF,
+  CanReuse,
+  RouteParams,
+  OnReuse
+} from 'angular2/router';
+
+
+// #docregion reuseCmp
+@Component({
+  selector: 'my-cmp',
+  template: `
+    <div>hello {{name}}!</div>
+    <div>message: <input id="message"></div>
+  `
+})
+class MyCmp implements CanReuse,
+    OnReuse {
+  name: string;
+  constructor(params: RouteParams) { this.name = params.get('name') || 'NOBODY'; }
+
+  routerCanReuse(next: ComponentInstruction, prev: ComponentInstruction) { return true; }
+
+  routerOnReuse(next: ComponentInstruction, prev: ComponentInstruction) {
+    this.name = next.params['name'];
+  }
+}
+// #enddocregion
+
+
+@Component({
+  selector: 'example-app',
+  template: `
+    <h1>Say hi to...</h1>
+    <a [routerLink]="['/HomeCmp', {name: 'naomi'}]" id="naomi-link">Naomi</a> |
+    <a [routerLink]="['/HomeCmp', {name: 'brad'}]" id="brad-link">Brad</a>
+    <router-outlet></router-outlet>
+  `,
+  directives: [ROUTER_DIRECTIVES]
+})
+@RouteConfig([
+  {path: '/', component: MyCmp, name: 'HomeCmp'},
+  {path: '/:name', component: MyCmp, name: 'HomeCmp'}
+])
+class AppCmp {
+}
+
+
+export function main() {
+  return bootstrap(AppCmp,
+                   [provide(APP_BASE_HREF, {useValue: '/angular2/examples/router/ts/reuse'})]);
+}

node_modules/angular2/ts/examples/router/ts/reuse/reuse_spec.ts

@@ -0,0 +1,36 @@
+import {verifyNoBrowserErrors, browser} from 'angular2/src/testing/e2e_util';
+import {expect} from 'angular2/testing';
+
+function waitForElement(selector: string) {
+  var EC = (<any>protractor).ExpectedConditions;
+  // Waits for the element with id 'abc' to be present on the dom.
+  browser.wait(EC.presenceOf($(selector)), 20000);
+}
+
+describe('reuse example app', function() {
+
+  afterEach(verifyNoBrowserErrors);
+
+  var URL = 'angular2/examples/router/ts/reuse/';
+
+  it('should build a link which points to the detail page', function() {
+    browser.get(URL);
+    waitForElement('my-cmp');
+
+    element(by.css('#naomi-link')).click();
+    waitForElement('my-cmp');
+    expect(browser.getCurrentUrl()).toMatch(/\/naomi$/);
+
+    // type something into input
+    element(by.css('#message')).sendKeys('long time no see!');
+
+    // navigate to Brad
+    element(by.css('#brad-link')).click();
+    waitForElement('my-cmp');
+    expect(browser.getCurrentUrl()).toMatch(/\/brad$/);
+
+    // check that typed input is the same
+    expect(element(by.css('#message')).getAttribute('value')).toEqual('long time no see!');
+  });
+
+});

node_modules/angular2/ts/examples/testing/ts/fake_async.ts

@@ -0,0 +1,29 @@
+import {describe, it, fakeAsync, expect, tick, clearPendingTimers} from 'angular2/testing';
+
+// #docregion basic
+describe('this test', () => {
+  it('looks async but is synchronous', <any>fakeAsync((): void => {
+       var flag = false;
+       setTimeout(() => { flag = true; }, 100);
+       expect(flag).toBe(false);
+       tick(50);
+       expect(flag).toBe(false);
+       tick(50);
+       expect(flag).toBe(true);
+     }));
+});
+// #enddocregion
+
+// #docregion pending
+describe('this test', () => {
+  it('aborts a timer', <any>fakeAsync((): void => {
+       // This timer is scheduled but doesn't need to complete for the
+       // test to pass (maybe it's a timeout for some operation).
+       // Leaving it will cause the test to fail...
+       setTimeout(() => {}, 100);
+
+       // Unless we clean it up first.
+       clearPendingTimers();
+     }));
+});
+// #enddocregion

node_modules/angular2/ts/examples/testing/ts/matchers.ts

@@ -0,0 +1,40 @@
+import {expect} from 'angular2/testing';
+
+var value: any;
+var element: any;
+var exception: any;
+
+abstract class OtherClass {}
+class SomeClass {}
+
+// #docregion toBePromise
+expect(value).toBePromise();
+// #enddocregion
+
+// #docregion toBeAnInstanceOf
+expect(value).toBeAnInstanceOf(SomeClass);
+// #enddocregion
+
+// #docregion toHaveText
+expect(element).toHaveText('Hello world!');
+// #enddocregion
+
+// #docregion toHaveCssClass
+expect(element).toHaveCssClass('current');
+// #enddocregion
+
+// #docregion toHaveCssStyle
+expect(element).toHaveCssStyle({width: '100px', height: 'auto'});
+// #enddocregion
+
+// #docregion toContainError
+expect(exception).toContainError('Failed to load');
+// #enddocregion
+
+// #docregion toThrowErrorWith
+expect(() => { throw 'Failed to load'; }).toThrowErrorWith('Failed to load');
+// #enddocregion
+
+// #docregion toImplement
+expect(SomeClass).toImplement(OtherClass);
+// #enddocregion

node_modules/angular2/ts/examples/testing/ts/testing.ts

@@ -0,0 +1,90 @@
+import {
+  describe,
+  fdescribe,
+  xdescribe,
+  it,
+  fit,
+  xit,
+  beforeEach,
+  afterEach,
+  beforeEachProviders,
+  inject
+} from 'angular2/testing';
+import {provide} from 'angular2/core';
+
+var db: any;
+class MyService {}
+class MyMockService implements MyService {}
+
+// #docregion describeIt
+describe('some component', () => {
+  it('does something', () => {
+                           // This is a test.
+                       });
+});
+// #enddocregion
+
+// #docregion fdescribe
+fdescribe('some component', () => {
+  it('has a test', () => {
+                       // This test will run.
+                   });
+});
+describe('another component',
+         () => { it('also has a test', () => { throw 'This test will not run.'; }); });
+// #enddocregion
+
+// #docregion xdescribe
+xdescribe('some component', () => { it('has a test', () => {throw 'This test will not run.'}); });
+describe('another component', () => {
+  it('also has a test', () => {
+                            // This test will run.
+                        });
+});
+// #enddocregion
+
+// #docregion fit
+describe('some component', () => {
+  fit('has a test', () => {
+                        // This test will run.
+                    });
+  it('has another test', () => { throw 'This test will not run.'; });
+});
+// #enddocregion
+
+// #docregion xit
+describe('some component', () => {
+  xit('has a test', () => { throw 'This test will not run.'; });
+  it('has another test', () => {
+                             // This test will run.
+                         });
+});
+// #enddocregion
+
+// #docregion beforeEach
+describe('some component', () => {
+  beforeEach(() => { db.connect(); });
+  it('uses the db', () => {
+                        // Database is connected.
+                    });
+});
+// #enddocregion
+
+// #docregion beforeEachProviders
+describe('some component', () => {
+  beforeEachProviders(() => [provide(MyService, {useClass: MyMockService})]);
+  it('uses MyService', inject([MyService], (service: MyMockService) => {
+                                               // service is an instance of MyMockService.
+                                           }));
+});
+// #enddocregion
+
+// #docregion afterEach
+describe('some component', () => {
+  afterEach((done: Function) => { db.reset().then((_: any) => done()); });
+  it('uses the db', () => {
+                        // This test can leave the database in a dirty state.
+                        // The afterEach will ensure it gets reset.
+                    });
+});
+// #enddocregion

node_modules/angular2/ts/http.ts

@@ -0,0 +1,304 @@
+/**
+ * @module
+ * @description
+ * The http module provides services to perform http requests. To get started, see the {@link Http}
+ * class.
+ */
+import {provide, Provider} from 'angular2/core';
+import {Http, Jsonp} from './src/http/http';
+import {XHRBackend, XHRConnection} from './src/http/backends/xhr_backend';
+import {JSONPBackend, JSONPBackend_, JSONPConnection} from './src/http/backends/jsonp_backend';
+import {BrowserXhr} from './src/http/backends/browser_xhr';
+import {BrowserJsonp} from './src/http/backends/browser_jsonp';
+import {BaseRequestOptions, RequestOptions} from './src/http/base_request_options';
+import {ConnectionBackend} from './src/http/interfaces';
+import {BaseResponseOptions, ResponseOptions} from './src/http/base_response_options';
+export {Request} from './src/http/static_request';
+export {Response} from './src/http/static_response';
+
+export {
+  RequestOptionsArgs,
+  ResponseOptionsArgs,
+  Connection,
+  ConnectionBackend
+} from './src/http/interfaces';
+
+export {BrowserXhr} from './src/http/backends/browser_xhr';
+export {BaseRequestOptions, RequestOptions} from './src/http/base_request_options';
+export {BaseResponseOptions, ResponseOptions} from './src/http/base_response_options';
+export {XHRBackend, XHRConnection} from './src/http/backends/xhr_backend';
+export {JSONPBackend, JSONPConnection} from './src/http/backends/jsonp_backend';
+export {Http, Jsonp} from './src/http/http';
+
+export {Headers} from './src/http/headers';
+
+export {ResponseType, ReadyState, RequestMethod} from './src/http/enums';
+export {URLSearchParams} from './src/http/url_search_params';
+
+/**
+ * Provides a basic set of injectables to use the {@link Http} service in any application.
+ *
+ * The `HTTP_PROVIDERS` should be included either in a component's injector,
+ * or in the root injector when bootstrapping an application.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/snj7Nv?p=preview))
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {bootstrap} from 'angular2/platform/browser';
+ * import {NgFor} from 'angular2/common';
+ * import {HTTP_PROVIDERS, Http} from 'angular2/http';
+ *
+ * @Component({
+ *   selector: 'app',
+ *   providers: [HTTP_PROVIDERS],
+ *   template: `
+ *     <div>
+ *       <h1>People</h1>
+ *       <ul>
+ *         <li *ngFor="#person of people">
+ *           {{person.name}}
+ *         </li>
+ *       </ul>
+ *     </div>
+ *   `,
+ *   directives: [NgFor]
+ * })
+ * export class App {
+ *   people: Object[];
+ *   constructor(http:Http) {
+ *     http.get('people.json').subscribe(res => {
+ *       this.people = res.json();
+ *     });
+ *   }
+ *   active:boolean = false;
+ *   toggleActiveState() {
+ *     this.active = !this.active;
+ *   }
+ * }
+ *
+ * bootstrap(App)
+ *   .catch(err => console.error(err));
+ * ```
+ *
+ * The primary public API included in `HTTP_PROVIDERS` is the {@link Http} class.
+ * However, other providers required by `Http` are included,
+ * which may be beneficial to override in certain cases.
+ *
+ * The providers included in `HTTP_PROVIDERS` include:
+ *  * {@link Http}
+ *  * {@link XHRBackend}
+ *  * `BrowserXHR` - Private factory to create `XMLHttpRequest` instances
+ *  * {@link RequestOptions} - Bound to {@link BaseRequestOptions} class
+ *  * {@link ResponseOptions} - Bound to {@link BaseResponseOptions} class
+ *
+ * There may be cases where it makes sense to extend the base request options,
+ * such as to add a search string to be appended to all URLs.
+ * To accomplish this, a new provider for {@link RequestOptions} should
+ * be added in the same injector as `HTTP_PROVIDERS`.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/aCMEXi?p=preview))
+ *
+ * ```
+ * import {provide} from 'angular2/core';
+ * import {bootstrap} from 'angular2/platform/browser';
+ * import {HTTP_PROVIDERS, BaseRequestOptions, RequestOptions} from 'angular2/http';
+ *
+ * class MyOptions extends BaseRequestOptions {
+ *   search: string = 'coreTeam=true';
+ * }
+ *
+ * bootstrap(App, [HTTP_PROVIDERS, provide(RequestOptions, {useClass: MyOptions})])
+ *   .catch(err => console.error(err));
+ * ```
+ *
+ * Likewise, to use a mock backend for unit tests, the {@link XHRBackend}
+ * provider should be bound to {@link MockBackend}.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/7LWALD?p=preview))
+ *
+ * ```
+ * import {provide} from 'angular2/core';
+ * import {bootstrap} from 'angular2/platform/browser';
+ * import {HTTP_PROVIDERS, Http, Response, XHRBackend} from 'angular2/http';
+ * import {MockBackend} from 'angular2/http/testing';
+ *
+ * var people = [{name: 'Jeff'}, {name: 'Tobias'}];
+ *
+ * var injector = Injector.resolveAndCreate([
+ *   HTTP_PROVIDERS,
+ *   MockBackend,
+ *   provide(XHRBackend, {useExisting: MockBackend})
+ * ]);
+ * var http = injector.get(Http);
+ * var backend = injector.get(MockBackend);
+ *
+ * // Listen for any new requests
+ * backend.connections.observer({
+ *   next: connection => {
+ *     var response = new Response({body: people});
+ *     setTimeout(() => {
+ *       // Send a response to the request
+ *       connection.mockRespond(response);
+ *     });
+ *   }
+ * });
+ *
+ * http.get('people.json').observer({
+ *   next: res => {
+ *     // Response came from mock backend
+ *     console.log('first person', res.json()[0].name);
+ *   }
+ * });
+ * ```
+ */
+export const HTTP_PROVIDERS: any[] = [
+  // TODO(pascal): use factory type annotations once supported in DI
+  // issue: https://github.com/angular/angular/issues/3183
+  provide(Http,
+          {
+            useFactory: (xhrBackend: XHRBackend, requestOptions: RequestOptions) =>
+                            new Http(xhrBackend, requestOptions),
+            deps: [XHRBackend, RequestOptions]
+          }),
+  BrowserXhr,
+  provide(RequestOptions, {useClass: BaseRequestOptions}),
+  provide(ResponseOptions, {useClass: BaseResponseOptions}),
+  XHRBackend
+];
+
+/**
+ * See {@link HTTP_PROVIDERS} instead.
+ *
+ * @deprecated
+ */
+export const HTTP_BINDINGS = HTTP_PROVIDERS;
+
+/**
+ * Provides a basic set of providers to use the {@link Jsonp} service in any application.
+ *
+ * The `JSONP_PROVIDERS` should be included either in a component's injector,
+ * or in the root injector when bootstrapping an application.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/vmeN4F?p=preview))
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {NgFor} from 'angular2/common';
+ * import {JSONP_PROVIDERS, Jsonp} from 'angular2/http';
+ *
+ * @Component({
+ *   selector: 'app',
+ *   providers: [JSONP_PROVIDERS],
+ *   template: `
+ *     <div>
+ *       <h1>People</h1>
+ *       <ul>
+ *         <li *ngFor="#person of people">
+ *           {{person.name}}
+ *         </li>
+ *       </ul>
+ *     </div>
+ *   `,
+ *   directives: [NgFor]
+ * })
+ * export class App {
+ *   people: Array<Object>;
+ *   constructor(jsonp:Jsonp) {
+ *     jsonp.request('people.json').subscribe(res => {
+ *       this.people = res.json();
+ *     })
+ *   }
+ * }
+ * ```
+ *
+ * The primary public API included in `JSONP_PROVIDERS` is the {@link Jsonp} class.
+ * However, other providers required by `Jsonp` are included,
+ * which may be beneficial to override in certain cases.
+ *
+ * The providers included in `JSONP_PROVIDERS` include:
+ *  * {@link Jsonp}
+ *  * {@link JSONPBackend}
+ *  * `BrowserJsonp` - Private factory
+ *  * {@link RequestOptions} - Bound to {@link BaseRequestOptions} class
+ *  * {@link ResponseOptions} - Bound to {@link BaseResponseOptions} class
+ *
+ * There may be cases where it makes sense to extend the base request options,
+ * such as to add a search string to be appended to all URLs.
+ * To accomplish this, a new provider for {@link RequestOptions} should
+ * be added in the same injector as `JSONP_PROVIDERS`.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/TFug7x?p=preview))
+ *
+ * ```
+ * import {provide} from 'angular2/core';
+ * import {bootstrap} from 'angular2/platform/browser';
+ * import {JSONP_PROVIDERS, BaseRequestOptions, RequestOptions} from 'angular2/http';
+ *
+ * class MyOptions extends BaseRequestOptions {
+ *   search: string = 'coreTeam=true';
+ * }
+ *
+ * bootstrap(App, [JSONP_PROVIDERS, provide(RequestOptions, {useClass: MyOptions})])
+ *   .catch(err => console.error(err));
+ * ```
+ *
+ * Likewise, to use a mock backend for unit tests, the {@link JSONPBackend}
+ * provider should be bound to {@link MockBackend}.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/HDqZWL?p=preview))
+ *
+ * ```
+ * import {provide, Injector} from 'angular2/core';
+ * import {JSONP_PROVIDERS, Jsonp, Response, JSONPBackend} from 'angular2/http';
+ * import {MockBackend} from 'angular2/http/testing';
+ *
+ * var people = [{name: 'Jeff'}, {name: 'Tobias'}];
+ * var injector = Injector.resolveAndCreate([
+ *   JSONP_PROVIDERS,
+ *   MockBackend,
+ *   provide(JSONPBackend, {useExisting: MockBackend})
+ * ]);
+ * var jsonp = injector.get(Jsonp);
+ * var backend = injector.get(MockBackend);
+ *
+ * // Listen for any new requests
+ * backend.connections.observer({
+ *   next: connection => {
+ *     var response = new Response({body: people});
+ *     setTimeout(() => {
+ *       // Send a response to the request
+ *       connection.mockRespond(response);
+ *     });
+ *   }
+ * });
+
+ * jsonp.get('people.json').observer({
+ *   next: res => {
+ *     // Response came from mock backend
+ *     console.log('first person', res.json()[0].name);
+ *   }
+ * });
+ * ```
+ */
+export const JSONP_PROVIDERS: any[] = [
+  // TODO(pascal): use factory type annotations once supported in DI
+  // issue: https://github.com/angular/angular/issues/3183
+  provide(Jsonp,
+          {
+            useFactory: (jsonpBackend: JSONPBackend, requestOptions: RequestOptions) =>
+                            new Jsonp(jsonpBackend, requestOptions),
+            deps: [JSONPBackend, RequestOptions]
+          }),
+  BrowserJsonp,
+  provide(RequestOptions, {useClass: BaseRequestOptions}),
+  provide(ResponseOptions, {useClass: BaseResponseOptions}),
+  provide(JSONPBackend, {useClass: JSONPBackend_})
+];
+
+/**
+ * See {@link JSONP_PROVIDERS} instead.
+ *
+ * @deprecated
+ */
+export const JSON_BINDINGS = JSONP_PROVIDERS;

node_modules/angular2/ts/http/testing.ts

@@ -0,0 +1 @@
+export * from 'angular2/src/http/backends/mock_backend';

node_modules/angular2/ts/i18n.ts

@@ -0,0 +1,9 @@
+/**
+ * @module
+ * @description
+ * Entry point to i18n
+ */
+export * from './src/i18n/message';
+export * from './src/i18n/xmb_serializer';
+export * from './src/i18n/message_extractor';
+export * from './src/i18n/i18n_html_parser';

node_modules/angular2/ts/instrumentation.ts

@@ -0,0 +1,7 @@
+export {
+  wtfCreateScope,
+  wtfLeave,
+  wtfStartTimeRange,
+  wtfEndTimeRange,
+  WtfScopeFn
+} from './src/core/profile/profile';

node_modules/angular2/ts/manual_typings/globals.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Subset of es6-shim typings.
+ * Angular should not require use of ES6 runtime but some API usages are already present.
+ * See https://github.com/angular/angular/issues/5242
+ * TODO(alexeagle): remove methods below which may not be present in targeted browser
+ */
+
+declare type PromiseConstructor = typeof Promise;
+
+interface String {
+  /**
+   * Returns true if the sequence of elements of searchString converted to a String is the
+   * same as the corresponding elements of this object (converted to a String) starting at
+   * position. Otherwise returns false.
+   */
+  startsWith(searchString: string, position?: number): boolean;
+
+  /**
+   * Returns true if the sequence of elements of searchString converted to a String is the
+   * same as the corresponding elements of this object (converted to a String) starting at
+   * endPosition – length(this). Otherwise returns false.
+   */
+  endsWith(searchString: string, endPosition?: number): boolean;
+}
+interface Array<T> {
+  /**
+   * Returns the value of the first element in the array where predicate is true, and undefined
+   * otherwise.
+   * @param predicate find calls predicate once for each element of the array, in ascending
+   * order, until it finds one where predicate returns true. If such an element is found, find
+   * immediately returns that element value. Otherwise, find returns undefined.
+   * @param thisArg If provided, it will be used as the this value for each invocation of
+   * predicate. If it is not provided, undefined is used instead.
+   */
+  find(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T;
+  /**
+   * Returns the this object after filling the section identified by start and end with value
+   * @param value value to fill array section with
+   * @param start index to start filling the array at. If start is negative, it is treated as
+   * length+start where length is the length of the array.
+   * @param end index to stop filling the array at. If end is negative, it is treated as
+   * length+end.
+   */
+  fill(value: T, start?: number, end?: number): T[];
+}
+interface NumberConstructor {
+  /**
+   * Returns true if the value passed is an integer, false otherwise.
+   * @param number A numeric value.
+   */
+  isInteger(number: number): boolean;
+}

node_modules/angular2/ts/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "angular2",
+  "version": "<%= packageJson.version %>",
+  "description": "Angular 2 - a web framework for modern web apps",
+  "homepage": "<%= packageJson.homepage %>",
+  "bugs": "<%= packageJson.bugs %>",
+  "contributors": <%= JSON.stringify(packageJson.contributors) %>,
+  "license": "<%= packageJson.license %>",
+  "repository": <%= JSON.stringify(packageJson.repository) %>,
+  "devDependencies": <%= JSON.stringify(packageJson.defaultDevDependencies) %>,
+  "peerDependencies": {
+    "es6-shim": "<%= packageJson.dependencies['es6-shim'] %>",
+    "reflect-metadata": "<%= packageJson.dependencies['reflect-metadata'] %>",
+    "rxjs": "<%= packageJson.dependencies['rxjs'] %>",
+    "zone.js": "<%= packageJson.dependencies['zone.js'] %>"
+  }
+}

node_modules/angular2/ts/platform/browser.ts

@@ -0,0 +1,111 @@
+export {AngularEntrypoint} from 'angular2/src/core/angular_entrypoint';
+export {
+  BROWSER_PROVIDERS,
+  ELEMENT_PROBE_PROVIDERS,
+  ELEMENT_PROBE_PROVIDERS_PROD_MODE,
+  inspectNativeElement,
+  BrowserDomAdapter,
+  By,
+  Title,
+  DOCUMENT,
+  enableDebugTools,
+  disableDebugTools
+} from 'angular2/src/platform/browser_common';
+
+import {Type, isPresent, CONST_EXPR} from 'angular2/src/facade/lang';
+import {
+  BROWSER_PROVIDERS,
+  BROWSER_APP_COMMON_PROVIDERS
+} from 'angular2/src/platform/browser_common';
+import {COMPILER_PROVIDERS} from 'angular2/compiler';
+import {ComponentRef, platform, reflector} from 'angular2/core';
+import {ReflectionCapabilities} from 'angular2/src/core/reflection/reflection_capabilities';
+import {XHRImpl} from "angular2/src/platform/browser/xhr_impl";
+import {XHR} from 'angular2/compiler';
+import {Provider} from 'angular2/src/core/di';
+
+/**
+ * An array of providers that should be passed into `application()` when bootstrapping a component.
+ */
+export const BROWSER_APP_PROVIDERS: Array<any /*Type | Provider | any[]*/> = CONST_EXPR([
+  BROWSER_APP_COMMON_PROVIDERS,
+  COMPILER_PROVIDERS,
+  new Provider(XHR, {useClass: XHRImpl}),
+]);
+
+/**
+ * Bootstrapping for Angular applications.
+ *
+ * You instantiate an Angular application by explicitly specifying a component to use
+ * as the root component for your application via the `bootstrap()` method.
+ *
+ * ## Simple Example
+ *
+ * Assuming this `index.html`:
+ *
+ * ```html
+ * <html>
+ *   <!-- load Angular script tags here. -->
+ *   <body>
+ *     <my-app>loading...</my-app>
+ *   </body>
+ * </html>
+ * ```
+ *
+ * An application is bootstrapped inside an existing browser DOM, typically `index.html`.
+ * Unlike Angular 1, Angular 2 does not compile/process providers in `index.html`. This is
+ * mainly for security reasons, as well as architectural changes in Angular 2. This means
+ * that `index.html` can safely be processed using server-side technologies such as
+ * providers. Bindings can thus use double-curly `{{ syntax }}` without collision from
+ * Angular 2 component double-curly `{{ syntax }}`.
+ *
+ * We can use this script code:
+ *
+ * {@example core/ts/bootstrap/bootstrap.ts region='bootstrap'}
+ *
+ * When the app developer invokes `bootstrap()` with the root component `MyApp` as its
+ * argument, Angular performs the following tasks:
+ *
+ *  1. It uses the component's `selector` property to locate the DOM element which needs
+ *     to be upgraded into the angular component.
+ *  2. It creates a new child injector (from the platform injector). Optionally, you can
+ *     also override the injector configuration for an app by invoking `bootstrap` with the
+ *     `componentInjectableBindings` argument.
+ *  3. It creates a new `Zone` and connects it to the angular application's change detection
+ *     domain instance.
+ *  4. It creates an emulated or shadow DOM on the selected component's host element and loads the
+ *     template into it.
+ *  5. It instantiates the specified component.
+ *  6. Finally, Angular performs change detection to apply the initial data providers for the
+ *     application.
+ *
+ *
+ * ## Bootstrapping Multiple Applications
+ *
+ * When working within a browser window, there are many singleton resources: cookies, title,
+ * location, and others. Angular services that represent these resources must likewise be
+ * shared across all Angular applications that occupy the same browser window. For this
+ * reason, Angular creates exactly one global platform object which stores all shared
+ * services, and each angular application injector has the platform injector as its parent.
+ *
+ * Each application has its own private injector as well. When there are multiple
+ * applications on a page, Angular treats each application injector's services as private
+ * to that application.
+ *
+ * ## API
+ *
+ * - `appComponentType`: The root component which should act as the application. This is
+ *   a reference to a `Type` which is annotated with `@Component(...)`.
+ * - `customProviders`: An additional set of providers that can be added to the
+ *   app injector to override default injection behavior.
+ *
+ * Returns a `Promise` of {@link ComponentRef}.
+ */
+export function bootstrap(
+    appComponentType: Type,
+    customProviders?: Array<any /*Type | Provider | any[]*/>): Promise<ComponentRef> {
+  reflector.reflectionCapabilities = new ReflectionCapabilities();
+  let appProviders =
+      isPresent(customProviders) ? [BROWSER_APP_PROVIDERS, customProviders] : BROWSER_APP_PROVIDERS;
+  return platform(BROWSER_PROVIDERS).application(appProviders).bootstrap(appComponentType);
+}

node_modules/angular2/ts/platform/browser_static.ts

@@ -0,0 +1,42 @@
+export {AngularEntrypoint} from 'angular2/src/core/angular_entrypoint';
+export {
+  BROWSER_PROVIDERS,
+  ELEMENT_PROBE_PROVIDERS,
+  ELEMENT_PROBE_PROVIDERS_PROD_MODE,
+  inspectNativeElement,
+  BrowserDomAdapter,
+  By,
+  Title,
+  enableDebugTools,
+  disableDebugTools
+} from 'angular2/src/platform/browser_common';
+
+import {Type, isPresent} from 'angular2/src/facade/lang';
+import {
+  BROWSER_PROVIDERS,
+  BROWSER_APP_COMMON_PROVIDERS
+} from 'angular2/src/platform/browser_common';
+import {ComponentRef, platform} from 'angular2/core';
+
+/**
+ * An array of providers that should be passed into `application()` when bootstrapping a component
+ * when all templates
+ * have been precompiled offline.
+ */
+export const BROWSER_APP_PROVIDERS: Array<any /*Type | Provider | any[]*/> =
+    BROWSER_APP_COMMON_PROVIDERS;
+
+/**
+ * See {@link bootstrap} for more information.
+ */
+export function bootstrapStatic(appComponentType: Type,
+                                customProviders?: Array<any /*Type | Provider | any[]*/>,
+                                initReflector?: Function): Promise<ComponentRef> {
+  if (isPresent(initReflector)) {
+    initReflector();
+  }
+
+  let appProviders =
+      isPresent(customProviders) ? [BROWSER_APP_PROVIDERS, customProviders] : BROWSER_APP_PROVIDERS;
+  return platform(BROWSER_PROVIDERS).application(appProviders).bootstrap(appComponentType);
+}

node_modules/angular2/ts/platform/common_dom.ts

@@ -0,0 +1,15 @@
+/**
+ * This is a set of classes and objects that can be used both in the browser and on the server.
+ */
+export {DOM, setRootDomAdapter, DomAdapter} from 'angular2/src/platform/dom/dom_adapter';
+export {DomRenderer} from 'angular2/src/platform/dom/dom_renderer';
+export {DOCUMENT} from 'angular2/src/platform/dom/dom_tokens';
+export {SharedStylesHost, DomSharedStylesHost} from 'angular2/src/platform/dom/shared_styles_host';
+export {DomEventsPlugin} from 'angular2/src/platform/dom/events/dom_events';
+export {
+  EVENT_MANAGER_PLUGINS,
+  EventManager,
+  EventManagerPlugin
+} from 'angular2/src/platform/dom/events/event_manager';
+export * from 'angular2/src/platform/dom/debug/by';
+export * from 'angular2/src/platform/dom/debug/ng_probe';

node_modules/angular2/ts/platform/server.dart

@@ -0,0 +1,2 @@
+// TODO: vsavkin add SERVER_PROVIDERS and SERVER_APP_PROVIDERS
+export 'package:angular2/src/platform/server/html_adapter.dart';

node_modules/angular2/ts/platform/server.ts

@@ -0,0 +1,2 @@
+// TODO: vsavkin add SERVER_PROVIDERS and SERVER_APP_PROVIDERS
+export {Parse5DomAdapter} from 'angular2/src/platform/server/parse5_adapter';

node_modules/angular2/ts/platform/testing/browser.ts

@@ -0,0 +1,21 @@
+import {
+  TEST_BROWSER_STATIC_PLATFORM_PROVIDERS,
+  ADDITIONAL_TEST_BROWSER_PROVIDERS
+} from 'angular2/platform/testing/browser_static';
+
+import {BROWSER_APP_PROVIDERS} from 'angular2/platform/browser';
+
+
+import {CONST_EXPR} from 'angular2/src/facade/lang';
+
+/**
+ * Default patform providers for testing.
+ */
+export const TEST_BROWSER_PLATFORM_PROVIDERS: Array<any /*Type | Provider | any[]*/> =
+    CONST_EXPR([TEST_BROWSER_STATIC_PLATFORM_PROVIDERS]);
+
+/**
+ * Default application providers for testing.
+ */
+export const TEST_BROWSER_APPLICATION_PROVIDERS: Array<any /*Type | Provider | any[]*/> =
+    CONST_EXPR([BROWSER_APP_PROVIDERS, ADDITIONAL_TEST_BROWSER_PROVIDERS]);

node_modules/angular2/ts/platform/testing/browser_static.ts

@@ -0,0 +1,69 @@
+import {
+  APP_ID,
+  DirectiveResolver,
+  NgZone,
+  Provider,
+  ViewResolver,
+  PLATFORM_COMMON_PROVIDERS,
+  PLATFORM_INITIALIZER
+} from 'angular2/core';
+import {BROWSER_APP_COMMON_PROVIDERS} from 'angular2/src/platform/browser_common';
+import {BrowserDomAdapter} from 'angular2/src/platform/browser/browser_adapter';
+
+import {AnimationBuilder} from 'angular2/src/animate/animation_builder';
+import {MockAnimationBuilder} from 'angular2/src/mock/animation_builder_mock';
+import {MockDirectiveResolver} from 'angular2/src/mock/directive_resolver_mock';
+import {MockViewResolver} from 'angular2/src/mock/view_resolver_mock';
+import {MockLocationStrategy} from 'angular2/src/mock/mock_location_strategy';
+import {LocationStrategy} from 'angular2/src/router/location/location_strategy';
+import {MockNgZone} from 'angular2/src/mock/ng_zone_mock';
+
+import {XHRImpl} from "angular2/src/platform/browser/xhr_impl";
+import {XHR} from 'angular2/compiler';
+
+import {TestComponentBuilder} from 'angular2/src/testing/test_component_builder';
+
+import {BrowserDetection} from 'angular2/src/testing/utils';
+
+import {ELEMENT_PROBE_PROVIDERS} from 'angular2/platform/common_dom';
+
+import {CONST_EXPR} from 'angular2/src/facade/lang';
+
+import {Log} from 'angular2/src/testing/utils';
+
+function initBrowserTests() {
+  BrowserDomAdapter.makeCurrent();
+  BrowserDetection.setup();
+}
+
+/**
+ * Default patform providers for testing without a compiler.
+ */
+export const TEST_BROWSER_STATIC_PLATFORM_PROVIDERS: Array<any /*Type | Provider | any[]*/> =
+    CONST_EXPR([
+      PLATFORM_COMMON_PROVIDERS,
+      new Provider(PLATFORM_INITIALIZER, {useValue: initBrowserTests, multi: true})
+    ]);
+
+export const ADDITIONAL_TEST_BROWSER_PROVIDERS: Array<any /*Type | Provider | any[]*/> =
+    CONST_EXPR([
+      new Provider(APP_ID, {useValue: 'a'}),
+      ELEMENT_PROBE_PROVIDERS,
+      new Provider(DirectiveResolver, {useClass: MockDirectiveResolver}),
+      new Provider(ViewResolver, {useClass: MockViewResolver}),
+      Log,
+      TestComponentBuilder,
+      new Provider(NgZone, {useClass: MockNgZone}),
+      new Provider(LocationStrategy, {useClass: MockLocationStrategy}),
+      new Provider(AnimationBuilder, {useClass: MockAnimationBuilder}),
+    ]);
+
+/**
+ * Default application providers for testing without a compiler.
+ */
+export const TEST_BROWSER_STATIC_APPLICATION_PROVIDERS: Array<any /*Type | Provider | any[]*/> =
+    CONST_EXPR([
+      BROWSER_APP_COMMON_PROVIDERS,
+      new Provider(XHR, {useClass: XHRImpl}),
+      ADDITIONAL_TEST_BROWSER_PROVIDERS
+    ]);

node_modules/angular2/ts/platform/testing/server.dart

@@ -0,0 +1 @@
+// Intentionally blank, the Parse5Adapater bindings for JavaScript don't apply.

node_modules/angular2/ts/platform/testing/server.ts

@@ -0,0 +1,90 @@
+import {
+  APP_ID,
+  DirectiveResolver,
+  NgZone,
+  Provider,
+  ViewResolver,
+  PLATFORM_COMMON_PROVIDERS,
+  PLATFORM_INITIALIZER,
+  APPLICATION_COMMON_PROVIDERS,
+  Renderer
+} from 'angular2/core';
+import {Parse5DomAdapter} from 'angular2/src/platform/server/parse5_adapter';
+
+import {AnimationBuilder} from 'angular2/src/animate/animation_builder';
+import {MockAnimationBuilder} from 'angular2/src/mock/animation_builder_mock';
+import {MockDirectiveResolver} from 'angular2/src/mock/directive_resolver_mock';
+import {MockViewResolver} from 'angular2/src/mock/view_resolver_mock';
+import {MockLocationStrategy} from 'angular2/src/mock/mock_location_strategy';
+import {LocationStrategy} from 'angular2/src/router/location/location_strategy';
+import {MockNgZone} from 'angular2/src/mock/ng_zone_mock';
+
+import {TestComponentBuilder} from 'angular2/src/testing/test_component_builder';
+import {XHR} from 'angular2/src/compiler/xhr';
+import {BrowserDetection} from 'angular2/src/testing/utils';
+
+import {COMPILER_PROVIDERS} from 'angular2/src/compiler/compiler';
+import {DOCUMENT} from 'angular2/src/platform/dom/dom_tokens';
+import {DOM} from 'angular2/src/platform/dom/dom_adapter';
+import {RootRenderer} from 'angular2/src/core/render/api';
+import {DomRootRenderer, DomRootRenderer_} from 'angular2/src/platform/dom/dom_renderer';
+import {DomSharedStylesHost} from 'angular2/src/platform/dom/shared_styles_host';
+
+import {
+  EventManager,
+  EVENT_MANAGER_PLUGINS,
+  ELEMENT_PROBE_PROVIDERS
+} from 'angular2/platform/common_dom';
+import {DomEventsPlugin} from 'angular2/src/platform/dom/events/dom_events';
+
+import {CONST_EXPR} from 'angular2/src/facade/lang';
+
+import {Log} from 'angular2/src/testing/utils';
+
+function initServerTests() {
+  Parse5DomAdapter.makeCurrent();
+  BrowserDetection.setup();
+}
+
+/**
+ * Default patform providers for testing.
+ */
+export const TEST_SERVER_PLATFORM_PROVIDERS: Array<any /*Type | Provider | any[]*/> = CONST_EXPR([
+  PLATFORM_COMMON_PROVIDERS,
+  new Provider(PLATFORM_INITIALIZER, {useValue: initServerTests, multi: true})
+]);
+
+function appDoc() {
+  try {
+    return DOM.defaultDoc();
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Default application providers for testing.
+ */
+export const TEST_SERVER_APPLICATION_PROVIDERS: Array<any /*Type | Provider | any[]*/> =
+    CONST_EXPR([
+      // TODO(julie): when angular2/platform/server is available, use that instead of making our own
+      // list here.
+      APPLICATION_COMMON_PROVIDERS,
+      COMPILER_PROVIDERS,
+      new Provider(DOCUMENT, {useFactory: appDoc}),
+      new Provider(DomRootRenderer, {useClass: DomRootRenderer_}),
+      new Provider(RootRenderer, {useExisting: DomRootRenderer}),
+      EventManager,
+      new Provider(EVENT_MANAGER_PLUGINS, {useClass: DomEventsPlugin, multi: true}),
+      new Provider(XHR, {useClass: XHR}),
+      new Provider(APP_ID, {useValue: 'a'}),
+      DomSharedStylesHost,
+      ELEMENT_PROBE_PROVIDERS,
+      new Provider(DirectiveResolver, {useClass: MockDirectiveResolver}),
+      new Provider(ViewResolver, {useClass: MockViewResolver}),
+      Log,
+      TestComponentBuilder,
+      new Provider(NgZone, {useClass: MockNgZone}),
+      new Provider(LocationStrategy, {useClass: MockLocationStrategy}),
+      new Provider(AnimationBuilder, {useClass: MockAnimationBuilder}),
+    ]);

node_modules/angular2/ts/platform/worker_app.dart

@@ -0,0 +1,16 @@
+library angular2.platform.worker_app;
+
+export "package:angular2/src/platform/worker_app_common.dart"
+    show WORKER_APP_PLATFORM, WORKER_APP_APPLICATION_COMMON;
+export "package:angular2/src/core/angular_entrypoint.dart"
+    show AngularEntrypoint;
+export "package:angular2/src/platform/worker_app.dart"
+    show WORKER_APP_APPLICATION, RENDER_SEND_PORT;
+export 'package:angular2/src/web_workers/shared/client_message_broker.dart'
+    show ClientMessageBroker, ClientMessageBrokerFactory, FnArg, UiArguments;
+export 'package:angular2/src/web_workers/shared/service_message_broker.dart'
+    show ReceivedMessage, ServiceMessageBroker, ServiceMessageBrokerFactory;
+export 'package:angular2/src/web_workers/shared/serializer.dart' show PRIMITIVE;
+export 'package:angular2/src/web_workers/shared/message_bus.dart';
+export 'package:angular2/src/web_workers/worker/router_providers.dart'
+  show WORKER_APP_ROUTER;

node_modules/angular2/ts/platform/worker_app.ts

@@ -0,0 +1,20 @@
+export {
+  WORKER_APP_PLATFORM,
+  WORKER_APP_APPLICATION_COMMON
+} from 'angular2/src/platform/worker_app_common';
+export {WORKER_APP_APPLICATION} from 'angular2/src/platform/worker_app';
+export {
+  ClientMessageBroker,
+  ClientMessageBrokerFactory,
+  FnArg,
+  UiArguments
+} from 'angular2/src/web_workers/shared/client_message_broker';
+export {
+  ReceivedMessage,
+  ServiceMessageBroker,
+  ServiceMessageBrokerFactory
+} from 'angular2/src/web_workers/shared/service_message_broker';
+export {PRIMITIVE} from 'angular2/src/web_workers/shared/serializer';
+export * from 'angular2/src/web_workers/shared/message_bus';
+export {AngularEntrypoint} from 'angular2/src/core/angular_entrypoint';
+export {WORKER_APP_ROUTER} from 'angular2/src/web_workers/worker/router_providers';

node_modules/angular2/ts/platform/worker_render.dart

@@ -0,0 +1,26 @@
+library angular2.platform.worker_render;
+
+export 'package:angular2/src/platform/worker_render_common.dart'
+    show
+        WORKER_SCRIPT,
+        WORKER_RENDER_PLATFORM,
+        WORKER_RENDER_APPLICATION_COMMON,
+        initializeGenericWorkerRenderer;
+
+export 'package:angular2/src/platform/worker_render.dart'
+    show WORKER_RENDER_APPLICATION, initIsolate, WebWorkerInstance;
+
+export '../src/web_workers/shared/client_message_broker.dart'
+    show ClientMessageBroker, ClientMessageBrokerFactory, FnArg, UiArguments;
+
+export '../src/web_workers/shared/service_message_broker.dart'
+    show ReceivedMessage, ServiceMessageBroker, ServiceMessageBrokerFactory;
+
+export '../src/web_workers/shared/serializer.dart' show PRIMITIVE;
+export '../src/web_workers/shared/message_bus.dart';
+export '../src/web_workers/ui/router_providers.dart' show WORKER_RENDER_ROUTER;
+
+import 'package:angular2/src/platform/worker_render_common.dart';
+
+const WORKER_RENDER_APP = WORKER_RENDER_APPLICATION_COMMON;
+

node_modules/angular2/ts/platform/worker_render.ts

@@ -0,0 +1,27 @@
+export {
+  WORKER_SCRIPT,
+  WORKER_RENDER_PLATFORM,
+  initializeGenericWorkerRenderer,
+  WORKER_RENDER_APPLICATION_COMMON
+} from 'angular2/src/platform/worker_render_common';
+export {WORKER_RENDER_APPLICATION, WebWorkerInstance} from 'angular2/src/platform/worker_render';
+export {
+  ClientMessageBroker,
+  ClientMessageBrokerFactory,
+  FnArg,
+  UiArguments
+} from '../src/web_workers/shared/client_message_broker';
+export {
+  ReceivedMessage,
+  ServiceMessageBroker,
+  ServiceMessageBrokerFactory
+} from '../src/web_workers/shared/service_message_broker';
+export {PRIMITIVE} from '../src/web_workers/shared/serializer';
+export * from '../src/web_workers/shared/message_bus';
+import {WORKER_RENDER_APPLICATION} from 'angular2/src/platform/worker_render';
+
+/**
+ * @deprecated Use WORKER_RENDER_APPLICATION
+ */
+export const WORKER_RENDER_APP = WORKER_RENDER_APPLICATION;
+export {WORKER_RENDER_ROUTER} from 'angular2/src/web_workers/ui/router_providers';

node_modules/angular2/ts/pubspec.yaml

@@ -0,0 +1,35 @@
+name: angular2
+version: <%= packageJson.version %>
+authors:
+<%= Object.keys(packageJson.contributors).map(function(name) {
+  return '- '+name+' <'+packageJson.contributors[name]+'>';
+}).join('\n') %>
+description: Angular 2 for Dart - a web framework for modern web apps
+homepage: <%= packageJson.homepage %>
+environment:
+  sdk: '>=1.10.0 <2.0.0'
+dependencies:
+  analyzer: '>=0.24.4 <0.28.0'
+  barback: '^0.15.2+2'
+  dart_style: '>=0.1.8 <0.3.0'
+  glob: '^1.0.0'
+  html: '^0.12.0'
+  intl: '^0.12.4'
+  logging: '>=0.9.0 <0.12.0'
+  observe: '^0.13.1'
+  path: '^1.0.0'
+  protobuf: '^0.5.0'
+  source_span: '^1.0.0'
+  stack_trace: '^1.1.1'
+  build: '>=0.0.1'
+dev_dependencies:
+  transformer_test: '^0.2.0'
+  guinness: '^0.1.18'
+  guinness2: '0.0.5'
+  quiver: '^0.21.4'
+  test: '^0.12.6'
+transformers:
+- angular2/transform/codegen
+- $dart2js:
+    commandLineOptions:
+    - --show-package-warnings

node_modules/angular2/ts/router.ts

@@ -0,0 +1,52 @@
+/**
+ * @module
+ * @description
+ * Maps application URLs into application states, to support deep-linking and navigation.
+ */
+
+export {Router} from './src/router/router';
+export {RouterOutlet} from './src/router/directives/router_outlet';
+export {RouterLink} from './src/router/directives/router_link';
+export {RouteParams, RouteData} from './src/router/instruction';
+export {PlatformLocation} from './src/router/location/platform_location';
+export {RouteRegistry, ROUTER_PRIMARY_COMPONENT} from './src/router/route_registry';
+export {LocationStrategy, APP_BASE_HREF} from './src/router/location/location_strategy';
+export {HashLocationStrategy} from './src/router/location/hash_location_strategy';
+export {PathLocationStrategy} from './src/router/location/path_location_strategy';
+export {Location} from './src/router/location/location';
+export * from './src/router/route_config/route_config_decorator';
+export * from './src/router/route_definition';
+export {OnActivate, OnDeactivate, OnReuse, CanDeactivate, CanReuse} from './src/router/interfaces';
+export {CanActivate} from './src/router/lifecycle/lifecycle_annotations';
+export {Instruction, ComponentInstruction} from './src/router/instruction';
+export {OpaqueToken} from 'angular2/core';
+export {ROUTER_PROVIDERS_COMMON} from 'angular2/src/router/router_providers_common';
+export {ROUTER_PROVIDERS, ROUTER_BINDINGS} from 'angular2/src/router/router_providers';
+
+import {RouterOutlet} from './src/router/directives/router_outlet';
+import {RouterLink} from './src/router/directives/router_link';
+import {CONST_EXPR} from './src/facade/lang';
+
+/**
+ * A list of directives. To use the router directives like {@link RouterOutlet} and
+ * {@link RouterLink}, add this to your `directives` array in the {@link View} decorator of your
+ * component.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/iRUP8B5OUbxCWQ3AcIDm))
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';
+ *
+ * @Component({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ *  {...},
+ * ])
+ * class AppCmp {
+ *    // ...
+ * }
+ *
+ * bootstrap(AppCmp, [ROUTER_PROVIDERS]);
+ * ```
+ */
+export const ROUTER_DIRECTIVES: any[] = CONST_EXPR([RouterOutlet, RouterLink]);

node_modules/angular2/ts/router/router_link_dsl.ts

@@ -0,0 +1,35 @@
+import {TEMPLATE_TRANSFORMS} from 'angular2/compiler';
+import {Provider} from 'angular2/core';
+import {RouterLinkTransform} from 'angular2/src/router/directives/router_link_transform';
+import {CONST_EXPR} from 'angular2/src/facade/lang';
+
+export {RouterLinkTransform} from 'angular2/src/router/directives/router_link_transform';
+
+/**
+ * Enables the router link DSL.
+ *
+ * Warning. This feature is experimental and can change.
+ *
+ * To enable the transformer pass the router link DSL provider to `bootstrap`.
+ *
+ * ## Example:
+ * ```
+ * import {bootstrap} from 'angular2/platform/browser';
+ * import {ROUTER_LINK_DSL_PROVIDER} from 'angular2/router/router_link_dsl';
+ *
+ * bootstrap(CustomApp, [ROUTER_LINK_DSL_PROVIDER]);
+ * ```
+ *
+ * The DSL allows you to express router links as follows:
+ * ```
+ * <a [routerLink]="route:User"> <!-- Same as <a [routerLink]="['User']"> -->
+ * <a [routerLink]="route:/User"> <!-- Same as <a [routerLink]="['User']"> -->
+ * <a [routerLink]="route:./User"> <!-- Same as <a [routerLink]="['./User']"> -->
+ * <a [routerLink]="./User(id: value, name: 'Bob')"> <!-- Same as <a [routerLink]="['./User', {id:
+ * value, name: 'Bob'}]"> -->
+ * <a [routerLink]="/User/Modal"> <!-- Same as <a [routerLink]="['/User', 'Modal']"> -->
+ * <a [routerLink]="User[Modal]"> <!-- Same as <a [routerLink]="['User', ['Modal']]"> -->
+ * ```
+ */
+export const ROUTER_LINK_DSL_PROVIDER =
+    CONST_EXPR(new Provider(TEMPLATE_TRANSFORMS, {useClass: RouterLinkTransform, multi: true}));

node_modules/angular2/ts/router/testing.ts

@@ -0,0 +1,2 @@
+export * from 'angular2/src/mock/mock_location_strategy';
+export * from 'angular2/src/mock/location_mock';

node_modules/angular2/ts/src/animate/animation.ts

@@ -0,0 +1,200 @@
+import {
+  DateWrapper,
+  StringWrapper,
+  RegExpWrapper,
+  NumberWrapper,
+  isPresent
+} from 'angular2/src/facade/lang';
+import {Math} from 'angular2/src/facade/math';
+import {camelCaseToDashCase} from 'angular2/src/platform/dom/util';
+import {StringMapWrapper} from 'angular2/src/facade/collection';
+import {DOM} from 'angular2/src/platform/dom/dom_adapter';
+
+import {BrowserDetails} from './browser_details';
+import {CssAnimationOptions} from './css_animation_options';
+
+export class Animation {
+  /** functions to be called upon completion */
+  callbacks: Function[] = [];
+
+  /** the duration (ms) of the animation (whether from CSS or manually set) */
+  computedDuration: number;
+
+  /** the animation delay (ms) (whether from CSS or manually set) */
+  computedDelay: number;
+
+  /** timestamp of when the animation started */
+  startTime: number;
+
+  /** functions for removing event listeners */
+  eventClearFunctions: Function[] = [];
+
+  /** flag used to track whether or not the animation has finished */
+  completed: boolean = false;
+
+  private _stringPrefix: string = '';
+
+  /** total amount of time that the animation should take including delay */
+  get totalTime(): number {
+    let delay = this.computedDelay != null ? this.computedDelay : 0;
+    let duration = this.computedDuration != null ? this.computedDuration : 0;
+    return delay + duration;
+  }
+
+  /**
+   * Stores the start time and starts the animation
+   * @param element
+   * @param data
+   * @param browserDetails
+   */
+  constructor(public element: HTMLElement, public data: CssAnimationOptions,
+              public browserDetails: BrowserDetails) {
+    this.startTime = DateWrapper.toMillis(DateWrapper.now());
+    this._stringPrefix = DOM.getAnimationPrefix();
+    this.setup();
+    this.wait((timestamp: any) => this.start());
+  }
+
+  wait(callback: Function) {
+    // Firefox requires 2 frames for some reason
+    this.browserDetails.raf(callback, 2);
+  }
+
+  /**
+   * Sets up the initial styles before the animation is started
+   */
+  setup(): void {
+    if (this.data.fromStyles != null) this.applyStyles(this.data.fromStyles);
+    if (this.data.duration != null)
+      this.applyStyles({'transitionDuration': this.data.duration.toString() + 'ms'});
+    if (this.data.delay != null)
+      this.applyStyles({'transitionDelay': this.data.delay.toString() + 'ms'});
+  }
+
+  /**
+   * After the initial setup has occurred, this method adds the animation styles
+   */
+  start(): void {
+    this.addClasses(this.data.classesToAdd);
+    this.addClasses(this.data.animationClasses);
+    this.removeClasses(this.data.classesToRemove);
+    if (this.data.toStyles != null) this.applyStyles(this.data.toStyles);
+    var computedStyles = DOM.getComputedStyle(this.element);
+    this.computedDelay =
+        Math.max(this.parseDurationString(
+                     computedStyles.getPropertyValue(this._stringPrefix + 'transition-delay')),
+                 this.parseDurationString(
+                     this.element.style.getPropertyValue(this._stringPrefix + 'transition-delay')));
+    this.computedDuration = Math.max(this.parseDurationString(computedStyles.getPropertyValue(
+                                         this._stringPrefix + 'transition-duration')),
+                                     this.parseDurationString(this.element.style.getPropertyValue(
+                                         this._stringPrefix + 'transition-duration')));
+    this.addEvents();
+  }
+
+  /**
+   * Applies the provided styles to the element
+   * @param styles
+   */
+  applyStyles(styles: {[key: string]: any}): void {
+    StringMapWrapper.forEach(styles, (value: any, key: string) => {
+      var dashCaseKey = camelCaseToDashCase(key);
+      if (isPresent(DOM.getStyle(this.element, dashCaseKey))) {
+        DOM.setStyle(this.element, dashCaseKey, value.toString());
+      } else {
+        DOM.setStyle(this.element, this._stringPrefix + dashCaseKey, value.toString());
+      }
+    });
+  }
+
+  /**
+   * Adds the provided classes to the element
+   * @param classes
+   */
+  addClasses(classes: string[]): void {
+    for (let i = 0, len = classes.length; i < len; i++) DOM.addClass(this.element, classes[i]);
+  }
+
+  /**
+   * Removes the provided classes from the element
+   * @param classes
+   */
+  removeClasses(classes: string[]): void {
+    for (let i = 0, len = classes.length; i < len; i++) DOM.removeClass(this.element, classes[i]);
+  }
+
+  /**
+   * Adds events to track when animations have finished
+   */
+  addEvents(): void {
+    if (this.totalTime > 0) {
+      this.eventClearFunctions.push(DOM.onAndCancel(
+          this.element, DOM.getTransitionEnd(), (event: any) => this.handleAnimationEvent(event)));
+    } else {
+      this.handleAnimationCompleted();
+    }
+  }
+
+  handleAnimationEvent(event: any): void {
+    let elapsedTime = Math.round(event.elapsedTime * 1000);
+    if (!this.browserDetails.elapsedTimeIncludesDelay) elapsedTime += this.computedDelay;
+    event.stopPropagation();
+    if (elapsedTime >= this.totalTime) this.handleAnimationCompleted();
+  }
+
+  /**
+   * Runs all animation callbacks and removes temporary classes
+   */
+  handleAnimationCompleted(): void {
+    this.removeClasses(this.data.animationClasses);
+    this.callbacks.forEach(callback => callback());
+    this.callbacks = [];
+    this.eventClearFunctions.forEach(fn => fn());
+    this.eventClearFunctions = [];
+    this.completed = true;
+  }
+
+  /**
+   * Adds animation callbacks to be called upon completion
+   * @param callback
+   * @returns {Animation}
+   */
+  onComplete(callback: Function): Animation {
+    if (this.completed) {
+      callback();
+    } else {
+      this.callbacks.push(callback);
+    }
+    return this;
+  }
+
+  /**
+   * Converts the duration string to the number of milliseconds
+   * @param duration
+   * @returns {number}
+   */
+  parseDurationString(duration: string): number {
+    var maxValue = 0;
+    // duration must have at least 2 characters to be valid. (number + type)
+    if (duration == null || duration.length < 2) {
+      return maxValue;
+    } else if (duration.substring(duration.length - 2) == 'ms') {
+      let value = NumberWrapper.parseInt(this.stripLetters(duration), 10);
+      if (value > maxValue) maxValue = value;
+    } else if (duration.substring(duration.length - 1) == 's') {
+      let ms = NumberWrapper.parseFloat(this.stripLetters(duration)) * 1000;
+      let value = Math.floor(ms);
+      if (value > maxValue) maxValue = value;
+    }
+    return maxValue;
+  }
+
+  /**
+   * Strips the letters from the duration string
+   * @param str
+   * @returns {string}
+   */
+  stripLetters(str: string): string {
+    return StringWrapper.replaceAll(str, RegExpWrapper.create('[^0-9]+$', ''), '');
+  }
+}

node_modules/angular2/ts/src/animate/animation_builder.ts

@@ -0,0 +1,19 @@
+import {Injectable} from 'angular2/src/core/di';
+
+import {CssAnimationBuilder} from './css_animation_builder';
+import {BrowserDetails} from './browser_details';
+
+@Injectable()
+export class AnimationBuilder {
+  /**
+   * Used for DI
+   * @param browserDetails
+   */
+  constructor(public browserDetails: BrowserDetails) {}
+
+  /**
+   * Creates a new CSS Animation
+   * @returns {CssAnimationBuilder}
+   */
+  css(): CssAnimationBuilder { return new CssAnimationBuilder(this.browserDetails); }
+}

node_modules/angular2/ts/src/animate/browser_details.ts

@@ -0,0 +1,55 @@
+import {Injectable} from 'angular2/src/core/di';
+import {Math} from 'angular2/src/facade/math';
+import {DOM} from 'angular2/src/platform/dom/dom_adapter';
+
+@Injectable()
+export class BrowserDetails {
+  elapsedTimeIncludesDelay = false;
+
+  constructor() { this.doesElapsedTimeIncludesDelay(); }
+
+  /**
+   * Determines if `event.elapsedTime` includes transition delay in the current browser.  At this
+   * time, Chrome and Opera seem to be the only browsers that include this.
+   */
+  doesElapsedTimeIncludesDelay(): void {
+    var div = DOM.createElement('div');
+    DOM.setAttribute(div, 'style', `position: absolute; top: -9999px; left: -9999px; width: 1px;
+      height: 1px; transition: all 1ms linear 1ms;`);
+    // Firefox requires that we wait for 2 frames for some reason
+    this.raf((timestamp: any) => {
+      DOM.on(div, 'transitionend', (event: any) => {
+        var elapsed = Math.round(event.elapsedTime * 1000);
+        this.elapsedTimeIncludesDelay = elapsed == 2;
+        DOM.remove(div);
+      });
+      DOM.setStyle(div, 'width', '2px');
+    }, 2);
+  }
+
+  raf(callback: Function, frames: number = 1): Function {
+    var queue: RafQueue = new RafQueue(callback, frames);
+    return () => queue.cancel();
+  }
+}
+
+class RafQueue {
+  currentFrameId: number;
+  constructor(public callback: Function, public frames: number) { this._raf(); }
+  private _raf() {
+    this.currentFrameId =
+        DOM.requestAnimationFrame((timestamp: number) => this._nextFrame(timestamp));
+  }
+  private _nextFrame(timestamp: number) {
+    this.frames--;
+    if (this.frames > 0) {
+      this._raf();
+    } else {
+      this.callback(timestamp);
+    }
+  }
+  cancel() {
+    DOM.cancelAnimationFrame(this.currentFrameId);
+    this.currentFrameId = null;
+  }
+}

node_modules/angular2/ts/src/animate/css_animation_builder.ts

@@ -0,0 +1,93 @@
+import {CssAnimationOptions} from './css_animation_options';
+import {Animation} from './animation';
+import {BrowserDetails} from './browser_details';
+
+export class CssAnimationBuilder {
+  /** @type {CssAnimationOptions} */
+  data: CssAnimationOptions = new CssAnimationOptions();
+
+  /**
+   * Accepts public properties for CssAnimationBuilder
+   */
+  constructor(public browserDetails: BrowserDetails) {}
+
+  /**
+   * Adds a temporary class that will be removed at the end of the animation
+   * @param className
+   */
+  addAnimationClass(className: string): CssAnimationBuilder {
+    this.data.animationClasses.push(className);
+    return this;
+  }
+
+  /**
+   * Adds a class that will remain on the element after the animation has finished
+   * @param className
+   */
+  addClass(className: string): CssAnimationBuilder {
+    this.data.classesToAdd.push(className);
+    return this;
+  }
+
+  /**
+   * Removes a class from the element
+   * @param className
+   */
+  removeClass(className: string): CssAnimationBuilder {
+    this.data.classesToRemove.push(className);
+    return this;
+  }
+
+  /**
+   * Sets the animation duration (and overrides any defined through CSS)
+   * @param duration
+   */
+  setDuration(duration: number): CssAnimationBuilder {
+    this.data.duration = duration;
+    return this;
+  }
+
+  /**
+   * Sets the animation delay (and overrides any defined through CSS)
+   * @param delay
+   */
+  setDelay(delay: number): CssAnimationBuilder {
+    this.data.delay = delay;
+    return this;
+  }
+
+  /**
+   * Sets styles for both the initial state and the destination state
+   * @param from
+   * @param to
+   */
+  setStyles(from: {[key: string]: any}, to: {[key: string]: any}): CssAnimationBuilder {
+    return this.setFromStyles(from).setToStyles(to);
+  }
+
+  /**
+   * Sets the initial styles for the animation
+   * @param from
+   */
+  setFromStyles(from: {[key: string]: any}): CssAnimationBuilder {
+    this.data.fromStyles = from;
+    return this;
+  }
+
+  /**
+   * Sets the destination styles for the animation
+   * @param to
+   */
+  setToStyles(to: {[key: string]: any}): CssAnimationBuilder {
+    this.data.toStyles = to;
+    return this;
+  }
+
+  /**
+   * Starts the animation and returns a promise
+   * @param element
+   */
+  start(element: HTMLElement): Animation {
+    return new Animation(element, this.data, this.browserDetails);
+  }
+}

node_modules/angular2/ts/src/animate/css_animation_options.ts

@@ -0,0 +1,22 @@
+export class CssAnimationOptions {
+  /** initial styles for the element */
+  fromStyles: {[key: string]: any};
+
+  /** destination styles for the element */
+  toStyles: {[key: string]: any};
+
+  /** classes to be added to the element */
+  classesToAdd: string[] = [];
+
+  /** classes to be removed from the element */
+  classesToRemove: string[] = [];
+
+  /** classes to be added for the duration of the animation */
+  animationClasses: string[] = [];
+
+  /** override the duration of the animation (in milliseconds) */
+  duration: number;
+
+  /** override the transition delay (in milliseconds) */
+  delay: number;
+}

node_modules/angular2/ts/src/common/common_directives.ts

@@ -0,0 +1,49 @@
+import {CONST_EXPR, Type} from 'angular2/src/facade/lang';
+
+import {FORM_DIRECTIVES} from './forms';
+import {CORE_DIRECTIVES} from './directives';
+
+/**
+ * A collection of Angular core directives that are likely to be used in each and every Angular
+ * application. This includes core directives (e.g., NgIf and NgFor), and forms directives (e.g.,
+ * NgModel).
+ *
+ * This collection can be used to quickly enumerate all the built-in directives in the `directives`
+ * property of the `@Component` decorator.
+ *
+ * ### Example
+ *
+ * Instead of writing:
+ *
+ * ```typescript
+ * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault, NgModel, NgForm} from
+ * 'angular2/common';
+ * import {OtherDirective} from './myDirectives';
+ *
+ * @Component({
+ *   selector: 'my-component',
+ *   templateUrl: 'myComponent.html',
+ *   directives: [NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault, NgModel, NgForm,
+ * OtherDirective]
+ * })
+ * export class MyComponent {
+ *   ...
+ * }
+ * ```
+ * one could import all the common directives at once:
+ *
+ * ```typescript
+ * import {COMMON_DIRECTIVES} from 'angular2/common';
+ * import {OtherDirective} from './myDirectives';
+ *
+ * @Component({
+ *   selector: 'my-component',
+ *   templateUrl: 'myComponent.html',
+ *   directives: [COMMON_DIRECTIVES, OtherDirective]
+ * })
+ * export class MyComponent {
+ *   ...
+ * }
+ * ```
+ */
+export const COMMON_DIRECTIVES: Type[][] = CONST_EXPR([CORE_DIRECTIVES, FORM_DIRECTIVES]);

node_modules/angular2/ts/src/common/directives.ts

@@ -0,0 +1,13 @@
+/**
+ * @module
+ * @description
+ * Common directives shipped with Angular.
+ */
+export {NgClass} from './directives/ng_class';
+export {NgFor} from './directives/ng_for';
+export {NgIf} from './directives/ng_if';
+export {NgStyle} from './directives/ng_style';
+export {NgSwitch, NgSwitchWhen, NgSwitchDefault} from './directives/ng_switch';
+export {NgPlural, NgPluralCase, NgLocalization} from './directives/ng_plural';
+export * from './directives/observable_list_diff';
+export {CORE_DIRECTIVES} from './directives/core_directives';

node_modules/angular2/ts/src/common/directives/core_directives.ts

@@ -0,0 +1,59 @@
+import {CONST_EXPR, Type} from 'angular2/src/facade/lang';
+import {NgClass} from './ng_class';
+import {NgFor} from './ng_for';
+import {NgIf} from './ng_if';
+import {NgStyle} from './ng_style';
+import {NgSwitch, NgSwitchWhen, NgSwitchDefault} from './ng_switch';
+import {NgPlural, NgPluralCase} from './ng_plural';
+
+/**
+ * A collection of Angular core directives that are likely to be used in each and every Angular
+ * application.
+ *
+ * This collection can be used to quickly enumerate all the built-in directives in the `directives`
+ * property of the `@Component` annotation.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/yakGwpCdUkg0qfzX5m8g?p=preview))
+ *
+ * Instead of writing:
+ *
+ * ```typescript
+ * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault} from 'angular2/common';
+ * import {OtherDirective} from './myDirectives';
+ *
+ * @Component({
+ *   selector: 'my-component',
+ *   templateUrl: 'myComponent.html',
+ *   directives: [NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault, OtherDirective]
+ * })
+ * export class MyComponent {
+ *   ...
+ * }
+ * ```
+ * one could import all the core directives at once:
+ *
+ * ```typescript
+ * import {CORE_DIRECTIVES} from 'angular2/common';
+ * import {OtherDirective} from './myDirectives';
+ *
+ * @Component({
+ *   selector: 'my-component',
+ *   templateUrl: 'myComponent.html',
+ *   directives: [CORE_DIRECTIVES, OtherDirective]
+ * })
+ * export class MyComponent {
+ *   ...
+ * }
+ * ```
+ */
+export const CORE_DIRECTIVES: Type[] = CONST_EXPR([
+  NgClass,
+  NgFor,
+  NgIf,
+  NgStyle,
+  NgSwitch,
+  NgSwitchWhen,
+  NgSwitchDefault,
+  NgPlural,
+  NgPluralCase
+]);

node_modules/angular2/ts/src/common/directives/ng_class.ts

@@ -0,0 +1,186 @@
+import {isPresent, isString, isArray} from 'angular2/src/facade/lang';
+import {
+  DoCheck,
+  OnDestroy,
+  Directive,
+  ElementRef,
+  IterableDiffers,
+  KeyValueDiffers,
+  Renderer,
+  IterableDiffer,
+  KeyValueDiffer,
+  CollectionChangeRecord,
+  KeyValueChangeRecord
+} from 'angular2/core';
+import {StringMapWrapper, isListLikeIterable} from 'angular2/src/facade/collection';
+
+/**
+ * The `NgClass` directive conditionally adds and removes CSS classes on an HTML element based on
+ * an expression's evaluation result.
+ *
+ * The result of an expression evaluation is interpreted differently depending on type of
+ * the expression evaluation result:
+ * - `string` - all the CSS classes listed in a string (space delimited) are added
+ * - `Array` - all the CSS classes (Array elements) are added
+ * - `Object` - each key corresponds to a CSS class name while values are interpreted as expressions
+ * evaluating to `Boolean`. If a given expression evaluates to `true` a corresponding CSS class
+ * is added - otherwise it is removed.
+ *
+ * While the `NgClass` directive can interpret expressions evaluating to `string`, `Array`
+ * or `Object`, the `Object`-based version is the most often used and has an advantage of keeping
+ * all the CSS class names in a template.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/a4YdtmWywhJ33uqfpPPn?p=preview)):
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {NgClass} from 'angular2/common';
+ *
+ * @Component({
+ *   selector: 'toggle-button',
+ *   inputs: ['isDisabled'],
+ *   template: `
+ *      <div class="button" [ngClass]="{active: isOn, disabled: isDisabled}"
+ *          (click)="toggle(!isOn)">
+ *          Click me!
+ *      </div>`,
+ *   styles: [`
+ *     .button {
+ *       width: 120px;
+ *       border: medium solid black;
+ *     }
+ *
+ *     .active {
+ *       background-color: red;
+ *    }
+ *
+ *     .disabled {
+ *       color: gray;
+ *       border: medium solid gray;
+ *     }
+ *   `]
+ *   directives: [NgClass]
+ * })
+ * class ToggleButton {
+ *   isOn = false;
+ *   isDisabled = false;
+ *
+ *   toggle(newState) {
+ *     if (!this.isDisabled) {
+ *       this.isOn = newState;
+ *     }
+ *   }
+ * }
+ * ```
+ */
+@Directive({selector: '[ngClass]', inputs: ['rawClass: ngClass', 'initialClasses: class']})
+export class NgClass implements DoCheck, OnDestroy {
+  private _iterableDiffer: IterableDiffer;
+  private _keyValueDiffer: KeyValueDiffer;
+  private _initialClasses: string[] = [];
+  private _rawClass: string[] | Set<string>;
+
+  constructor(private _iterableDiffers: IterableDiffers, private _keyValueDiffers: KeyValueDiffers,
+              private _ngEl: ElementRef, private _renderer: Renderer) {}
+
+  set initialClasses(v: string) {
+    this._applyInitialClasses(true);
+    this._initialClasses = isPresent(v) && isString(v) ? v.split(' ') : [];
+    this._applyInitialClasses(false);
+    this._applyClasses(this._rawClass, false);
+  }
+
+  set rawClass(v: string | string[] | Set<string>| {[key: string]: any}) {
+    this._cleanupClasses(this._rawClass);
+
+    if (isString(v)) {
+      v = (<string>v).split(' ');
+    }
+
+    this._rawClass = <string[] | Set<string>>v;
+    this._iterableDiffer = null;
+    this._keyValueDiffer = null;
+    if (isPresent(v)) {
+      if (isListLikeIterable(v)) {
+        this._iterableDiffer = this._iterableDiffers.find(v).create(null);
+      } else {
+        this._keyValueDiffer = this._keyValueDiffers.find(v).create(null);
+      }
+    }
+  }
+
+  ngDoCheck(): void {
+    if (isPresent(this._iterableDiffer)) {
+      var changes = this._iterableDiffer.diff(this._rawClass);
+      if (isPresent(changes)) {
+        this._applyIterableChanges(changes);
+      }
+    }
+    if (isPresent(this._keyValueDiffer)) {
+      var changes = this._keyValueDiffer.diff(this._rawClass);
+      if (isPresent(changes)) {
+        this._applyKeyValueChanges(changes);
+      }
+    }
+  }
+
+  ngOnDestroy(): void { this._cleanupClasses(this._rawClass); }
+
+  private _cleanupClasses(rawClassVal: string[] | Set<string>| {[key: string]: any}): void {
+    this._applyClasses(rawClassVal, true);
+    this._applyInitialClasses(false);
+  }
+
+  private _applyKeyValueChanges(changes: any): void {
+    changes.forEachAddedItem(
+        (record: KeyValueChangeRecord) => { this._toggleClass(record.key, record.currentValue); });
+    changes.forEachChangedItem(
+        (record: KeyValueChangeRecord) => { this._toggleClass(record.key, record.currentValue); });
+    changes.forEachRemovedItem((record: KeyValueChangeRecord) => {
+      if (record.previousValue) {
+        this._toggleClass(record.key, false);
+      }
+    });
+  }
+
+  private _applyIterableChanges(changes: any): void {
+    changes.forEachAddedItem(
+        (record: CollectionChangeRecord) => { this._toggleClass(record.item, true); });
+    changes.forEachRemovedItem(
+        (record: CollectionChangeRecord) => { this._toggleClass(record.item, false); });
+  }
+
+  private _applyInitialClasses(isCleanup: boolean) {
+    this._initialClasses.forEach(className => this._toggleClass(className, !isCleanup));
+  }
+
+  private _applyClasses(rawClassVal: string[] | Set<string>| {[key: string]: any},
+                        isCleanup: boolean) {
+    if (isPresent(rawClassVal)) {
+      if (isArray(rawClassVal)) {
+        (<string[]>rawClassVal).forEach(className => this._toggleClass(className, !isCleanup));
+      } else if (rawClassVal instanceof Set) {
+        (<Set<string>>rawClassVal).forEach(className => this._toggleClass(className, !isCleanup));
+      } else {
+        StringMapWrapper.forEach(<{[k: string]: any}>rawClassVal,
+                                 (expVal: any, className: string) => {
+                                   if (isPresent(expVal)) this._toggleClass(className, !isCleanup);
+                                 });
+      }
+    }
+  }
+
+  private _toggleClass(className: string, enabled: boolean): void {
+    className = className.trim();
+    if (className.length > 0) {
+      if (className.indexOf(' ') > -1) {
+        var classes = className.split(/\s+/g);
+        for (var i = 0, len = classes.length; i < len; i++) {
+          this._renderer.setElementClass(this._ngEl.nativeElement, classes[i], enabled);
+        }
+      } else {
+        this._renderer.setElementClass(this._ngEl.nativeElement, className, enabled);
+      }
+    }
+  }
+}

node_modules/angular2/ts/src/common/directives/ng_for.ts

@@ -0,0 +1,183 @@
+import {
+  DoCheck,
+  Directive,
+  ChangeDetectorRef,
+  IterableDiffer,
+  IterableDiffers,
+  ViewContainerRef,
+  TemplateRef,
+  EmbeddedViewRef,
+  TrackByFn
+} from 'angular2/core';
+import {isPresent, isBlank, stringify, getTypeNameForDebugging} from 'angular2/src/facade/lang';
+import {
+  DefaultIterableDiffer,
+  CollectionChangeRecord
+} from "../../core/change_detection/differs/default_iterable_differ";
+import {BaseException} from "../../facade/exceptions";
+
+/**
+ * The `NgFor` 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
+ *
+ * `NgFor` provides several exported values that can be aliased to local variables:
+ *
+ * * `index` will be set to the current loop iteration for each template context.
+ * * `last` will be set to a boolean value indicating whether the item is the last one in the
+ *   iteration.
+ * * `even` will be set to a boolean value indicating whether this item has an even index.
+ * * `odd` will be set to a boolean value indicating whether this item has an odd index.
+ *
+ * # Change Propagation
+ *
+ * When the contents of the iterator changes, `NgFor` 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.
+ *
+ * # Syntax
+ *
+ * - `<li *ngFor="#item of items; #i = index">...</li>`
+ * - `<li template="ngFor #item of items; #i = index">...</li>`
+ * - `<template ngFor #item [ngForOf]="items" #i="index"><li>...</li></template>`
+ *
+ * ### Example
+ *
+ * See a [live demo](http://plnkr.co/edit/KVuXxDp0qinGDyo307QW?p=preview) for a more detailed
+ * example.
+ */
+@Directive({selector: '[ngFor][ngForOf]', inputs: ['ngForTrackBy', 'ngForOf', 'ngForTemplate']})
+export class NgFor implements DoCheck {
+  /** @internal */
+  _ngForOf: any;
+  _ngForTrackBy: TrackByFn;
+  private _differ: IterableDiffer;
+
+  constructor(private _viewContainer: ViewContainerRef, private _templateRef: TemplateRef,
+              private _iterableDiffers: IterableDiffers, private _cdr: ChangeDetectorRef) {}
+
+  set ngForOf(value: any) {
+    this._ngForOf = value;
+    if (isBlank(this._differ) && isPresent(value)) {
+      try {
+        this._differ = this._iterableDiffers.find(value).create(this._cdr, this._ngForTrackBy);
+      } catch (e) {
+        throw new BaseException(
+            `Cannot find a differ supporting object '${value}' of type '${getTypeNameForDebugging(value)}'. NgFor only supports binding to Iterables such as Arrays.`);
+      }
+    }
+  }
+
+  set ngForTemplate(value: TemplateRef) {
+    if (isPresent(value)) {
+      this._templateRef = value;
+    }
+  }
+
+  set ngForTrackBy(value: TrackByFn) { this._ngForTrackBy = value; }
+
+  ngDoCheck() {
+    if (isPresent(this._differ)) {
+      var changes = this._differ.diff(this._ngForOf);
+      if (isPresent(changes)) this._applyChanges(changes);
+    }
+  }
+
+  private _applyChanges(changes: DefaultIterableDiffer) {
+    // TODO(rado): check if change detection can produce a change record that is
+    // easier to consume than current.
+    var recordViewTuples: RecordViewTuple[] = [];
+    changes.forEachRemovedItem((removedRecord: CollectionChangeRecord) =>
+                                   recordViewTuples.push(new RecordViewTuple(removedRecord, null)));
+
+    changes.forEachMovedItem((movedRecord: CollectionChangeRecord) =>
+                                 recordViewTuples.push(new RecordViewTuple(movedRecord, null)));
+
+    var insertTuples = this._bulkRemove(recordViewTuples);
+
+    changes.forEachAddedItem((addedRecord: CollectionChangeRecord) =>
+                                 insertTuples.push(new RecordViewTuple(addedRecord, null)));
+
+    this._bulkInsert(insertTuples);
+
+    for (var i = 0; i < insertTuples.length; i++) {
+      this._perViewChange(insertTuples[i].view, insertTuples[i].record);
+    }
+
+    for (var i = 0, ilen = this._viewContainer.length; i < ilen; i++) {
+      var viewRef = <EmbeddedViewRef>this._viewContainer.get(i);
+      viewRef.setLocal('last', i === ilen - 1);
+    }
+
+    changes.forEachIdentityChange((record) => {
+      var viewRef = <EmbeddedViewRef>this._viewContainer.get(record.currentIndex);
+      viewRef.setLocal('\$implicit', record.item);
+    });
+  }
+
+  private _perViewChange(view: EmbeddedViewRef, record: CollectionChangeRecord) {
+    view.setLocal('\$implicit', record.item);
+    view.setLocal('index', record.currentIndex);
+    view.setLocal('even', (record.currentIndex % 2 == 0));
+    view.setLocal('odd', (record.currentIndex % 2 == 1));
+  }
+
+  private _bulkRemove(tuples: RecordViewTuple[]): RecordViewTuple[] {
+    tuples.sort((a: RecordViewTuple, b: RecordViewTuple) =>
+                    a.record.previousIndex - b.record.previousIndex);
+    var movedTuples: RecordViewTuple[] = [];
+    for (var i = tuples.length - 1; i >= 0; i--) {
+      var tuple = tuples[i];
+      // separate moved views from removed views.
+      if (isPresent(tuple.record.currentIndex)) {
+        tuple.view = this._viewContainer.detach(tuple.record.previousIndex);
+        movedTuples.push(tuple);
+      } else {
+        this._viewContainer.remove(tuple.record.previousIndex);
+      }
+    }
+    return movedTuples;
+  }
+
+  private _bulkInsert(tuples: RecordViewTuple[]): RecordViewTuple[] {
+    tuples.sort((a, b) => a.record.currentIndex - b.record.currentIndex);
+    for (var i = 0; i < tuples.length; i++) {
+      var tuple = tuples[i];
+      if (isPresent(tuple.view)) {
+        this._viewContainer.insert(tuple.view, tuple.record.currentIndex);
+      } else {
+        tuple.view =
+            this._viewContainer.createEmbeddedView(this._templateRef, tuple.record.currentIndex);
+      }
+    }
+    return tuples;
+  }
+}
+
+class RecordViewTuple {
+  view: EmbeddedViewRef;
+  record: any;
+  constructor(record: any, view: EmbeddedViewRef) {
+    this.record = record;
+    this.view = view;
+  }
+}

node_modules/angular2/ts/src/common/directives/ng_if.ts

@@ -0,0 +1,41 @@
+import {Directive, ViewContainerRef, TemplateRef} from 'angular2/core';
+import {isBlank} from 'angular2/src/facade/lang';
+
+/**
+ * Removes or recreates a portion of the DOM tree based on an {expression}.
+ *
+ * If the expression assigned to `ngIf` evaluates to a false value then the element
+ * is removed from the DOM, otherwise a clone of the element is reinserted into the DOM.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/fe0kgemFBtmQOY31b4tw?p=preview)):
+ *
+ * ```
+ * <div *ngIf="errorCount > 0" class="error">
+ *   <!-- Error message displayed when the errorCount property on the current context is greater
+ * than 0. -->
+ *   {{errorCount}} errors detected
+ * </div>
+ * ```
+ *
+ * ### Syntax
+ *
+ * - `<div *ngIf="condition">...</div>`
+ * - `<div template="ngIf condition">...</div>`
+ * - `<template [ngIf]="condition"><div>...</div></template>`
+ */
+@Directive({selector: '[ngIf]', inputs: ['ngIf']})
+export class NgIf {
+  private _prevCondition: boolean = null;
+
+  constructor(private _viewContainer: ViewContainerRef, private _templateRef: TemplateRef) {}
+
+  set ngIf(newCondition: any /* boolean */) {
+    if (newCondition && (isBlank(this._prevCondition) || !this._prevCondition)) {
+      this._prevCondition = true;
+      this._viewContainer.createEmbeddedView(this._templateRef);
+    } else if (!newCondition && (isBlank(this._prevCondition) || this._prevCondition)) {
+      this._prevCondition = false;
+      this._viewContainer.clear();
+    }
+  }
+}

node_modules/angular2/ts/src/common/directives/ng_plural.ts

@@ -0,0 +1,146 @@
+import {
+  Directive,
+  ViewContainerRef,
+  TemplateRef,
+  ContentChildren,
+  QueryList,
+  Attribute,
+  AfterContentInit,
+  Input
+} from 'angular2/core';
+import {isPresent, NumberWrapper} from 'angular2/src/facade/lang';
+import {Map} from 'angular2/src/facade/collection';
+import {SwitchView} from './ng_switch';
+
+const _CATEGORY_DEFAULT = 'other';
+
+export abstract class NgLocalization { abstract getPluralCategory(value: any): string; }
+
+/**
+ * `ngPlural` is an i18n directive that displays DOM sub-trees that match the switch expression
+ * value, or failing that, DOM sub-trees that match the switch expression's pluralization category.
+ *
+ * To use this directive, you must provide an extension of `NgLocalization` that maps values to
+ * category names. You then define a container element that sets the `[ngPlural]` attribute to a
+ * switch expression.
+ *    - Inner elements defined with an `[ngPluralCase]` attribute will display based on their
+ * expression.
+ *    - If `[ngPluralCase]` is set to a value starting with `=`, it will only display if the value
+ * matches the switch expression exactly.
+ *    - Otherwise, the view will be treated as a "category match", and will only display if exact
+ * value matches aren't found and the value maps to its category using the `getPluralCategory`
+ * function provided.
+ *
+ * If no matching views are found for a switch expression, inner elements marked
+ * `[ngPluralCase]="other"` will be displayed.
+ *
+ * ```typescript
+ * class MyLocalization extends NgLocalization {
+ *    getPluralCategory(value: any) {
+ *       if(value < 5) {
+ *          return 'few';
+ *       }
+ *    }
+ * }
+ *
+ * @Component({
+ *    selector: 'app',
+ *    providers: [provide(NgLocalization, {useClass: MyLocalization})]
+ * })
+ * @View({
+ *   template: `
+ *     <p>Value = {{value}}</p>
+ *     <button (click)="inc()">Increment</button>
+ *
+ *     <div [ngPlural]="value">
+ *       <template ngPluralCase="=0">there is nothing</template>
+ *       <template ngPluralCase="=1">there is one</template>
+ *       <template ngPluralCase="few">there are a few</template>
+ *       <template ngPluralCase="other">there is some number</template>
+ *     </div>
+ *   `,
+ *   directives: [NgPlural, NgPluralCase]
+ * })
+ * export class App {
+ *   value = 'init';
+ *
+ *   inc() {
+ *     this.value = this.value === 'init' ? 0 : this.value + 1;
+ *   }
+ * }
+ *
+ * ```
+ */
+
+@Directive({selector: '[ngPluralCase]'})
+export class NgPluralCase {
+  _view: SwitchView;
+  constructor(@Attribute('ngPluralCase') public value: string, template: TemplateRef,
+              viewContainer: ViewContainerRef) {
+    this._view = new SwitchView(viewContainer, template);
+  }
+}
+
+
+@Directive({selector: '[ngPlural]'})
+export class NgPlural implements AfterContentInit {
+  private _switchValue: number;
+  private _activeView: SwitchView;
+  private _caseViews = new Map<any, SwitchView>();
+  @ContentChildren(NgPluralCase) cases: QueryList<NgPluralCase> = null;
+
+  constructor(private _localization: NgLocalization) {}
+
+  @Input()
+  set ngPlural(value: number) {
+    this._switchValue = value;
+    this._updateView();
+  }
+
+  ngAfterContentInit() {
+    this.cases.forEach((pluralCase: NgPluralCase): void => {
+      this._caseViews.set(this._formatValue(pluralCase), pluralCase._view);
+    });
+    this._updateView();
+  }
+
+  /** @internal */
+  _updateView(): void {
+    this._clearViews();
+
+    var view: SwitchView = this._caseViews.get(this._switchValue);
+    if (!isPresent(view)) view = this._getCategoryView(this._switchValue);
+
+    this._activateView(view);
+  }
+
+  /** @internal */
+  _clearViews() {
+    if (isPresent(this._activeView)) this._activeView.destroy();
+  }
+
+  /** @internal */
+  _activateView(view: SwitchView) {
+    if (!isPresent(view)) return;
+    this._activeView = view;
+    this._activeView.create();
+  }
+
+  /** @internal */
+  _getCategoryView(value: number): SwitchView {
+    var category: string = this._localization.getPluralCategory(value);
+    var categoryView: SwitchView = this._caseViews.get(category);
+    return isPresent(categoryView) ? categoryView : this._caseViews.get(_CATEGORY_DEFAULT);
+  }
+
+  /** @internal */
+  _isValueView(pluralCase: NgPluralCase): boolean { return pluralCase.value[0] === "="; }
+
+  /** @internal */
+  _formatValue(pluralCase: NgPluralCase): any {
+    return this._isValueView(pluralCase) ? this._stripValue(pluralCase.value) : pluralCase.value;
+  }
+
+  /** @internal */
+  _stripValue(value: string): number { return NumberWrapper.parseInt(value.substring(1), 10); }
+}

node_modules/angular2/ts/src/common/directives/ng_style.ts

@@ -0,0 +1,101 @@
+import {
+  DoCheck,
+  KeyValueDiffer,
+  KeyValueDiffers,
+  ElementRef,
+  Directive,
+  Renderer
+} from 'angular2/core';
+import {isPresent, isBlank, print} from 'angular2/src/facade/lang';
+import {KeyValueChangeRecord} from "../../core/change_detection/differs/default_keyvalue_differ";
+
+/**
+ * The `NgStyle` directive changes styles based on a result of expression evaluation.
+ *
+ * An expression assigned to the `ngStyle` property must evaluate to an object and the
+ * corresponding element styles are updated based on changes to this object. Style names to update
+ * are taken from the object's keys, and values - from the corresponding object's values.
+ *
+ * ### Syntax
+ *
+ * - `<div [ngStyle]="{'font-style': style}"></div>`
+ * - `<div [ngStyle]="styleExp"></div>` - here the `styleExp` must evaluate to an object
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/YamGS6GkUh9GqWNQhCyM?p=preview)):
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {NgStyle} from 'angular2/common';
+ *
+ * @Component({
+ *  selector: 'ngStyle-example',
+ *  template: `
+ *    <h1 [ngStyle]="{'font-style': style, 'font-size': size, 'font-weight': weight}">
+ *      Change style of this text!
+ *    </h1>
+ *
+ *    <hr>
+ *
+ *    <label>Italic: <input type="checkbox" (change)="changeStyle($event)"></label>
+ *    <label>Bold: <input type="checkbox" (change)="changeWeight($event)"></label>
+ *    <label>Size: <input type="text" [value]="size" (change)="size = $event.target.value"></label>
+ *  `,
+ *  directives: [NgStyle]
+ * })
+ * export class NgStyleExample {
+ *    style = 'normal';
+ *    weight = 'normal';
+ *    size = '20px';
+ *
+ *    changeStyle($event: any) {
+ *      this.style = $event.target.checked ? 'italic' : 'normal';
+ *    }
+ *
+ *    changeWeight($event: any) {
+ *      this.weight = $event.target.checked ? 'bold' : 'normal';
+ *    }
+ * }
+ * ```
+ *
+ * In this example the `font-style`, `font-size` and `font-weight` styles will be updated
+ * based on the `style` property's value changes.
+ */
+@Directive({selector: '[ngStyle]', inputs: ['rawStyle: ngStyle']})
+export class NgStyle implements DoCheck {
+  /** @internal */
+  _rawStyle: {[key: string]: string};
+  /** @internal */
+  _differ: KeyValueDiffer;
+
+  constructor(private _differs: KeyValueDiffers, private _ngEl: ElementRef,
+              private _renderer: Renderer) {}
+
+  set rawStyle(v: {[key: string]: string}) {
+    this._rawStyle = v;
+    if (isBlank(this._differ) && isPresent(v)) {
+      this._differ = this._differs.find(this._rawStyle).create(null);
+    }
+  }
+
+  ngDoCheck() {
+    if (isPresent(this._differ)) {
+      var changes = this._differ.diff(this._rawStyle);
+      if (isPresent(changes)) {
+        this._applyChanges(changes);
+      }
+    }
+  }
+
+  private _applyChanges(changes: any): void {
+    changes.forEachAddedItem(
+        (record: KeyValueChangeRecord) => { this._setStyle(record.key, record.currentValue); });
+    changes.forEachChangedItem(
+        (record: KeyValueChangeRecord) => { this._setStyle(record.key, record.currentValue); });
+    changes.forEachRemovedItem(
+        (record: KeyValueChangeRecord) => { this._setStyle(record.key, null); });
+  }
+
+  private _setStyle(name: string, val: string): void {
+    this._renderer.setElementStyle(this._ngEl.nativeElement, name, val);
+  }
+}

node_modules/angular2/ts/src/common/directives/ng_switch.ts

@@ -0,0 +1,202 @@
+import {Directive, Host, ViewContainerRef, TemplateRef} from 'angular2/core';
+import {isPresent, isBlank, normalizeBlank, CONST_EXPR} from 'angular2/src/facade/lang';
+import {ListWrapper, Map} from 'angular2/src/facade/collection';
+
+const _WHEN_DEFAULT = CONST_EXPR(new Object());
+
+export class SwitchView {
+  constructor(private _viewContainerRef: ViewContainerRef, private _templateRef: TemplateRef) {}
+
+  create(): void { this._viewContainerRef.createEmbeddedView(this._templateRef); }
+
+  destroy(): void { this._viewContainerRef.clear(); }
+}
+
+/**
+ * Adds or removes DOM sub-trees when their match expressions match the switch expression.
+ *
+ * Elements within `NgSwitch` but without `NgSwitchWhen` or `NgSwitchDefault` directives will be
+ * preserved at the location as specified in the template.
+ *
+ * `NgSwitch` simply inserts nested elements based on which match expression matches the value
+ * obtained from the evaluated switch expression. In other words, you define a container element
+ * (where you place the directive with a switch expression on the
+ * **`[ngSwitch]="..."` attribute**), define any inner elements inside of the directive and
+ * place a `[ngSwitchWhen]` attribute per element.
+ *
+ * The `ngSwitchWhen` property is used to inform `NgSwitch` which element to display when the
+ * expression is evaluated. If a matching expression is not found via a `ngSwitchWhen` property
+ * then an element with the `ngSwitchDefault` attribute is displayed.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/DQMTII95CbuqWrl3lYAs?p=preview))
+ *
+ * ```typescript
+ * @Component({
+ *   selector: 'app',
+ *   template: `
+ *     <p>Value = {{value}}</p>
+ *     <button (click)="inc()">Increment</button>
+ *
+ *     <div [ngSwitch]="value">
+ *       <p *ngSwitchWhen="'init'">increment to start</p>
+ *       <p *ngSwitchWhen="0">0, increment again</p>
+ *       <p *ngSwitchWhen="1">1, increment again</p>
+ *       <p *ngSwitchWhen="2">2, stop incrementing</p>
+ *       <p *ngSwitchDefault>&gt; 2, STOP!</p>
+ *     </div>
+ *
+ *     <!-- alternate syntax -->
+ *
+ *     <p [ngSwitch]="value">
+ *       <template ngSwitchWhen="init">increment to start</template>
+ *       <template [ngSwitchWhen]="0">0, increment again</template>
+ *       <template [ngSwitchWhen]="1">1, increment again</template>
+ *       <template [ngSwitchWhen]="2">2, stop incrementing</template>
+ *       <template ngSwitchDefault>&gt; 2, STOP!</template>
+ *     </p>
+ *   `,
+ *   directives: [NgSwitch, NgSwitchWhen, NgSwitchDefault]
+ * })
+ * export class App {
+ *   value = 'init';
+ *
+ *   inc() {
+ *     this.value = this.value === 'init' ? 0 : this.value + 1;
+ *   }
+ * }
+ *
+ * bootstrap(App).catch(err => console.error(err));
+ * ```
+ */
+@Directive({selector: '[ngSwitch]', inputs: ['ngSwitch']})
+export class NgSwitch {
+  private _switchValue: any;
+  private _useDefault: boolean = false;
+  private _valueViews = new Map<any, SwitchView[]>();
+  private _activeViews: SwitchView[] = [];
+
+  set ngSwitch(value: any) {
+    // Empty the currently active ViewContainers
+    this._emptyAllActiveViews();
+
+    // Add the ViewContainers matching the value (with a fallback to default)
+    this._useDefault = false;
+    var views = this._valueViews.get(value);
+    if (isBlank(views)) {
+      this._useDefault = true;
+      views = normalizeBlank(this._valueViews.get(_WHEN_DEFAULT));
+    }
+    this._activateViews(views);
+
+    this._switchValue = value;
+  }
+
+  /** @internal */
+  _onWhenValueChanged(oldWhen: any, newWhen: any, view: SwitchView): void {
+    this._deregisterView(oldWhen, view);
+    this._registerView(newWhen, view);
+
+    if (oldWhen === this._switchValue) {
+      view.destroy();
+      ListWrapper.remove(this._activeViews, view);
+    } else if (newWhen === this._switchValue) {
+      if (this._useDefault) {
+        this._useDefault = false;
+        this._emptyAllActiveViews();
+      }
+      view.create();
+      this._activeViews.push(view);
+    }
+
+    // Switch to default when there is no more active ViewContainers
+    if (this._activeViews.length === 0 && !this._useDefault) {
+      this._useDefault = true;
+      this._activateViews(this._valueViews.get(_WHEN_DEFAULT));
+    }
+  }
+
+  /** @internal */
+  _emptyAllActiveViews(): void {
+    var activeContainers = this._activeViews;
+    for (var i = 0; i < activeContainers.length; i++) {
+      activeContainers[i].destroy();
+    }
+    this._activeViews = [];
+  }
+
+  /** @internal */
+  _activateViews(views: SwitchView[]): void {
+    // TODO(vicb): assert(this._activeViews.length === 0);
+    if (isPresent(views)) {
+      for (var i = 0; i < views.length; i++) {
+        views[i].create();
+      }
+      this._activeViews = views;
+    }
+  }
+
+  /** @internal */
+  _registerView(value: any, view: SwitchView): void {
+    var views = this._valueViews.get(value);
+    if (isBlank(views)) {
+      views = [];
+      this._valueViews.set(value, views);
+    }
+    views.push(view);
+  }
+
+  /** @internal */
+  _deregisterView(value: any, view: SwitchView): void {
+    // `_WHEN_DEFAULT` is used a marker for non-registered whens
+    if (value === _WHEN_DEFAULT) return;
+    var views = this._valueViews.get(value);
+    if (views.length == 1) {
+      this._valueViews.delete(value);
+    } else {
+      ListWrapper.remove(views, view);
+    }
+  }
+}
+
+/**
+ * Insert the sub-tree when the `ngSwitchWhen` expression evaluates to the same value as the
+ * enclosing switch expression.
+ *
+ * If multiple match expression match the switch expression value, all of them are displayed.
+ *
+ * See {@link NgSwitch} for more details and example.
+ */
+@Directive({selector: '[ngSwitchWhen]', inputs: ['ngSwitchWhen']})
+export class NgSwitchWhen {
+  // `_WHEN_DEFAULT` is used as a marker for a not yet initialized value
+  /** @internal */
+  _value: any = _WHEN_DEFAULT;
+  /** @internal */
+  _view: SwitchView;
+  private _switch: NgSwitch;
+
+  constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef,
+              @Host() ngSwitch: NgSwitch) {
+    this._switch = ngSwitch;
+    this._view = new SwitchView(viewContainer, templateRef);
+  }
+
+  set ngSwitchWhen(value: any) {
+    this._switch._onWhenValueChanged(this._value, value, this._view);
+    this._value = value;
+  }
+}
+
+/**
+ * Default case statements are displayed when no match expression matches the switch expression
+ * value.
+ *
+ * See {@link NgSwitch} for more details and example.
+ */
+@Directive({selector: '[ngSwitchDefault]'})
+export class NgSwitchDefault {
+  constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef,
+              @Host() sswitch: NgSwitch) {
+    sswitch._registerView(_WHEN_DEFAULT, new SwitchView(viewContainer, templateRef));
+  }
+}

node_modules/angular2/ts/src/common/directives/observable_list_diff.dart

@@ -0,0 +1,63 @@
+library angular2.directives.observable_list_iterable_diff;
+
+import 'package:observe/observe.dart' show ObservableList;
+import 'package:angular2/core.dart';
+import 'package:angular2/src/core/change_detection/differs/default_iterable_differ.dart';
+import 'dart:async';
+
+class ObservableListDiff extends DefaultIterableDiffer {
+  ChangeDetectorRef _ref;
+  ObservableListDiff(this._ref);
+
+  bool _updated = true;
+  ObservableList _collection;
+  StreamSubscription _subscription;
+
+  onDestroy() {
+    if (this._subscription != null) {
+      this._subscription.cancel();
+      this._subscription = null;
+      this._collection = null;
+    }
+  }
+
+  DefaultIterableDiffer diff(ObservableList collection) {
+    if (collection is! ObservableList) {
+      throw "Cannot change the type of a collection";
+    }
+
+    // A new collection instance is passed in.
+    // - We need to set up a listener.
+    // - We need to diff collection.
+    if (!identical(_collection, collection)) {
+      _collection = collection;
+
+      if (_subscription != null) _subscription.cancel();
+      _subscription = collection.changes.listen((_) {
+        _updated = true;
+        _ref.markForCheck();
+      });
+      _updated = false;
+      return super.diff(collection);
+
+      // An update has been registered since the last change detection check.
+      // - We reset the flag.
+      // - We diff the collection.
+    } else if (_updated) {
+      _updated = false;
+      return super.diff(collection);
+
+      // No updates has been registered.
+    } else {
+      return null;
+    }
+  }
+}
+
+class ObservableListDiffFactory implements IterableDifferFactory {
+  const ObservableListDiffFactory();
+  bool supports(obj) => obj is ObservableList;
+  IterableDiffer create(ChangeDetectorRef cdRef, [Function trackByFn]) {
+    return new ObservableListDiff(cdRef);
+  }
+}

node_modules/angular2/ts/src/common/directives/observable_list_diff.ts

@@ -0,0 +1,10 @@
+// TS does not have Observables
+
+// I need to be here to make TypeScript think this is a module.
+import {} from 'angular2/src/facade/lang';
+
+/**
+ * This module exists in Dart, but not in Typescript. This exported symbol
+ * is only here to help Typescript think this is a module.
+ */
+export var workaround_empty_observable_list_diff: any;

node_modules/angular2/ts/src/common/forms.ts

@@ -0,0 +1,64 @@
+/**
+ * @module
+ * @description
+ * This module is used for handling user input, by defining and building a {@link ControlGroup} that
+ * consists of
+ * {@link Control} objects, and mapping them onto the DOM. {@link Control} objects can then be used
+ * to read information
+ * from the form DOM elements.
+ *
+ * This module is not included in the `angular2` module; you must import the forms module
+ * explicitly.
+ *
+ */
+export {AbstractControl, Control, ControlGroup, ControlArray} from './forms/model';
+
+export {AbstractControlDirective} from './forms/directives/abstract_control_directive';
+export {Form} from './forms/directives/form_interface';
+export {ControlContainer} from './forms/directives/control_container';
+export {NgControlName} from './forms/directives/ng_control_name';
+export {NgFormControl} from './forms/directives/ng_form_control';
+export {NgModel} from './forms/directives/ng_model';
+export {NgControl} from './forms/directives/ng_control';
+export {NgControlGroup} from './forms/directives/ng_control_group';
+export {NgFormModel} from './forms/directives/ng_form_model';
+export {NgForm} from './forms/directives/ng_form';
+export {ControlValueAccessor, NG_VALUE_ACCESSOR} from './forms/directives/control_value_accessor';
+export {DefaultValueAccessor} from './forms/directives/default_value_accessor';
+export {NgControlStatus} from './forms/directives/ng_control_status';
+export {CheckboxControlValueAccessor} from './forms/directives/checkbox_value_accessor';
+export {
+  NgSelectOption,
+  SelectControlValueAccessor
+} from './forms/directives/select_control_value_accessor';
+export {FORM_DIRECTIVES, RadioButtonState} from './forms/directives';
+export {NG_VALIDATORS, NG_ASYNC_VALIDATORS, Validators} from './forms/validators';
+export {
+  RequiredValidator,
+  MinLengthValidator,
+  MaxLengthValidator,
+  PatternValidator,
+  Validator
+} from './forms/directives/validators';
+export {FormBuilder} from './forms/form_builder';
+import {FormBuilder} from './forms/form_builder';
+import {RadioControlRegistry} from './forms/directives/radio_control_value_accessor';
+import {Type, CONST_EXPR} from 'angular2/src/facade/lang';
+
+/**
+ * Shorthand set of providers used for building Angular forms.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * bootstrap(MyApp, [FORM_PROVIDERS]);
+ * ```
+ */
+export const FORM_PROVIDERS: Type[] = CONST_EXPR([FormBuilder, RadioControlRegistry]);
+
+/**
+ * See {@link FORM_PROVIDERS} instead.
+ *
+ * @deprecated
+ */
+export const FORM_BINDINGS = FORM_PROVIDERS;